The gold standard with Docker Compose, Nginx, and MariaDB: Building scalable clusters of PHP applications

The gold standard of Docker Compose, Nginx and MariaDB: Building scalable PHP application clusters

Introduction
With the continuous development of Internet applications, more and more The more websites and services need to handle large amounts of concurrent requests and data, how to build scalable application clusters has become a hot topic. In this article, we'll cover how to use Docker Compose, Nginx, and MariaDB to build a scalable cluster of PHP applications. We will use specific code examples to show how to configure and manage this cluster, and how to achieve dynamic expansion and load balancing of resources.

1. Configuration of Docker Compose
Docker Compose is a tool for defining and running multiple Docker containers. It can manage dependencies and network connections between containers through a configuration file. In our application cluster, we will use Docker Compose to define and manage three containers: Nginx, PHP application, and MariaDB.

First, we need to create a docker-compose.yml file and define our container service.

version: '3'

services:
  nginx:
    image: nginx
    ports:
      - 80:80
    depends_on:
      - php

  php:
    build:
      context: .
      dockerfile: Dockerfile.php
    volumes:
      - ./php:/var/www/html

  db:
    image: mariadb
    environment:
      MYSQL_ROOT_PASSWORD: example

In this configuration file, we define three services: Nginx, PHP and MariaDB. The Nginx container uses the official Nginx image and maps the container's port 80 to the host's port 80. The PHP container is built using our own Dockerfile and mounts the host's ./php directory to the container's /var/www/html directory. The MariaDB container uses the official MariaDB image and has a root password set.

2. Nginx configuration
Nginx is a high-performance web server and reverse proxy server. It can be used to directly provide static resources, and can also be used to reverse proxy to back-end PHP applications. . In our cluster, Nginx will play the role of forwarding requests to the backend PHP container.

We need to configure a virtual host in the Nginx container to forward requests to the container of the PHP application. In the Nginx configuration file, we can use the upstream directive to define the address of the back-end PHP container, and use the proxy_pass directive to forward the request to this address.

We can add the following configuration to the nginx.conf file:

http {
    upstream php {
        server php:9000;
    }

    server {
        listen 80;

        location / {
            proxy_pass http://php;
        }
    }
}

In this configuration, we define a using upstream php A backend address named php and forward the request to port 9000 on that address. Then, in a server block, we set up Nginx to listen on port 80 and forward all requests to the back-end PHP container through the proxy_pass directive.

3. Configuration of PHP application
In the container of the PHP application, we need to configure the PHP interpreter and application code. We can build this container through a custom Dockerfile and install the necessary dependencies and extensions during the build process.

The following is the content of an example Dockerfile.php file:

FROM php:7.4-fpm

WORKDIR /var/www/html

COPY . .

RUN apt-get update && apt-get install -y 
    libpq-dev 
    && docker-php-ext-install pdo_mysql pdo_pgsql

In this Dockerfile, we use the official PHP 7.4-fpm image as the basis and set the working directory to /var/www/html and then copy the host's application code into the container. Finally, we installed some PHP extensions using the apt-get command.

4. Cluster deployment and management
After completing the above configuration, we can use Docker Compose to start the entire cluster and achieve dynamic expansion and load balancing of resources.

In the command line, we can use the following command to start the cluster:

docker-compose up -d

This command will start all the containers and put them in a separate network so that they can communicate with each other. Nginx will listen on port 80 of the host machine and forward the request to the PHP container on the backend.

If we wish to expand our application cluster, we can use the following command to start more PHP containers:

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

This command will start 3 PHP containers, thereby expanding our Application cluster. Nginx will automatically implement load balancing based on the number of backend containers.

If we need to stop the cluster, we can use the following command:

docker-compose down

This command will stop and delete all containers and networks.

Conclusion
This article introduces how to use Docker Compose, Nginx and MariaDB to build a scalable PHP application cluster, and demonstrates the configuration and management methods through specific code examples. By using Docker Compose, we can easily launch, manage and scale our application clusters. At the same time, with the reverse proxy function of Nginx, we can achieve load balancing of requests, thereby improving application performance and availability.

The above is the detailed content of The gold standard with Docker Compose, Nginx, and MariaDB: Building scalable clusters of PHP applications. For more information, please follow other related articles on the PHP Chinese website!