A step-by-step guide on how to create a Docker container that runs Apache, PHP, and Composer. This container allows one to install and run PHP packages with Composer, and the generated output files are exposed to the local network and can be accessed via a web browser.
Create a Docker Image File
Create a file named Dockerfile and enter the following content into the file:
# start with the official Composer image and name it
FROM composer:latest AS composer
ENV COMPOSER_ALLOW_SUPERUSER 1
# Use an official PHP and Apache base image
FROM php:8.2-apache AS php-apache
ENV HOSTNAME php-apache
# Expose port 80 for Apache
EXPOSE 80
# Start Apache in the foreground
CMD ["apache2-foreground"]
# copy the Composer PHAR from the Composer image into the PHP image
COPY --from=composer /usr/bin/composer /usr/bin/composer
# show that both Composer and PHP run as expected
RUN composer --version && php -v
# Add git to enable git commands, a necessary composer dependency
RUN apt-get update && \
apt-get upgrade -y && \
apt-get install -y git
The script above will pull images from the official Composer and PHP/Apache images. Then it will install Git in the container so we can successfully run Composer commands.
Build a Docker Image
The next step would be to build this image and give it a name, apache-php. To achieve this, run the following command in the shell:
docker build -t apache-php ./The above command assumes the file Dockerfile lives in the current working directory. If you run a command from an external directory, replace ./ with the full path to your Dockerfile.
Create a Container from the Docker Image
Then create a script to create and run a Docker container from the image we created above. Let's call this script run_docker.sh. In this script, we want to achieve the following:
- Expose the container to the network, so we can view the files in a browser
- Map a directory on the drive to the container, this is where our source code lives
- Define a virtual host for the Apache
- Map a subdirectory on the local drive to the virtual host domain
The following command will give all of that to us, save it into the run_docker.sh:
docker run -d --network host --name my-project -v ~/my-project:/var/www/html -v ~/my-project/vhosts.conf:/etc/apache2/sites-enabled/vhosts.conf apache-phpThe explanation of each part of the command:
docker run -d ... apache-php- create and run a new container in a detached mode and give it the name apache-php--network host- expose the container to the host network, meaning the computer network, so the image will be accessible via web browser at a URL 127.0.0.1 or localhost--name my-project- give your image a name-v ~/my-project:/var/www/html- map the directory~/my-projecton the local drive to a directory Apache root directory/var/www/htmlin the Docker container-v ~/my-project/vhosts.conf:/etc/apache2/sites-enabled/vhosts.conf- map a vhost.conf from a local directory to a Apache configuration directory in the Docker image
Note, that this configuration assumes that there are no services running on port 80, if some are running, you may have to remap to a different port, such as 8080. The directive -p 8080:80 should do the trick.
Configure vhost.conf
In the configuration above, we mapped the project directory to Apache's root directory. When running a Composer project, it is necessary to allow us to run Composer command lines in the root directory. However, in some cases, the code is compiled into a subdirectory. In such cases, we'll have to define a custom virtual host configuration for Apache.
<VirtualHost my-project.localhost:80>
# The ServerName directive sets the request scheme, hostname and port that
# the server uses to identify itself. This is used when creating
# redirection URLs. In the context of virtual hosts, the ServerName
# specifies what hostname must appear in the request's Host: header to
# match this virtual host. For the default virtual host (this file) this
# value is not decisive as it is used as a last resort host regardless.
# However, you must set it for any further virtual host explicitly.
#ServerName www.example.com
ServerAdmin webmaster@localhost
DocumentRoot /var/www/html/dist/
# Available loglevels: trace8, ..., trace1, debug, info, notice, warn,
# error, crit, alert, emerg.
# It is also possible to configure the loglevel for particular
# modules, e.g.
#LogLevel info ssl:warn
ErrorLog ${APACHE_LOG_DIR}/error.log
CustomLog ${APACHE_LOG_DIR}/access.log combined
# For most configuration files from conf-available/, which are
# enabled or disabled at a global level, it is possible to
# include a line for only one particular virtual host. For example the
# following line enables the CGI configuration for this host only
# after it has been globally disabled with "a2disconf".
#Include conf-available/serve-cgi-bin.conf
</VirtualHost>
In this case, the project root folder is mapped to /var/www/html/, the Composer will build the production-ready files into dist directory. So we define a my-project.localhost to map to this directory.
I generated the file above by spinning up the container first, and then copying the default configuration file with the following command:docker cp my-project:/etc/apache2/sites-available/000-default.conf ./vhost.conf. Then I modified the standard file.
Run the container
Now that all the pieces are in place, run the container by executing the shell script we created above.
./run_docker.shInstalling Composer Dependencies
Once the container is up and running, we can shell into it and install our Composer dependencies and compile our code.
docker exec -it my-project bash
composer install
# Run your compilation command, for example
php ./vendor/couscous/couscous/bin/couscous generate
Access via Web Browser
Now you should be able to access your project in a web browser via the URL http://127.0.0.1, http://my-project.localhost or just http://localhost. Note, you would have to modify your /etc/hosts file (on Linux and macOS) to map the custom domain to the local IP address.