Ultimate Guide to Drupal Docker (Setup and Customization)

Drupal, being one of the best content management systems (CMS), is a go-to choice for many developers due to its flexibility and security. However, setting up and managing a Drupal development environment can be time-consuming.

That’s where Docker comes into play. Docker is a platform that allows developers to build, test, and deploy applications in containers. By leveraging Docker, Drupal developers can build websites, ensuring consistency and simplified deployment.

To help you with the integration, we’ll learn how to set up Drupal with Docker. We’ll also learn how to create Docker images in Drupal. With that, let’s begin by understanding what exactly Docker is.

What is Docker?

Docker is a platform that allows you to build, run, and deploy applications in isolated environments called containers. Containers are portable units that combine the applications with all of their dependencies, making them run consistently across different environments. That ensures the site behaves the same way, regardless of the underlying infrastructure.

Key Features of Docker

• Containers: It uses containers to package applications and their dependencies into a single unit. Containers are lightweight and isolated from each other, making them ideal for running multiple web apps on a single host.
• Docker Images: These are lightweight, standalone, and immutable snapshots of an application. You can create your own images or pull pre-built images from the Docker Hub repository with thousands of built images.
• Docker Hub: It is a cloud-based repository where developers can find, store, and share Docker images. Docker Hub includes official images for popular software (like Drupal, Nginx, and MySQL) as well as community-contributed images.
• Orchestration: It can be used with orchestration tools like Kubernetes to manage and scale containers across multiple hosts.
• Version Control: Docker images can be versioned, allowing you to roll back to previous versions of a site if needed. This makes it easier to track and manage changes over time.
• Portability: Docker containers can run on any system that supports Docker (Linux, macOS, Windows). This ensures that your site behaves the same in development, testing, and production environments, eliminating the “it works on my machine” problem.
• Docker Compose: It allows you to define and manage multi-container Docker applications. Using a simple docker-compose.yml file, you can configure the site services and run them all with a single command (docker-compose up).

These features make Docker a highly versatile and efficient tool for modern web development. It enables web development experts to work faster, deploy more consistently, and scale their sites easily.

Why use Docker for Drupal development?

Using Docker for Drupal development offers several advantages that can streamline workflows and improve consistency. Here’s why Docker is a valuable tool for Drupal development:

Consistent Development Environment

Docker provides a consistent development environment for Drupal projects. By isolating each project in its own container, it ensures that dependencies and configurations don’t conflict. This reproducibility is achieved through the Dockerfile. It maintains consistency across different machines and OS, streamlining the development process.

Simplified Deployment

It simplifies the deployment process for Drupal applications. Containers can be easily moved between different environments (development, staging, production) without making significant changes to the application. This portability, combined with automation through CI/CD pipelines, reduces the time and effort needed for deployment.

Improved Performance

Docker offers improved performance compared to traditional virtual machines. Its lightweight nature and efficient resource allocation lead to faster response and reduced resource consumption. This results in better performance for Drupal sites, especially under heavy load.

Scalability

The scalability of Docker is a major advantage for Drupal sites. It allows for both horizontal and vertical scaling to handle increased traffic or load. Horizontal scaling involves adding more containers to a cluster. Conversely, vertical scaling involves adding more resources to containers. This flexibility makes the Drupal site more adaptable to upcoming changes.

Collaboration and Teamwork

It fosters collaboration and teamwork among developers. By providing a shared development environment, it enables teams to work together more efficiently. Additionally, Docker images can be version-controlled. That allows for easy tracking and management of changes to the development environment.

Integration with Other Tools

Docker seamlessly integrates with other tools commonly used in Drupal development. It can be integrated with configuration tools like Ansible, Puppet, and Chef to automate the configuration of Drupal environments. Plus, Docker can be used with platforms like Swarm and Kubernetes to manage and scale Drupal sites across multiple hosts.

The benefits such as portability, performance, scalability and more make Docker a valuable tool for Drupal development experts. So, how can you leverage Docker for your Drupal site? Let’s learn how in the next section.

How to Set Up a Drupal Docker Environment?

Setting up a basic Drupal environment with Docker involves creating a set of containers that include services for Drupal to run. It includes managing services such as a web server, PHP, and a database (MySQL or MariaDB). The most easy way to manage this is by using Docker Compose. Here is how to set up a basic Drupal Docker environment:

Step 1: Install Docker and Docker Compose

