PostgreSQL in Docker: guida passo passo per principianti

Configurare PostgreSQL in Docker

L’unica cosa di cui hai bisogno per eseguire il database Postgres in Docker è il motore Docker stesso.

In questa sezione ti guiderò attraverso i prerequisiti e l’avvio di un database PostgreSQL pienamente funzionante in un container Docker.

Prerequisiti

Prima di iniziare con PostgreSQL in Docker, ti serve Docker installato sul tuo sistema.

L’installazione varia in base al sistema operativo. Su Windows e macOS puoi semplicemente installare Docker Desktop, un’interfaccia grafica facile da usare per gestire i container. Scaricalo dal sito ufficiale di Docker.

Gli utenti Linux possono installare direttamente Docker Engine tramite il gestore pacchetti della distribuzione. Per esempio, su Ubuntu:

sudo apt update
sudo apt install docker.io
sudo systemctl enable --now docker

Oltre ad avere Docker installato, è consigliabile avere dimestichezza con i comandi base del terminale e con i concetti fondamentali di Docker, come immagini, container e volumi. Queste guide pratiche di DataCamp ti coprono:

• Docker per principianti: guida pratica ai container
• Installa Docker su Ubuntu: dall’installazione al primo container

Scaricare l’immagine Docker di PostgreSQL

Prima di eseguire PostgreSQL, devi scaricare l’immagine Docker ufficiale di PostgreSQL da Docker Hub. Quest’immagine funge da template per creare i container.

Per scaricare l’ultima immagine di PostgreSQL, apri il terminale o il prompt dei comandi ed esegui:

docker pull postgres

Questo comando scarica l’ultima versione stabile di PostgreSQL. Se ti serve una versione specifica, puoi indicarla con un tag:

docker pull postgres:17

Immagine 1 - Download dell’ultima versione stabile dell’immagine del database PostgreSQL

Alcuni tag spesso usati per l’immagine di PostgreSQL includono:

• postgres:latest - La versione stabile più recente di PostgreSQL
• postgres:17 - PostgreSQL versione 14.x (la patch più recente della versione 17)
• postgres:17.4 - Una versione specifica (in questo caso 17.4).
• postgres:bookworm - PostgreSQL compilato sulla distribuzione Debian Bookworm.

Puoi vedere tutti i tag disponibili sulla pagina ufficiale di PostgreSQL su Docker Hub.

Eseguire PostgreSQL in un container Docker

Una volta ottenuta l’immagine di PostgreSQL, puoi creare e avviare un container con un singolo comando:

docker run --name postgres-db -e POSTGRES_PASSWORD=mypassword postgres

Immagine 2 - Avvio di un container PostgreSQL

Questo comando crea un nuovo container chiamato postgres-db e imposta una variabile d’ambiente per la password di PostgreSQL.

Tuttavia, questo comando base ha dei limiti. Ti consiglio di usare opzioni aggiuntive:

docker run --name postgres-db \
  -e POSTGRES_PASSWORD=mypassword \
  -e POSTGRES_USER=myuser \
  -e POSTGRES_DB=mydatabase \
  -p 5432:5432 \
  -v postgres-data:/var/lib/postgresql/data \
  -d postgres

Immagine 3 - Avvio di un container PostgreSQL con variabili d’ambiente in modalità detached

Ecco una spiegazione delle opzioni aggiuntive:

• Variabili d’ambiente:
  • POSTGRES_PASSWORD: imposta la password per l’utente superuser di PostgreSQL (obbligatoria).
  • POSTGRES_USER: crea un nuovo superuser con questo nome (predefinito "postgres" se non specificato).
  • POSTGRES_DB: crea un nuovo database con questo nome (predefinito uguale all’username se non specificato).
• Mapping delle porte (-p 5432:5432) mappa la porta PostgreSQL del container (5432) alla stessa porta sulla macchina host, permettendoti di connetterti a PostgreSQL usando localhost:5432.
• Montaggio del volume (-v postgres-data:/var/lib/postgresql/data) crea un volume Docker chiamato postgres-data che conserva i file del database al di fuori del container. In questo modo i dati non si perdono quando il container si ferma o viene rimosso.
• Il flag -d fa sì che il container giri in modalità detached. In parole povere, il container gira in background.

