Cara Menggunakan Kubernet untuk Memelihara Persekitaran PHP Pengeluaran Konsisten dan Piawaian Konfigurasi Bekas Tempatan

Untuk menyelesaikan masalah ketidakkonsistenan antara persekitaran dan pengeluaran PHP, terasnya adalah menggunakan keupayaan kontena dan orkestra Kubernetes untuk mencapai penyatuan alam sekitar. Langkah -langkah khusus adalah seperti berikut: 1. Membina imej Docker bersatu, termasuk semua versi PHP, sambungan, kebergantungan dan konfigurasi pelayan web untuk memastikan imej yang sama digunakan dalam pembangunan dan pengeluaran; 2. Gunakan konfigurasi dan rahsia Kubernetes untuk menguruskan konfigurasi yang tidak sensitif dan sensitif, dan melaksanakan konfigurasi persekitaran yang berbeza melalui gunung volum atau suntikan pembolehubah persekitaran untuk mencapai konfigurasi persekitaran yang berbeza; 2. 4. Mewujudkan saluran paip CI/CD untuk mencapai automasi proses penuh dari pembinaan, ujian untuk penempatan, dan mengurangkan risiko campur tangan manusia dan hanyutan alam sekitar; 5. Gunakan konfigurasi dan alat yang selaras dengan pengeluaran dalam persekitaran Kubernet tempatan, menggabungkan kod volum kod, pemetaan pelabuhan dan strategi debugging untuk meningkatkan kecekapan pembangunan dan mengesahkan keserasian pengeluaran terlebih dahulu.

Kita semua mengalami mimpi ngeri seperti "boleh lari di mesin saya", bukan? Terutama untuk PHP, versi, sambungan, dan konfigurasi INI, mereka akan sangat berbeza jika anda tidak berhati -hati. Kubernet pada asasnya menyelesaikan masalah persekitaran PHP yang hanyut antara tempatan dan pengeluaran. Dengan memaksa konsistensi imej kontena, pengurusan konfigurasi dan definisi sumber, "konsistensi persekitaran" tidak lagi slogan, tetapi amalan kejuruteraan sebenar. Kuncinya ialah kita mesti menyeragamkan proses pembinaan, memanfaatkan keupayaan pengurusan konfigurasi K8S, dan menyatukan orkestra dan definisi.

Penyelesaian

Untuk memastikan persekitaran PHP sangat konsisten secara tempatan dan dalam pengeluaran, terasnya adalah untuk membentangkan "persekitaran" itu sendiri dan menggunakan keupayaan orkestra yang kuat dari Kubernet untuk memaksa konsistensi ini. Ini bukan hanya mengenai aplikasi PHP yang memasuki Docker, ia juga merupakan transformasi proses dan pemikiran.

Langkah pertama dan paling kritikal ialah membina imej Docker yang berwibawa . Imej ini mengandungi semua versi PHP, sambungan, kebergantungan komposer, dan juga konfigurasi pelayan web asas (seperti Nginx atau Apache) yang diperlukan oleh aplikasi anda. Kedua -dua persekitaran pembangunan dan persekitaran pengeluaran mesti menggunakan imej yang sama. Ini bermakna bahawa bekas yang dilancarkan secara tempatan oleh pemaju dan bekas yang akhirnya dikerahkan ke persekitaran pengeluaran adalah sama dengan sistem operasi asas mereka, versi PHP, semua sambungan dan versi masing -masing. Apabila membina imej, kami akan memasang semua kebergantungan sistem yang diperlukan dan sambungan PHP (seperti pdo_mysql , redis , opcache , dll.).

Kedua, pengurusan konfigurasi adalah satu lagi tiang untuk mencapai konsistensi alam sekitar. Konfigurasi aplikasi PHP, seperti tetapan php.ini , pembolehubah persekitaran, rentetan sambungan pangkalan data, alamat pelayan cache, dan lain-lain, tidak boleh dikodkan dalam cermin. Sebaliknya, kita harus menggunakan ConfigMap dan Secret Kubernetes untuk menguruskan konfigurasi ini. ConfigMap digunakan untuk konfigurasi yang tidak sensitif, seperti pelarasan php.ini , atau konfigurasi hos maya nginx; Secret digunakan untuk data sensitif, seperti kata laluan pangkalan data dan kekunci API. Konfigurasi ini boleh disuntik ke dalam bekas melalui gunung volum atau pembolehubah persekitaran. Kelebihan pendekatan ini ialah anda boleh menyediakan ConfigMap atau Secret yang berbeza untuk persekitaran yang berbeza (pembangunan, ujian, pengeluaran) tanpa mengubah atau membina semula imej Docker.

