Build scalable PHP application clusters using Docker Compose, Nginx and MariaDB

Build scalable PHP application clusters using Docker Compose, Nginx and MariaDB

Introduction:
In modern application development, build scalable applications Program clustering is crucial. By using Docker Compose, Nginx, and MariaDB, we can easily build a scalable PHP application cluster that provides high availability and flexibility to our applications. In this article, we'll explore how to use these tools to build a simple yet powerful cluster of PHP applications, and provide concrete code examples.

Part One: Environment Setup

Before we begin, we need to ensure that Docker and Docker Compose have been installed. Open a terminal in your development environment and run the following command to check whether they have been installed correctly:

$ docker --version
$ docker-compose --version

If the corresponding version information is returned, Docker and Docker Compose have been successfully installed. Next, we will create a new project directory and create a docker-compose.yml file in it.

$ mkdir my-php-cluster
$ cd my-php-cluster
$ touch docker-compose.yml

Part 2: Writing the Docker Compose File
Next, we will define the configuration of our application cluster in the docker-compose.yml file. This configuration will include service definitions for PHP, Nginx, and MariaDB. Here is an example of a basic docker-compose.yml file:

version: '3'

services:
  php:
    build:
      context: .
      dockerfile: Dockerfile.php
    restart: always
    ports:
      - "8000:80"
  nginx:
    build:
      context: .
      dockerfile: Dockerfile.nginx
    restart: always
    ports:
      - "80:80"
    depends_on:
      - php
  db:
    image: mariadb
    command: --default-authentication-plugin=mysql_native_password
    restart: always
    ports:
      - "3306:3306"
    environment:
      MYSQL_ROOT_PASSWORD: secret

In this example, we define three services: php, nginx, and db. The php service will build a Docker image containing PHP and map the port to the host's port 8000. The nginx service will build a Docker image containing Nginx and map the port to port 80 of the host. The db service will use the Docker image officially provided by MariaDB and map the port to the host's 3306 port. Finally, we also specify the environment variable of the db service to set the root password.

Part 3: Writing the Dockerfile
In order for our image to be built successfully, we also need to write the Dockerfile.

First, we create a file named Dockerfile.php and copy the following content into the file:

FROM php:7.4-fpm

WORKDIR /var/www/html

RUN apt-get update && apt-get install -y 
    libzip-dev 
    zip 
    unzip 
    && docker-php-ext-install zip

COPY . .

RUN composer install --no-dev

This Dockerfile uses the official PHP 7.4 FPM image as the base image, and Some additional dependencies are installed via RUN command. We then copied the entire application directory to the container's /var/www/html directory and ran the composer install command to install the PHP dependencies.

Next, we create a file named Dockerfile.nginx and copy the following content into the file:

FROM nginx:latest

COPY nginx.conf /etc/nginx/nginx.conf

This Dockerfile uses the latest Nginx official image as the base image, and Copy the customized nginx.conf file to the /etc/nginx/ directory of the container.

Part 4: Create Nginx configuration file
In our Dockerfile, we mentioned a configuration file called nginx.conf. Now, we create a file called nginx.conf and copy the following content into the file:

events {}

http {
  upstream php {
    server php:9000;
  }

  server {
    listen 80;

    location / {
      proxy_pass http://php;
      proxy_set_header Host $host;
      proxy_set_header X-Real-IP $remote_addr;
      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
      proxy_set_header X-Forwarded-Proto $scheme;
    }
  }
}

This nginx.conf configuration file defines an upstream server named php that will proxy requests To the 9000 port of the php service. We then defined a server block that listens on port 80 and proxies all requests to the PHP upstream server.

Part 5: Running the Application Cluster
Now that we have completed all the configuration, we can start our application cluster by running the docker-compose up command.

In the terminal, enter our project directory and run the following command:

$ docker-compose up -d

The above command will start our application cluster in the background. Please wait a moment until all services start successfully.

Part Six: Testing the Application Cluster
Once our application cluster has successfully started, we can test it by accessing http://localhost through the browser.

Enter http://localhost in the browser and press Enter. If everything is fine, you should be able to see your application running.

Part 7: Scaling the Application Cluster
By using the scale feature of Docker Compose, we can easily scale our application cluster.

Suppose we want to increase the number of instances of the php service, we can run the following command:

$ docker-compose up -d --scale php=3

The above command will start 3 php instances to achieve horizontal expansion of our application cluster.

Conclusion:
By using Docker Compose, Nginx and MariaDB, we can easily build a scalable PHP application cluster. In this article, we provide a basic example to get you started, as well as detailed code examples. I hope this article was helpful and inspired you to build a more powerful application cluster.

The above is the detailed content of Build scalable PHP application clusters using Docker Compose, Nginx and MariaDB. For more information, please follow other related articles on the PHP Chinese website!