Puoi verificare che il container sia in esecuzione con:

docker ps

Immagine 4 - Elenco dei container in esecuzione

Nella prossima sezione ti mostrerò come configurare ulteriormente il tuo container PostgreSQL per casi d’uso specifici.

Configurare PostgreSQL in Docker

La configurazione di base vista nella sezione precedente è un buon inizio, ma per esigenze più avanzate vorrai probabilmente personalizzare il tuo container PostgreSQL.

È proprio l’obiettivo di questa sezione.

Impostare lo storage persistente con i volumi

Uno degli aspetti più importanti nell’eseguire un database in Docker è garantire che i dati persistano oltre il ciclo di vita del container. Per impostazione predefinita, tutti i dati nel container si perdono quando il container viene rimosso. Per un database, raramente è ciò che vuoi.

I volumi Docker risolvono il problema archiviando i dati al di fuori del filesystem del container.

Per configurarli, inizia creando un volume con nome:

docker volume create postgres-data

Facoltativamente, puoi ispezionare i dettagli del volume con il seguente comando:

docker volume inspect postgres-data

Immagine 5 - Dettagli del volume

Ora, quando avvii il container PostgreSQL, monta il volume sulla directory dei dati di PostgreSQL:

docker run --name postgres-db \
  -e POSTGRES_PASSWORD=mysecretpassword \
  -v postgres-data:/var/lib/postgresql/data \
  -d postgres

Il parametro -v postgres-data:/var/lib/postgresql/data collega il volume nominato alla directory dei dati del container.

In sintesi, usare i volumi con PostgreSQL offre questi vantaggi:

• I tuoi dati persistono anche se rimuovi il container.
• Puoi fermare, riavviare o aggiornare il container senza perdere i dati.
• Puoi creare backup dei dati effettuando il backup del volume.
• Migliori prestazioni rispetto ai bind mount (soprattutto su macOS e Windows).

Esporre le porte per connettersi a PostgreSQL

Per connetterti al database PostgreSQL da applicazioni in esecuzione sulla macchina host, devi esporre la porta PostgreSQL (5432) al sistema locale.

L’approccio più semplice è mappare la porta 5432 del container alla stessa porta sull’host:

docker run --name postgres-db \
  -e POSTGRES_PASSWORD=mysecretpassword \
  -p 5432:5432 \
  -d postgres

Il parametro -p 5432:5432 mappa la porta 5432 del container alla 5432 dell’host.

Se hai già PostgreSQL o un altro servizio che usa la porta 5432 sull’host, puoi mappare a una porta diversa:

docker run --name postgres-db \
  -e POSTGRES_PASSWORD=mysecretpassword \
  -p 5433:5432 \
  -d postgres

Ora la porta 5432 del container è mappata alla 5433 sull’host. In fase di connessione, dovrai specificare la 5433 invece della predefinita 5432.

Per impostazione predefinita, la porta è esposta su tutte le interfacce di rete (0.0.0.0). Per maggiore sicurezza, puoi limitarla a localhost:

docker run --name postgres-db \
  -e POSTGRES_PASSWORD=mysecretpassword \
  -p 127.0.0.1:5432:5432 \
  -d postgres

In questo modo le connessioni sono consentite solo dalla tua macchina locale, non da altre macchine in rete.

Configurare le impostazioni di PostgreSQL

Puoi modificare molte impostazioni predefinite di PostgreSQL all’avvio del container. Un approccio comune, ma non l’unico, è usare variabili d’ambiente.

Ecco alcune variabili che puoi usare per configurare il database:

docker run --name postgres-db \
  -e POSTGRES_PASSWORD=mysecretpassword \
  -e POSTGRES_USER=myuser \
  -e POSTGRES_DB=mydatabase \
  -e POSTGRES_INITDB_ARGS="--data-checksums" \
  -e POSTGRES_HOST_AUTH_METHOD=scram-sha-256 \
  -d postgres

Ecco cosa fa ognuna di queste:

