Build resilient PHP application architecture using Docker Compose, Nginx and MariaDB

Build elastic PHP application architecture using Docker Compose, Nginx and MariaDB

With the development of cloud computing and containerization technology, building elastic application architecture has changed. becomes more important. In this article, we will introduce how to use Docker Compose, Nginx and MariaDB to build a resilient PHP application architecture, and provide specific code examples.

1. Install Docker and Docker Compose
   First, we need to install Docker and Docker Compose on the local machine. Docker is a lightweight containerization platform that helps us build and manage containers, and Docker Compose is a tool that allows us to define and run multiple Docker containers through a single configuration file. Please refer to the official documentation for installation and configuration according to your operating system type.
2. Create a Docker Compose file
   Next, we need to create a Docker Compose configuration file to define our application architecture. Create a file named docker-compose.yml in the root directory of the project and add the following content:

version: '3'
services:
  web:
    image: nginx:latest
    restart: always
    ports:
      - 80:80
      - 443:443
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
    depends_on:
      - php
  php:
    image: php:latest
    restart: always
    volumes:
      - ./code:/var/www/html
  db:
    image: mariadb:latest
    restart: always
    environment:
      - MYSQL_ROOT_PASSWORD=root
      - MYSQL_DATABASE=app
      - MYSQL_USER=appuser
      - MYSQL_PASSWORD=apppassword

The above configuration file defines three services: web, php and db. The web service uses the latest Nginx image to map ports 80 and 443 to the host. The web service also customizes the Nginx configuration by mounting the local nginx.conf file into the container. The php service uses the latest PHP image and shares code by mounting the local code directory into the container. The db service uses the latest MariaDB image, and the passwords for the root user and app database are set.

3. Create Nginx configuration file
   In order for Nginx to work properly, we need to create an Nginx configuration file and mount it into the web container. Create a file named nginx.conf in the root directory of the project and add the following content:

worker_processes auto;
pid /run/nginx.pid;

events {
    worker_connections 1024;
}

http {
    include /etc/nginx/mime.types;
    default_type application/octet-stream;

    server {
        listen 80;

        location / {
            proxy_pass http://php:80;
            proxy_set_header Host $host;
        }
    }
}

The above configuration file specifies the number of Nginx worker processes, as well as the port and proxy rules for Nginx listening . In this example, Nginx proxies all requests to port 80 in the PHP container.

4. Write PHP application
   Write the code for the PHP application in the code directory. We will not show the specific PHP code here. You can write PHP applications according to your own needs. The important thing is to place these codes in the code directory to share them with the PHP container.
5. Start the container
   Open the terminal in the root directory of the project and run the following command to start the container:

docker-compose up -d

This command will be based on the configuration in the docker-compose.yml file Start and manage all containers. Adding the -d parameter will cause the container to run in the background.

6. Accessing the Application
   You can now access your PHP application via your browser by visiting http://localhost. Nginx will proxy the request to the PHP application running in the php container and return the results to the browser.
7. Extending Containers
   If your application needs to scale, it's very easy to do so in Docker Compose. You can handle more requests by increasing the number of php containers. Just modify the php service in the docker-compose.yml file and increase the number of copies as follows:

  php:
    image: php:latest
    restart: always
    volumes:
      - ./code:/var/www/html
    scale: 3

The above configuration will create 3 php containers, each container has the same Code and configuration. In this way, when more requests come, Docker Compose will automatically distribute the requests to different php containers, thus achieving scaling.

Summary
This article introduces how to use Docker Compose, Nginx and MariaDB to build a resilient PHP application architecture. By using Docker Compose, we can easily define and run multiple Docker containers, implement request proxying and load balancing through Nginx, and store application data through MariaDB. We also demonstrated how to scale the application by increasing the number of PHP containers. I hope this article was helpful and if you have any questions, please feel free to ask.

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