Containerisering af Go-apps med Docker

Docker er den mest populære containeriseringsteknologi på grund af dens enkelhed og brugervenlighed. Docker lindrer stresset med problemer med portabilitet i softwareudvikling og distribution. Du kan implementere dine docker-containere til de fleste cloud-tjenesteudbydere.

Containerisering af dine Go-apps med Docker kan hjælpe dig med at sikre ensartet og pålidelig implementering på tværs af forskellige miljøer. Du kan implementere dine Go-apps til forskellige miljøer som udvikling, iscenesættelse og produktion. Docker-containere er lette og fylder mindre end traditionelle virtuelle maskiner. Dette kan spare dig penge på hostingomkostninger, og det kan også gøre dine implementeringer hurtigere.

Opsætning af en simpel webserver på vej

Go-standardbiblioteket indeholder de pakker, du skal bruge for at konfigurere en simpel webserver.

Først skal du importere

http, log, og json pakker. du vil bruge Go's http-pakke at opsætte serveren og FÅ anmode om slutpunkt. Det log pakke til at logge mulige fejl til din konsol. Det json-pakke til kodning af en struct til JSON for API-endepunktet.

importere (
"encoding/json"
"log"
"net/http"
)

Du kan kode en struct-instans som JSON til klienten som et svar baseret på gyldigheden af ​​anmodningen på følgende måde:

type Besked struktur {
 Respons snor`json:"svar"`
 Beskrivelse snor`json:"beskrivelse"`
}

Behandlerfunktionen ville returnere en vellykket besked til klienten, hvis anmodningen til slutpunktet er en FÅ anmodning.

// dockerTestEndpoint håndterer API-endepunktet til test af Docker-forbindelse
funcdockerTestEndpoint(forfatter http. ResponseWriter, anmod om *http. Anmodning) {
// Indstil svaroverskriften til at angive JSON-indhold
 forfatter. Header().Set("Indholdstype,""applikation/json")
// Hvis anmodningsmetoden er GET
hvis anmodning. Metode == "FÅ" {
// Indstil svarstatuskoden til 200 OK
 forfatter. WriteHeader (http. Status OK)
// Opret en meddelelsesstruktur for et vellykket svar
 besked := besked{
 Respons: "Vellykket",
 Beskrivelse: "Du har nået API-endepunktet" +
"Fra din Docker Container",
 }
// Kod beskeden som JSON og send den som svar
 fejl := json. NewEncoder (writer).Encode(&besked)
hvis fejl!= nul {
Vend tilbage
 }
 } andet {
// Hvis anmodningsmetoden ikke er GET
// Indstil svarstatuskoden til 400 Bad Request
 forfatter. WriteHeader (http. StatusBadRequest)
// Opret en meddelelsesstruktur for et dårligt anmodningssvar
 besked := besked{
 Respons: "Dårlig anmodning",
 Beskrivelse: "Du har nået API-endepunktet fra din" +
"Docker Container, men du har lavet en dårlig anmodning",
 }
// Kod beskeden som JSON og send den som svar
 fejl := json. NewEncoder (writer).Encode(&besked)
hvis fejl!= nul {
Vend tilbage
 }
 }
}

Du opsætter handlerfunktionen i hovedfunktionen med ruten som /api/docker/go. Det dockerTestEndpoint handlerfunktionen validerer, at anmodningen til behandleren er en GET-anmodning. Hvis det er en GET-anmodning, koder den en instansieret Besked struct instans til klienten baseret på anmodningens status.

Sådan kan du montere handlerfunktionen på en rute og konfigurere serveren til at køre på port 8080:

funcvigtigste() {
// Registrer handlerfunktionen 'dockerTestEndpoint'
// til at håndtere anmodninger om "/api/docker/go" URL'en.
 http. HandleFunc("/api/docker/go", dockerTestEndpoint)
// Start HTTP-serveren og lyt efter indgående anmodninger på port 8080.
 fejl := http. LytOgServe(":8080", nul)
hvis fejl!= nul {
 log. Fatalln("Der er en fejl med serveren:", fejl)
 }
}

Det vigtigste funktion er serverens indgangspunkt, som lytter på port 8080. Det HandleFunc metode monterer ruterne på handlerfunktionen. Det ListenAndServe metoden starter serveren på den angivne lokale værtsport 8080.

Kom godt i gang med at containerisere dine Go-apps med Docker

Efter installation og opsætning af Docker skal du bruge en Docker-fil ved navn Dockerfile for at oprette og bygge et Docker-billede til din Go-app. Du skal angive kommandoer til basisbilledet og kommandoer til at kopiere filerne, tilføje arbejdsmappen og køre appen i Dockerfilen.

Kør denne kommando i terminalen på dit arbejdsområde for at oprette en Dockerfile.

tryk på Dockerfile

Du specificerer kommandoerne til at bygge dit Docker-billede i Dockerfilen.

Hvis der er nogle filer, du vil adskille fra dit Docker-billede, kan du bruge en .dockerignore fil. Det .dockerignore filer fungerer nøjagtigt som .gitignore filer.

berør .dockerignore

Dernæst skal du angive build-kommandoer i din Dockerfile for at containerisere dine apps.

Definer kommandoer i Dockerfilen

Dockerfiler kan tilpasses baseret på dit projekts specifikationer. Du definerer kommandoer til at bygge basisbilledet til opbygning af applikationen.

Her er et eksempel på indholdet af en Dockerfile, der bygger webserveren ovenfor:

# Brug et Golang-basebillede
FRA golang: seneste
# Indstil arbejdsmappen inde i beholderen
WORKDIR /app
# Kopierer alle filerne i den lokale mappe til arbejdsmappen i containeren
KOPI. .
# Download Go-modulets afhængigheder
LØB go mod download
# Byg Go-applikationen
LØB gå til at bygge -o app
# Indstil indgangspunktet for applikationen
INDGANG ["./app"]

Dockerfilen bruger golang: seneste basisbillede, for at bygge appen efter at have indstillet arbejdsbiblioteket til /app.

Dockerfilen kopierer filerne med KOPI kommando og downloads afhængigheder med LØB kommando.

Filen angiver en bygge- og kørselsoperation med LØB kommando, og indstiller derefter kommandoen til at køre, når containeren starter med CMD kommando.

Gem Dockerfilen i samme mappe som din go.mod og main.go filer; kør derefter denne kommando for at bygge et Docker-billede fra denne Dockerfil:

docker build -t GolangTutorial .

Ovenstående kommando vil oprette et Docker-billede med tagget golangtutorial. Du kan køre en container med denne kommando:

docker run -p 8080:8080 golangtutorial

Kommandoen kortlægger port 8080 fra containeren til port 8080 på værtsmaskinens lokale vært. Du kan anmode om serveren, der kører i Docker-beholderen, fra værtsmaskinen.

Her er resultatet fra sender CURL-anmodningen til serveren, denne gang kører på Docker:

Du kan bruge Docker Compose til Container Orchestration

Docker Compose er et værktøj, som du kan bruge til at orkestrere (arbejde med mange) Docker-containere. Docker Compose giver dig mulighed for at definere en multi-container-applikation i en enkelt YAML-fil. Du kan køre og administrere hele applikationen med en enkelt kommando.

Du kan bruge Docker Compose til at implementere og administrere komplekse containeriserede applikationer. Docker Compose forenkler administrationen med automatiserede og ensartede implementeringer.