Seterusnya, fail definisi penempatan Kubernet (penempatan, perkhidmatan, kemasukan, dan lain -lain) adalah jaminan penting untuk konsistensi alam sekitar. Fail YAML ini menentukan bagaimana aplikasi anda berjalan: berapa banyak CPU dan memori yang diperlukan, yang mana portnya mendedahkan, bagaimana pemeriksaan kesihatan dilakukan, dan bagaimana ia diakses secara luaran. Dengan juga termasuk fail definisi ini dalam kawalan versi dan memastikan persekitaran pembangunan tempatan (seperti Kubernet Desktop Dockube atau Docker) dan persekitaran pengeluaran menggunakan fail definisi yang sama, anda dapat memastikan corak tingkah laku aplikasi dalam persekitaran yang berbeza adalah konsisten. Sebagai contoh, logik pemeriksaan kesihatan yang anda uji secara tempatan masih sah dalam persekitaran pengeluaran.

Akhirnya, saluran paip CI/CD adalah jaminan automatik yang memastikan strategi di atas dilaksanakan. Apabila kod tersebut dihantar, sistem CI/CD secara automatik akan membina imej Docker, menjalankan ujian, dan kemudian tolak imej ke pendaftaran kontena. Apabila dikerahkan ke Kubernet, CI/CD menarik imej terkini dan terbukti dan menggunakan fail manifes Kubernet yang telah ditetapkan. Ini memastikan bahawa keseluruhan proses dari kod ke penggunaan adalah automatik dan berulang, sangat mengurangkan risiko kesilapan manusia dan hanyutan alam sekitar.

Bagaimana untuk membina imej Docker PHP yang boleh diguna semula untuk memastikan perpaduan persekitaran tempatan dan pengeluaran?

Membina imej Docker PHP yang boleh diguna semula tidak semudah menulis Dockerfile, ia melibatkan strategi yang dipikirkan dengan baik. Pengalaman saya ialah teras terletak pada "Bangunan pada satu masa, menjalankan pelbagai tempat". Ini bermakna bahawa imej yang anda bina boleh dijalankan di komputer riba pemaju dan dalam persekitaran ujian, dan akhirnya dengan lancar digunakan ke persekitaran pengeluaran.

Kami biasanya bermula dengan imej asas PHP-FPM rasmi, seperti php:8.2-fpm-alpine atau php:8.1-fpm-bullseye . Kelebihan memilih sistem alpine ialah saiz imej kecil, tetapi jika anda menghadapi beberapa masalah pergantungan kompilasi, sistem Debian (seperti bullseye) mungkin lebih bimbang. Ini bergantung pada projek khusus dan keutamaan pasukan anda.

Di Dockerfile, saya akan menentukan versi PHP secara eksplisit dan memasang semua sambungan PHP yang diperlukan. Berikut adalah tip: Pasang sambungan yang diperlukan untuk persekitaran pembangunan dan pengeluaran secara langsung. Walau bagaimanapun, untuk alat yang hanya diperlukan dalam persekitaran pembangunan (seperti XDEBUG, alat debugging khusus), anda boleh mempertimbangkan menggunakan membina pelbagai peringkat. Sebagai contoh, satu fasa membina didedikasikan untuk memasang kebergantungan komposer dan alat ujian, dan fasa lain hanya mengandungi set minimum yang diperlukan untuk menjalankan aplikasi.

 # --- Peringkat 1: Bangunan Ketergantungan dan Alat Pembangunan ---
Dari PHP: 8.2-fpm-alpine sebagai pembina

# Pasang Sistem ketergantungan Run APK Tambah --No-cache \
    git \
    zip \
    unzip \
    iciu-dev \
    libpq-dev \
    # ... Ketergantungan membina lain # Pasang PHP Extension Run Docker-PHP-Ext-Install PDO_MYSQL OPCACHE BCMATH INTL EXIF PCNTL \
    && dock-php-sumber padam \
    # Pasang pelanjutan pecl & pecl Pasang redis \
    && docker-php-ext-enable redis

# Pasang komposer
Salin -dari = komposer: terbaru/usr/bin/komposer/usr/tempatan/bin/komposer

Workdir /App
Salin komposer.* ./
Jalankan Pemasangan Komposer --No-Dev-Mengoptimumkan-Autoloader-No-Scripts

# --- Tahap 2: Pencerminan Akhir Pengeluaran Alam Sekitar ---
Dari PHP: 8.2-fpm-alpine

