Come creare un'immagine Docker NGINX personalizzata

NGINX dentro un container Docker può offrire un servizio web affidabile in molti ambienti. Potresti lavorare a un sito personale, a un servizio web leggero o a un progetto per l’home lab. Docker ti aiuta a mantenerlo coerente su macchine e configurazioni diverse. Questo approccio consente di eseguire NGINX con meno preoccupazioni di overhead passando dallo sviluppo alla produzione. È comune affidarsi a Docker per un packaging semplice del server web, così da condividere i progetti senza passaggi manuali macchinosi.

Questo articolo spiega come eseguire un’immagine NGINX pronta all’uso, come servire contenuti dalla tua macchina locale e come creare un’immagine con funzionalità personalizzate. Copre anche i passaggi di configurazione per un reverse proxy e l’uso di Docker Compose per il deployment di più servizi. Alla fine, vedrai come gestire i container con pochi comandi e avere una visione dettagliata di come integrare Docker e NGINX per attività pratiche.

Se sei alle prime armi con Docker, dai un’occhiata alla nostra guida Docker per principianti per imparare le basi. 

Che cos’è Docker NGINX?

Docker NGINX si riferisce all’esecuzione del server web NGINX all’interno di un container leggero. I container Docker sono simili a piccoli pacchetti che contengono un’applicazione e tutte le dipendenze necessarie. 

NGINX è un server web molto diffuso, noto per le buone prestazioni, la configurazione semplice e la gestione flessibile del traffico HTTP. Abbinare NGINX a Docker è interessante perché mantiene l’ambiente coerente. Che tu esegua su macOS, Windows o Linux, il contenuto del container resta lo stesso. Significa che il comportamento è identico, indipendentemente dal sistema operativo host.

Un’immagine Docker tipica per NGINX include il software del server, una configurazione predefinita e una struttura di directory per i file pubblicati. Puoi avviare subito quel container oppure adattarlo mappando cartelle specifiche, modificando i file di configurazione o creando un’immagine basata sul tuo Dockerfile. In questo modo, puoi aggiungere moduli o script personalizzati per adattare NGINX alla tua applicazione.

Per saperne di più su come containerizzare le applicazioni, consulta il nostro tutorial Come containerizzare un’applicazione con Docker. Approfondisce come containerizzare applicazioni di machine learning con Docker in modo accessibile ai principianti. 

Prerequisiti

Prima di iniziare a eseguire container NGINX, verifica che Docker sia installato. Docker offre installer ufficiali per macOS, Windows e varie distribuzioni Linux. La documentazione Docker fornisce una procedura passo passo per ogni sistema operativo. 

Dai un’occhiata al nostro corso Introduzione a Docker per una guida completa su come iniziare con Docker. 

Verifica l’installazione con un comando rapido come:

docker version
derrickmwiti@Derricks-MacBook-Pro% docker version
Client:
 Version:           28.0.1
 API version:       1.48
 Go version:        go1.23.6
 Git commit:        068a01e
 Built:             Wed Feb 26 10:38:16 2025
 OS/Arch:           darwin/arm64
 Context:           desktop-linux
Server: Docker Desktop 4.39.0 (184744)
 Engine:
  Version:          28.0.1
  API version:      1.48 (minimum version 1.24)
  Go version:       go1.23.6
  Git commit:       bbd0a17
  Built:            Wed Feb 26 10:40:57 2025
  OS/Arch:          linux/arm64
  Experimental:     false
 containerd:
  Version:          1.7.25
  GitCommit:        bcc810d6b9066471b0b6fa75f557a15a1cbf31bb
 runc:
  Version:          1.2.4
  GitCommit:        v1.2.4-0-g6c52b3f
 docker-init:
  Version:          0.19.0
  GitCommit:        de40ad0Offerto da

Se vedi i dettagli di versione, significa che Docker è pronto. Oltre a Docker, ti serve l’accesso a Internet per scaricare l’immagine NGINX da Docker Hub. Se prevedi di creare la tua immagine, ti servirà un editor di testo per scrivere un Dockerfile. Qualsiasi editor va bene: scegli quello con cui ti trovi meglio.

Configurare NGINX in un container Docker

Eseguire NGINX da un’immagine pronta è di solito il metodo più rapido. Puoi scaricarla da Docker Hub in pochi secondi e poi avviare un container. Dopodiché, vedrai la pagina predefinita nel browser. Questo breve processo è spesso il primo passo in molte configurazioni server basate su Docker.

Scaricare l’immagine Docker di NGINX

