Containerisierung von Go-Apps mit Docker

Docker ist aufgrund seiner Einfachheit und Benutzerfreundlichkeit die beliebteste Containerisierungstechnologie. Docker entlastet Sie von Portabilitätsproblemen bei der Softwareentwicklung und -verteilung. Sie können Ihre Docker-Container bei den meisten Cloud-Dienstanbietern bereitstellen.

Durch die Containerisierung Ihrer Go-Apps mit Docker können Sie eine konsistente und zuverlässige Bereitstellung in verschiedenen Umgebungen sicherstellen. Sie können Ihre Go-Apps in verschiedenen Umgebungen wie Entwicklung, Staging und Produktion bereitstellen. Docker-Container sind leichtgewichtig und nehmen weniger Platz ein als herkömmliche virtuelle Maschinen. Dadurch können Sie Geld bei den Hosting-Kosten sparen und Ihre Bereitstellungen werden schneller.

Einrichten eines einfachen Webservers in Go

Die Go-Standardbibliothek enthält die Pakete, die Sie zum Einrichten eines einfachen Webservers benötigen.

Importieren Sie zunächst die http, Protokoll, Und json Pakete. Du wirst es verwenden Gos http-Paket um den Server einzurichten und ERHALTEN Endpunkt anfordern. Der Protokoll Paket zum Protokollieren möglicher Fehler auf Ihrer Konsole. Der JSON-Paket zum Codieren einer Struktur in JSON für den API-Endpunkt.

importieren (
„Kodierung/json“
"Protokoll"
„net/http“
)

Sie können eine Strukturinstanz als JSON als Antwort an den Client basierend auf der Gültigkeit der Anfrage codieren:

Typ Nachricht Struktur {
 Antwort Zeichenfolge`json:"response"`
 Beschreibung Zeichenfolge`json:"description"`
}

Die Handlerfunktion würde eine erfolgreiche Nachricht an den Client zurückgeben, wenn die Anfrage an den Endpunkt eine ist ERHALTEN Anfrage.

// dockerTestEndpoint verwaltet den API-Endpunkt zum Testen der Docker-Konnektivität
FunktiondockerTestEndpoint(Autor http. ResponseWriter, Anfrage *http. Anfrage) {
// Den Antwortheader so festlegen, dass er den JSON-Inhalt anzeigt
 Schriftsteller. Header().Set("Inhaltstyp,"„application/json“)
// Wenn die Anforderungsmethode GET ist
Wenn Anfrage. Methode == "ERHALTEN" {
// Den Antwortstatuscode auf 200 OK setzen
 Schriftsteller. WriteHeader (http. StatusOK)
// Erstellen Sie eine Nachrichtenstruktur für eine erfolgreiche Antwort
 Nachricht := Nachricht{
 Antwort: "Erfolgreich",
 Beschreibung: „Sie haben den API-Endpunkt erfolgreich erreicht“ +
„Aus Ihrem Docker-Container“,
 }
// Die Nachricht als JSON kodieren und als Antwort senden
 ähm := json. NewEncoder (writer).Encode(&message)
Wenn äh!= Null {
zurückkehren
 }
 } anders {
// Wenn die Anforderungsmethode nicht GET ist
// Den Antwortstatuscode auf 400 Bad Request setzen
 Schriftsteller. WriteHeader (http. StatusBadRequest)
// Erstelle eine Nachrichtenstruktur für eine fehlerhafte Anfrageantwort
 Nachricht := Nachricht{
 Antwort: "Ungültige Anforderung",
 Beschreibung: „Sie haben den API-Endpunkt von Ihrem“ aus erfolgreich erreicht. +
„Docker Container, aber Sie haben eine schlechte Anfrage gestellt“,
 }
// Die Nachricht als JSON kodieren und als Antwort senden
 ähm := json. NewEncoder (writer).Encode(&message)
Wenn äh!= Null {
zurückkehren
 }
 }
}

Sie richten die Handlerfunktion in der Hauptfunktion mit der Route als ein /api/docker/go. Der dockerTestEndpoint Die Handlerfunktion überprüft, ob die Anfrage an den Handler eine GET-Anfrage ist. Wenn es sich um eine GET-Anfrage handelt, wird eine Instanziierung kodiert Nachricht Strukturinstanz an den Client basierend auf dem Status der Anfrage.

So können Sie die Handler-Funktion auf einer Route bereitstellen und den Server so einrichten, dass er auf dem Port ausgeführt wird 8080:

