Methoden und Schritte zum Bereitstellen von Go-Projekten basierend auf Docker-Images

Abhängigkeit vom Wissen

• Grundlagen der Go-Cross-Kompilierung
• Docker-Grundlagen
• Grundlagen zu benutzerdefinierten Dockerfile-Images
• Grundlagen des Schreibens von Docker-Compose-Orchestrierungsdateien

Natürlich können Sie diese Schritte auch ausführen, um die Bereitstellung abzuschließen, selbst wenn Sie nichts darüber wissen. Wenn jedoch zwischendurch einige kleine Probleme auftreten, wissen Sie möglicherweise nicht, wie Sie diese lösen können. Natürlich können Sie auch eine Nachricht hinterlassen.

Ich habe es auf einem Mac entwickelt und getestet. Wenn Sie Windows verwenden, kann es einige Unterschiede geben, aber das sollte kein großes Problem sein.

1. Abhängigkeit von der Umwelt

• Docker

2. Schreiben Sie ein GoLang-Webprogramm

Ich werde hier ein einfaches „Hallo Welt“-Programm schreiben und der Abhörport ist Port 80.
Erstellen Sie eine neue main.go -Datei mit folgendem Inhalt:

Paket Haupt
importieren (
  "fmt"
  "Protokoll"
  "net/http"
)
Funktion sayHello(w http.ResponseWriter, r *http.Request) {
  fmt.Fprintf(w, "Hallo Welt")
}
Funktion main() {
  http.HandleFunc("/", sayHello)//Registriere URI-Pfad und entsprechende Verarbeitungsfunktion log.Println("[Standardprojekt] Dienst hat erfolgreich mit dem Abhören von Port 80 begonnen")
  er := http.ListenAndServe("0.0.0.0:80", nil)
  wenn er != nil {
    log.Fatal("ListenAndServe: ", er)
  }
}

3. Unter Linux in ein Paket kompilieren

Ich habe es auf einem Mac entwickelt und musste die Cross-Kompilierung von Go verwenden. Wenn Sie mit der Cross-Kompilierung nicht vertraut sind, können Sie die Dokumentation lesen oder einfach den folgenden Befehl zum Kompilieren kopieren.
Wir möchten es in Docker basierend auf dem golang -Image ausführen, daher müssen wir es in ein Programm kompilieren, das mit dem i386 Prozessor kompatibel ist.

sudo env GOOS=linux GOARCH=386 go build main.go

Nach Abschluss der Kompilierung wird lokal ein zusätzliches main vorhanden sein. Ignorieren Sie es vorerst einfach und bewahren Sie es als Backup auf.

4. Verwenden Sie Dockerfile, um das Image unseres Go-Programms anzupassen

Erstellen Sie einen neuen Ordner, erstellen Sie darin eine neue Dockerfile Datei und erstellen Sie darin dann zwei neue Dateien, app und script “. Legen Sie main aus dem vorherigen Schritt in den app Ordner und erstellen Sie im script eine Skriptdatei build.sh . Ignorieren Sie den Inhalt der Datei vorerst, ich werde ihn später erklären.
Die spezifische Dateistruktur ist wie folgt.

.
├── Docker-Datei
├── App
│ └── Haupt
└── Skript
  └── build.sh

Im Folgenden wird der Inhalt der Dockerfile -Datei geschrieben. Ich werde zuerst den Code posten:

VON golang
WARTUNGSBEARBEITER Qianyi ARBEITSVERZEICHNIS /go/src/
KOPIEREN . .
AUSSETZEN 80
CMD ["/bin/bash", "/go/src/script/build.sh"]

Hier ist die Erklärung:

FROM ist das Image, aus dem es integriert wird. Unser Go-Programm stellt offiziell ein golang Image bereit, das wir direkt verwenden können.

MAINTAINER ist die Bezeichnung für Wartung.

WORKDIR Arbeitsverzeichnis.

COPY ist ein Kopierbefehl, der alle lokalen Dateien in das Arbeitsverzeichnis kopiert.

EXPOSE Dies ist der von der anderen Partei entwickelte Port. Ich öffne standardmäßig Port 80. Sie können ihn entsprechend der tatsächlichen Situation ändern.

CMD führt einen Befehl mit Parametern aus. Ich habe es so geschrieben, dass script/build.sh ausgeführt wird, wenn das Image gestartet wird. Dieses Skript enthält den Befehl zum Starten des Go-Programms.

Ich füge den Inhalt hier ein:

#!/usr/bin/env bash
cd /go/src/app/ && ./main

Nur diese beiden Zeilen.

5. Kompilieren Sie unser eigenes Bild

Dies gehört zum Docker -Wissen, ich füge den Befehl ein.

Docker-Build -t Go-Web.

• Wenn dieser Befehl ausgeführt wird und lokal kein golang Image vorhanden ist, wird zuerst zur offiziellen Image-Bibliothek gegangen, um das Image abzurufen und dann zu kompilieren. Wir müssen nur ruhig darauf warten.
• go-web ist der Name des von Ihnen kompilierten Images. Sie können ihn nach Belieben ändern und auch eine Versionsnummer hinzufügen, z. B. go-web:v1 .

Die obige Ausgabe bedeutet, dass die Kompilierung erfolgreich war und Ihr lokales Image ein Image mit dem Namen go-web enthält. Sie können docker images für die Abfrage verwenden:

6. Schreiben Sie die Datei docker-compose.yml

Dies ist unser letzter Schritt. Wenn wir go-web verwenden, um unser Go-Programm auszuführen:

Version: '2'
Netzwerke:
 Basic:
Leistungen:
 Welt:
  Containername: Welt
  Bild: go-web
  Häfen:
   - „8099:80“
  Bände:
   - ./app/go/world:/go/src/app:rw
  Netzwerke:
   - Grundkenntnisse

An diesem Punkt wurde unsere Orchestrierungsdatei geschrieben. Jetzt müssen wir nur noch docker-compose verwenden, um unsere Orchestrierungsdatei zu starten. Der Startbefehl lautet wie folgt:

docker-compose -f docker-compose.yml up -d Welt

Wenn die folgende Eingabeaufforderung ausgegeben wird, bedeutet dies, dass der Start erfolgreich war.

Welt erschaffen ... fertig

Nach erfolgreichem Start können Sie

Docker PS

Lassen Sie uns überprüfen, ob der Start erfolgreich war.

Jetzt können wir auf unser Go-Programm zugreifen, indem wir http://127.0.0.1:8099 besuchen.

Dies ist das Ende dieses Artikels über die Schritte zum Bereitstellen eines Go-Projekts basierend auf einem Docker-Image. Weitere Informationen zum Bereitstellen eines Go-Projekts mit einem Docker-Image finden Sie in früheren Artikeln auf 123WORDPRESS.COM oder in den folgenden verwandten Artikeln. Ich hoffe, Sie werden 123WORDPRESS.COM auch in Zukunft unterstützen!