Go-apps in containers plaatsen met Docker

Docker is de meest populaire containertechnologie vanwege zijn eenvoud en gebruiksgemak. Docker verlicht de stress van portabiliteitsproblemen bij softwareontwikkeling en -distributie. U kunt uw docker-containers implementeren bij de meeste cloudserviceproviders.

Door uw Go-apps in containers te plaatsen met Docker, kunt u zorgen voor een consistente en betrouwbare implementatie in verschillende omgevingen. U kunt uw Go-apps implementeren in verschillende omgevingen, zoals ontwikkeling, staging en productie. Docker-containers zijn licht van gewicht en nemen minder ruimte in beslag dan traditionele virtuele machines. Dit kan u geld besparen op hostingkosten en het kan uw implementaties ook sneller maken.

Een eenvoudige webserver opzetten in Go

De Go-standaardbibliotheek bevat de pakketten die u nodig hebt om een ​​eenvoudige webserver op te zetten.

Importeer eerst de http, loggen, En json pakketjes. Je zult gebruiken Go's http-pakket om de server in te stellen en KRIJGEN eindpunt aanvragen. De loggen pakket voor het loggen van mogelijke fouten op uw console. De json-pakket voor het coderen van een struct naar JSON voor het API-eindpunt.

importeren (
"codering/json"
"logboek"
"net/http"
)

U kunt een struct-instantie coderen als JSON voor de client als een antwoord op basis van de geldigheid van het verzoek als volgt:

type Bericht structuur {
 Antwoord snaar`json:"antwoord"`
 Beschrijving snaar`json:"beschrijving"`
}

De handlerfunctie retourneert een succesvol bericht naar de client als het verzoek aan het eindpunt een KRIJGEN verzoek.

// dockerTestEndpoint verwerkt het API-eindpunt voor het testen van Docker-connectiviteit
funcdockerTestEndpoint(schrijver http. ResponseWriter, vraag *http. Verzoek) {
// Stel de antwoordheader in om JSON-inhoud aan te geven
 auteur. Koptekst().Set("Inhoudstype,""toepassing/json")
// Als de aanvraagmethode GET is
als verzoek. Methode == "KRIJGEN" {
// Stel de antwoordstatuscode in op 200 OK
 auteur. Schrijfkop (http. StatusOK)
// Maak een berichtstructuur voor een succesvolle reactie
 bericht := Bericht{
 Antwoord: "Succesvol",
 Beschrijving: "U heeft met succes het API-eindpunt bereikt" +
"Vanuit uw Docker-container",
 }
// Codeer het bericht als JSON en verzend het als antwoord
 fout := json. NewEncoder (schrijver).Encode(&bericht)
als fout!= nihil {
opbrengst
 }
 } anders {
// Als de aanvraagmethode niet GET is
// Stel de antwoordstatuscode in op 400 Bad Request
 auteur. Schrijfkop (http. StatusBadRequest)
// Maak een berichtstructuur voor een slecht verzoekantwoord
 bericht := Bericht{
 Antwoord: "Foute aanvraag",
 Beschrijving: "U heeft met succes het API-eindpunt bereikt vanaf uw " +
"Docker Container, maar je hebt een slecht verzoek gedaan",
 }
// Codeer het bericht als JSON en verzend het als antwoord
 fout := json. NewEncoder (schrijver).Encode(&bericht)
als fout!= nihil {
opbrengst
 }
 }
}

De handlerfunctie stel je in de hoofdfunctie in met de route als /api/docker/go. De dockerTestEndpoint handler-functie valideert dat het verzoek aan de handler een GET-verzoek is. Als het een GET-verzoek is, codeert het een geïnstantieerd Bericht struct naar de client op basis van de status van het verzoek.

Hier leest u hoe u de handlerfunctie op een route kunt koppelen en de server kunt instellen om op poort te draaien 8080:

