Data backup and restoration of PHP applications through Docker Compose, Nginx and MariaDB

With the rapid development of cloud computing and containerization technology, more and more of applications choose to use Docker to deploy and run. In the Docker ecosystem, Docker Compose is a very popular tool that can define and manage multiple containers through a single configuration file.

This article will introduce how to use Docker Compose, Nginx and MariaDB to implement data backup and restoration of PHP applications. We'll use a sample project to demonstrate this process.

The sample project structure is as follows:

.
├── docker-compose.yml
├── nginx
│   └── default.conf
├── mariadb
│   ├── Dockerfile
│   └── init.sql
└── php
    ├── Dockerfile
    └── index.php

First, we need to create a docker-compose.yml file to define the container configuration of the entire project. The sample configuration is as follows:

version: '3'
services:
  nginx:
    image: nginx:latest
    ports:
      - 80:80
    volumes:
      - ./nginx:/etc/nginx/conf.d
      - ./php:/var/www/html
    depends_on:
      - php
  mariadb:
    build:
      context: ./mariadb
    environment:
      - MYSQL_ROOT_PASSWORD=123456
      - MYSQL_DATABASE=mydb
    volumes:
      - ./mariadb/data:/var/lib/mysql
    ports:
      - 3306:3306
  php:
    build:
      context: ./php
    volumes:
      - ./php:/var/www/html

In the above configuration, we defined three services: Nginx, MariaDB and PHP. The Nginx service is responsible for processing HTTP requests and forwarding the requests to the application on the PHP container; the MariaDB service provides database services; the PHP container runs the PHP application.

Next, we need to create an Nginx configuration file default.conf for forwarding HTTP requests to the application on the PHP container. The sample configuration is as follows:

server {
    listen 80;
    server_name localhost;
    root /var/www/html;
    
    location / {
        try_files $uri $uri/ /index.php?$query_string;
    }
    
    location ~ .php$ {
        try_files $uri =404;
        fastcgi_pass php:9000;
        fastcgi_index index.php;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        include fastcgi_params;
    }
}

In the above configuration, we defined two location blocks. The first location block is used to handle static file requests, such as images, CSS, and JavaScript files; the second location block is used to forward PHP script requests to the FastCGI process on the PHP container.

Then, we need to create a MariaDB container Dockerfile and initialization script init.sql. The sample Dockerfile is as follows:

FROM mariadb:latest

COPY init.sql /docker-entrypoint-initdb.d

Sampleinit.sql The script is used to create a mydb database and a users table:

CREATE DATABASE IF NOT EXISTS mydb;
USE mydb;

CREATE TABLE IF NOT EXISTS users (
    id INT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(100) NOT NULL
);

Finally, we need to create a Dockerfile for the PHP container and a sample PHP application index.php. The sample Dockerfile is as follows:

FROM php:7.4-fpm

RUN apt-get update && 
    apt-get install -y 
    zlib1g-dev 
    libzip-dev

RUN docker-php-ext-install zip pdo_mysql

COPY index.php /var/www/html

Sampleindex.phpThe application is used to demonstrate the process of data backup and restoration:

<?php

$dbHost = 'mariadb';
$dbUser = 'root';
$dbPass = '123456';
$dbName = 'mydb';

try {
    $pdo = new PDO("mysql:host=$dbHost;dbname=$dbName", $dbUser, $dbPass, [
        PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
        PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC
    ]);

    // 插入數(shù)據(jù)
    $pdo->exec("INSERT INTO users (name, email) VALUES ('John Doe', 'john@example.com')");

    // 查詢(xún)數(shù)據(jù)
    $stmt = $pdo->query("SELECT * FROM users");
    $users = $stmt->fetchAll();

    // 打印數(shù)據(jù)
    foreach ($users as $user) {
        echo $user['name'] . ' (' . $user['email'] . ')' . PHP_EOL;
    }

} catch (PDOException $e) {
    echo "Error: " . $e->getMessage();
}

Now, we can run docker- compose up command to start the entire project. Visit http://localhost in the browser, and you should be able to see the inserted data and printed results.

In order to achieve data backup, we can add a Shell script to perform database backup operations regularly. The sample script is as follows:

#!/bin/bash

BACKUP_DIR="/path/to/backup"
DATE=$(date +%Y%m%d%H%M%S)
BACKUP_FILE="$BACKUP_DIR/mydb_$DATE.sql"

docker exec -i CONTAINER_NAME mysqldump -uroot -p123456 mydb > $BACKUP_FILE

if [ $? -eq 0 ]; then
    echo "Backup completed: $BACKUP_FILE"
else
    echo "Backup failed"
fi

The above script first defines the backup directory and backup file name. It then uses the docker exec command to execute the mysqldump command to export the database and saves the exported data to a backup file.

In order to achieve data restoration, we can create a Shell script to perform database restore operations. The sample script is as follows:

#!/bin/bash

BACKUP_FILE="/path/to/backup/mydb_20210101120000.sql"

docker exec -i CONTAINER_NAME mysql -uroot -p123456 mydb < $BACKUP_FILE

if [ $? -eq 0 ]; then
    echo "Restore completed"
else
    echo "Restore failed"
fi

The above script will use the docker exec command to import the data in the backup file into the database.

Through the above steps, we successfully implemented data backup and restoration of PHP applications using Docker Compose, Nginx and MariaDB. By executing the backup script regularly, we can create a snapshot of the database so that we can restore it when needed. This provides our application with higher availability and fault tolerance.

The above is the detailed content of Data backup and restoration of PHP applications through Docker Compose, Nginx and MariaDB. For more information, please follow other related articles on the PHP Chinese website!