Containerizzazione delle app Go con Docker

Docker è la tecnologia di containerizzazione più popolare grazie alla sua semplicità e facilità d'uso. Docker allevia lo stress dei problemi di portabilità nello sviluppo e nella distribuzione del software. Puoi distribuire i tuoi container docker alla maggior parte dei provider di servizi cloud.

La containerizzazione delle tue app Go con Docker può aiutarti a garantire una distribuzione coerente e affidabile in diversi ambienti. Puoi distribuire le tue app Go in diversi ambienti come sviluppo, gestione temporanea e produzione. I container Docker sono leggeri e occupano meno spazio rispetto alle macchine virtuali tradizionali. Ciò può farti risparmiare sui costi di hosting e può anche rendere più veloci le tue implementazioni.

Configurazione di un semplice server Web in Go

La libreria standard Go contiene i pacchetti necessari per configurare un semplice server web.

Innanzitutto, importa il file http, tronco d'albero, E json Pacchetti. Userai Il pacchetto http di Go per configurare il server e OTTENERE terminale di richiesta. IL tronco d'albero pacchetto per registrare possibili errori nella tua console. IL json per codificare una struttura in JSON per l'endpoint API.

importare (
"codifica/json"
"tronco d'albero"
"rete/http"
)

Puoi codificare un'istanza struct come JSON al client come risposta in base alla validità della richiesta come segue:

tipo Messaggio struct {
 Risposta corda`json:"risposta"`
 Descrizione corda`json:"descrizione"`
}

La funzione del gestore restituirà un messaggio di successo al client se la richiesta all'endpoint è a OTTENERE richiesta.

// dockerTestEndpoint gestisce l'endpoint API per testare la connettività Docker
funzdockerTestEndpoint(scrittore http. ResponseWriter, richiesta *http. Richiesta) {
// Imposta l'intestazione della risposta per indicare il contenuto JSON
 scrittore. Intestazione().Set("Tipo di contenuto,""applicazione/json")
// Se il metodo di richiesta è GET
Se richiesta. Metodo == "OTTENERE" {
// Imposta il codice di stato della risposta su 200 OK
 scrittore. WriteHeader (http. StatoOK)
// Crea una struttura del messaggio per una risposta riuscita
 messaggio := Messaggio{
 Risposta: "Riuscito",
 Descrizione: "Hai raggiunto correttamente l'endpoint API" +
"Dal tuo contenitore Docker",
 }
// Codifica il messaggio come JSON e invialo come risposta
 err := json. NewEncoder (scrittore).Codifica(&messaggio)
Se errare!= zero {
ritorno
 }
 } altro {
// Se il metodo di richiesta non è GET
// Imposta il codice di stato della risposta su 400 Bad Request
 scrittore. WriteHeader (http. StatusBadRequest)
// Crea una struttura del messaggio per una risposta alla richiesta errata
 messaggio := Messaggio{
 Risposta: "Brutta richiesta",
 Descrizione: "Hai raggiunto con successo l'endpoint API dal tuo " +
"Docker Container, ma hai fatto una richiesta sbagliata",
 }
// Codifica il messaggio come JSON e invialo come risposta
 err := json. NewEncoder (scrittore).Codifica(&messaggio)
Se errare!= zero {
ritorno
 }
 }
}

Si imposta la funzione gestore nella funzione principale con il percorso come /api/docker/go. IL dockerTestEndpoint La funzione del gestore convalida che la richiesta al gestore è una richiesta GET. Se si tratta di una richiesta GET, codifica un'istanza Messaggio struct al client in base allo stato della richiesta.

Ecco come puoi montare la funzione del gestore su un percorso e configurare il server per l'esecuzione sulla porta 8080:

funzprincipale() {
// Registra la funzione del gestore 'dockerTestEndpoint'
// per gestire le richieste per l'URL "/api/docker/go".
 http. HandleFunc("/api/docker/vai", dockerTestEndpoint)
// Avvia il server HTTP e ascolta le richieste in arrivo sulla porta 8080.
 err := http. AscoltaEServi(":8080", zero)
Se errare!= zero {
 tronco d'albero. fatale("C'è un errore con il server:", ehm)
 }
}

IL principale La funzione è il punto di ingresso del server, che è in ascolto sulla porta 8080. IL ManigliaFunc Il metodo monta le rotte sulla funzione gestore. IL Ascolta e servi Il metodo avvia il server sulla porta host locale specificata 8080.

Iniziare a containerizzare le tue app Go con Docker

Dopo aver installato e configurato Docker, avrai bisogno di un file Docker denominato Dockerfile per creare e creare un'immagine Docker per la tua app Go. Specificherai i comandi per l'immagine di base e i comandi per copiare i file, aggiungere la directory di lavoro ed eseguire l'app nel Dockerfile.

Esegui questo comando nel terminale del tuo spazio di lavoro per creare un Dockerfile.

toccare Dockerfile

Specificherai i comandi per creare la tua immagine Docker nel Dockerfile.

Se sono presenti file che desideri separare dall'immagine Docker, puoi utilizzare un file .dockerignore file. IL .dockerignore i file funzionano esattamente come .gitignore File.

toccare .dockerignore

Successivamente, specificherai i comandi di build nel tuo Dockerfile per containerizzare le tue app.

Definizione dei comandi nel Dockerfile

I Dockerfile sono personalizzabili in base alle specifiche del tuo progetto. Definirai i comandi per creare l'immagine di base per la creazione dell'applicazione.

Ecco un esempio del contenuto di un Dockerfile che crea il server web sopra:

# Usa un'immagine di base Golang
DA golang: ultimo
# Imposta la directory di lavoro all'interno del contenitore
WORKDIR /app
# Copia tutti i file nella directory locale nella directory di lavoro nel contenitore
COPIA. .
# Scarica le dipendenze del modulo Go
CORRERE vai al download mod
# Costruisci l'applicazione Go
CORRERE vai build -o app
# Imposta il punto di ingresso per l'applicazione
PUNTO D'ENTRATA ["./applicazione"]

Il Dockerfile utilizza golang: ultimo immagine di base, per creare l'app dopo aver impostato la directory di lavoro su /app.

Il Dockerfile copia i file con l'estensione COPIA comando e scarica le dipendenze con il file CORRERE comando.

Il file specifica un'operazione di compilazione ed esecuzione con l'estensione CORRERE command, quindi imposta il comando in modo che venga eseguito quando il contenitore viene avviato con il cmd comando.

Salva il Dockerfile nella stessa directory del tuo file vai.mod E main.go File; quindi esegui questo comando per creare un'immagine Docker da questo Dockerfile:

finestra mobile build -t GolangTutorial .

Il comando precedente creerà un'immagine Docker con il tag golangtutorial. Puoi eseguire un contenitore con questo comando:

docker run -p 8080:8080 golangtutorial

Il comando esegue il mapping della porta 8080 dal contenitore alla porta 8080 sull'host locale della macchina host. È possibile richiedere il server in esecuzione nel contenitore Docker dalla macchina host.

Ecco il risultato di inviando la richiesta CURL al server, questa volta in esecuzione su Docker:

Puoi usare Docker Compose per l'orchestrazione dei container

Docker Compose è uno strumento che puoi usare per orchestrare (lavorare con molti) contenitori Docker. Docker Compose ti consente di definire un'applicazione multi-contenitore in un singolo file YAML. Puoi eseguire e gestire l'intera applicazione con un singolo comando.

Puoi utilizzare Docker Compose per la distribuzione e la gestione di complesse applicazioni containerizzate. Docker Compose semplifica la gestione con distribuzioni automatizzate e coerenti.