• POSTGRES_PASSWORD: imposta la password del superuser (obbligatoria).
• POSTGRES_USER: imposta il nome del superuser (predefinito "postgres").
• POSTGRES_DB: imposta il nome del database predefinito (predefinito uguale all’utente).
• POSTGRES_INITDB_ARGS: passa argomenti al comando initdb di PostgreSQL.
• POSTGRES_HOST_AUTH_METHOD: imposta il metodo di autenticazione.

Oltre alle variabili d’ambiente, puoi anche personalizzare la configurazione di PostgreSQL per modifiche più avanzate.

Impostazioni di PostgreSQL spesso personalizzate:

• max_connections: controlla quante connessioni accetta PostgreSQL (predefinito 100).
• shared_buffers: imposta la memoria usata per la cache (spesso troppo bassa per la produzione).
• work_mem: memoria usata per le operazioni di query.
• maintenance_work_mem: memoria usata per le operazioni di manutenzione.

Per un’implementazione pratica, inizia creando un file, chiamiamolo my-postgres-conf:

max_connections = 200
shared_buffers = 1GB
work_mem = 16MB
maintenance_work_mem = 256MB

Ora monta questo file quando avvii il container:

docker run --name postgres-db \
  -e POSTGRES_PASSWORD=mysecretpassword \
  -v ./my-postgres.conf:/etc/postgresql/postgresql.conf \
  -v postgres-data:/var/lib/postgresql/data \
  -d postgres \
  -c 'config_file=/etc/postgresql/postgresql.conf'

In breve, configurando correttamente persistenza, accesso di rete e impostazioni di PostgreSQL, puoi creare un ambiente PostgreSQL basato su Docker che si comporta esattamente come vuoi. L’immagine base postgres:latest è solo questo — una base — su cui puoi intervenire in molti modi.

Nella prossima sezione ti mostrerò come connetterti al database PostgreSQL in esecuzione in Docker.

Connettersi a PostgreSQL in esecuzione in Docker

Ora che il tuo container PostgreSQL è attivo, il passo successivo è connetterti. In fondo, perché altrimenti eseguire un database?

In questa sezione ti mostrerò due modi per connetterti al database PostgreSQL containerizzato: tramite lo strumento da riga di comando psql e tramite un’interfaccia grafica.

Per riferimento, sto eseguendo il mio container database con questo comando:

docker run --name postgres-db \
  -e POSTGRES_PASSWORD=mysecretpassword \
  -e POSTGRES_USER=myuser \
  -e POSTGRES_DB=mydatabase \
  -v postgres-data:/var/lib/postgresql/data \
  -p 5432:5432 \
  -d postgres

Connessione tramite lo strumento da riga di comando psql

Lo strumento da riga di comando psql è il client ufficiale di PostgreSQL che ti consente di interagire con il database usando comandi SQL. 

Per connetterti al database PostgreSQL in esecuzione nel container dalla tua macchina host, esegui il seguente comando, ricordandoti di aggiornare utente e database:

docker exec -it postgres-db psql -U myuser -d mydatabase

Immagine 6 - Connessione al database Postgres con psql

E questo è tutto!

Se non ti è chiaro cosa fa il comando, ecco una breve spiegazione:

• docker exec -it postgres-db: esegue un comando interattivo all’interno del container chiamato "postgres-db".
• psql -U myuser -d mydatabase: avvia psql, connettendosi come "myuser" al database "mydatabase".

Se incontri problemi di connessione, verifica queste cause comuni:

• Conferma che il container sia in esecuzione con docker ps.
• Verifica il mapping delle porte con docker port postgres-db.

Connessione tramite uno strumento GUI

Molti sviluppatori preferiscono un tool grafico alla CLI — me compreso. pgAdmin è una scelta popolare e gratuita per PostgreSQL, ma il processo di connessione è simile anche con DBeaver, DataGrip o TablePlus.

L’installazione di pgAdmin è semplice, quindi non la tratterò qui.

Supponendo che tu l’abbia installato e avviato, fai clic destro su "Servers" nel pannello di navigazione e seleziona "Register > Server". Nella scheda General, assegna un nome alla connessione:

Immagine 7 - Scheda generale di pgAdmin