L’immagine ufficiale di NGINX è disponibile pubblicamente su Docker Hub con il nome nginx. 

Scaricala così:

docker pull nginx
derrickmwiti@Derricks-MacBook-Pro % docker pull nginx
Using default tag: latest
latest: Pulling from library/nginx
4c7c1a5bd3af: Download complete 
bef2ee7fab45: Download complete 
d9b636547744: Downloading [======================>                            ]  12.58MB/28.04MB
0994e771ba34: Downloading [===>                                               ]  3.146MB/40.56MB
589701e352f8: Download complete 
13f89c653285: Download complete 
8e77214beb25: Download complete Offerto da

Questo contatta il registry e scarica l’ultima versione. Quando tutto è completo, puoi verificare che sia presente sulla tua macchina:

docker images
derrickmwiti@Derricks-MacBook-Pro% docker images
REPOSITORY                                                                     TAG                                                                           IMAGE ID       CREATED         SIZE

nginx                                                                          latest                                                                        124b44bfc9cc   6 weeks ago     280MB
keras-custom-training-container                                                latest                                                                                                                                     <none>                                                                        7de0f04013e5   7                                                  Offerto da

Questo comando mostra l’elenco delle immagini nella tua libreria locale. Dovresti vedere l’immagine nginx nella tabella. Significa che sei pronto a creare un container a partire da essa. Scopri un elenco di immagini utili per i tuoi progetti di data science nel nostro tutorial Top 12 Docker Container Images for Machine Learning and AI. 

Eseguire il container NGINX

Una volta che l’immagine NGINX è sul tuo sistema, puoi avviare il container con un solo comando:

docker run --name mynginx -p 8080:80 -d nginx
derrickmwiti@Derricks-MacBook-Pro % docker run --name mynginx -p 8080:80 -d nginx
ec44d1a43016e9684b602437b967c0ed8e11c933a8a76b341b68c25168d2af70Offerto da

Questo comando fa diverse cose. Esegue un container chiamato mynginx in background (grazie all’opzione -d). Mappa la porta 8080 della tua macchina host alla porta 80 dentro il container. Questa mappatura significa che puoi visitare http://localhost:8080 nel browser e vedere la pagina predefinita di NGINX. Il container usa l’immagine nginx scaricata da Docker Hub.

Il nuovo container dovrebbe restare in esecuzione perché NGINX è attivo. Se controlli i log con:

docker logs mynginx
derrickmwiti@Derricks-MacBook-Pro % docker logs mynginx
/docker-entrypoint.sh: /docker-entrypoint.d/ is not empty, will attempt to perform configuration
/docker-entrypoint.sh: Looking for shell scripts in /docker-entrypoint.d/
/docker-entrypoint.sh: Launching /docker-entrypoint.d/10-listen-on-ipv6-by-default.sh
10-listen-on-ipv6-by-default.sh: info: Getting the checksum of /etc/nginx/conf.d/default.conf
10-listen-on-ipv6-by-default.sh: info: Enabled listen on IPv6 in /etc/nginx/conf.d/default.conf
/docker-entrypoint.sh: Sourcing /docker-entrypoint.d/15-local-resolvers.envsh
/docker-entrypoint.sh: Launching /docker-entrypoint.d/20-envsubst-on-templates.sh
/docker-entrypoint.sh: Launching /docker-entrypoint.d/30-tune-worker-processes.sh
/docker-entrypoint.sh: Configuration complete; ready for start up
2025/03/20 04:33:10 [notice] 1#1: using the "epoll" event method
2025/03/20 04:33:10 [notice] 1#1: nginx/1.27.4
2025/03/20 04:33:10 [notice] 1#1: built by gcc 12.2.0 (Debian 12.2.0-14) 
2025/03/20 04:33:10 [notice] 1#1: OS: Linux 6.10.14-linuxkit
2025/03/20 04:33:10 [notice] 1#1: getrlimit(RLIMIT_NOFILE): 1048576:1048576
2025/03/20 04:33:10 [notice] 1#1: start worker processes
2025/03/20 04:3Offerto da

Puoi vedere eventuali messaggi scritti da NGINX. 

Pubblicare contenuti personalizzati con NGINX

Potresti voler pubblicare una pagina HTML, anziché la pagina predefinita inclusa nell’immagine del container. Puoi creare un semplice file sulla tua macchina locale e poi montarlo nel container. In questo modo i tuoi contenuti restano separati dal container. Ogni volta che modifichi la pagina, puoi aggiornare il browser per vedere il cambiamento.

