Melaksanakan penerbitan skala kelabu aplikasi PHP menggunakan Docker Compose, Nginx dan MariaDB

Menggunakan Docker Compose, Nginx dan MariaDB untuk melaksanakan keluaran skala kelabu aplikasi PHP

Keluaran skala kelabu ialah strategi keluaran perisian dengan keluaran dengan memperkenalkan versi baharu secara beransur-ansur ke dalam pengeluaran. Dalam aplikasi praktikal, kami boleh menggunakan Docker Compose untuk mengurus aplikasi kontena, dan menggabungkan pengimbangan beban Nginx dan MariaDB untuk mencapai penerbitan skala kelabu.

Docker Compose ialah alat untuk mentakrif dan menjalankan aplikasi Docker berbilang bekas. Ia membolehkan kami menggunakan fail YAML untuk mentakrifkan komponen aplikasi, konfigurasi rangkaian dan perhubungan antara pelbagai komponen.

Pertama, kita perlu mencipta fail konfigurasi Docker Compose docker-compose.yml. Dalam fail ini, kita perlu menentukan tiga perkhidmatan untuk Nginx, PHP dan MariaDB.

Berikut ialah contoh fail docker-compose.yml untuk melaksanakan penerbitan skala kelabu bagi aplikasi PHP mudah:

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:

Dalam fail konfigurasi ini, kami Dua perkhidmatan web (web dan web_new) ditakrifkan, sepadan dengan dua versi aplikasi PHP yang berbeza. Kami membezakannya dengan mentakrifkan port yang berbeza dan menggunakan mereka dalam kedua-dua rangkaian hujung belakang dan hadapan.

Kami juga mentakrifkan perkhidmatan nginx, menggunakan Nginx sebagai pengimbang beban dan memetakannya ke port 8000 hos. Kita perlu memetakan fail nginx.conf ke lokasi /etc/nginx/nginx.conf dalam bekas untuk mengkonfigurasi peraturan pengimbangan beban Nginx.

Akhir sekali, kami mentakrifkan perkhidmatan MariaDB (db) untuk menyimpan data aplikasi. Kami mengkonfigurasi kata laluan pengguna root dan pangkalan data lalai dengan menetapkan pembolehubah persekitaran.

Seterusnya, kita perlu mencipta fail nginx.conf untuk mengkonfigurasi peraturan pengimbangan beban Nginx. Fail ini hendaklah berada dalam direktori yang sama dengan fail docker-compose.yml. Berikut ialah contoh fail 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;
        }
    }
}

Dalam fail konfigurasi ini, kami mula-mula mentakrifkan blok huluan bernama apl, menyatakan dua pelayan hujung belakang (web dan web_new). Dalam contoh ini, kami menggunakan web_new sebagai pelayan sandaran.

Kemudian, kami mentakrifkan blok pelayan yang mendengar pada port 80 dan memajukan semua permintaan ke blok huluan apl melalui arahan proxy_pass. Dengan cara ini, Nginx akan mengedarkan permintaan kepada pelayan bahagian belakang yang berbeza mengikut dasar pengimbangan beban.

Kini, kita boleh melaksanakan arahan docker-compose up untuk memulakan aplikasi kita. Ini akan membuat dan memulakan bekas yang sepadan berdasarkan fail docker-compose.yml.

Setelah bekas berjaya dimulakan, kami boleh mengakses aplikasi PHP kami dengan melawati http://localhost:8000. Nginx akan mengedarkan permintaan kepada pelayan bahagian belakang yang berbeza mengikut peraturan pengimbangan beban.

Semasa proses keluaran skala kelabu, kami boleh secara beransur-ansur mengarahkan trafik ke versi baharu aplikasi PHP. Kita boleh mencapai ini dengan mengubah suai peraturan huluan secara beransur-ansur dalam fail nginx.conf. Sebagai contoh, kami boleh meningkatkan berat pelayan web_new secara beransur-ansur sehingga akhirnya semua trafik diarahkan ke versi baharu.

Dengan menggunakan Docker Compose, Nginx dan MariaDB, kami boleh melaksanakan penerbitan skala kelabu aplikasi PHP dengan mudah. Pendekatan ini membantu kami mengurangkan risiko yang berkaitan dengan keluaran dan menguji prestasi dan kestabilan versi baharu aplikasi dalam persekitaran pengeluaran dengan berkesan.

Perlu diingatkan bahawa ini hanyalah satu contoh dan konfigurasi sebenar mungkin berbeza-beza berdasarkan aplikasi dan keperluan tertentu. Dalam aplikasi sebenar, kita mungkin perlu menggunakan strategi pengimbangan beban yang lebih kompleks, mengkonfigurasi lebih banyak pembolehubah persekitaran, mengendalikan lebih banyak konfigurasi rangkaian, dsb.

Atas ialah kandungan terperinci Melaksanakan penerbitan skala kelabu aplikasi PHP menggunakan Docker Compose, Nginx dan MariaDB. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!