Applications on Scalingo are executed inside a Docker container. This base Docker image is maintained by Scalingo and based on a Docker image of a well-known Linux distribution.

Scalingo currently supports two stacks based on Ubuntu. The corresponding base Docker images are open source and can be found on the Docker hub:

All Scalingo buildpacks officially supported by Scalingo are compatible with all stacks.

The default stack for all newly created applications is scalingo-22.

These base Docker images are used for all applications hosted on the platform, as a result, it is a generic image which is unspecialized. That’s why they are based on a stable Ubuntu LTS environment.

Viewing Stack Used by your Application

The stack used by your application is available using Scalingo CLI:

scalingo --app my-app apps-info
+----------------+-------------+
|    SETTINGS    |    VALUE    |
+----------------+-------------+
[...]
| Stack          | scalingo-22 |
[...]
+----------------+-------------+

Migrating to a New Stack

You can switch to the latest stack with:

scalingo --app my-app stacks-set scalingo-22

Then redeploy your application:

git commit --allow-empty -m "Upgrading to scalingo-22"
git push scalingo master

You can view the list of all available stacks with the CLI:

scalingo stacks

It is advisable to first test this change on a staging application. You may already have such staging application hosted on Scaling. In such situation, the above-mentioned migration steps can be applied on it.

Otherwise, a nice solution to test the stack upgrade without affecting your currently running application is to create a review app and add a scalingo.json file containing:

{
  "stack": "scalingo-22"
}

Make sure your review app deploys successfully and works flawlessly. Once your application is ready for the new stack, switch to the desired stack and redeploy with the method described above.

The Build Process

Each time any user deploys a new release of their applications, a new Docker image is created. A new layer is added on top of the base image. It’s built using the buildpack and contains the application code and all its dependencies. When the build is done, the resulting Docker image is sent to our private repository and our orchestrator will use it subsequently to actually run the application in our infrastructure.

The maximum build time is 30 minutes. After that duration the build will be cancelled by the platform.

Installed Libraries

We’ve installed different libraries and softwares which are commonly used in the build process or used by human when running one-off container.

You’ll find:

• Build essentials utility (GCC, make, autotools, …)
• Curl, git, telnet, ssh, ssh-client, openssl, dnsutils, sqlite
• Node.js, Ruby, Perl, Python, Java
• ImageMagick

The advantage of using a single base Docker image is that once it has been fetched on a hosting node, we’re done. Even if we sacrifice a few megabytes of disk space, when a new container starts, only the application layer is fetched and nothing else.

Of course you can inspect this base image: it’s a completely standard Docker image after all! You can use something like:

$ docker pull scalingo/scalingo-20
$ docker run --rm -it scalingo/scalingo-20:latest bash

Timezone

The timezone configured inside our base image is UTC±00:00. You can set it to a different value by setting the environment variable TZ with the desired timezone:

scalingo --app my-app env-set TZ=Europe/Paris

A list of existing timezones is available here.