funcvoornaamst() {
// Registreer de handlerfunctie 'dockerTestEndpoint'
// om aanvragen voor de URL "/api/docker/go" af te handelen.
 http. HandvatFunc("/api/docker/go", dockerTestEndpoint)
// Start de HTTP-server en luister naar inkomende verzoeken op poort 8080.
 fout := http. LuisterEnServe(":8080", nihil)
als fout!= nihil {
 loggen. dodelijk("Er is een fout met de server:", fout)
 }
}

De voornaamst functie is het ingangspunt van de server, die op poort luistert 8080. De HandgreepFunc methode koppelt de routes aan de handlerfunctie. De ListenAndServe methode start de server op de opgegeven lokale hostpoort 8080.

Aan de slag Uw Go-apps in containers plaatsen met Docker

Nadat je Docker hebt geïnstalleerd en ingesteld, heb je een Docker-bestand met de naam Dockerfile nodig om een ​​Docker-image voor je Go-app te maken en te bouwen. U geeft opdrachten op voor de basisafbeelding en opdrachten om de bestanden te kopiëren, de werkmap toe te voegen en de app in de Dockerfile uit te voeren.

Voer deze opdracht uit in de terminal van uw werkruimte om een ​​Dockerfile te maken.

raak Dockerfile aan

U specificeert de opdrachten voor het bouwen van uw Docker-image in de Dockerfile.

Als er bestanden zijn die u wilt scheiden van uw Docker-image, kunt u een .dockerignore bestand. De .dockerignore bestanden werken precies zoals .gitignore bestanden.

tik op .dockerignore

Vervolgens specificeert u build-opdrachten in uw Dockerfile om uw apps in containers te plaatsen.

Opdrachten definiëren in de Dockerfile

Dockerfiles kunnen worden aangepast op basis van de specificaties van uw project. U definieert opdrachten om de basisafbeelding te bouwen voor het bouwen van de applicatie.

Hier is een voorbeeld van de inhoud van een Dockerfile die de bovenstaande webserver bouwt:

# Gebruik een Golang-basisafbeelding
VAN golang: laatste
# Stel de werkmap in de container in
WERKDIR /app
# Kopieert alle bestanden in de lokale directory naar de werkdirectory in de container
KOPIËREN. .
# Download de afhankelijkheden van de Go-module
LOOP ga mod downloaden
# Bouw de Go-applicatie
LOOP ga bouwen -o app
# Stel het startpunt voor de applicatie in
INGANGSPUNT ["./app"]

De Dockerfile gebruikt golang: laatste basisafbeelding, om de app te bouwen nadat de werkmap is ingesteld op /app.

De Dockerfile kopieert de bestanden met de KOPIËREN opdracht en downloadt afhankelijkheden met de LOOP commando.

Het bestand specificeert een bouw- en uitvoeringsbewerking met de LOOP opdracht, stelt vervolgens de opdracht in om te worden uitgevoerd wanneer de container begint met de CMD commando.

Sla de Dockerfile op in dezelfde map als uw ga.mod En hoofd.go bestanden; voer vervolgens deze opdracht uit om een ​​Docker-image te bouwen van deze Dockerfile:

docker build -t GolangTutorial.

De bovenstaande opdracht maakt een Docker-afbeelding met de tag golangtutorial. U kunt een container uitvoeren met deze opdracht:

docker run -p 8080:8080 golangtutorial

De opdracht wijst poort 8080 van de container toe aan poort 8080 op de localhost van de hostcomputer. U kunt de server die in de Docker-container draait opvragen vanaf de hostcomputer.

Hier is het resultaat van het verzenden van het CURL-verzoek naar de server, dit keer draaiend op Docker:

U kunt Docker Compose gebruiken voor containerorkestratie

Docker Compose is een tool die u kunt gebruiken om Docker-containers te orkestreren (werken met veel). Met Docker Compose kunt u een toepassing met meerdere containers definiëren in één YAML-bestand. U kunt de volledige applicatie uitvoeren en beheren met een enkele opdracht.

U kunt Docker Compose gebruiken voor het implementeren en beheren van complexe containertoepassingen. Docker Compose vereenvoudigt het beheer met geautomatiseerde en consistente implementaties.