Creare una pagina HTML personalizzata

Scegli una posizione comoda sulla tua macchina. Ad esempio, una cartella chiamata html_content nella tua home. Crea lì un file index.html. Potrebbe essere così:

<html>
<head>
    <title>My NGINX Page</title>
</head>
<body>
    <h1>Hello from my Docker NGINX setup!</h1>
    <p>This is a custom page served from a local folder.</p>
</body>
</html>Offerto da

Questa è una pagina HTML di base. Puoi inserire qualsiasi testo o stile desideri. Aggiungi immagini o JavaScript, o qualsiasi altra cosa ti serva.

Montare la pagina HTML nel container NGINX

L’immagine ufficiale di NGINX pubblica i contenuti da /usr/share/nginx/html per impostazione predefinita. Puoi mappare la tua cartella locale a quella posizione nel container. Si fa con il flag -v (volume) di Docker. Arresta qualsiasi container esistente chiamato mynginx per evitare conflitti di porta:

docker stop mynginx
docker rm mynginxOfferto da

Poi avvia un nuovo container:

docker run --name mynginx -p 8080:80 -d \
    -v /Users/derrickmwiti/Documents/html_content:/usr/share/nginx/html \
    nginx
6f68085733eeac418c3302e5c580a4f7c5c0c36d3591d8e2a7f35f69f6308d18Offerto da

Sostituisci /path/to/html_content  con il percorso reale sul tuo computer. In questo modo, ogni volta che navighi su http://localhost:8080, il container servirà il file HTML che hai messo in html_content. Per impostazione predefinita, se lo chiami index.html, NGINX lo caricherà automaticamente.

Questo approccio è utile quando vuoi aggiornare spesso i contenuti. Non devi ricreare il container ogni volta. Il server legge i contenuti dalla tua cartella locale al volo. 

Se vedi un avviso relativo ai permessi, potrebbe essere necessario assicurarsi che il tuo utente locale e Docker possano leggere quella cartella. 

Su Linux, ciò può significare regolare la proprietà o i permessi dei file. Su Windows o macOS, può voler dire concedere a Docker l’accesso all’unità.

Creare un’immagine Docker NGINX personalizzata

Montare una cartella locale è una soluzione rapida per test semplici. Potresti però volere moduli extra, configurazioni speciali o altre modifiche. È qui che creare un’immagine può essere utile. 

Docker semplifica la creazione di un piccolo file di ricetta, chiamato Dockerfile, che imposta un container esattamente come vuoi tu. Otterrai così un’immagine che puoi condividere con altri o pubblicare su un registry. Può essere più comodo che dire alle persone di montare una serie di file locali.

Creare un Dockerfile

Un Dockerfile è semplicemente un file di testo. Puoi chiamarlo Dockerfile o scegliere un altro nome se preferisci. Mettilo in una nuova directory. Ecco un esempio semplice:

FROM nginx:latest

COPY index.html /usr/share/nginx/html/index.htmlOfferto da

Questo usa come base l’immagine ufficiale nginx:latest. Poi copia un file locale chiamato index.html nella cartella predefinita dei contenuti web dentro il container. Puoi aggiungere altre righe se ti servono. Per esempio, potresti copiare un nginx.conf personalizzato o aggiungere moduli da installare. Dipende dalle tue esigenze. Se vuoi solo pubblicare una pagina statica, lo snippet sopra è sufficiente.

Quando hai pronto il Dockerfile, aggiungi il tuo index.html nella stessa cartella. Poi puoi creare l’immagine. Il comando tipico è:

docker build -t mynginximage .
[+] Building 2.6s (7/7) FINISHED                                                                                                                                                       docker:desktop-linux
 => [internal] load build definition from Dockerfile                                                                                                                                                   0.0s
 => => transferring dockerfile: 245B                                                                                                                                                                   0.0s
 => [internal] load metadata for docker.io/library/nginx:latest                                                                                                                                        0.0s
 => [internal] load .dockerignore                                                                                                                                                                      0.0s
 => => transferring context: 2B                                                                                                                                                                        0.0s
 => [internal] load build context                                                                                                                                                                      0.0s
 => => transferring context: 365B                                                                                                                                                                      0.0s
 => [1/2] FROM docker.io/library/nginx:latest@sha256:124b44bfc9ccd1f3cedf4b592d4d1e8bddb78b51ec2ed5056c52d3692baebc19                                                                                  2.3s
 => => resolve docker.io/library/nginx:latest@sha256:124b44bfc9ccd1f3cedf4b592d4d1e8bddb78b51ec2ed5056c52d3692baebc19                                                                                  2.3s
 => [2/2] COPY index.html /usr/share/nginx/html/index.html                                                                                                                                             0.0s
 => exporting to image                                                                                                                                                                                 0.1s
 => => exporting layers                                                                                                                                                                                0.0s
 => => exporting manifest sha256:19dd719772fd7ac839fadb7d49862f84422f4571a442994ffaca152e9674553a                                                                                                      0.0s
 => => exporting config sha256:e974f3ab92a0278e419f0fe4c5a6fc43fafb4a75da27895d90c4f2d5d385daa1                                                                                                        0.0s
 => => exporting attestation manifest sha256:e391b0212e5a100bd9132fbbd6cb4052e288dbbcba093839b55f8b197131372b                                                                                          0.0s
 => => exporting manifest list sha256:d35c2bbe10ab0b7e46d1ef8fba6c6cb28628eb9c283db02607e32e95b62e14d5                                                                                                 0.0s
 => => naming to docker.io/library/mynginximage:latest                                                                                                                                                 0.0s
 => => unpacking to docker.io/library/mynginximage:latest                                                                                                                                              0.0sOfferto da

Il punto alla fine indica la directory corrente come contesto di build. Docker legge il Dockerfile in quella directory. Otterrai un’immagine chiamata mynginximage sul tuo sistema locale. Verificala con:

docker images
mynginximage                                                                   latest                                                                        d35c2bbe10ab   36 seconds ago   281MBOfferto da

Dovresti vedere il nuovo nome nell’elenco. Questo approccio significa che il tuo Dockerfile e l’HTML sono combinati in un’unica immagine. Non devi montare nulla in fase di esecuzione.

Creare ed eseguire l’immagine personalizzata

Ora che hai creato mynginximage, puoi eseguirla:

docker run --name mycustomnginx -p 8080:80 -d mynginximageOfferto da

Assicurati di arrestare il container precedente per evitare conflitti di porta. 

Questo container serve automaticamente la pagina che hai inserito nel Dockerfile. Se apri un browser su http://localhost:8080, dovresti vedere quel testo HTML. 

Puoi condividere il tuo Dockerfile con altri o pubblicare l’immagine creata su un registry. Così i tuoi colleghi possono avviarla senza copiare cartelle locali.

Questo completa il processo di creazione di una minima immagine NGINX personalizzata. Sei partito dalla base ufficiale, hai copiato uno o due file e hai prodotto un nuovo container che include il tuo sito personalizzato. Puoi estendere ulteriormente il Dockerfile. Ad esempio, potresti voler cambiare la configurazione per gestire PHP con php-fpm in una build multi-stage o aggiungere moduli personalizzati non inclusi di default in NGINX.

Questo approccio evidenzia la flessibilità di Docker: ogni layer nel Dockerfile può svolgere un certo compito e l’immagine finale può essere distribuita facilmente. Hai il controllo sui contenuti web, oltre alla possibilità di ritoccare le impostazioni affinché il container si adatti al tuo progetto. 

Esplora queste 10 idee di progetti Docker per imparare Docker con progetti pratici incentrati sulla creazione e l’ottimizzazione di applicazioni di data science.

Configurare NGINX come reverse proxy

NGINX può indirizzare le richieste in arrivo ad altri servizi sulla stessa macchina o anche a servizi in esecuzione su macchine separate. Questo viene tipicamente chiamato configurazione di reverse proxy. Puoi posizionare NGINX davanti a un gruppo di applicazioni così che le richieste passino da un unico punto di ingresso. 

È comune quando hai più container Docker in ascolto su porte diverse e vuoi un unico nome di dominio per tutto. NGINX ascolta su una porta standard, come 80 o 443, quindi instrada il traffico verso il servizio corretto in base al percorso, all’hostname o ad altri fattori.

Capire il reverse proxy

Quando NGINX è configurato in questo modo, il client non è consapevole della comunicazione in background. NGINX funge da facciata pubblica, ricevendo e inoltrando le richieste e poi inviando le risposte al client. 

Questo design semplifica la struttura della rete. Offre anche l’opportunità di regolare la cache, aggiungere certificati TLS, gestire il load balancing o svolgere altre attività avanzate. Spesso è più facile gestire queste attività in un unico punto, invece di distribuirle tra più servizi.

Uno scenario tipico può prevedere un container con NGINX in ascolto sulla porta 80 che invia le richieste a un container dell’applicazione sulla porta 3000. Mentre il client visita http://yourdomain.com, il traffico viene indirizzato dietro le quinte a un container separato. 