Poi passa alla scheda "Connection" e inserisci questi dettagli:

• Host name/address: localhost
• Port: 5432 (o la porta a cui hai fatto il mapping)
• Maintenance database: mydatabase
• Username: myuser
• Password: la tua password PostgreSQL

Immagine 8 - Scheda di connessione di pgAdmin

Infine, fai clic su "Save" per connetterti:

Immagine 9 - Connessione riuscita

Una volta connesso, puoi iniziare a lavorare con il tuo database come faresti con un’istanza PostgreSQL installata in locale o fornita dal cloud. Il bello di Docker è che, dal punto di vista della tua applicazione o del client, non c’è differenza: è semplicemente un database PostgreSQL raggiungibile all’indirizzo indicato.

>Ti serve accesso programmatico al database PostgreSQL? Scopri come accedervi da Python.

Nella prossima sezione, vedremo come gestire il container PostgreSQL: arresto, avvio e monitoraggio.

Gestire PostgreSQL in Docker

Eseguire un database PostgreSQL in un container e connetterti è un conto, gestirlo è un altro. Per fortuna, hai a disposizione una manciata di comandi utili.

In questa sezione coprirò operazioni essenziali come fermare e avviare il container, esaminare i log e mantenere aggiornata la versione di PostgreSQL.

Arrestare, riavviare e rimuovere il container PostgreSQL

Gli strumenti da riga di comando di Docker ti permettono di gestire il ciclo di vita del container PostgreSQL.

Per fermare un container PostgreSQL in esecuzione, esegui:

docker stop postgres-db

Analogamente, esegui il seguente comando quando vuoi riavviarlo:

docker start postgres-db

Immagine 10 - Arresto e avvio del container

Se vuoi riavviare un container in esecuzione, utile dopo aver cambiato alcune configurazioni, esegui:

docker restart postgres-db

Nei casi in cui hai finito del tutto con un container e vuoi rimuoverlo, ecco i due comandi da usare:

docker stop postgres-db
docker rm postgres-db

Ricorda che rimuovere un container non elimina i dati se hai configurato correttamente un volume. I dati resteranno nel volume postgres-data creato in precedenza.

Puoi verificare che il container sia stato rimosso eseguendo:

docker ps -a

Il flag -a mostra tutti i container, inclusi quelli fermati. Se è stato rimosso, il tuo container non comparirà nell’elenco:

Immagine 11 - Elenco di tutti i container

Ispezionare i log

Quando qualcosa non va o vuoi monitorare l’attività del database, controllare i log è un buon primo passo.

Esegui questo comando per visualizzare i log del container PostgreSQL:

docker logs postgres-db

Mostra tutti i log dall’avvio del container. Se l’output è molto lungo, puoi limitarlo, ad esempio, alle ultime 50 righe:

docker logs --tail 50 postgres-db

Immagine 12 - Visualizzazione dei log del container

Se vuoi invece seguire i log in tempo reale, esegui:

docker logs -f postgres-db

Immagine 13 - Visualizzazione dei log del container in tempo reale

È particolarmente utile per fare debug di problemi di connessione o osservare l’attività del database durante lo sviluppo.

Premi Ctrl+C/CMD+C per smettere di seguire i log.

Aggiornare PostgreSQL in Docker

Col tempo vorrai aggiornare la tua versione di PostgreSQL per ottenere le ultime funzionalità, miglioramenti di performance e patch di sicurezza.

Al momento della scrittura, postgres:17.4 è l’ultima versione, ma ipotizziamo che sia stata rilasciata postgres:17.5. Questa sezione ti mostra come aggiornare la versione del database nel tuo container.

Per iniziare, scarica l’ultima immagine di PostgreSQL (o una versione specifica):

docker pull postgres:17.5

Poi arresta e rimuovi il container esistente:

docker stop postgres-db
docker rm postgres-db

Infine, crea un nuovo container con lo stesso volume:

docker run --name postgres-db \
  -e POSTGRES_PASSWORD=mysecretpassword \
  -e POSTGRES_USER=myuser \
  -e POSTGRES_DB=mydatabase \
  -v postgres-data:/var/lib/postgresql/data \
  -p 5432:5432 \
  -d postgres:17.5

