Meilleures pratiques pour Docker Compose, Nginx et MariaDB : conception architecturale d'applications PHP hautement disponibles

Meilleures pratiques pour Docker Compose, Nginx et MariaDB : conception d'architecture d'application PHP hautement disponible

Introduction :
À l'ère Internet d'aujourd'hui, la création d'applications hautement disponibles est devenue de plus en plus importante. À mesure que le nombre d’utilisateurs Internet augmente, les performances, la fiabilité et l’évolutivité des applications deviennent des considérations clés. Cet article expliquera comment utiliser Docker Compose, Nginx et MariaDB pour concevoir une architecture d'application PHP hautement disponible et fournira des exemples de code spécifiques.

Première partie : Présentation de l'architecture
Nous souhaitons créer une application PHP hautement disponible qui doit répondre aux exigences suivantes :

1. Haute fiabilité : une application qui peut fournir une haute disponibilité lorsque le serveur tombe en panne ou que le réseau est anormal. passer automatiquement au serveur de sauvegarde.
2. Évolutivité : Capable d'adapter dynamiquement la capacité de l'application en fonction de la demande pour faire face à un accès simultané soudain et élevé.
3. Optimisation des performances : améliorez les performances et la réactivité des applications en utilisant Nginx comme serveur proxy inverse et équilibreur de charge.
4. Fiabilité de la base de données : utilisez MariaDB comme base de données de votre application et assurez la fiabilité et la cohérence des données.

Partie 2 : Créer une image Docker
Avant de créer une application PHP hautement disponible, nous devons d'abord empaqueter l'application et toutes les dépendances dans une image Docker. Vous pouvez utiliser un Dockerfile pour définir le processus de création d'une image Docker.

Voici un exemple de fichier Docker :

# 使用基础PHP镜像
FROM php:7.4-fpm

# 安装PHP依赖项
RUN apt-get update && apt-get install -y 
    git 
    zip 
    curl 
    libpng-dev 
    libonig-dev 
    libxml2-dev 
    && docker-php-ext-install pdo_mysql mbstring exif pcntl bcmath gd

# 设置工作目录
WORKDIR /var/www/html

# 将应用程序复制到工作目录
COPY . .

# 安装依赖项
RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer
RUN composer install --no-scripts --no-autoloader

# 自动生成Autoload文件
RUN composer dump-autoload --optimize

# 修改文件权限
RUN chown -R www-data:www-data /var/www/html/storage

# 启动PHP-FPM服务器
CMD ["php-fpm"]

# 暴露端口
EXPOSE 9000

En utilisant le fichier Docker ci-dessus, nous pouvons créer une image Docker qui contient l'application et toutes les dépendances. L'image peut être construite à l'aide de la commande suivante :

docker build -t myapp .

Troisième partie : Construire l'architecture à l'aide de Docker Compose
Ensuite, nous utiliserons Docker Compose pour définir et gérer l'ensemble de l'architecture de l'application PHP hautement disponible. Docker Compose est un outil permettant de définir et d'exécuter des applications Docker multi-conteneurs.

Ce qui suit est un exemple de fichier docker-compose.yaml :

version: '3'
services:
  app:
    build: 
      context: .
      dockerfile: Dockerfile
    volumes:
      - .:/var/www/html
    ports:
      - 9000
    networks:
      - my-network
  nginx:
    image: nginx
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
      - ./site.conf:/etc/nginx/conf.d/default.conf
    ports:
      - 80:80
    depends_on:
      - app
    networks:
      - my-network
  db:
    image: mariadb
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: 'password'
    networks:
      - my-network

networks:
  my-network:

Dans le fichier docker-compose.yaml de l'exemple ci-dessus, nous définissons trois services : app, nginx et db. Parmi eux, le service d'application est l'image d'application PHP que nous avons créée auparavant. Le service nginx utilise l'image officielle de Nginx. Le service db est l'image officielle de MariaDB.

Nous définissons également un réseau appelé my-network pour connecter ces trois services.

Partie 4 : Configurer Nginx comme serveur proxy inverse et équilibreur de charge
Afin d'améliorer les performances et la vitesse de réponse de l'application, nous utiliserons Nginx comme serveur proxy inverse et équilibreur de charge.

Ce qui suit est un exemple de fichier nginx.conf :

user www-data;
worker_processes auto;
error_log /var/log/nginx/error.log;
pid /var/run/nginx.pid;

events {
    worker_connections 1024;
    multi_accept on;
}

http {
    sendfile on;
    tcp_nopush on;
    tcp_nodelay on;
    keepalive_timeout 65;
    types_hash_max_size 2048;
    
    include /etc/nginx/mime.types;
    default_type application/octet-stream;

    access_log /var/log/nginx/access.log combined;

    gzip on;
    gzip_disable "msie6";

    gzip_vary on;
    gzip_proxied any;
    gzip_comp_level 6;
    gzip_buffers 16 8k;
    gzip_http_version 1.1;
    gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/xml+rss text/javascript;

    include /etc/nginx/conf.d/*.conf;
}

Dans l'exemple ci-dessus, nous avons spécifié la configuration de Nginx. Ensuite, nous devons définir une configuration de site pour Nginx.

Ce qui suit est un exemple de fichier site.conf :

server {
    listen 80;
    server_name myapp.example.com;

    location / {
        proxy_pass http://app:9000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

        client_max_body_size 100M;

        proxy_buffering off;
        proxy_request_buffering off;
    }
}

Dans l'exemple ci-dessus, nous avons défini un hôte virtuel Nginx pour proxy toutes les requêtes HTTP vers le port 9000 du service d'application.

Partie 5 : Exécution de l'architecture
Utilisez la commande suivante pour démarrer l'architecture d'application PHP hautement disponible que nous avons définie :

docker-compose up -d

Maintenant, notre application PHP hautement disponible a été exécutée avec succès. La convivialité et les performances de l'application peuvent être testées en visitant http://myapp.example.com.

Conclusion :
En utilisant Docker Compose, Nginx et MariaDB, nous pouvons concevoir et construire une architecture d'application PHP hautement disponible. Docker Compose peut nous aider à définir et gérer des applications multi-conteneurs, Nginx peut fournir des fonctions de proxy inverse et d'équilibrage de charge hautes performances, et MariaDB peut fournir des services de base de données fiables et stables. Grâce à cette architecture, nous pouvons améliorer la disponibilité, la fiabilité et les performances des applications et répondre aux besoins des utilisateurs en applications de haute qualité.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!