Erstellen einer Go-Anwendung mit Docker auf AWS: Erstellen einer RESTful-Schnittstelle zum Hinzufügen und Abrufen von Elementen

Einführung

Während die meisten Go-Anwendungen in einer einzigen Binärdatei kompiliert werden, enthalten Webanwendungen auch Vorlagen, Assets und Konfigurationsdateien. Diese können nicht mehr synchron sein und fehlerhafte Bereitstellungen verursachen.
Mit Docker können wir ein eigenständiges Image mit allem erstellen, was unsere Anwendung zum Ausführen benötigt. In diesem Artikel erfahren Sie, wie Sie eine Go-Webanwendung mithilfe von Docker bereitstellen, das auf einer Instanz installiert ist, und wie Docker Ihnen dabei helfen kann, Ihren Entwicklungsworkflow und Bereitstellungsprozess zu verbessern.

Die Schritte, die wir benötigen, sind wie folgt:

- Starten Sie eine Instanz (Ihre Maschine), auf der Sie Docker aufbauen können, und los geht’s
Anwendung
- Docker in der Instanz installieren
- Go in der Instanz installieren
- Erstellen Sie Codedateien für Ihre Go-Anwendung
- Anwendungstests

Starten Sie eine Instanz (Ihre Maschine), auf der Sie Docker aufbauen können, und los geht’s
Anwendung

Die gleichen Schritte zum Starten und Verbinden einer Instanz finden Sie im Artikel:

https://dev.to/zahraajawad/building-a-jupyter-notebook-environment-in-docker-for-data-analysis-on-aws-ec2-376i

Hinweis: Stellen Sie sicher, dass Sie die Sicherheitsgruppe auswählen:

• SSH-Port 22: Für den Zugriff und die Verbindung zur Instanz über SSH
  Protokoll zur Fernverwaltung des Systems.

• HTTP-Port 8080: Um die Go-Anwendung auf diesem Port (8080) auszuführen und über das Internet oder ein lokales Netzwerk darauf zuzugreifen, muss dieser Port geöffnet sein.

- Installieren Sie Docker in unserer Instanz

Die spezifische Workflow-Architektur, die wir erstellen werden, nutzt Docker, um eine integrierte Workflow-Umgebung bereitzustellen.
Nachdem Sie also über SSH eine Verbindung zur Instanz hergestellt und die Root-Berechtigung erhalten haben, verwenden Sie die folgende Befehlsautomatisierung, um Docker zu installieren:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add - && sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stabile" && sudo apt-get update && apt- Cache-Richtlinie docker-ce

Docker-Erfahrung: Führen Sie einen einfachen Testbefehl docker -v aus, um zu überprüfen, ob Docker ordnungsgemäß funktioniert, und um die Docker-Version anzuzeigen:

Go installieren

Sie können Go installieren, indem Sie es von der offiziellen Go-Website https://go.dev/dl/ herunterladen
wget https://golang.org/dl/go1.20.linux-amd64.tar.gz
sudo tar -C /usr/local -xzf go1.20.linux-amd64.tar.gz
echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bash_profile
Quelle ~/.bash_profile

wo:
wget https://golang.org/dl/go1.20.linux-amd64.tar.gz dient zum Herunterladen der Go-Binärdatei.

und
sudo tar -C /usr/local -xzf go1.20.linux-amd64.tar.gz dient zum Extrahieren des Tarballs nach /usr/local.
und
echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bash_profile, um die Umgebungsvariable PATH zu aktualisieren.
und source ~/.bash_profile, um die am Profil vorgenommenen Änderungen zu übernehmen

Also nach der Ausführung der Befehle und der Überprüfung der Ausführung mit dem Befehl ls, um die heruntergeladenen Dateien anzuzeigen:

Initialisieren Sie die Go-Anwendung mit dem folgenden Code:
go mod init my-go-app

Jetzt müssen wir mit dem folgenden Befehl einen Projektordner erstellen:
mkdir
Ändern Sie dann das aktuelle Verzeichnis mit dem Befehl:
cd
Die Ausführung lautet also:

Erstellen Sie Codedateien für Ihre Go-Anwendung

Die main.go-Datei

Wir erstellen eine neue Datei namens main.go, die die folgenden Funktionen und Codes enthält, die wir im Detail erklären, und fügen dann alle Codes in die Datei main.go ein:

• Um die notwendigen Pakete zu importieren, verwenden wir den Code:

import (
    "encoding/json"
    "log"
    "net/http"
    "github.com/gorilla/mux"
    "os"
)

• Für das Datenstrukturelement:

type Item struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

