The Red Hat Ecosystem Catalog is the official source for discovering and learning more about the Red Hat Ecosystem of both Red Hat and certified third-party products and services.
We’re the world’s leading provider of enterprise open source solutions—including Linux, cloud, container, and Kubernetes. We deliver hardened solutions that make it easier for enterprises to work across platforms and environments, from the core datacenter to the network edge.
PHP 7.4 available as container is a base platform for building and running various PHP 7.4 applications and frameworks. PHP is an HTML-embedded scripting language. PHP attempts to make it easy for developers to write dynamically generated web pages. PHP also offers built-in database integration for several commercial and non-commercial database management systems, so writing a database-enabled webpage with PHP is fairly simple. The most common use of PHP coding is probably as a replacement for CGI scripts.
This container image includes an npm utility, so users can use it to install JavaScript modules for their web applications. There is no guarantee for any specific npm or nodejs version, that is included in the image; those versions can be changed anytime and the nodejs itself is included just to make the npm work.
In this example, we will assume that you are using the ubi8/php-74
image, available via php:74
imagestream tag in Openshift.
To build a simple cakephp-sample-app application in Openshift:
oc new-app php:7.4~https://github.com/sclorg/cakephp-ex.git
To access the application:
$ oc get pods
$ oc exec <pod> -- curl 127.0.0.1:8080
Accessing the application:
$ curl 127.0.0.1:8080
This image supports the Source-to-Image (S2I) strategy in OpenShift. The Source-to-Image is an OpenShift framework which makes it easy to write images that take application source code as an input, use a builder image like this PHP container image, and produce a new image that runs the assembled application as an output.
To support the Source-to-Image framework, important scripts are included in the builder image:
/usr/libexec/s2i/assemble
script inside the image is run to produce a new image with the application artifacts. The script takes sources of a given application and places them into appropriate directories inside the image. It utilizes some common patterns in PHP application development (see the Environment variables section below)./usr/libexec/s2i/run
script is set as the default command in the resulting container image (the new image with the application artifacts). It runs httpd
with PHP support enabled.Compared to the Source-to-Image strategy, using a Dockerfile is a more flexible way to build a PHP container image with an application. Use a Dockerfile when Source-to-Image is not sufficiently flexible for you or when you build the image outside of the OpenShift environment.
To use the PHP image in a Dockerfile, follow these steps:
podman pull ubi8/php-74
An UBI image ubi8/php-74
is used in this example. This image is usable and freely redistributable under the terms of the UBI End User License Agreement (EULA). See more about UBI at UBI FAQ.
An example application available at https://github.com/sclorg/cakephp-ex.git is used here. Feel free to clone the repository for further experiments.
git clone https://github.com/sclorg/cakephp-ex.git app-src
This step usually consists of at least these parts:
For all these three parts, users can either setup all manually and use commands ./composer.phar
or other commands explicitly in the Dockerfile (3.1.), or users can use the Source-to-Image scripts inside the image (3.2.; see more about these scripts in the section "Source-to-Image framework and scripts" above), that already know how to set-up and run some common PHP applications.
FROM ubi8/php-74
# Add application sources
ADD app-src .
# Install the dependencies
RUN TEMPFILE=$(mktemp) && \
curl -o "$TEMPFILE" "https://getcomposer.org/installer" && \
php <"$TEMPFILE" && \
./composer.phar install --no-interaction --no-ansi --optimize-autoloader
# Run script uses standard ways to configure the PHP application
# and execs httpd -D FOREGROUND at the end
# See more in <version>/s2i/bin/run in this repository.
# Shortly what the run script does: The httpd daemon and php needs to be
# configured, so this script prepares the configuration based on the container
# parameters (e.g. available memory) and puts the configuration files into
# the approriate places.
# This can obviously be done differently, and in that case, the final CMD
# should be set to "CMD httpd -D FOREGROUND" instead.
CMD /usr/libexec/s2i/run
FROM ubi8/php-74
# Add application sources to a directory that the assemble script expects them
# and set permissions so that the container runs without root access
USER 0
ADD app-src /tmp/src
RUN chown -R 1001:0 /tmp/src
USER 1001
# Install the dependencies
RUN /usr/libexec/s2i/assemble
# Set the default command for the resulting image
CMD /usr/libexec/s2i/run
podman build -t cakephp-app .
podman run -d cakephp-app
To set these environment variables, you can place them as a key value pair into a .s2i/environment
file inside your source code repository.
The following environment variables set their equivalent property value in the php.ini file:
The following environment variables set their equivalent property value in the opcache.ini file:
You can also override the entire directory used to load the PHP configuration by setting:
You can override the Apache MPM prefork settings to increase the performance for of the PHP application. In case you set some Cgroup limits, the image will attempt to automatically set the optimal values. You can override this at any time by specifying the values yourself:
HTTPD_START_SERVERS
HTTPD_MAX_REQUEST_WORKERS
MaxRequestWorkers
was called MaxClients
before version httpd 2.3.13.TOTAL_MEMORY / 15MB
. The 15MB is average size of a single httpd process.You can use a custom composer repository mirror URL to download packages instead of the default 'packagist.org':
composer install
command line (for example --no-dev
).You do not need to change anything in your existing PHP project's repository. However, if these files exist they will affect the behavior of the build process:
composer.json
List of dependencies to be installed with composer
. The format is documented
here.
.htaccess
In case the DocumentRoot of the application is nested within the source directory /opt/app-root/src
,
users can provide their own Apache .htaccess file. This allows the overriding of Apache's behavior and
specifies how application requests should be handled. The .htaccess file needs to be located at the root
of the application source.
In order to immediately pick up changes made in your application source code, you need to run your built image with the OPCACHE_REVALIDATE_FREQ=0
environment variable passed to Podman -e
run flag:
$ podman run -e OPCACHE_REVALIDATE_FREQ=0 -p 8080:8080 php-app
To change your source code in running container, use Podman's exec) command:
podman exec -it <CONTAINER_ID> /bin/bash
After you Podman exec into the running container, your current directory is set
to /opt/app-root/src
, where the source code is located.
Not only content, but also startup scripts and configuration of the image can be extended using source-to-image.
The structure of the application can look like this:
Folder name | Description |
---|---|
./httpd-cfg | Can contain additional Apache configuration files (*.conf ) |
./httpd-ssl | Can contain own SSL certificate (in certs/ subdirectory) and key (in private/ subdirectory) |
./php-pre-start | Can contain shell scripts (*.sh ) that are sourced before httpd is started |
./php-post-assemble | Can contain shell scripts (*.sh ) that are sourced at the end of assemble script |
./ | Application source code |
Dockerfile and other sources are available on https://github.com/sclorg/s2i-php-container.
In that repository you also can find another versions of Python environment Dockerfiles.
Dockerfile for CentOS is called Dockerfile
, Dockerfile for RHEL7 is called Dockerfile.rhel7
,
for RHEL8 it's Dockerfile.rhel8
and the Fedora Dockerfile is called Dockerfile.fedora.
-p 8080:8080
Opens container port 8080 and maps it to the same port on the Host.
Use the following instructions to get images from a Red Hat container registry using registry service account tokens. You will need to create a registry service account to use prior to completing any of the following tasks.
First, you will need to add a reference to the appropriate secret and repository to your Kubernetes pod configuration via an imagePullSecrets field.
Then, use the following from the command line or from the OpenShift Dashboard GUI interface.
Use the following command(s) from a system with podman installed
Use the following command(s) from a system with docker service installed and running
Use the following instructions to get images from a Red Hat container registry using your Red Hat login.
For best practices, it is recommended to use registry tokens when pulling content for OpenShift deployments.
Use the following command(s) from a system with podman installed
Use the following command(s) from a system with docker service installed and running
Source code is available for all Red Hat UBI-based images in the form of downloadable containers. Here are a few things you should know about Red Hat source containers.
Use skopeo to copy the source image to a local directory
Inspect the image
Untar the contents
Begin examining and using the content.