Dato che stai usando lo stesso volume (postgres-data), tutti i tuoi dati esistenti verranno preservati.

Se esegui un upgrade di versione principale (ad esempio da 17 a 18), PostgreSQL eseguirà automaticamente le migrazioni dei dati necessarie all’avvio. Tieni solo a mente:

• Gli upgrade di major version andrebbero testati prima in ambienti non di produzione.
• Fai sempre il backup del volume dati prima di un upgrade di major version.
• Controlla le release note di PostgreSQL per eventuali breaking change.

Per creare un backup prima dell’upgrade, esegui questo comando:

docker run --rm -v postgres-data:/data -v $(pwd):/backup postgres:17.4 \
  bash -c "pg_dumpall -U myuser > /backup/postgres_backup.sql"

Questo crea un file di backup SQL nella directory corrente che potrai usare per il ripristino in caso di problemi.

>Potresti trovare utile la nostra Cheat Sheet dei fondamenti di PostgreSQL come riferimento rapido mentre lavori in Docker.

Nella prossima sezione, tratterò le best practice per usare PostgreSQL in Docker, incluse considerazioni sulla sicurezza e consigli di ottimizzazione.

Best practice per usare PostgreSQL in Docker

La flessibilità di Docker va di pari passo con la responsabilità. In questa sezione, condivido alcune best practice per rendere il tuo setup PostgreSQL containerizzato affidabile, sicuro e in linea con gli standard del settore.

Proteggi i tuoi dati con backup regolari

Indipendentemente da come esegui PostgreSQL, i backup regolari sono imprescindibili. Ho già menzionato i backup nella sezione precedente, ma qui alzo l’asticella. 

Il modo più semplice per fare il backup di un database PostgreSQL in Docker è usare pg_dump:

docker exec -t postgres-db pg_dump -U myuser mydatabase > backup.sql

Immagine 14 - Backup PostgreSQL

Per un backup completo di tutti i database, incluse role e tablespace, usa pg_dumpall:

docker exec -t postgres-db pg_dumpall -U myuser > full_backup.sql

Immagine 15 - Backup completo del database PostgreSQL

L’immagine mostra solo un paio di comandi di backup, dato che non è possibile far stare tutto nello schermo.

Per automatizzare i backup, puoi creare un semplice script shell ed eseguirlo con cron:

#!/bin/bash
# backup.sh
TIMESTAMP=$(date +"%Y%m%d")
BACKUP_DIR="/Users/dradecic/Documents/pg-backups"

# Make sure the backup directory exists
mkdir -p $BACKUP_DIR

# Create the backup
docker exec postgres-db pg_dumpall -U myuser | gzip > $BACKUP_DIR/postgres_$TIMESTAMP.sql.gz

# Remove backups older than 30 days
find $BACKUP_DIR -name "postgres_*.sql.gz" -mtime +30 -delete

Rendi lo script eseguibile ed eseguilo:

chmod +x backup.sh

bash backup.sh

Immagine 16 - Esecuzione di uno script di backup del database PostgreSQL

Per automatizzare completamente il backup, puoi aggiungere lo script al tuo crontab per eseguirlo ogni giorno:

0 3 * * * /path/to/backup.sh

Questa pianificazione esegue il backup ogni giorno alle 3:00, ma ovviamente puoi adattare orario e frequenza alle tue esigenze. 

>Dai un’occhiata alla mia guida completa sui cron job per saperne di più su questo utile strumento di automazione.

Per gli ambienti di produzione, valuta di archiviare i backup off-site o in cloud per il disaster recovery.

Usa volumi nominati per la persistenza dei dati

Anche se ho già parlato dei volumi, vale la pena rivederli più in dettaglio.

Come regola generale, non dovresti mai eseguire PostgreSQL in Docker senza un volume correttamente configurato. In caso contrario, i dati andranno persi quando il container viene rimosso o durante le operazioni di cleanup di Docker.

Usare volumi con nome (piuttosto che anonimi) rende backup e gestione dei dati molto più semplici:

# Create a named volume
docker volume create postgres-data