Before setting up a Drupal environment with Docker, you need to have Docker and Docker Compose installed on your machine. Docker provides the platform for containerization, while Docker Compose allows you to define and manage multi-container applications.

• Install Docker: Follow the instructions on the Docker website to install Docker on your operating system.
• Install Docker Compose: You can find installation instructions on the Docker Compose documentation.

We installed Docker and Docker Compose on our system. That ensures we have the necessary tools to create and manage our Drupal Docker environment.

Step 2: Create a New Project Directory

Create a directory for your Drupal project. This directory will contain all your Docker configuration files and Drupal code.

mkdir drupal-docker
cd drupal-docker

Here, we created a new directory and navigated into it, providing a dedicated space for our project.

Step 3: Create a docker-compose.yml File

Create a docker-compose.yml file in your project directory. This file defines the containers you’ll need for Drupal (e.g., Drupal, database, etc.).

touch docker-compose.yml

In this step, we created a docker-compose.yml file in our project directory. It will contain the instructions for Docker Compose to build and run our containers.

Step 4: Define the Services in docker-compose.yml

Here’s a basic example of a docker-compose.yml file for setting up Drupal with MySQL and phpMyAdmin (optional for database management):

version: '3'
services:
  drupal:
    image: drupal:9 # Official Drupal Docker image (version 9)
    container_name: drupal
    ports:
      - "8080:80" # Maps the container's port 80 to localhost's port 8080
    volumes:
      - ./drupal:/var/www/html # Mounts the local 'drupal' directory to the Drupal container
    depends_on:
      - db
    networks:
      - drupal-network
  db:
    image: mysql:5.7 # MySQL image (version 5.7)
    container_name: drupal-db
    environment:
      MYSQL_ROOT_PASSWORD: root
      MYSQL_DATABASE: drupal
      MYSQL_USER: drupal
      MYSQL_PASSWORD: drupal
    volumes:
      - db-data:/var/lib/mysql # Persistent storage for the database
    networks:
      - drupal-network
  phpmyadmin:
    image: phpmyadmin/phpmyadmin # phpMyAdmin for easy database management
    container_name: phpmyadmin
    ports:
      - "8081:80"
    environment:
      PMA_HOST: db
      MYSQL_ROOT_PASSWORD: root
    depends_on:
      - db
    networks:
      - drupal-network
volumes:
  db-data:
networks:
  drupal-network:
    driver: bridge

We added services to our docker-compose.yml file and defined the images to be used for these services. Here is a breakdown of the configuration:

Drupal Service:

