Containerizing Go-apper med Docker

Docker er den mest populære containeriseringsteknologien på grunn av sin enkelhet og brukervennlighet. Docker lindrer stresset med portabilitetsproblemer i programvareutvikling og distribusjon. Du kan distribuere docker-beholderne dine til de fleste skytjenesteleverandører.

Containerisering av Go-appene dine med Docker kan hjelpe deg med å sikre konsistent og pålitelig distribusjon på tvers av forskjellige miljøer. Du kan distribuere Go-appene dine til forskjellige miljøer som utvikling, iscenesettelse og produksjon. Docker-containere er lette og tar mindre plass enn tradisjonelle virtuelle maskiner. Dette kan spare deg penger på hostingkostnader, og det kan også gjøre distribusjonene dine raskere.

Sette opp en enkel webserver i farten

Go-standardbiblioteket inneholder pakkene du trenger for å sette opp en enkel webserver.

Først importerer du http, Logg

, og json pakker. du vil bruke Go's http-pakke for å sette opp serveren og FÅ be om endepunkt. De Logg pakke for å logge mulige feil til konsollen din. De json-pakke for koding av en struktur til JSON for API-endepunktet.

import (
"encoding/json"
"Logg"
"net/http"
)

Du kan kode en struct-instans som JSON til klienten som et svar basert på gyldigheten av forespørselen slik:

type Beskjed struktur {
 Respons streng`json:"svar"`
 Beskrivelse streng`json:"beskrivelse"`
}

Behandlerfunksjonen vil returnere en vellykket melding til klienten hvis forespørselen til endepunktet er en FÅ be om.

// dockerTestEndpoint håndterer API-endepunktet for å teste Docker-tilkobling
funcdockerTestEndpoint(forfatter http. ResponseWriter, be om *http. Be om) {
// Angi svaroverskriften for å indikere JSON-innhold
 forfatter. Header().Set("Innholdstype,""applikasjon/json")
// Hvis forespørselsmetoden er GET
hvis be om. Metode == "FÅ" {
// Sett svarstatuskoden til 200 OK
 forfatter. WriteHeader (http. StatusOK)
// Lag en meldingsstruktur for et vellykket svar
 melding := melding{
 Respons: "Vellykket",
 Beskrivelse: "Du har nådd API-endepunktet" +
"Fra Docker Container",
 }
// Kod meldingen som JSON og send den som svar
 feil := json. NewEncoder (writer).Encode(&melding)
hvis feil!= null {
komme tilbake
 }
 } ellers {
// Hvis forespørselsmetoden ikke er GET
// Sett svarstatuskoden til 400 Bad Request
 forfatter. WriteHeader (http. StatusBadRequest)
// Opprett en meldingsstruktur for et dårlig forespørselssvar
 melding := melding{
 Respons: "Dårlig forespørsel",
 Beskrivelse: "Du har nådd API-endepunktet fra din" +
"Docker Container, men du kom med en dårlig forespørsel",
 }
// Kod meldingen som JSON og send den som svar
 feil := json. NewEncoder (writer).Encode(&melding)
hvis feil!= null {
komme tilbake
 }
 }
}

Du setter opp handlerfunksjonen i hovedfunksjonen med ruten som /api/docker/go. De dockerTestEndpoint behandlerfunksjonen validerer at forespørselen til behandleren er en GET-forespørsel. Hvis det er en GET-forespørsel, koder den en instansiert Beskjed struct forekomst til klienten basert på forespørselens status.

Her er hvordan du kan montere behandlerfunksjonen på en rute og sette opp serveren til å kjøre på port 8080:

funchoved-() {
// Registrer behandlerfunksjonen 'dockerTestEndpoint'
// for å håndtere forespørsler om "/api/docker/go" URL.
 http. HandleFunc("/api/docker/go", dockerTestEndpoint)
// Start HTTP-serveren og lytt etter innkommende forespørsler på port 8080.
 feil := http. ListenAndServe(":8080", null)
hvis feil!= null {
 Logg. Fatalln("Det er en feil med serveren:", feil)
 }
}

De hoved- funksjon er serverens inngangspunkt, som lytter på port 8080. De HandleFunc metoden monterer rutene på handlerfunksjonen. De ListenAndServe metoden starter serveren på den angitte lokale vertsporten 8080.

Komme i gang containerisering av Go-appene dine med Docker

Etter å ha installert og satt opp Docker, trenger du en Docker-fil kalt Dockerfile for å lage og bygge et Docker-bilde for Go-appen din. Du spesifiserer kommandoer for basisbildet og kommandoer for å kopiere filene, legge til arbeidskatalogen og kjøre appen i Dockerfilen.

Kjør denne kommandoen i terminalen på arbeidsområdet for å lage en Dockerfile.

trykk på Dockerfile

Du spesifiserer kommandoene for å bygge Docker-bildet ditt i Dockerfilen.

Hvis det er noen filer du vil skille fra Docker-bildet ditt, kan du bruke en .dockerignore fil. De .dockerignore filer fungerer akkurat som .gitignore filer.

trykk på .dockerignore

Deretter spesifiserer du byggekommandoer i Dockerfile for å beholde appene dine.

Definere kommandoer i Dockerfilen

Dockerfiler kan tilpasses basert på prosjektets spesifikasjoner. Du vil definere kommandoer for å bygge grunnbildet for å bygge applikasjonen.

Her er et eksempel på innholdet i en Dockerfile som bygger webserveren ovenfor:

# Bruk et Golang-grunnbilde
FRA golang: siste
# Sett arbeidskatalogen inne i beholderen
WORKDIR /app
# Kopierer alle filene i den lokale katalogen til arbeidskatalogen i beholderen
KOPIERE. .
# Last ned Go-modulens avhengigheter
LØPE Last ned go mod
# Bygg Go-applikasjonen
LØPE gå bygge -o app
# Angi inngangspunktet for applikasjonen
INNGANGSPUNKT ["./app"]

Dockerfilen bruker golang: siste basisbilde, for å bygge appen etter å ha satt arbeidskatalogen til /app.

Dockerfilen kopierer filene med KOPIERE kommando og nedlastingsavhengigheter med LØPE kommando.

Filen spesifiserer en bygge- og kjøringsoperasjon med LØPE kommandoen, setter deretter kommandoen til å kjøre når beholderen starter med CMD kommando.

Lagre Dockerfilen i samme katalog som din go.mod og main.go filer; kjør deretter denne kommandoen for å bygge et Docker-bilde fra denne Dockerfilen:

docker build -t GolangTutorial .

Kommandoen ovenfor vil lage et Docker-bilde med taggen golangtutorial. Du kan kjøre en beholder med denne kommandoen:

docker run -p 8080:8080 golangtutorial

Kommandoen tilordner port 8080 fra containeren til port 8080 på den lokale vertsmaskinen. Du kan be om serveren som kjører i Docker-beholderen fra vertsmaskinen.

Her er resultatet fra sender CURL-forespørselen til serveren, denne gangen kjører på Docker:

Du kan bruke Docker Compose for Container Orchestration

Docker Compose er et verktøy som du kan bruke til å orkestrere (arbeide med mange) Docker-beholdere. Docker Compose lar deg definere en flerbeholderapplikasjon i en enkelt YAML-fil. Du kan kjøre og administrere hele applikasjonen med en enkelt kommando.

Du kan bruke Docker Compose for å distribuere og administrere komplekse containeriserte applikasjoner. Docker Compose forenkler administrasjonen med automatiserte og konsistente distribusjoner.