Funktionhauptsächlich() {
// Registrieren Sie die Handler-Funktion 'dockerTestEndpoint'
// um Anfragen für die URL „/api/docker/go“ zu verarbeiten.
 http. HandleFunc(„/api/docker/go“, dockerTestEndpoint)
// Starten Sie den HTTP-Server und warten Sie auf eingehende Anfragen auf Port 8080.
 ähm := http. ListenAndServe(":8080", Null)
Wenn äh!= Null {
 Protokoll. Fatalln(„Es liegt ein Fehler mit dem Server vor:“, irren)
 }
}

Der hauptsächlich Die Funktion ist der Einstiegspunkt des Servers, der den Port überwacht 8080. Der HandleFunc Die Methode mountet die Routen in der Handler-Funktion. Der ListenAndServe Die Methode startet den Server am angegebenen lokalen Host-Port 8080.

Erste Schritte bei der Containerisierung Ihrer Go-Apps mit Docker

Nach der Installation und Einrichtung von Docker benötigen Sie eine Docker-Datei namens Dockerfile, um ein Docker-Image für Ihre Go-App zu erstellen und zu erstellen. Sie geben Befehle für das Basis-Image und Befehle zum Kopieren der Dateien, zum Hinzufügen des Arbeitsverzeichnisses und zum Ausführen der App in der Docker-Datei an.

Führen Sie diesen Befehl im Terminal Ihres Arbeitsbereichs aus, um eine Docker-Datei zu erstellen.

Berühren Sie Dockerfile

Sie geben die Befehle zum Erstellen Ihres Docker-Images in der Docker-Datei an.

Wenn Sie Dateien von Ihrem Docker-Image trennen möchten, können Sie a .dockerignore Datei. Der .dockerignore Dateien funktionieren genau wie .gitignore Dateien.

Berühren Sie .dockerignore

Als Nächstes geben Sie Build-Befehle in Ihrer Docker-Datei an, um Ihre Apps zu containerisieren.

Definieren von Befehlen in der Docker-Datei

Docker-Dateien können basierend auf den Spezifikationen Ihres Projekts angepasst werden. Sie definieren Befehle zum Erstellen des Basis-Images zum Erstellen der Anwendung.

Hier ist ein Beispiel für den Inhalt einer Docker-Datei, die den obigen Webserver erstellt:

# Verwenden Sie ein Golang-Basisbild
AUS golang: spätestens
# Legen Sie das Arbeitsverzeichnis im Container fest
ARBEITSVERZEICHNIS /app
# Kopiert alle Dateien im lokalen Verzeichnis in das Arbeitsverzeichnis im Container
KOPIEREN. .
# Laden Sie die Abhängigkeiten des Go-Moduls herunter
LAUFEN Gehen Sie zum Mod-Download
# Erstellen Sie die Go-Anwendung
LAUFEN Gehen Sie build -o app
# Legen Sie den Einstiegspunkt für die Anwendung fest
EINSTIEGSPUNKT ["./app"]

Die Docker-Datei verwendet golang: spätestens Basis-Image, um die App zu erstellen, nachdem das Arbeitsverzeichnis festgelegt wurde /app.

Das Dockerfile kopiert die Dateien mit dem KOPIEREN Befehl und lädt Abhängigkeiten mit dem herunter LAUFEN Befehl.

Die Datei gibt einen Build- und Ausführungsvorgang mit an LAUFEN Befehl und legt dann fest, dass der Befehl ausgeführt wird, wenn der Container mit dem startet CMD Befehl.

Speichern Sie die Docker-Datei im selben Verzeichnis wie Ihre go.mod Und main.go Dateien; Führen Sie dann diesen Befehl aus, um ein Docker-Image aus dieser Docker-Datei zu erstellen:

docker build -t GolangTutorial .

Der obige Befehl erstellt ein Docker-Image mit dem Tag golangtutorial. Mit diesem Befehl können Sie einen Container ausführen:

docker run -p 8080:8080 golangtutorial

Der Befehl ordnet Port 8080 vom Container dem Port 8080 auf dem Localhost des Hostcomputers zu. Sie können den im Docker-Container ausgeführten Server vom Host-Computer anfordern.

Hier ist das Ergebnis von Senden der CURL-Anfrage an den Server, dieses Mal läuft es auf Docker:

Sie können Docker Compose für die Container-Orchestrierung verwenden

Docker Compose ist ein Tool, mit dem Sie Docker-Container orchestrieren (mit vielen) arbeiten können. Mit Docker Compose können Sie eine Multi-Container-Anwendung in einer einzigen YAML-Datei definieren. Sie können die gesamte Anwendung mit einem einzigen Befehl ausführen und verwalten.

Sie können Docker Compose zum Bereitstellen und Verwalten komplexer Containeranwendungen verwenden. Docker Compose vereinfacht die Verwaltung durch automatisierte und konsistente Bereitstellungen.