Applications might require native PHP extensions which are usually written in C. Consequently, they need to be compiled as shared libraries (.so files) to be used by PHP.

Some of them are pre-installed and shipped by default with the deployed version of PHP. Others are dynamically installed if specified in the project’s composer.json file.

Working With PHP Built-in Extensions

Available PHP Built-in Extensions

The following table lists the PHP built-in extensions we bundle with PHP and that are available on Scalingo.

• Some are enabled by default and can’t be disabled. You don’t have to add them to your composer.json file to enable them (but you can).
  They are marked as Enabled in the following table.
• Some others are disabled by default and can be enabled.
  They are marked as Optional in the following table.
• Unavailable extensions are marked with a blank cell.

Enabling a PHP Built-in Extension

To enable an optional PHP built-in extension, add its name to the require block of your composer.json file, like so:

{
  "require": {
    "ext-pdo_pgsql": "*",
    "ext-gettext": "*",
    ...
  }
}

Adding a PHP Built-in Extension

To add a PHP built-in extension that is not available, please get in touch with our support team.

Working With PECL Extensions

Available PECL Extensions

The following table lists the PECL extensions that we pre-compile and make available on Scalingo.

• Some are enabled by default and can’t be disabled. You don’t have to add them to your composer.json file to enable them (but you can).
  They are marked as Enabled in the following table.
• Some others are disabled by default and can be enabled.
  They are marked as Optional in the following table.
• Unavailable extensions are marked with a blank cell.

Available Versions

The following table lists the supported versions of available PECL extensions:

Enabling an Available PECL Extension

To enable an available PECL extension, add its name to the require block of your composer.json file, like so (notice the ext- prefix!):

{
  "require": {
    "ext-apcu": "*",
    "ext-igbinary": "*",
    ...
  }
}

Adding a PECL Extension

If the PECL extension you need is not listed in the table of available PECL extensions, you may want to instruct the platform to compile it and install it during the build phase of your deployment.

To do so, add its name in the require block of your composer.json, like so (notice the ext- prefix!):

{
  "require": {
    "ext-my_pecl_extension": "*",
    ...
  }
}

Adding a PECL Extension That Has Dependencies

While some PECL extensions compile and install just fine out of the box, some others have precise requirements. In most cases, these requirements consist in libraries and libraries headers, which are generally available and distributed as OS packages.

The documentation of the extension should normally specify the name(s) (and sometimes the versions) of these required package(s).

To install these packages in your container, and when possible, we strongly recommend to use the APT buildpack along with the multi-buildpack.

Adding a PECL Extension With Specific Compilation Flags

Some extensions also require specific compilation flags to be set. To specify these flags, create a new environment variable named after the extension and prefixed with PHP_PECL_EXTENSION_CONFIGURE_ARGS_ (see Full Example, below). Then, put the compilation flags you want to use in this variable.

Each extension requiring specific compilation flags must have its own environment variable.

Full Example

In this example, we are going to install the PECL extension named yaml. This is a good example as it requires thelibyaml and libyaml-dev packages to be installed, and it also needs some specific compilation flags.

First, let’s tell the platform we need this extension. To do so, we will have to create a file named composer.json at the root of our project, like this:

{
  "require": {
    "ext-yaml": "*"
  }
}

As recommended, we will use the multi-buildpack to tell the platform to:

1. first, call the APT buildpack to install the required packages;
2. and then, use the PHP buildpack to install PHP, Composer and the required extensions.

Let’s create a file named .buildpacks at the root of the project with the following content:

https://github.com/Scalingo/apt-buildpack
https://github.com/Scalingo/php-buildpack

libyaml is already available in our containers so we don’t have to worry about it. But we still have to install libyaml-dev. To do so, create another file, named Aptfile, at the root of the project:

libyaml-dev

We then need to create a dedicated environment variable, named PHP_PECL_EXTENSION_CONFIGURE_ARGS_yaml and set its value to --with-yaml=$BUILD_DIR/.apt/usr. This instructs the platform to compile the extension with this flag, which tells the compile script where to find the libyaml headers.

The last step consists in committing your work and pushing it to Scalingo.

Working With Third-Party Extensions

Available Third-Party Extensions

The following table lists the third-party extensions that are available on Scalingo, along with the versions available.

• They are all disabled by default and can be enabled.

Enabling an Available Third-Party Extension

To enable an available third-party extension, please refer to the corresponding instructions:

• For Datadog
• For New Relic
• For Scout APM

Adding a Third-Party Extension

To add a third-party extension that is not available, please get in touch with our support team.