Ausführen eines in Docker erstellten Go-Programms

Einführung

Docker hat die Art und Weise, wie Entwickler Anwendungen erstellen, verpacken und bereitstellen, revolutioniert. In diesem Tutorial lernen Sie, wie Sie ein Go-Programm innerhalb eines Docker-Containers ausführen, um eine konsistente und zuverlässige Ausführungsumgebung sicherzustellen.

Einführung in Docker

Docker ist eine beliebte Containerisierungsplattform, die es Entwicklern ermöglicht, ihre Anwendungen und alle Abhängigkeiten in einem einzigen, portablen Container zu verpacken. Dieser Container kann dann einfach auf jedem System mit installiertem Docker ausgeführt werden, unabhängig vom zugrunde liegenden Betriebssystem oder der Infrastruktur.

Was ist Docker?

Docker ist eine Open-Source-Softwareplattform, die die Bereitstellung, Skalierung und Verwaltung von Anwendungen innerhalb von Softwarecontainern automatisiert. Container sind leichte, eigenständige, ausführbare Softwarepakete, die alles enthalten, was zum Ausführen einer Anwendung benötigt wird, einschließlich Code, Laufzeitumgebung, Systemtools und Bibliotheken.

Warum Docker verwenden?

Docker bietet Entwicklern und IT-Experten mehrere Vorteile:

1. Konsistenz: Docker-Container stellen sicher, dass Anwendungen unabhängig von der zugrunde liegenden Infrastruktur auf dieselbe Weise ausgeführt werden.
2. Portabilität: Docker-Container können problemlos zwischen verschiedenen Umgebungen wie Entwicklung, Test und Produktion verschoben werden.
3. Skalierbarkeit: Docker erleichtert die Skalierung von Anwendungen nach oben oder unten, abhängig von der Arbeitslast.
4. Effizienz: Docker-Container sind leichtgewichtig und verbrauchen weniger Ressourcen als herkömmliche virtuelle Maschinen, was zu einer effizienteren Ausführung führt.

Erste Schritte mit Docker

Um mit Docker zu beginnen, müssen Sie die Docker Engine auf Ihrem System installieren. Sie können Docker von der offiziellen Docker-Website (https://www.docker.com/get-started) herunterladen und installieren. Sobald Docker installiert ist, können Sie mit der Erstellung und Ausführung von Docker-Containern beginnen.

Tabelle 1: Docker CLI-Befehle

Nun, da Sie ein grundlegendes Verständnis von Docker haben, können wir mit der Erstellung einer Go-Anwendung in einem Docker-Container fortfahren.

Erstellen einer Go-Anwendung in Docker

Erstellen einer Go-Anwendung

Beginnen wir mit der Erstellung einer einfachen Go-Anwendung. Erstellen Sie eine neue Datei namens main.go mit folgendem Inhalt:

package main

import (
    "fmt"
    "net/http"
)

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "Hello, LabEx!")
    })

    fmt.Println("Server startet auf Port :8080")
    http.ListenAndServe(":8080", nil)
}

Diese Go-Anwendung lauscht auf Port 8080 und antwortet mit der Nachricht "Hello, LabEx!", wenn eine Anfrage an die Root-URL (/) gesendet wird.

Erstellen eines Docker Images

Um diese Go-Anwendung in einem Docker-Container auszuführen, müssen wir ein Docker-Image erstellen. Erstellen Sie eine neue Datei namens Dockerfile mit folgendem Inhalt:

FROM golang:1.18-alpine
WORKDIR /app
COPY . .
RUN go build -o main .
CMD ["./main"]

Dieses Dockerfile:

1. Verwendet das offizielle golang:1.18-alpine Image als Basis-Image.
2. Legt das Arbeitsverzeichnis auf /app fest.
3. Kopiert den Go-Anwendungskode in den Container.
4. Erstellt die Go-Anwendung und erzeugt eine ausführbare Datei namens main.
5. Legt den Befehl fest, den ausführbaren main-Befehl beim Starten des Containers auszuführen.

Erstellen des Docker Images

Um das Docker-Image zu erstellen, führen Sie den folgenden Befehl im selben Verzeichnis wie das Dockerfile aus:

docker build -t my-go-app .

Dieser Befehl erstellt ein Docker-Image mit dem Tag my-go-app.

Überprüfen des Docker Images

Sie können die verfügbaren Docker-Images auf Ihrem System auflisten, indem Sie den folgenden Befehl ausführen:

docker images

Sie sollten das Image my-go-app in der Liste sehen.

Nun, da wir ein Docker-Image für unsere Go-Anwendung haben, können wir es in einem Docker-Container ausführen.

Ausführen der Go-Anwendung in Docker

Ausführen des Docker-Containers

Um die Go-Anwendung in einem Docker-Container auszuführen, verwenden Sie den folgenden Befehl:

docker run -p 8080:8080 my-go-app

Dieser Befehl:

1. Führt das Docker-Image my-go-app aus.
2. Mapt den Port 8080 des Containers auf den Port 8080 des Hostsystems. Dadurch können Sie auf die Anwendung von Ihrem lokalen Rechner aus zugreifen.

Überprüfen des laufenden Containers

Sie können die laufenden Docker-Container mit folgendem Befehl auflisten:

docker ps

Sie sollten den Container my-go-app in der Liste sehen.

Zugriff auf die Go-Anwendung

Um auf die in dem Docker-Container laufende Go-Anwendung zuzugreifen, öffnen Sie einen Webbrowser und navigieren Sie zu http://localhost:8080. Sie sollten die Nachricht "Hello, LabEx!" angezeigt bekommen.

Beenden des Docker-Containers

Um den laufenden Docker-Container zu beenden, verwenden Sie den folgenden Befehl:

docker stop <container_id>

Ersetzen Sie <container_id> durch die ID des laufenden Containers, die Sie mit dem Befehl docker ps ermitteln können.

Fazit

In diesem Tutorial haben Sie gelernt, wie man:

1. Eine einfache Go-Anwendung erstellt.
2. Ein Docker-Image für die Go-Anwendung erstellt.
3. Die Go-Anwendung in einem Docker-Container ausgeführt.
4. Auf die in dem Docker-Container laufende Go-Anwendung zugegriffen hat.

Durch die Containerisierung Ihrer Go-Anwendungen mit Docker stellen Sie eine konsistente und zuverlässige Bereitstellung in verschiedenen Umgebungen sicher und erleichtern so die Entwicklung, den Test und die Bereitstellung Ihrer Anwendungen.

Zusammenfassung

Am Ende dieses Tutorials verfügen Sie über ein fundiertes Verständnis der Erstellung und Ausführung einer Go-Anwendung in einem Docker-Container. Dies ermöglicht eine einfache Verteilung und Bereitstellung Ihrer Software in verschiedenen Umgebungen. Die Containerisierungstechnologie von Docker vereinfacht den Entwicklungs- und Bereitstellungsprozess und ermöglicht es Ihnen, sich auf die Erstellung großartiger Code konzentrieren zu können.