Implémentation de la publication en niveaux de gris d'applications PHP à l'aide de Docker Compose, Nginx et MariaDB

Utilisation de Docker Compose, Nginx et MariaDB pour implémenter la version en niveaux de gris des applications PHP

La version en niveaux de gris est une stratégie de publication de logiciels qui atténue les risques de publication en introduisant progressivement de nouvelles versions dans l'environnement de production. Dans les applications pratiques, nous pouvons utiliser Docker Compose pour gérer des applications conteneurisées et combiner l'équilibrage de charge Nginx et MariaDB pour réaliser une publication en niveaux de gris.

Docker Compose est un outil permettant de définir et d'exécuter des applications Docker multi-conteneurs. Il nous permet d'utiliser des fichiers YAML pour définir les composants de l'application, la configuration réseau et les relations entre les différents composants.

Tout d'abord, nous devons créer un fichier de configuration Docker Compose docker-compose.yml. Dans ce fichier, nous devons définir trois services pour Nginx, PHP et MariaDB.

Ce qui suit est un exemple de fichier docker-compose.yml utilisé pour implémenter la publication en niveaux de gris d'une simple application PHP :

version: '3.8'
services:
  web:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - 80
    networks:
      - backend
      - frontend
  web_new:
    build:
      context: .
      dockerfile: Dockerfile-new
    ports:
      - 8080
    networks:
      - backend
      - frontend
  nginx:
    image: nginx:latest
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
    ports:
      - 8000:80
    networks:
      - frontend
  db:
    image: mariadb:latest
    environment:
      - MYSQL_ROOT_PASSWORD=password
      - MYSQL_DATABASE=mydatabase
    networks:
      - backend

networks:
  backend:
  frontend:

Dans ce fichier de configuration, nous définissons deux services web (web et web_new), correspondant à deux versions différentes de PHP candidatures. Nous les distinguons en définissant différents ports et les déployons dans les réseaux backend et frontend.

Nous avons également défini un service nginx, utilisé Nginx comme équilibreur de charge et l'avons mappé sur le port 8000 de l'hôte. Nous devons mapper le fichier nginx.conf à l'emplacement /etc/nginx/nginx.conf dans le conteneur pour configurer les règles d'équilibrage de charge de Nginx.

Enfin, nous définissons un service MariaDB (db) pour stocker les données de l'application. Nous configurons le mot de passe de l'utilisateur root et la base de données par défaut en définissant des variables d'environnement.

Ensuite, nous devons créer un fichier nginx.conf pour configurer les règles d'équilibrage de charge de Nginx. Ce fichier doit se trouver dans le même répertoire que le fichier docker-compose.yml. Voici un exemple de fichier nginx.conf :

worker_processes auto;
events {
    worker_connections 1024;
}

http {
    upstream app {
        zone blue 64k;
        server web:80;
        server web_new:8080 backup;
    }
    
    server {
        listen 80;
        
        location / {
            proxy_pass http://app;
        }
    }
}

Dans ce fichier de configuration, nous définissons d'abord un bloc en amont appelé app, spécifiant les deux serveurs backend (web et web_new). Dans cet exemple, nous utilisons web_new comme serveur de sauvegarde.

Ensuite, nous définissons un bloc serveur qui écoute sur le port 80 et transmet toutes les requêtes au bloc amont de l'application via la directive proxy_pass. De cette manière, Nginx distribuera les requêtes aux différents serveurs backend selon la politique d'équilibrage de charge.

Maintenant, nous pouvons exécuter la commande docker-compose up pour démarrer notre application. Cela créera et démarrera le conteneur correspondant basé sur le fichier docker-compose.yml.

Une fois le conteneur démarré avec succès, nous pouvons accéder à notre application PHP en visitant http://localhost:8000. Nginx distribuera les requêtes à différents serveurs backend en fonction de règles d'équilibrage de charge.

Pendant le processus de publication en niveaux de gris, nous pouvons progressivement diriger le trafic vers la nouvelle version de l'application PHP. Nous pouvons y parvenir en modifiant progressivement les règles en amont dans le fichier nginx.conf. Par exemple, nous pouvons augmenter progressivement le poids du serveur web_new jusqu'à ce que finalement tout le trafic soit dirigé vers la nouvelle version.

En utilisant Docker Compose, Nginx et MariaDB, nous pouvons facilement implémenter la publication en niveaux de gris d'applications PHP. Cette approche nous aide à réduire les risques associés aux versions et à tester efficacement les performances et la stabilité des nouvelles versions des applications dans un environnement de production.

Veuillez noter qu'il ne s'agit que d'un exemple et que la configuration réelle peut varier en fonction des applications et des besoins spécifiques. Dans les applications réelles, nous devrons peut-être utiliser des stratégies d'équilibrage de charge plus complexes, configurer davantage de variables d'environnement, gérer davantage de configurations réseau, etc.

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!