L'utilisation de l'image de base PHP correcte et la configuration d'un environnement Docker sécurisé et optimisé sont la clé pour obtenir la production prête. 1. Utilisez PHP: 8.3-FPM-Alpine comme image de base pour réduire la surface d'attaque et améliorer les performances; 2. Désactiver les fonctions dangereuses via PHP.ini personnalisé, désactiver l'affichage des erreurs et activer Opcache et Jit pour améliorer la sécurité et les performances; 3. Utilisez Nginx comme proxy inverse pour restreindre l'accès aux fichiers sensibles et transférer correctement les demandes PHP à PHP-FPM; 4. Utilisez des images d'optimisation en plusieurs étapes pour supprimer les dépendances de développement et configurez les utilisateurs non racinaires pour exécuter des conteneurs; 5. Supervisord facultatif pour gérer plusieurs processus tels que Cron; 6. Vérifiez qu'aucune fuite d'informations sensibles, le journal de journal vers le flux standard, configurez les contr?les de santé, analysez les vulnérabilités de l'image et l'application peut s'exécuter indépendamment. En fin de compte, s'assurer que l'environnement est s?r, les performances élevées, la maintenabilité et l'observabilité s'appellent la production prête.

La mise en place d'un environnement Docker prêt pour la production pour PHP ne consiste pas seulement à faire fonctionner votre application - il s'agit de sécurité, de performances, de maintenance et d'évolutivité. De nombreux tutoriels s'arrêtent à ?cela fonctionne localement?, mais les environnements de production réels exigent davantage. Voici comment construire une configuration Docker robuste, sécurisée et efficace pour PHP qui est prête pour un déploiement du monde réel.

? Utilisez la bonne image de base PHP

Commencez par une image de base minimale et sécurisée. évitez php:latest ou axées sur le développement comme php:8.3-cli .

Recommandé:

• php:8.3-fpm-alpine pour les services backend (léger, sécurisé)
• Associez à nginx dans un conteneur séparé pour servir le trafic Web

Pourquoi Alpine?
Plus petite surface d'attaque, construit plus rapidement et utilisation des ressources inférieures. Mais soyez prudent: certaines extensions de PHP peuvent nécessiter des étapes supplémentaires à installer en Alpine en raison de MUSL vs GLIBC.

 De PHP: 8,3-fpm-alpine

# Installer des extensions PHP essentielles (compilées pour Alpine)
Exécuter apk add --no-cache \
    nginx \
    superviseur \
    postgresql-dev \
    && docker-php-ext-stall -j $ (nproc) \
    PDO_PGSQL \
    opcache \
    && docker-php-ext-enable pdo_pgsql

évitez RUN apk add --update && pecl install ... sauf si vous avez absolument nécessaire - chaque commande augmente la taille de l'image et le temps de construction.

? Configuration de PHP sécurisée

Les paramètres php.ini par défaut ne sont pas en sécurité de production. Remplacez-les explicitement.

Créer des fichiers de configuration personnalisés:

 ./docker/php/php.ini
./docker/php/opcache.ini

Exemple de réglages php.ini :

 ; Désactiver les fonctions dangereuses
Disable_Functions = Exec, Passthru, Shell_Exec, System, Proc_Open, Popen

; Limiter l'exposition
exposer_php = off
display_errors = off
log_errors = sur

; Fixer des limites raisonnables
upload_max_filesize = 16m
post_max_size = 18m
max_execution_time = 30

OPCACH (critique pour les performances):

 opcache.enable = 1
opcache.validate_timestamps = 0; Seulement en production (utilisez des déploiements roulants pour effacer)
opcache.max_accelerated_files = 20000
opcache.memory_consumption = 256
opcache.jit = 1205; Activer Jit dans PHP 8

Copiez-les dans l'image:

 Copier ./docker/php/php.ini /usr/local/etc/php/conf.d/app.ini
Copier ./docker/php/opcache.ini /usr/local/etc/php/conf.d/opcache.ini