# Use it when running the container
docker run --name postgres-db \
  -e POSTGRES_PASSWORD=mysecretpassword \
  -v postgres-data:/var/lib/postgresql/data \
  -d postgres

Niente di nuovo fin qui.

I volumi nominati sono anche più facili da salvare. Per creare un backup dell’intero volume, esegui:

docker run --rm -v postgres-data:/data -v $(pwd):/backup alpine tar czf /backup/postgres-data-backup.tar.gz /data

Questo creerà un file postgres-data-backup.tar.gz nella stessa cartella da cui hai eseguito il comando.

Per ripristinare questo volume, esegui invece:

docker run --rm -v postgres-data:/data -v $(pwd):/backup alpine sh -c "cd /data && tar xzf /backup/postgres-data-backup.tar.gz --strip 1"

Tutto qui!

Mettere in sicurezza PostgreSQL in Docker

Quando si parla di database, la sicurezza non dovrebbe mai essere un ripensamento. Questa sottosezione ti guida in alcune pratiche essenziali per mettere in sicurezza il tuo container PostgreSQL.

Usa password robuste e uniche

Evita password predefinite o deboli. Genera una password lunga e casuale per il superuser di PostgreSQL:

export POSTGRES_PASSWORD=$(openssl rand -base64 32)
echo "$POSTGRES_PASSWORD" > postgres-password.txt

docker run --name postgres-db \
  -e POSTGRES_PASSWORD="$POSTGRES_PASSWORD" \
  -v postgres-data:/var/lib/postgresql/data \
  -d postgres

Immagine 17 - Uso di una password sicura

Conserva questa password in modo sicuro, ad esempio in un password manager o in un file di variabili d’ambiente non tracciato nel controllo versione.

Limita l’accesso di rete

Per impostazione predefinita, Docker espone la porta di PostgreSQL su tutte le interfacce. Per maggiore sicurezza, soprattutto in produzione, limita l’accesso a localhost:

docker run --name postgres-db \
  -e POSTGRES_PASSWORD=mysecretpassword \
  -p 127.0.0.1:5432:5432 \
  -v postgres-data:/var/lib/postgresql/data \
  -d postgres

Usa una configurazione personalizzata di PostgreSQL

Crea una configurazione più sicura modificando parametri come i seguenti:

# Require SSL
ssl = on
ssl_cert_file = '/etc/ssl/certs/ssl-cert-snakeoil.pem'
ssl_key_file = '/etc/ssl/private/ssl-cert-snakeoil.key'

# Limit connection attempts
max_connections = 100
authentication_timeout = 1min

# Restrict access
listen_addresses = 'localhost'

Monta questo file di configurazione all’avvio del container:

docker run --name postgres-db \
  -e POSTGRES_PASSWORD=mysecretpassword \
  -v ./pg_hba.conf:/var/lib/postgresql/data/pg_hba.conf \
  -v ./postgresql.conf:/var/lib/postgresql/data/postgresql.conf \
  -v postgres-data:/var/lib/postgresql/data \
  -d postgres

Aggiorna regolarmente l’immagine di PostgreSQL

Tieni aggiornata la versione di PostgreSQL per ottenere le ultime patch di sicurezza:

docker pull postgres:latest
docker stop postgres-db
docker rm postgres-db
# Then recreate with the latest image

Queste best practice ti permetteranno di creare un ambiente PostgreSQL in Docker più affidabile e sicuro, adatto sia allo sviluppo che alla produzione.

Nella prossima sezione, vedremo come risolvere i problemi più comuni quando esegui PostgreSQL in Docker.

Risoluzione dei problemi con PostgreSQL in Docker

Prima o poi, è probabile che tu incontri dei problemi eseguendo PostgreSQL in Docker. In questa sezione tratto i problemi più comuni e le relative soluzioni, così da farti risparmiare tempo e frustrazione.

Problemi comuni con i container PostgreSQL

Un problema frequente è che il container si arresta immediatamente dopo l’avvio. Se succede, controlla i log per identificare il problema:

docker logs postgres-db

L’errore potrebbe essere dovuto a problemi di permessi con i volumi montati. In tal caso, vedrai un messaggio simile:

