Containerizing Go-appar med Docker

Docker är den mest populära containeriseringstekniken på grund av dess enkelhet och användarvänlighet. Docker lindrar stressen med portabilitetsproblem i mjukvaruutveckling och distribution. Du kan distribuera dina dockningscontainrar till de flesta molntjänstleverantörer.

Att behålla dina Go-appar med Docker kan hjälpa dig att säkerställa konsekvent och pålitlig distribution i olika miljöer. Du kan distribuera dina Go-appar i olika miljöer som utveckling, iscensättning och produktion. Dockercontainrar är lätta och tar mindre plats än traditionella virtuella maskiner. Detta kan spara pengar på värdkostnader, och det kan också göra dina distributioner snabbare.

Konfigurera en enkel webbserver i farten

Go-standardbiblioteket innehåller de paket du behöver för att konfigurera en enkel webbserver.

Importera först http, logga, och json paket. Du kommer att använda

Go's http-paket för att ställa in servern och SKAFFA SIG begära slutpunkt. De logga paket för att logga möjliga fel till din konsol. De json-paket för att koda en struct till JSON för API-slutpunkten.

importera (
"encoding/json"
"logga"
"net/http"
)

Du kan koda en struct-instans som JSON till klienten som ett svar baserat på begärans giltighet på följande sätt:

typ Meddelande struktur {
 Svar sträng`json:"svar"`
 Beskrivning sträng`json:"beskrivning"`
}

Hanterarfunktionen skulle returnera ett lyckat meddelande till klienten om begäran till slutpunkten är en SKAFFA SIG begäran.

// dockerTestEndpoint hanterar API-slutpunkten för att testa Docker-anslutning
funcdockerTestEndpoint(författare http. ResponseWriter, begär *http. Begäran) {
// Ställ in svarshuvudet för att indikera JSON-innehåll
 författare. Header().Set("Innehållstyp,""applikation/json")
// Om förfrågningsmetoden är GET
om begäran. Metod == "SKAFFA SIG" {
// Ställ in svarsstatuskoden till 200 OK
 författare. WriteHeader (http. StatusOK)
// Skapa en meddelandestruktur för ett framgångsrikt svar
 meddelande := meddelande{
 Svar: "Framgångsrik",
 Beskrivning: "Du har lyckats nå API-slutpunkten" +
"Från din Docker Container",
 }
// Koda meddelandet som JSON och skicka det som svar
 fel := json. NewEncoder (writer).Encode(&meddelande)
om fel!= noll {
lämna tillbaka
 }
 } annan {
// Om förfrågningsmetoden inte är GET
// Ställ in svarsstatuskoden till 400 Bad Request
 författare. WriteHeader (http. StatusBadRequest)
// Skapa en meddelandestruktur för ett dåligt förfrågningssvar
 meddelande := meddelande{
 Svar: "Dålig förfrågan",
 Beskrivning: "Du har lyckats nå API-slutpunkten från din" +
"Docker Container, men du gjorde en dålig begäran",
 }
// Koda meddelandet som JSON och skicka det som svar
 fel := json. NewEncoder (writer).Encode(&meddelande)
om fel!= noll {
lämna tillbaka
 }
 }
}

Du ställer in hanterarfunktionen i huvudfunktionen med rutten som /api/docker/go. De dockerTestEndpoint hanterarfunktionen validerar att begäran till hanteraren är en GET-förfrågan. Om det är en GET-förfrågan kodar den en instansierad Meddelande struct instans till klienten baserat på begärans status.

Så här kan du montera hanterarfunktionen på en rutt och ställa in servern så att den körs på port 8080:

funchuvud() {
// Registrera hanterarfunktionen 'dockerTestEndpoint'
// för att hantera förfrågningar om "/api/docker/go" URL.
 http. HandleFunc("/api/docker/go", dockerTestEndpoint)
// Starta HTTP-servern och lyssna efter inkommande förfrågningar på port 8080.
 fel := http. Lyssna OchServe(":8080", noll)
om fel!= noll {
 logga. Fatalln("Det är ett fel med servern:", fel)
 }
}

De huvud funktion är serverns ingångspunkt, som lyssnar på port 8080. De HandleFunc metod monterar rutterna på hanterarfunktionen. De ListenAndServe metod startar servern på den angivna lokala värdporten 8080.

Komma igång Containerizing dina Go-appar med Docker

När du har installerat och konfigurerat Docker behöver du en Docker-fil som heter Dockerfile för att skapa och bygga en Docker-avbildning för din Go-app. Du kommer att ange kommandon för basbilden och kommandon för att kopiera filerna, lägga till arbetskatalogen och köra appen i Dockerfilen.

Kör det här kommandot i terminalen på din arbetsyta för att skapa en Dockerfil.

tryck på Dockerfile

Du anger kommandona för att bygga din Docker-bild i Dockerfilen.

Om det finns några filer du vill separera från din Docker-bild kan du använda en .dockerignore fil. De .dockerignore filer fungerar precis som .gitignore filer.

tryck på .dockerignore

Därefter anger du byggkommandon i din Dockerfile för att behålla dina appar.

Definiera kommandon i Dockerfilen

Dockerfiler är anpassningsbara baserat på ditt projekts specifikationer. Du kommer att definiera kommandon för att bygga basbilden för att bygga applikationen.

Här är ett exempel på innehållet i en Dockerfil som bygger webbservern ovan:

# Använd en Golang-basbild
FRÅN golang: senaste
# Ställ in arbetskatalogen inuti behållaren
WORKDIR /app
# Kopierar alla filer i den lokala katalogen till arbetskatalogen i behållaren
KOPIERA. .
# Ladda ner Go-modulens beroenden
SPRINGA ladda ner go mod
# Bygg Go-applikationen
SPRINGA gå bygg -o app
# Ställ in startpunkten för programmet
INKÖRSPORT ["./app"]

Dockerfilen använder golang: senaste basbild, för att bygga appen efter att ha ställt in arbetskatalogen till /app.

Dockerfilen kopierar filerna med KOPIERA kommando och nedladdningsberoenden med SPRINGA kommando.

Filen anger en bygg- och köroperation med SPRINGA kommandot, ställer sedan in kommandot att köras när behållaren startar med CMD kommando.

Spara Dockerfilen i samma katalog som din go.mod och main.go filer; kör sedan det här kommandot för att bygga en Docker-bild från denna Dockerfil:

docker build -t Golang Tutorial .

Kommandot ovan skapar en Docker-bild med taggen golangtutorial. Du kan köra en behållare med detta kommando:

docker run -p 8080:8080 golangtutorial

Kommandot mappar port 8080 från behållaren till port 8080 på värddatorns lokala värd. Du kan begära servern som körs i Docker-behållaren från värddatorn.

Här är resultatet från skicka CURL-begäran till servern, den här gången körs på Docker:

Du kan använda Docker Compose för Container Orchestration

Docker Compose är ett verktyg som du kan använda för att orkestrera (arbeta med många) Docker-containrar. Docker Compose låter dig definiera en multicontainerapplikation i en enda YAML-fil. Du kan köra och hantera hela applikationen med ett enda kommando.

Du kan använda Docker Compose för att distribuera och hantera komplexa containeriserade applikationer. Docker Compose förenklar hanteringen med automatiserade och konsekventa implementeringar.