? Utilisez un proxy inversé (NGINX) PHP-FPM

N'exposez jamais directement PHP-FPM. Utilisez Nginx comme proxy inverse.

Structure typique:

 # docker-compose.yml (pour la mise en scène / CI)
Version: '3.8'
services:
  nginx:
    Image: Nginx: Alpine
    PORTS:
      - "80:80"
    Volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
      - ./public:/var/www/html/public
    DenFend_on:
      - PHP

  PHP:
    construire: .
    Volumes:
      - ./:/var/www/html
    environnement:
      - app_env = prod

Ningx Config Sights:

• Servir uniquement le public/ répertoire
• Bloquer l'accès aux fichiers .env , .git et config
• Définir les en-têtes appropriés (sécurité, mise en cache)
• Passer les demandes PHP à php:9000

Exemple de bloc d'emplacement:

 Emplacement ~ \ .php $ {
    FastCGI_PASS PHP: 9000;
    fastcgi_index index.php;
    FastCGI_PARAM Script_filename / var / www / html / public $ Fastcgi_Script_name;
    Inclure FastCGI_PARAMS;
}

? Optimiser pour la construction et le temps d'exécution

Builds en plusieurs étapes (si nécessaire pour des outils comme le compositeur):

 # Stage de construction
De composer: le plus récent en tant que compositeur
Copier composer.json composer.lock ./
Run Composer Installer --No-Dev - Optimize-Autoloader - No-Scripts

# Stage final
De PHP: 8,3-fpm-alpine
Copier --from = compositeur / app / vendeur ./Vendor
Copie. .

Optimisations des clés:

• Définissez APP_ENV=prod pour activer les optimisations du cadre (par exemple, Symfony, Laravel)
• Utilisez --optimize-autoloader et --classmap-authoritative dans Composer
• Exécuter en tant qu'utilisateur non racinaire:

   Exécuter addUser -d -s / bin / sh www
  Utilisateur www

? ? Ajouter SuperVisord (facultatif mais utile)

Si vous devez exécuter PHP-FPM et Cron ou d'autres démons:

 Exécutez APK ADD - NO-CACHE Superviseur
Copier ./docker/supervvisord.conf /etc/supervvisor/conf.d/supervvisord.conf
Cmd ["/ usr / bin / supervisord", "-c", "/etc/supervvisor/conf.d/supervvisord.conf"]

SuperVisord Config:

 [SuperVisord]
nodaemon = vrai

[Programme: PHP-FPM]
commande = php-fpm
stdout_logfile = / dev / stdout
stderr_logfile = / dev / stderr

[Programme: Cron]
commande = cron -f

? Tester avant le déploiement

Avant de l'appeler "prêt pour la production"

• [] Aucune information sensible dans l'environnement ou la configuration
• [] Les journaux d'erreur vont sur stdout / stderr (pour les pilotes de journalisation docker)
• [] Le contr?le de santé est défini:

   HealthCheck - Interval = 30S - TimeOut = 3S --Start-PérioD = 5S --retries = 3 \
    CMD Curl -f http: // localhost / Health || sortie 1

• [] L'image est scannée pour les vulnérabilités (utilisez docker scan ou un outillage CI)
• [] Cela fonctionne sans supports de volume (c'est-à-dire, le code est intégré)

---

Notes finales

Un solde de configuration Docker PHP prêt pour la production:

• Sécurité (image minimale, configts sécurisés, utilisateur non racine)
• Performance (Opcache, JIT, Autoloader Optimisation)
• Maintenabilité (Dockerfiles clairs, séparation des préoccupations)
• Observabilité (journaux à STDOUT, vérifications de santé)

Vous n'avez pas besoin de Kubernetes le premier jour, mais vous avez besoin d'une base solide. Démarrez la configuration simple et automatique et testez comme si c'était déjà en production.

Fondamentalement: s'il n'est pas s?r, rapide et observable, il n'est pas prêt pour la production.

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!