initdb: could not change permissions of directory "/var/lib/postgresql/data": Operation not permitted

Per risolvere, controlla proprietà e permessi del volume e correggili se necessario:

# Check the ownership
docker run --rm -v postgres-data:/data alpine ls -la /data

# Fix the permissions
docker run --rm -v postgres-data:/data alpine chmod 700 /data

Un altro problema comune sono le variabili d’ambiente obbligatorie mancanti. Un tipico messaggio di log è questo:

Database is uninitialized and superuser password is not specified

Per risolvere, assicurati di impostare la variabile obbligatoria POSTGRES_PASSWORD — o qualsiasi altra variabile necessaria:

docker run --name postgres-db \
  -e POSTGRES_PASSWORD=mysecretpassword \
  -v postgres-data:/var/lib/postgresql/data \
  -d postgres

È comune anche l’errore “Data directory not empty but missing PostgreSQL files”. Questo è il messaggio che probabilmente vedrai:

PostgreSQL Database directory appears to contain a database; Skipping initialization

Seguito da errori relativi a file mancanti.

Di solito accade quando monti un volume che contiene file ma non un database PostgreSQL valido. Potresti dover reinizializzare usando un nuovo volume:

docker volume create postgres-data-new
docker run --name postgres-db \
  -e POSTGRES_PASSWORD=mysecretpassword \
  -v postgres-data-new:/var/lib/postgresql/data \
  -d postgres

Risoluzione dei problemi di connettività

Se non riesci a connetterti al database PostgreSQL in container, inizia verificando che il container sia in esecuzione:

docker ps | grep postgres-db

Se non è elencato, potrebbe essere andato in crash. Controlla i log come descritto prima.

Se è elencato ma non riesci comunque a connetterti, verifica il mapping delle porte:

docker port postgres-db

Dovresti vedere qualcosa del genere:

Immagine 18 - Mapping delle porte del container

Se non è così, il mapping delle porte potrebbe essere errato. Ricrea il container con l’opzione -p corretta.

Se ancora non riesci a connetterti al database, è il momento di controllare le impostazioni di connessione. Verifica questi parametri:

• Hostname: localhost o 127.0.0.1 (non il nome del container).
• Porta: la porta host del mapping (di solito 5432).
• Username: il valore di POSTGRES_USER (predefinito "postgres").
• Password: il valore di POSTGRES_PASSWORD.
• Database: il valore di POSTGRES_DB (predefinito uguale a POSTGRES_USER).

Riprova dopo aver sistemato questi aspetti. Se il problema persiste, prova a testare la connettività dall’interno del container:

docker exec -it postgres-db psql -U postgres

Se funziona, il problema riguarda il mapping delle porte o la rete esterna.

Infine, puoi verificare eventuali problemi di firewall. Il firewall del sistema potrebbe bloccare le connessioni alla porta di PostgreSQL, quindi controlla così:

# Linux
sudo iptables -L | grep 5432

# macOS
sudo pfctl -sr | grep 5432

Controllando questi aspetti dovresti riuscire a identificare e risolvere la maggior parte dei problemi con PostgreSQL in Docker. Se sei ancora in difficoltà, la documentazione e i forum delle community di PostgreSQL e Docker sono ottime risorse per troubleshooting più specifici.

Riepilogo: database PostgreSQL in Docker

Eccoci arrivati — la guida definitiva per configurare ed eseguire database PostgreSQL in Docker! Abbiamo visto tutto ciò che ti serve per iniziare: dall’avvio del primo container alla configurazione, connessione e gestione del database. 

Le opzioni tradizionali per PostgreSQL, come l’installazione locale o il provisioning in cloud, sono spesso poco ottimali o costose per lo sviluppo. Docker colma questo divario. Che tu lo usi per sviluppo locale, test o perfino produzione, PostgreSQL containerizzato offre una flessibilità e una coerenza difficili da superare.

Ora sei più che pronto per integrare un database Postgres containerizzato nelle tue applicazioni.

Se vuoi approfondire, ti consiglio questi corsi di DataCamp:

• Creating PostgreSQL Databases
• Introduction to Docker
• SQL for Database Administrators
• Functions for Manipulating Data in PostgreSQL