# Pasang kebergantungan sistem yang diperlukan untuk persekitaran pengeluaran yang dijalankan APK Tambah --No-cache \
    libpq \
    # ... Ketergantungan Runtime Lain# Salin Sambungan PHP (jika diperlukan)
# Pasang sambungan yang diperlukan secara langsung dalam imej pengeluaran, atau salin yang dijalankan dari panggung pembina docker-php-ext-memasang pdo_mysql opcache bcmath intl exif pcntl \
    && dock-php-sumber padam \
    && pecl pasang redis \
    && docker-php-ext-enable redis

# Salin salinan kod aplikasi -dari = pembina /aplikasi /aplikasi

# Tetapkan kerja /aplikasi direktori direktori kerja

# Expose port FPM Expose 9000

# Default CMD, boleh ditimpa oleh Kubernetes Deployment ["PHP-FPM"]

Dalam praktiknya, saya akan memastikan bahawa composer install dilakukan semasa proses bangunan imej dan penggunaan --no-dev dan --optimize-autoloader untuk memastikan bahawa imej pengeluaran adalah kecil dan cekap yang mungkin. Untuk kod itu, saya akan menyalinnya ke dalam imej dan bukannya pemasangan pada masa runtime, kecuali jika ia adalah gunung sementara untuk lelaran cepat semasa pembangunan.

Pengurusan versi cermin juga penting. Gunakan tag yang bermakna, seperti my-app:1.0.0 atau my-app:latest . Untuk cawangan pembangunan, anda boleh menambah akhiran -dev , seperti my-app:feature-branch-dev . Dengan cara ini, dalam fail penempatan Kubernet, anda hanya perlu mengemas kini tag cermin untuk menukar versi, yang sangat mudah.

Bagaimana dengan cekap menguruskan konfigurasi dan data sensitif aplikasi PHP di Kubernet untuk mengelakkan perbezaan alam sekitar?

Kunci untuk menguruskan konfigurasi aplikasi PHP dan data sensitif dalam Kubernet adalah untuk meremehkan: pelucutan konfigurasi dari cermin dan menjadikannya bebas daripada kod dan runtime. Ini bukan sahaja untuk konsistensi alam sekitar, tetapi juga untuk keselamatan dan penyelenggaraan. Saya peminat besar dan ConfigMap Secret

ConfigMap sangat sesuai untuk menyimpan konfigurasi yang tidak mengandungi maklumat sensitif, seperti tetapan tersuai php.ini anda, konfigurasi tapak Nginx, atau beberapa pembolehubah persekitaran peringkat aplikasi. Anda boleh menentukan ConfigMap dan menyuntiknya ke dalam pod dalam dua cara utama:

1. Suntikan sebagai pembolehubah persekitaran: Sesuai untuk item konfigurasi kecil dan mudah.

    Apiversiti: Apps/V1
   Jenis: Penyebaran
   metadata:
     Nama: my-php-app
   spesifikasi:
     Templat:
       spesifikasi:
         Bekas:
         - Nama: PHP-FPM
           Imej: my-php-app: 1.0.0
           ENVFROM:
           - configmapref:
               Nama: App-Config
   ---
   Apiversiti: v1
   Kind: Configmap
   metadata:
     Nama: App-Config
   data:
     APP_ENV: Pengeluaran
     Php_memory_limit: 256m

2. Sebagai Mount Volume File: Ini adalah cara saya mencadangkan lebih banyak, terutamanya untuk fail konfigurasi kompleks (seperti konfigurasi php.ini atau nginx penuh).

    Apiversiti: Apps/V1
   Jenis: Penyebaran
   metadata:
     Nama: my-php-app
   spesifikasi:
     Templat:
       spesifikasi:
         Bekas:
         - Nama: PHP-FPM
           Imej: my-php-app: 1.0.0
           VolumeMounts:
           -Nama: php-in-volume
             Mountpath: /usr/local/etc/php/conf.d/custom.ini # overwrite atau tambah php.ini konfigurasi subpath: custom.ini
           -Nama: nginx-config-volume
             Mountpath: /etc/nginx/conf.d/default.conf
             Subpath: default.conf
         Jilid:
         -Nama: php-in-volume
           configmap:
             Nama: php-custom-ini
         -Nama: nginx-config-volume
           configmap:
             Nama: Nginx-Site-Config
   ---
   Apiversiti: v1
   Kind: Configmap
   metadata:
     Nama: php-custom-ini
   data:
     custom.ini: |
       Memory_limit = 256m
       upload_max_filesize = 128m
       post_max_size = 128m
   ---
   Apiversiti: v1
   Kind: Configmap
   metadata:
     Nama: Nginx-Site-Config
   data:
     default.conf: |
       pelayan {
           Dengar 80;
           server_name _;
           root /app /public;
           index index.php index.html;
   
           lokasi / {
               try_files $ uri $ uri / /index.php?$Query_string;
           }
   
           Lokasi ~ \ .php $ {
               fastcgi_pass 127.0.0.1:9000; # atau nama perkhidmatan php-fpm fastcgi_index index.php;
               fastcgi_param script_filename $ document_root $ fastcgi_script_name;
               termasuk fastcgi_params;
           }
       }