• Uses the official drupal:9 Docker image.
• Maps port 80 from the container to port 8080 on your local machine (so Drupal can be accessed at http://localhost:8080).
• Mounts the local drupal folder to the /var/www/html directory in the container, which holds the Drupal files.
• Depends on the database service (db) to ensure the database is ready before Drupal starts.

Database (MySQL) Service:

• Uses the official mysql:5.7 image.
• Defines environment variables for the MySQL root password, database name, user, and password.
• A volume is set up to persist the database data on your local machine.

phpMyAdmin Service (optional):

• Provides an easy web-based interface to manage the MySQL database.
• Accessible via http://localhost:8081.

By defining these services you will be able to add security and authentication for your Drupal. Now, you will be able to run Docker containers.

Step 5: Start the Docker Containers

Run the following command in the project directory to start all the services defined in your docker-compose.yml file:

docker-compose up -d

This command will download the necessary Docker images (if not already downloaded). Plus, it creates and starts the Drupal, MySQL, and phpMyAdmin containers in detached mode (-d).

Step 6: Access Drupal and phpMyAdmin

Open your browser and go to http://localhost:8080 to begin the Drupal installation. During the installation process, you’ll need to connect to the MySQL database. Use the following credentials:

• Database name: drupal
• Username: drupal
• Password: drupal
• Host: db (as defined in docker-compose.yml)

To manage the database through a web interface, go to http://localhost:8081. Use the root credentials to log in:

• Username: root
• Password: root

We opened a web browser and navigated to the specified URL to access our Drupal installation. Plus, we also accessed phpMyAdmin to manage our database.

Step 7: Persist Data with Volumes

The docker-compose.yml includes volumes for both Drupal files and the MySQL database:

• Drupal Volume: The ./drupal directory on your local machine is mounted to the /var/www/html directory inside the container. This means any changes made to the Drupal files locally will be reflected in the container.
• Database Volume: The db-data volume ensures that the database data is persisted even if the database container is restarted.

By setting up volumes, you’ve ensured that your Drupal data and configurations are preserved across container restarts and re-creations.

Step 8: Managing Docker Containers

Docker provides various commands for managing containers, such as starting, stopping, restarting, and viewing them.

• To view running containers: docker ps
• To stop the containers, run: docker-compose down
• To restart them, use: docker-compose up -d
• To view logs from the containers, run: docker-compose logs

Effective container management will help you troubleshoot and maintain your Drupal sites as needed.

Step 9: Customize Your Setup

You can extend this basic setup by adding additional services, such as:

• Redis for caching
• Varnish for reverse proxying
• Apache Solr for search functionality
• Xdebug for debugging PHP code

Customizing your setup allows you to fulfill specific development needs. That enhances your development workflow and ensures it meets your project’s demands.

By following these steps, you will have a basic Drupal environment running in Docker containers. You can now proceed with creating content and developing your website. However, this process could be complex for most; therefore, contact our Drupal development company for seamless integration.

How to Create Custom Docker Images for Drupal?

Creating custom Docker images for Drupal allows you to customize the environment to meet specific needs. Here’s a step-by-step guide to creating custom Docker images for Drupal:

Step 1: Create a Dockerfile

A Dockerfile is a text document that contains instructions for building a Docker image. It defines the base image, packages to install, environment variables, and other configuration settings. Here, we will create a new file named Dockerfile in your project directory.

Step 2: Define the Base Image

The base image provides the foundation for your custom image. It includes the operating system, libraries, and other essential components. For Drupal, you can use the official Drupal image or a more lightweight base image like nginx:alpine.

FROM drupal:latest

We specified the drupal:latest image as the base image, which includes the Drupal application and its dependencies.

Step 3: Install Additional Packages

If your Drupal project requires additional packages, you can install them using the RUN instruction in the Dockerfile.

FROM drupal:latest
RUN apt-get update && apt-get install -y php-gd php-imageapi

We installed the php-gd and php-imageapi packages, which are often required for image processing in Drupal.

Step 4: Copy Drupal Files

Copy your Drupal project files into the container’s /var/www/html directory, where they will be served by the web server.

FROM drupal:latest
COPY ./drupal /var/www/html

Here, we copied the contents of our local drupal directory into the container’s /var/www/html directory.

Step 5: Set Environment Variables

Environment variables are used to configure your Drupal application. Set environment variables using the ENV instruction.

FROM drupal:latest
ENV DRUPAL_DB_NAME=drupal
ENV DRUPAL_DB_USER=root
ENV DRUPAL_DB_PASS=your_mysql_password

In this step, we have set environment variables for the database name, username, and password.

Step 6: Expose Ports

Expose the ports that your application will use for communication:

FROM drupal:latest
EXPOSE 80

Here, we exposed port 80, which is typically used for HTTP traffic.

Step 7: Build the Image

Run the following command in your terminal to build the image:

docker build -t my-drupal-image

Replace my-drupal-image with a suitable name for your image. Once you run the command, a new Docker image will be created.

Step 8: Run a Container

Create a container from the newly built image and start it. Here is the command to run a container:

docker run -p 8080:80 --name my-drupal-container my-drupal-image

Here, we ran the docker run command to start a container from the image, specifying the port mapping and a name for the container.

Example Dockerfile

FROM drupal:latest
RUN apt-get update && apt-get install -y php-gd php-imageapi
COPY ./drupal /var/www/html
ENV DRUPAL_DB_NAME=drupal
ENV DRUPAL_DB_USER=root
ENV DRUPAL_DB_PASS=your_mysql_password
EXPOSE 80

By following these steps, you can create custom Docker images for your Drupal projects that are customized to your needs and requirements. To get your site customized with the best practices followed, consider hiring Drupal developers.

FAQs About Drupal Docker

Final Thoughts

Docker has changed the way Drupal development is done by providing a consistent, portable, and scalable environment. With Docker, you can easily manage complex Drupal projects without worrying about dependency conflicts or manual configurations.

The setup of using Docker with Drupal starts with installing Docker and ends with customizing the setup. Once the setup is done, you can build your site and create custom Docker images for Drupal.

If you are struggling with the setup and need a seamless development service, hire Drupal developers.