wobei item eine Datenstruktur ist, die eine Kennung (ID) und einen Namen (Name) enthält. Diese Felder werden mithilfe von Tags (json:"id" und json:"name" in das JSON-Format konvertiert.

• Elemente variabel

var items []Item

das ist ein Teil der im Serverspeicher gespeicherten Elemente.

• Über die Hauptfunktion werden die Strukturen durch das Lesen des Ports (hier auf Port 8080) sowie durch die Steuerung der verschiedenen Anforderungen vom Abrufen oder Hinzufügen eines neuen Elements bis hin zur Anzeige einer einfachen HTML-Seite angeordnet.

import (
    "encoding/json"
    "log"
    "net/http"
    "github.com/gorilla/mux"
    "os"
)

• Die Funktion getItems gibt eine Liste von Elementen im JSON-Format zurück. Der Inhaltstyp im Header ist auf application/json festgelegt.

type Item struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

• Die Funktion „createItem“ fügt der Artikelliste ein neues Element hinzu. Die Daten werden aus dem Anforderungstext im JSON-Format gelesen, dem Element wird eine ID basierend auf der Anzahl der vorhandenen Elemente zugewiesen und das hinzugefügte Element wird als JSON zurückgegeben.

var items []Item

• Die ServeHome-Funktion zeigt eine einfache HTML-Seite mit einer Willkommensnachricht (Willkommen in der Go-App) und Links zum Zugriff auf die Daten an.

func main() {
    port := os.Getenv("PORT")
    if port == "" {
        port = "8080"
    }

    router := mux.NewRouter()
    router.HandleFunc("/items", getItems).Methods("GET")
    router.HandleFunc("/items", createItem).Methods("POST")
    router.HandleFunc("/", serveHome).Methods("GET")

    log.Printf("Server is running on port %s...\n", port)
    log.Fatal(http.ListenAndServe(":"+port, router))
}

Die gesamte main.go-Datei lautet also:

func getItems(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(items)
}

Erstellen Sie nun mit dem Befehl vim oder nano die Datei main.go und fügen Sie den obigen Code in die Datei ein. Hier verwenden wir den Befehl nano:

nano main.go

Und vorbei an den Codes:

Verlassen Sie dann die Datei über die Tastatur mit Strg x und dann y (um die Datei zu speichern) und klicken Sie dann auf Eingabetaste

Docker-Datei:

Ist ein Textdokument, das alle Befehle enthält, die ein Benutzer in der Befehlszeile aufrufen könnte, um ein Bild zusammenzustellen.
Dockerfile kann Bilder automatisch erstellen, indem es die Anweisungen aus einer Dockerfile liest.

Erstellen Sie eine Docker-Datei:

Eine Docker-Datei mit Build-Anweisungen ist erforderlich, um ein Container-Image mit Docker zu erstellen.
Wir erstellen ein Dockerfile und fügen den folgenden Code auf die gleiche Weise wie zuvor über den Befehl nano Dockerfile:

hinzu

Details zum Dockerfile-Befehl finden Sie auf der Docker-Docs-Homepage https://docs.docker.com/guides/golang/build-images/

Da wir nun die Docker-Datei vorbereitet haben, ist es an der Zeit, ein Docker-Image für die Go-Anwendung zu erstellen. Das Image kann aus den offiziellen Docker-Images erstellt werden:

docker build -t my-go-app .

Das Image wurde erfolgreich erstellt. Um den Build sicherzustellen, verwenden Sie den folgenden Befehl:
Docker-Bilder

Um den Container nach dem Erstellen des Images auszuführen, verwenden wir Folgendes:

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

wobei 8080 der Port der Webserver ist, der Ausführungslauf ist also:

Anwendungstests

- Testen Sie die Go-Anwendung mit dem Curl-Befehl

Um mit dem Curl-Befehl zu testen, ob die Go-Anwendung ordnungsgemäß funktioniert:

curl http://localhost:8080/items

oder

curl http://<öffentliche IPv4-Adresse unserer Instanz>:8080/items

Die Ausführung ist null, was bedeutet, dass die Anwendung funktioniert, wir aber noch keine Daten haben.

Um ein Element hinzuzufügen, verwenden Sie den folgenden Befehl:

curl -X POST -H "Content-Type: application/json" -d '{"name": "item"}' http://localhost:8080/items

oder

curl -X POST -H "Content-Type: application/json" -d '{"name": "item"}' http://<öffentliche IPv4-Adresse unserer Instanz>:8080/items

also die Ausführung des Hinzufügens:

Wir können einen weiteren Artikel hinzufügen:

- Testen Sie die Go-Anwendung auf der Webseite

Um zu testen, ob die Go-Anwendung über die Webseite ordnungsgemäß funktioniert, führen Sie die folgenden Schritte aus:

• Gehen Sie zurück zur Instanz und wählen Sie sie über das Kontrollkästchen aus.
• Gehen Sie zu den Details und kopieren Sie die öffentliche IPv4-Adresse.
• Fügen Sie die öffentliche IPv4-Adresse mit Port 8080 in den Browser ein und drücken Sie Geben Sie ein.

Die Webseite funktioniert und wenn wir auf der Seite auf Elemente klicken, erhalten wir die Elemente, die mit dem Curl-Befehl hinzugefügt werden.

Oder Sie können auf das Kontrollkästchen „Pretty-print“ klicken:

Referenzen:

• https://dev.to/zahraajawad/building-a-jupyter-notebook-environment-in-docker-for-data-analysis-on-aws-ec2-376i
• https://semaphoreci.com/community/tutorials/how-to-deploy-a-go-web-application-with-docker
• https://hub.docker.com/_/golang
• https://docs.docker.com/guides/golang/build-images/
• https://github.com/gorilla/mux

Das obige ist der detaillierte Inhalt vonErstellen einer Go-Anwendung mit Docker auf AWS: Erstellen einer RESTful-Schnittstelle zum Hinzufügen und Abrufen von Elementen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!