Untuk data sensitif, Secret digunakan sama untuk ConfigMap , tetapi ia disimpan dalam pengekodan Base64 di dalam Kubernet (tidak disulitkan, memerlukan alat tambahan seperti rahsia atau peti besi untuk penyulitan sebenar). Begitu juga, ia boleh disuntik melalui pembolehubah persekitaran atau pemasangan volum fail.

 Apiversiti: Apps/V1
Jenis: Penyebaran
metadata:
  Nama: my-php-app
spesifikasi:
  Templat:
    spesifikasi:
      Bekas:
      - Nama: PHP-FPM
        Imej: my-php-app: 1.0.0
        Env:
        - Nama: db_password
          Valuefrom:
            SecretKeyref:
              Nama: Secrets App
              Kunci: db_password
        VolumeMounts:
        -Nama: API-KEY-VOLUME
          Mountpath:/etc/Secrets/API_Key
          Subpath: API_KEY
      Jilid:
      -Nama: API-KEY-VOLUME
        Rahsia:
          Nama Sekretari: Secrets App
---
Apiversiti: v1
jenis: rahsia
metadata:
  Nama: Secrets App
Jenis: legap
data:
  db_password: <base64 yang dikodkan kata laluan>
  API_KEY: <BASE64 Kunci API yang Dikodkan>

Dalam projek sebenar, kami juga akan menggabungkan alat seperti Helm atau Kustomize untuk menguruskan konfigurasi pelbagai persekitaran. Mereka membolehkan Secret menentukan template manifest Kubernet asas dan kemudian memberikan values.yaml kustomization.yaml ConfigMap . Dengan cara ini, logik penempatan teras anda tetap tidak berubah, tetapi konfigurasi berubah dengan alam sekitar, sangat mengurangkan kerumitan pengurusan konfigurasi dan memastikan konsistensi antara persekitaran. Saya telah melihat terlalu banyak projek yang secara langsung membungkus fail INI ke dalam cermin, dan kemudian membina semula imej setiap kali saya menukar had memori. Itu hanya bencana. Kaedah decoupling ini adalah cara yang betul.

Strategi apa yang boleh digunakan untuk mensimulasikan pengeluaran dalam persekitaran Kubernet tempatan dan meningkatkan kecekapan pembangunan?

Tujuan persekitaran pengeluaran simulasi Kubernets secara tempatan adalah untuk membolehkan pemaju menjalankan dan debug kod dengan cara yang paling dekat untuk pengeluaran, dengan itu mengurangkan masalah "boleh berjalan di mesin saya". Ini bukan hanya isu teknikal, tetapi juga pengoptimuman proses pembangunan.

Pertama, memilih alat Kubernet tempatan yang betul adalah penting. Kedua-dua minikube dan jenis adalah pilihan yang baik, yang dapat dengan cepat melancarkan kluster Kubernet tunggal atau multi-nod pada komputer riba anda. Jika anda menggunakan desktop Docker, fungsi Kubernet terbina dalamnya juga cukup kuat, dan ia sering menjadi yang paling mudah untuk kebanyakan pembangunan aplikasi PHP. Saya secara peribadi lebih suka desktop desktop k8s kerana ia diintegrasikan dengan ekosistem Docker, menjimatkan anda masalah pemasangan dan konfigurasi tambahan.

Kuncinya ialah menggunakan fail manifes Kubernet yang sama secara tempatan dan dalam persekitaran pengeluaran . Ini bermakna bahawa Deployment.yaml anda.yaml, Service.yaml , Ingress.yaml , ConfigMap dan definisi Secret semua harus menjadi set yang sama. Sudah tentu, untuk persekitaran tempatan, anda mungkin perlu menyesuaikan beberapa nilai, seperti permintaan sumber (tempatan mungkin tidak memerlukan had CPU/memori yang tinggi), atau sambungan pangkalan data menunjuk kepada bekas MySQL tempatan dan bukannya RDS jauh. Perbezaan ini dapat dicapai dengan menimpa konfigurasi tempatan yang disebutkan di atas atau Kustomize dan bukannya mengubah suai fail teras.

