[opensourcedex]

tsuru is a free, open source build & deployment project written in Go and released under BSD-3-Clause. It has 5,310 GitHub stars, 551 forks and 17 open issues, and was last pushed 36 hours ago. On this registry it ranks #26 of 59 tracked projects in Build & Deployment, with 5 head-to-head comparisons available.

What is tsuru?

What it is

tsuru is an open source, extensible Platform as a Service written in Go and released under the BSD-3-Clause license. It lives in the cloud-native and DevOps ecosystem alongside Docker, Kubernetes, and the wider container tooling world, and it has been developed in public for roughly fifteen years. Rather than asking developers to think about servers, tsuru presents a platform on which applications are deployed as units and managed through a single command-line client. The project describes itself as extensible, which reflects a design where the set of supported runtimes and backing services can be grown rather than fixed.

The concrete problem it solves is the gap between raw container infrastructure and the everyday work of shipping an application. A team that has a Kubernetes cluster still needs a repeatable way to publish code, attach databases and caches, and inspect what is running. tsuru supplies that layer: developers write applications in the language of their choice, back them with add-on resources such as SQL and NoSQL databases, memcached, and Redis, and manage the result through the tsuru command-line tool. Platform definitions are maintained for Python, Node.js, Go, Ruby, PHP, Perl, Lua, and Java, so the same workflow covers many stacks.

Key capabilities

  • Applications deploy in the programming language of the developer's choice, with maintained platform definitions for Python, Node.js, Go, Ruby, PHP, Perl, Lua, and Java.
  • Applications can be backed by add-on resources, including SQL and NoSQL databases, memcached, and Redis.
  • The tsuru command-line client manages applications, and targets work in a manner similar to Kubernetes' kubeconfig.
  • The platform is extensible, allowing additional platforms and add-ons beyond those shipped in the repository.
  • Deployment targets include Minikube for local clusters and Google Kubernetes Engine for hosted clusters.
  • Local development dependencies are Docker or Podman, Minikube, Go, and yq, with the tsuru client used to talk to the API.
  • The project publishes a tsuru-dashboard application, which tsuru app list is expected to return as a check that the installation works.

Who uses it and how

  • Application developers deploy code to a tsuru cluster and manage it through the tsuru CLI instead of handling servers directly.
  • Platform teams run tsuru on Kubernetes, using either Minikube or GKE as the install guide describes, and register the platforms their developers need.
  • Operators provisioning backing services attach add-ons such as SQL, NoSQL, memcached, and Redis to applications.
  • Contributors run the stack locally with make local.setup followed by make local.run, then point the CLI at the local API with tsuru target-set local-dev.
  • Teams using Podman instead of Docker pass the alternative binary explicitly, for example `make local
project readme (upstream, from github) — read inline

tsuru

Build Status Go Report Card

What is tsuru?

tsuru is an extensible and open source Platform as a Service (PaaS) that makes application deployments faster and easier. With tsuru, you don’t need to think about servers at all. As an application developer, you can:

  • Write apps in the programming language of your choice
  • Back apps with add-on resources such as SQL and NoSQL databases, including memcached, Redis, and many others
  • Manage apps using the tsuru command-line tool

Links:

Popular platforms supported:

Quick Start

Getting tsuru-client

Download the latest release for your platform at: https://github.com/tsuru/tsuru-client/releases/

Example for release 1.1.1 and OS X:

$ curl -sSL https://github.com/tsuru/tsuru-client/releases/download/1.1.1/tsuru-1.1.1-darwin_amd64.tar.gz | tar xz

Install Guides

Testing

If everything's gone well you have the tsuru running in a Kubernetes Cluster. Call app list to see tsuru working, this command needs to return one app called tsuru-dashboard.

tsuru app list

Local development

Dependencies

Before starting, make sure you have the following tools installed:

You'll also need the Tsuru Client to interact with the Tsuru API. If you haven't installed it yet, please do so.

For macOS users: We recommend using the qemu driver with socket_vmnet for Minikube clusters. For more information on installing qemu and socket_vmnet, refer to the following links:

Note: If you are using Docker-compatible alternatives like Podman, be sure to specify the DOCKER variable with the correct binary when running make commands. For example: make local.run DOCKER=podman.

Running local environment

To run the Tsuru API locally, you'll need to first set up the local environment. This setup process is crucial because it creates the default configuration files, initializes required dependencies, and prepares your local system to host the Tsuru API. The following command will handle all these tasks:

make local.setup

Once the setup is complete, you won’t need to run this command again unless you want to reset your environment.

After the initial setup, you can start the Tsuru API and its dependencies using the following command:

make local.run

Once the Tsuru API is running, open a new terminal window and configure your Tsuru CLI to point to the local-dev target. This target tells the CLI to interact with your local Tsuru API instance rather than a remote server. You can set the target using this command:

tsuru target-set local-dev

Tsuru's targets function similarly to Kubernetes' kubectl config contexts, allowing you to switch between different environments easily.

To confirm that everything is set up correctly, you can log in and list the clusters managed by your Tsuru API instance:

tsuru login [email protected] # password: admin@123
tsuru cluster list

If everything is working as expected, you should see your local Minikube cluster listed as the default provisioner.

Creating an app or job

For that, you will have to create a team, pool and set a label to the minikube nodes to allow deploys on it

tsuru team create my-team
tsuru pool add my-pool

# make sure you are using the right kube config
kubectl label nodes minikube tsuru.io/pool=my-pool

Running Integration tests

In order to run integration tests, you must:

  1. Ensure that your local Tsuru API instance is up and running.
  2. Create a Kubectl config file that must not be $HOME/.kube/config that points only to your Minikube cluster.
  3. Run the integration tests using the following command:
INTEGRATION_KUBECONFIG=<your-minikube-kubeconfig> make local.test-ci-integration

Cleaning up

When you're done working with your local environment, it's important to stop the services to free up system resources. You can stop the dependencies using:

make local.stop

If you want to fully reset your environment, or if you no longer need the Tsuru API and its dependencies on your local machine, you can remove all associated resources using:

make local.cleanup

Frequently asked questions

Is tsuru free to use?

tsuru is open source under the BSD-3-Clause licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does tsuru do?

Open source and extensible Platform as a Service (PaaS).

What is tsuru written in?

tsuru is primarily written in Go. Its source is publicly available at https://github.com/tsuru/tsuru, and it has 5,310 GitHub stars.