Questo può permettere al container dell’applicazione di mantenere la sua porta predefinita, con un overhead minimo per l’utente. Un altro motivo è che potresti voler nascondere i dettagli interni dei tuoi servizi o presentare una struttura di URL uniforme.

Configurare NGINX per il reverse proxy

Per ottenere questo risultato, ti serve un file di configurazione per NGINX personalizzato che usi le direttive proxy. Puoi farlo montando un nuovo file di configurazione quando avvii il container o creando un’immagine personalizzata che lo includa. Ecco un esempio semplice per illustrare l’idea generale:

server {
    listen 80;

    location / {
        proxy_pass http://myapp:3000/;
    }
}Offerto da

Nello snippet sopra, qualsiasi richiesta che arriva al tuo container NGINX sulla porta 80 viene inviata a myapp:3000. Il nome myapp suggerisce che esista un altro container raggiungibile con quel nome, cosa comune quando si usa il networking di Docker. 

Se usi container standalone, potresti mappare l’indirizzo IP del container o usare l’IP dell’host. Puoi anche aggiungere impostazioni più avanzate, come proxy_set_header Host $host, o regolare i timeout in base alla tua applicazione.

Se preferisci montare questo file a runtime, puoi fare qualcosa del genere:

docker run --name nginxproxy -p 8080:80 -d \
    -v /path/to/nginx.conf:/etc/nginx/conf.d/default.conf \
    --network mynetwork \
    nginxOfferto da

Questo comando esegue il container NGINX montando il tuo nginx.conf locale come configurazione predefinita. Collega anche il container a una rete Docker chiamata mynetwork, dove risiede l’altro container (myapp). Spesso è l’approccio più semplice se vuoi mantenere la configurazione fuori dal container. 

È anche possibile inserire quel file in un Dockerfile se vuoi una soluzione statica. Entrambi gli approcci funzionano, purché i riferimenti corrispondano ai nomi dei tuoi container e delle reti.

Questo design ti consente di avere un unico dominio o IP per tutti i tuoi servizi web, insieme a una porta comune. Se gestisci più container di back-end, puoi definire più location nella configurazione, ciascuna puntata a una porta diversa del container. NGINX può quindi instradare a ogni servizio in base al percorso URL. È un approccio popolare per i microservizi perché consolida i punti di ingresso in modo ordinato.

Usare Docker Compose per il deployment di NGINX

Un reverse proxy diventa spesso più utile quando hai diversi container che lavorano insieme. Docker Compose è uno strumento che ti permette di definire molti servizi in un unico file. Poi puoi avviarli o arrestarli con un solo comando. Riduce la possibilità di errori nella creazione dei container o nella mappatura delle porte perché tutti i dettagli risiedono in un file standard.

Introduzione a Docker Compose

Docker Compose ti consente di gestire insiemi di container. Descrivi ciascun servizio, specifichi l’immagine da usare, le porte da pubblicare, i volumi da montare e le reti a cui collegarsi. Poi un semplice comando (docker compose up -d) avvia tutto in una volta. 

Questo approccio è comodo per lo sviluppo locale o per ambienti di staging dove devi coordinare più container Docker. Il formato del file è solitamente YAML.

Sebbene Docker Compose funzioni su vari sistemi operativi, devi assicurarti che sia installato e riconosciuto. Le moderne installazioni di Docker Desktop spesso lo includono di default. Controlla la versione con:

docker compose version
Docker Compose version v2.33.1-desktop.1Offerto da

Se vedi i dettagli della versione, sei pronto per procedere. In caso contrario, consulta la documentazione Docker su come abilitare o installare Docker Compose.

Creare un file docker-compose.yml

Il file include tipicamente una sezione services. Di seguito un semplice esempio di file docker-compose.yml che imposta un singolo container NGINX per servire contenuti statici: 

services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"
    volumes:
      - ./html:/usr/share/nginx/htmlOfferto da

Ecco come interpretare il file:

• services: definisce i servizi (container) che compongono la tua applicazione.

• web: questo servizio usa l’ultima immagine NGINX.
• ports: mappa la porta 80 all’interno del container alla porta 8080 sulla tua macchina host. Questo ti consente di accedere al server web via http://localhost:8080.
• volumes: monta la directory locale html nella directory predefinita dei contenuti di NGINX all’interno del container (/usr/share/nginx/html). Questa configurazione consente a NGINX di servire i tuoi contenuti statici personalizzati.