Untuk meningkatkan kecekapan pembangunan, terutamanya untuk bahasa yang ditafsirkan seperti PHP, kami biasanya tidak mahu membina semula imej Docker setiap kali kami mengubah suai kod tersebut. Berikut adalah perdagangan kecil:

1. Volume Mounts untuk Kod: Dalam persekitaran pembangunan, anda boleh melancarkan direktori kod tempatan terus ke direktori /app dari bekas PHP-FPM. Dengan cara ini, jika anda mengubah suai kod tempatan, kod di dalam bekas akan dikemas kini dengan segera tanpa membina semula imej atau memulakan semula pod.

    Apiversiti: Apps/V1
   Jenis: Penyebaran
   metadata:
     Nama: my-php-app-dev
   spesifikasi:
     Templat:
       spesifikasi:
         Bekas:
         - Nama: PHP-FPM
           Imej: My-PhP-App: Terkini # atau VolumeMounts Imej Dev Khas:
           - Nama: App-Code
             MountPath: /App
         Jilid:
         - Nama: App-Code
           HostPath:
             Laluan:/Pengguna/Youruser/Projek/My-Php-App # Jenis Laluan Projek Tempatan Anda: Direktori

   Nota: Kaedah ini hanya digunakan untuk pembangunan, dan persekitaran pengeluaran tidak boleh melakukan ini. Kod persekitaran pengeluaran mestilah sebahagian daripada cermin.

2. Resolusi DNS Tempatan dan Pendedahan Perkhidmatan: Anda mungkin perlu memetakan port perkhidmatan dalaman K8S ke port tempatan melalui kubectl port-forward , atau mengkonfigurasi fail tempatan /etc/hosts untuk menunjuk nama domain ingress ke alamat IP kluster Kubernet tempatan. Ini membolehkan anda mengakses aplikasi berjalan secara tempatan melalui nama domain atau port tertentu sama seperti anda akan mengakses perkhidmatan pengeluaran sebenar.

3. Strategi Debugging: Untuk aplikasi PHP, Xdebug adalah alat penyahpepijatan yang diperlukan. Dalam persekitaran Kubernet, anda perlu memastikan bahawa Xdebug disambungkan dengan betul ke pelabuhan debug IDE tempatan anda. Ini biasanya melibatkan mengkonfigurasi xdebug.client_host xdebug untuk menunjuk ke IP tempatan anda dan memastikan bahawa pod boleh mengakses IP ini (mungkin memerlukan host.docker.internal atau IP hos anda). Sementara itu, pelabuhan debug Xdebug (biasanya 9003) dipetakan dari pod ke tempatan melalui kubectl port-forward .

4. Ketergantungan Perkhidmatan Luaran: Aplikasi PHP anda mungkin bergantung kepada MySQL, Redis, dan lain -lain. Secara tempatan, anda boleh memilih:

   • Menyebarkan perkhidmatan ini dalam kluster K8S tempatan (menggunakan carta Helm rasmi mereka atau penggunaan mudah).
   • Mulakan perkhidmatan ini di Docker mengarang, dan kemudian sambungkan aplikasi PHP dalam K8S ke perkhidmatan di Docker Compose Network.
   • Sambungkan terus ke pangkalan data atau perkhidmatan ujian luaran yang berjalan pada mesin tempatan. Kaedah yang mana untuk dipilih bergantung kepada kerumitan projek dan penggunaan sumber. Untuk pembangunan mudah, ia mungkin lebih mudah untuk disambungkan ke pangkalan data tempatan secara langsung.

Melalui strategi ini, pemaju boleh melakukan pembangunan dan ujian berulang dalam persekitaran pengeluaran yang sangat simulasi, dengan ketara mengurangkan risiko masalah yang ditemui hanya selepas penggunaan untuk pengeluaran. Ia agak seperti meletakkan kod anda sebagai "mini-versi yang ditetapkan untuk persekitaran pengeluaran" dan anda boleh merasakan sama ada ia sesuai terlebih dahulu di dalam negara.

Atas ialah kandungan terperinci Cara Menggunakan Kubernet untuk Memelihara Persekitaran PHP Pengeluaran Konsisten dan Piawaian Konfigurasi Bekas Tempatan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!