Implementing a backup and recovery strategy for PHP applications using Docker Compose, Nginx, and MariaDB

Implementing backup and recovery strategies for PHP applications using Docker Compose, Nginx and MariaDB

Introduction:
In modern software development, backup and recovery strategies It's a crucial part. When designing a backup and recovery strategy for PHP applications, we can use a combination of Docker Compose, Nginx, and MariaDB to achieve a reliable and flexible solution. This article will provide detailed steps and code examples to help readers get started quickly.

1. Create a Docker Compose file

1. First, we need to create a file named docker-compose.yml and define our service in it . The following is the basic structure of a sample file:

version: '3'
services:
  app:
    build:
      context: ./app
      dockerfile: Dockerfile
    volumes:
      - ./app:/var/www/html
    depends_on:
      - db
    restart: always

  db:
    image: mariadb
    ports:
      - 3306:3306
    restart: always

  web:
    image: nginx
    ports:
      - 80:80
    volumes:
      - ./nginx:/etc/nginx/conf.d
    depends_on:
      - app
    restart: always

2. In the above example, we have three services defined: app, db and web. Among them, the app service is the container of the PHP application, the db service is the container of the MariaDB database, and the web service is the container of the Nginx server.
3. We also use the volumes attribute to mount the data volume. In the example, we mount the ./app directory to the /var/www/html directory of the app service to persistently store application data. .

2. Nginx backup strategy

1. In the docker-compose.yml file, we define a file named web Nginx service. In order to implement the backup strategy, we will use Nginx’s ngx_http_upstream_module module to configure load balancing and reverse proxy. The following is a basic Nginx configuration example:

http {
  upstream backend {
    server app:80;
  }

  server {
    listen 80;
    server_name localhost;

    location / {
      proxy_pass http://backend;
      proxy_set_header Host $host;
      proxy_set_header X-Real-IP $remote_addr;
    }
  }
}

2. In the above example, we used the upstream directive to define a file named backend's backend service, and takes the address and port of the app service as its parameters. Next, we use the proxy_pass directive in the server block to set up a reverse proxy and forward the request to the backend service.
3. After the configuration is completed, we can use the docker-compose up command to start all services. At this time, Nginx will listen on port 80 of the host and forward the request to the app service.

3. MariaDB backup and recovery strategy

1. In the docker-compose.yml file, we define a file named MariaDB service of db. In order to implement the backup and recovery strategy, we will use MariaDB's mysqldump tool to implement database backup and recovery. The following is a basic backup script example:

#!/bin/bash

backup_path="/path/to/backup"
date=$(date +%Y%m%d%H%M%S)
db_container=$(docker ps --filter "name=db" --format "{{.ID}}")

docker exec -it $db_container mysqldump -u root -p<password> --all-databases > $backup_path/db_backup_$date.sql

2. In the above example, we used the mysqldump command to export the backup of the database and save it to the specified under the backup path. We also used the date command to generate a timestamp so that each backup has a unique filename. Finally, we execute the backup command in the db container through the docker exec command.
3. To restore the database, we can use the following command:

docker exec -i $db_container mysql -u root -p<password> < $backup_path/db_backup_$date.sql

4. In the above command, we used the mysql command to execute the backup file to restore the database. Through the symbol, we import the contents of the backup file into the <code>mysql command.

Conclusion:
This article introduces how to use Docker Compose, Nginx and MariaDB to implement a backup and recovery strategy for PHP applications. We demonstrate Nginx's load balancing and reverse proxy configuration and MariaDB's backup and recovery scripts with sample code. Through these steps, readers should be able to get started quickly and apply it to their own PHP applications in actual projects. Hope this article can be helpful to readers.

The above is the detailed content of Implementing a backup and recovery strategy for PHP applications using Docker Compose, Nginx, and MariaDB. For more information, please follow other related articles on the PHP Chinese website!