Implementierung der Graustufenveröffentlichung von PHP-Anwendungen mit Docker Compose, Nginx und MariaDB

Verwendung von Docker Compose, Nginx und MariaDB zur Implementierung der Grayscale-Release von PHP-Anwendungen

Grayscale-Release ist eine Software-Release-Strategie, die die Risiken der Veröffentlichung durch die schrittweise Einführung neuer Versionen in der Produktionsumgebung verringert. In praktischen Anwendungen können wir Docker Compose zum Verwalten von Containeranwendungen verwenden und Nginx-Lastausgleich und MariaDB kombinieren, um eine Graustufenveröffentlichung zu erreichen.

Docker Compose ist ein Tool zum Definieren und Ausführen von Docker-Anwendungen mit mehreren Containern. Es ermöglicht uns, YAML-Dateien zu verwenden, um die Komponenten der Anwendung, die Netzwerkkonfiguration und die Beziehungen zwischen den verschiedenen Komponenten zu definieren.

Zuerst müssen wir eine Docker Compose-Konfigurationsdatei docker-compose.yml erstellen. In dieser Datei müssen wir drei Dienste für Nginx, PHP und MariaDB definieren.

Das Folgende ist eine Beispieldatei für docker-compose.yml, die zum Implementieren der Graustufenveröffentlichung einer einfachen PHP-Anwendung verwendet wird:

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:

In dieser Konfigurationsdatei definieren wir zwei Webdienste (web und web_new), die zwei verschiedenen Versionen von PHP entsprechen Anwendungen. Wir unterscheiden sie durch die Definition verschiedener Ports und stellen sie sowohl in Backend- als auch Frontend-Netzwerken bereit.

Wir haben außerdem einen Nginx-Dienst definiert, Nginx als Load Balancer verwendet und ihn dem Port 8000 des Hosts zugeordnet. Wir müssen die Datei nginx.conf dem Speicherort /etc/nginx/nginx.conf im Container zuordnen, um die Lastausgleichsregeln von Nginx zu konfigurieren.

Schließlich definieren wir einen MariaDB-Dienst (db), um die Daten der Anwendung zu speichern. Wir konfigurieren das Passwort und die Standarddatenbank des Root-Benutzers, indem wir Umgebungsvariablen festlegen.

Als nächstes müssen wir eine nginx.conf-Datei erstellen, um die Lastausgleichsregeln von Nginx zu konfigurieren. Diese Datei sollte sich im selben Verzeichnis wie die Datei docker-compose.yml befinden. Hier ist ein Beispiel für eine nginx.conf-Datei:

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;
        }
    }
}

In dieser Konfigurationsdatei definieren wir zunächst einen Upstream-Block namens app und geben die beiden Backend-Server (web und web_new) an. In diesem Beispiel verwenden wir web_new als Backup-Server.

Dann definieren wir einen Serverblock, der Port 80 abhört und alle Anfragen über die Proxy_pass-Direktive an den App-Upstream-Block weiterleitet. Auf diese Weise verteilt Nginx Anforderungen gemäß der Lastausgleichsrichtlinie an verschiedene Backend-Server.

Jetzt können wir den Befehl docker-compose up ausführen, um unsere Anwendung zu starten. Dadurch wird der entsprechende Container basierend auf der Datei docker-compose.yml erstellt und gestartet.

Sobald der Container erfolgreich gestartet ist, können wir über http://localhost:8000 auf unsere PHP-Anwendung zugreifen. Nginx verteilt Anfragen basierend auf Lastausgleichsregeln an verschiedene Backend-Server.

Während des Grayscale-Release-Prozesses können wir den Datenverkehr nach und nach auf die neue Version der PHP-Anwendung leiten. Wir können dies erreichen, indem wir die Upstream-Regeln in der Datei nginx.conf schrittweise ändern. Beispielsweise können wir die Gewichtung des web_new-Servers schrittweise erhöhen, bis schließlich der gesamte Datenverkehr auf die neue Version umgeleitet wird.

Durch die Verwendung von Docker Compose, Nginx und MariaDB können wir die Graustufenveröffentlichung von PHP-Anwendungen problemlos implementieren. Dieser Ansatz hilft uns, das mit Releases verbundene Risiko zu reduzieren und die Leistung und Stabilität neuer Anwendungsversionen in einer Produktionsumgebung effektiv zu testen.

Bitte beachten Sie, dass dies nur ein Beispiel ist und die tatsächliche Konfiguration je nach spezifischen Anwendungen und Anforderungen variieren kann. In tatsächlichen Anwendungen müssen wir möglicherweise komplexere Lastausgleichsstrategien verwenden, mehr Umgebungsvariablen konfigurieren, mehr Netzwerkkonfigurationen verwalten usw.

Das obige ist der detaillierte Inhalt vonImplementierung der Graustufenveröffentlichung von PHP-Anwendungen mit Docker Compose, Nginx und MariaDB. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!