Dockerisieren Sie Ihre Go-API mit mehrstufigen Builds

Okay, Team! Wir bringen unsere Go-API auf die nächste Ebene, indem wir sie dockerisieren und, was noch wichtiger ist, sie mit mehrstufigen Builds leicht und effizient machen. Am Ende dieses Beitrags verfügen Sie über eine API, die nicht nur portierbar, sondern auch für schnellere Bereitstellungen optimiert ist. ?

Warum mehrstufige Builds? ?

Mehrstufige Builds ermöglichen es uns, unser endgültiges Docker-Image schlank zu halten, indem wir die Build--Umgebung von der Laufzeitumgebung trennen. Für Go-Anwendungen ist dies besonders nützlich, da wir die Anwendung in einem Schritt erstellen können (mit allen erforderlichen Tools und Abhängigkeiten) und dann nur die resultierende Binärdatei in ein kleineres, endgültiges Image kopieren können.

Vorteile mehrstufiger Builds:

• Kleinere Bildgröße: Indem wir unnötige Build-Abhängigkeiten entfernen, erhalten wir am Ende ein Bild, das nur einen Bruchteil der Größe hat.
• Schnellere Bereitstellung: Ein kleineres Image bedeutet schnellere Downloads und Bereitstellungen.
• Reduzierte Angriffsfläche: Weniger Komponenten in der Laufzeitumgebung bedeuten weniger potenzielle Schwachstellen.

Schritt 1: Schreiben der Docker-Datei mit mehrstufigen Builds

Lassen Sie uns eine Docker-Datei erstellen, die einen mehrstufigen Build nutzt. Dies wird uns helfen, unsere Go-API für die Produktion zu optimieren, indem wir die endgültige Bildgröße reduzieren.

Erstellen Sie im Stammverzeichnis Ihres Projekts eine Docker-Datei mit folgendem Inhalt:

# Build stage
FROM golang:1.21.0-alpine3.17 AS builder
WORKDIR /app
COPY . .

# Install dependencies and build the application
RUN go mod download
RUN go build -o main .

# Run stage (lightweight)
FROM alpine:3.18.3
WORKDIR /app

# Copy the binary from the builder stage
COPY --from=builder /app/main .

# Expose the API port
EXPOSE 8000

# Run the binary
CMD ["/app/main"]

Aufschlüsselung der Docker-Datei:

1. Builder-Phase:

   • Wir beginnen mit dem offiziellen Go Alpine-Bild, das kleiner ist als das Standard-Go-Bild.
   • Alle Abhängigkeiten werden heruntergeladen und wir kompilieren die Anwendung mit go build in eine Binärdatei (Hauptdatei).

2. Laufzeitphase:

   • Wir wechseln zu einem noch leichteren Alpine-Image, das weder den Go-Compiler noch andere Build-Abhängigkeiten enthält.
   • Die kompilierte Binärdatei wird aus der Builder-Phase kopiert und wir legen Port 8000 offen, um den Zugriff auf unsere API zu ermöglichen.

Mit diesem Ansatz enthält unser endgültiges Bild nur das, was zum Ausführen der API erforderlich ist, was zu einem deutlich kleineren Bild führt.

Schritt 2: Erstellen und Ausführen des Docker-Containers

Da wir nun unsere optimierte Docker-Datei haben, erstellen wir das Docker-Image und führen es aus.

1. Erstellen Sie das Docker-Image:

   docker build -t my-go-api .

1. Führen Sie den Docker-Container aus:

   docker run -p 8000:8000 my-go-api

Ihre API sollte unter http://localhost:8000 ausgeführt werden, genau wie auf Ihrem lokalen Computer!

Schritt 3: Weitere Optimierung mit dem Scratch-Image (optional)

Für eine noch weitere Optimierung können Sie die Alpine-Laufzeitstufe durch das Scratch-Bild ersetzen. Das Scratch-Image ist völlig leer – kein Betriebssystem, keine Dienstprogramme – was zu einer noch kleineren Image-Größe führt. Dies bedeutet jedoch auch, dass Sie keinen Zugriff auf Debugging-Tools im Container haben.

So würde die Docker-Datei mit dem Scratch-Image aussehen:

# Build stage
FROM golang:1.21.0-alpine3.17 AS builder
WORKDIR /app
COPY . .

RUN go mod download
RUN go build -o main .

# Run stage
FROM scratch
WORKDIR /app

COPY --from=builder /app/main .

EXPOSE 8000

CMD ["/app/main"]

Dieser Ansatz kann die endgültige Bildgröße auf nur 10-15 MB reduzieren! Bedenken Sie jedoch, dass die Verwendung von Scratch am besten für sehr einfache, eigenständige Anwendungen geeignet ist.

Schritt 4: Testen des optimierten Containers?

Testen wir unseren Container, um sicherzustellen, dass er wie erwartet funktioniert:

curl http://localhost:8000/books

Wenn Ihre API richtig reagiert, dann herzlichen Glückwunsch! Sie haben Ihre Go-API erfolgreich mit Docker optimiert und containerisiert. ?

Vorteile mehrstufiger Builds in der Produktion

• Effiziente Bereitstellung: Kleinere Bilder bedeuten schnellere Abrufzeiten, was in Produktionsumgebungen von entscheidender Bedeutung sein kann.
• Ressourceneinsparungen: Durch reduzierten Speicher- und Speicherbedarf werden Ihre Infrastrukturkosten niedrig gehalten.
• Sicherheit: Weniger Komponenten im endgültigen Bild reduzieren das Potenzial für Schwachstellen.

Was kommt als nächstes?

Jetzt, da Ihre API Docker-fähig und für die Produktion optimiert ist, sind Sie für eine reibungslose Bereitstellung und Skalierung gerüstet! Beim nächsten Mal schalten wir den Gang um und stürzen uns in Unit-Tests für Go, um sicherzustellen, dass Ihre API nicht nur bereitstellbar, sondern auch grundsolide ist. ??

Behalten Sie außerdem mein ThrottleX GitHub-Repo im Auge, um Updates zu erhalten – ich werde bald ein Tutorial zur Integration meines benutzerdefinierten Ratenbegrenzers veröffentlichen!

Das obige ist der detaillierte Inhalt vonDockerisieren Sie Ihre Go-API mit mehrstufigen Builds. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!