Distribuire i servizi con Docker Compose

Nella stessa directory del file docker-compose.yml, crea una sottocartella chiamata html.

Metti i tuoi file HTML statici (ad es., index.html) dentro questa directory html. In questo caso, ho creato una semplice pagina in stile Bootstrap per dimostrazione. 

Apri un terminale e vai nella directory del progetto che contiene il file docker-compose.yml.

Esegui il seguente comando per avviare il servizio:

docker compose up -d
[+] Running 1/1
 ✔ Container html_content-web-1  Started Offerto da

Il flag -d esegue il container in modalità detached, permettendogli di girare in background.

Docker Compose guarda il file docker-compose.yml nella directory corrente. Scarica le immagini non ancora presenti e poi avvia ogni container. 

Apri il browser e vai su http://localhost:8080.

Dovresti vedere i tuoi contenuti statici serviti da NGINX.

Puoi ispezionare lo stato dei servizi in esecuzione controllando:

docker compose psOfferto da

Se devi smantellare tutto, un solo comando può rimuovere i container:

docker compose downOfferto da

Questo li arresta e li rimuove tutti in una volta. Se vuoi replicare l’intero ambiente, ti basta copiare il file Docker Compose e il codice rilevante su una nuova macchina ed eseguire gli stessi comandi. In questo modo ottieni risultati coerenti con il minimo sforzo manuale.

Gestire i container NGINX

Sebbene l’approccio con Docker Compose sia popolare per workflow multi-servizio, a volte ti serve solo gestire un singolo container o un piccolo cluster. Docker fornisce alcuni comandi di base che aiutano a vedere cosa è in esecuzione, mettere in pausa o arrestare i container e rimuoverli se necessario. 

Questi sono essenziali per la manutenzione, soprattutto se stai sperimentando con più container NGINX o build ripetute.

Visualizzare i container in esecuzione

Ogni volta che vuoi vedere quali container sono in esecuzione, puoi usare:

docker ps
CONTAINER ID   IMAGE          COMMAND                  CREATED         STATUS         PORTS                  NAMES
2d386c085129   mynginximage   "/docker-entrypoint.…"   4 minutes ago   Up 4 minutes   0.0.0.0:8080->80/tcp   mycustomnginxOfferto da

Questo comando stampa una tabella dei container attivi, ognuno con ID, immagine, nome e altro. Se hai bisogno di vedere tutti i container, inclusi quelli arrestati, usa:

docker ps -aOfferto da

Questo mostra tutti i container presenti sul tuo sistema, anche quelli terminati. Spesso è utile vedere quali container sono rimasti da esecuzioni precedenti. Potresti avere container chiamati mynginx, mycustomnginx o altro se hai fatto vari esperimenti con più immagini.

Arrestare e rimuovere i container

Quando hai finito con un container, puoi arrestarlo per nome:

docker stop mynginx
CONTAINER ID   IMAGE          COMMAND                  CREATED         STATUS         PORTS                  NAMES
2d386c085129   mynginximage   "/docker-entrypoint.…"   4 minutes ago   Up 4 minutes   0.0.0.0:8080->80/tcp   mycustomnginxOfferto da

Questo dice a Docker di inviare un segnale di stop al container, che dovrebbe far chiudere NGINX in modo pulito. Se vuoi rimuovere subito dopo il container, puoi fare:

docker rm mynginxOfferto da

Se preferisci un unico comando che arresti e rimuova in un colpo solo, prova:

docker rm -f mynginxOfferto da

Questo forza la rimozione, arrestando il container se è ancora in esecuzione. Usa cautela in produzione, perché termina il container senza uno shutdown graduale. Un altro comando di manutenzione è docker rmi, che rimuove le immagini dal sistema. 

È utile se non ti servono più certe immagini e vuoi liberare spazio. Tuttavia, Docker elimina solo le immagini non utilizzate da un container in esecuzione.

Conclusione

NGINX in Docker è un modo pratico per servire pagine web o instradare il traffico verso altri servizi. Puoi eseguire l’immagine ufficiale o crearne una tua con un semplice Dockerfile. Docker Compose può coordinare più container, semplificando la gestione di configurazioni complesse. 

Con questi metodi, puoi distribuire contenuti, gestire l’inoltro e mantenere un ambiente affidabile per i progetti web. 

Se hai bisogno di un approccio più pratico per imparare Docker, dai un’occhiata al nostro corso Introduzione a Docker per scoprirne l’importanza nel toolkit di un data professional.