0Pricing
PHP Academy · Lezione

Containerizzazione di un'applicazione PHP

Creare un'immagine Docker per PHP + Nginx e orchestrarla con Docker Compose.

Containerizzazione di un'applicazione PHP è una lezione PHP Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento PHP Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso PHP Academy include 4 lezioni in totale.

Perché utilizzare Docker per PHP?

Docker impacchetta l'applicazione e le sue dipendenze in un'immagine container portabile. La stessa immagine viene eseguita in modo identico negli ambienti di sviluppo, CI e produzione, eliminando i problemi del tipo "sul mio computer funziona".

Dockerfile PHP di base

Un Dockerfile minimo per un'applicazione PHP + Nginx.

# Dockerfile
FROM php:8.3-fpm-alpine

# Install extensions
RUN docker-php-ext-install pdo pdo_mysql opcache

# Install Composer
COPY --from=composer:2 /usr/bin/composer /usr/bin/composer

WORKDIR /app
COPY composer.json composer.lock ./
RUN composer install --no-dev --optimize-autoloader

COPY . .

RUN chown -R www-data:www-data /app/storage /app/bootstrap/cache

Build a più fasi

Utilizzate build a più fasi per mantenere ridotte le dimensioni dell'immagine finale: installate gli strumenti di build in una fase e copiate solo gli artefatti nell'immagine finale.

# Stage 1: builder
FROM composer:2 AS builder
WORKDIR /app
COPY composer.json composer.lock ./
RUN composer install --no-dev --optimize-autoloader

# Stage 2: runtime
FROM php:8.3-fpm-alpine
WORKDIR /app
COPY --from=builder /app/vendor ./vendor
COPY . .

docker-compose.yml

Orchestrate più servizi (PHP-FPM, Nginx, MySQL, Redis) con Docker Compose.

# docker-compose.yml
services:
  app:
    build: .
    volumes:
      - .:/app
  nginx:
    image: nginx:alpine
    ports: ["80:80"]
    volumes:
      - .:/app
      - ./docker/nginx.conf:/etc/nginx/conf.d/default.conf
  mysql:
    image: mysql:8
    environment:
      MYSQL_DATABASE: myapp
      MYSQL_ROOT_PASSWORD: secret
    volumes:
      - db_data:/var/lib/mysql
  redis:
    image: redis:alpine
volumes:
  db_data:

Configurazione del container Nginx

Montate una configurazione Nginx personalizzata per inoltrare le richieste a PHP-FPM.

# docker/nginx.conf
server {
    listen 80;
    root /app/public;
    index index.php;
    location / { try_files $uri /index.php?$query_string; }
    location ~ \.php$ {
        fastcgi_pass app:9000;  # service name from docker-compose
        fastcgi_param SCRIPT_FILENAME $realpath_root$fastcgi_script_name;
        include fastcgi_params;
    }
}

Variabili d'ambiente

Passate le variabili d'ambiente ai container: non incorporate mai i segreti nelle immagini.

# docker-compose.yml:
services:
  app:
    env_file: .env
    # or explicit:
    environment:
      - APP_ENV=production
      - DB_HOST=mysql

Comandi Artisan di Laravel

Eseguite i comandi Artisan all'interno del container.

$ docker compose exec app php artisan migrate
$ docker compose exec app php artisan config:cache
$ docker compose exec app php artisan queue:work

Controlli di integrità

Aggiungete controlli di integrità, in modo che gli orchestratori (Kubernetes, ECS) sappiano quando il container è pronto.

# Dockerfile:
HEALTHCHECK --interval=30s --timeout=5s \
  CMD curl -f http://localhost/health || exit 1

Creazione e pubblicazione delle immagini

Create e pubblicate l'immagine in un registry (Docker Hub, ECR, GHCR).

$ docker build -t myorg/myapp:1.0.0 .
$ docker push myorg/myapp:1.0.0

Distribuzione su Kubernetes

In Kubernetes, definite le risorse Deployment e Service utilizzando la vostra immagine. Distribuite le nuove versioni con kubectl set image oppure aggiornate il file YAML ed eseguitelo.

Messa in sicurezza per la produzione

Buone pratiche Docker per la produzione: utilizzate un utente non root, un filesystem root in sola lettura, un'immagine di base minima (Alpine), nessuna dipendenza di sviluppo, tag delle immagini bloccati e analisi delle CVE con docker scout.

Riepilogo

Create un Dockerfile per PHP-FPM + Composer. Utilizzate docker-compose per lo sviluppo locale con i servizi Nginx, MySQL e Redis. In produzione, utilizzate build a più fasi, iniettate le variabili d'ambiente ed eseguite l'applicazione tramite Kubernetes o ECS.

Verifica rapida

Qual è il principale vantaggio delle build Docker a più fasi?

Domande Frequenti

La lezione «Containerizzazione di un'applicazione PHP» è gratuita?

Sì — il testo completo di «Containerizzazione di un'applicazione PHP» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso PHP Academy, passa a CoddyKit PRO. Il corso PHP Academy include 4 lezioni in totale.

Cosa imparerò in «Containerizzazione di un'applicazione PHP»?

Creare un'immagine Docker per PHP + Nginx e orchestrarla con Docker Compose. Eserciti PHP Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare PHP Academy?

Non è richiesta alcuna esperienza precedente. PHP Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Containerizzazione di un'applicazione PHP»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione PHP Academy?

Sì. Ogni lezione PHP Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Configurazione di Nginx e PHP-FPM
  2. Variabili d'ambiente e file .env
  3. Deploy con GitHub Actions
  4. Containerizzazione di un'applicazione PHP
← Torna a PHP Academy