Wie man eine Golang-Anwendung einsetzt

Go (Golang) ist eine Programmiersprache, die 2009 von Google entwickelt wurde, um häufige Probleme bei der Entwicklung großer Systeme zu lösen, wie z. B. langsame Kompilierung und die Notwendigkeit gleichzeitiger Programmierung.

Die Sprache wurde im Hinblick auf Einfachheit, Effizienz und Benutzerfreundlichkeit mit einer C-ähnlichen Syntax entwickelt. Außerdem wird Go kompiliert, was es schneller macht als interpretierte Sprachen.

Eine der wichtigsten Eigenschaften von Go ist die Unterstützung von Gleichzeitigkeit, die es Ihnen ermöglicht, mehrere Aufgaben gleichzeitig über leichtgewichtige Threads, sogenannte Goroutines, auszuführen.

Go ist auch für seine starke Unterstützung für Netzwerk- und Webentwicklung bekannt. Die Standardbibliothek von Go enthält Pakete für HTTP, TCP/IP und andere Netzwerkprotokolle, die das Erstellen von Netzwerkanwendungen erleichtern.

In diesem Artikel werden Sie die Vorteile, Einschränkungen und Bereitstellungsoptionen für Go-Anwendungen kennenlernen. Außerdem werden Sie eine Go-Anwendung mit dem kostenlosen Containerisierungsdienst von Back4app erstellen, andocken und bereitstellen.

Lesen Sie weiter, um zu erfahren, wie Sie eine Go-Anwendung bereitstellen.

Vorteile von Golang in der Webentwicklung

Die zunehmende Popularität von Go kommt nicht von ungefähr. Es gibt viele Vorteile, die Sie durch die Verwendung von Go für Ihre Anwendungen erlangen und nutzen können.

Hohe Leistung

Hohe Leistung ist einer der Hauptgründe, warum Unternehmen wie Dropbox und Uber Go verwenden. Go ist auf schnelle Ausführungszeiten ausgelegt, was die Sprache zu einer idealen Wahl für Anwendungen macht, die eine hohe Leistung erfordern.

Go verwendet einen Garbage Collector, der den Overhead bei der Speicherverwaltung reduziert und so schnellere Ausführungszeiten ermöglicht. Außerdem können Sie die in Go integrierte Unterstützung für Parallelität nutzen, um die Leistung Ihrer Anwendung zu steigern.

Skalierbarkeit

Go ist eine hervorragende Wahl für die Entwicklung skalierbarer Anwendungen. Mit Concurrency können Sie Programme erstellen, die viele Aufgaben bewältigen können. Dadurch eignet sich Go für Anwendungen, die einen hohen Datenverkehr bewältigen und schnell skaliert werden müssen.

Go bietet außerdem eine hervorragende Unterstützung für verteilte Systeme und ist damit die ideale Wahl für die Entwicklung umfangreicher Anwendungen, die auf mehreren Rechnern laufen müssen.

Go ist kampferprobt

Viele bekannte Unternehmen verwenden Go, um umfangreiche Anwendungen zu erstellen, darunter die von Google, Uber und Dropbox. Dies bedeutet, dass Go im Kampf erprobt wurde und sich als zuverlässig und stabil für die Entwicklung komplexer Anwendungen für große Benutzergruppen erwiesen hat.

Go legt großen Wert auf Abwärtskompatibilität, und in Golang geschriebene Anwendungen werden auch dann noch funktionieren, wenn sich die Sprache weiterentwickelt.

Große Unterstützung durch die Gemeinschaft

Seit seiner Veröffentlichung ist Go eine der am schnellsten wachsenden Sprachen, was die Akzeptanz angeht, und hat somit eine große und aktive Gemeinschaft geschaffen. Die Tatsache, dass Go eine große aktive Gemeinschaft hat, bedeutet, dass Sie leicht Ressourcen und Antworten auf Fragen finden können.

Go ist die Heimat vieler Open-Source-Bibliotheken und -Werkzeuge, die Sie verwenden können, um die Entwicklungszeit zu verkürzen. Beliebte Build-Tools wie Kubernetes, Docker und Hugo verwenden Pakete wie Cobra für ihre CLI-Tools.

Beschränkungen von Golang

Während Golang eine sehr leistungsfähige und skalierbare Programmiersprache ist, hat Go seine Grenzen, die Sie berücksichtigen sollten, bevor Sie mit dieser Sprache entwickeln.

Erhöhte Komplexität für bestimmte Aufgaben

Go ist zwar leicht zu erlernen und zu lesen, aber bestimmte Aufgaben sind in anderen Sprachen einfacher als in Go. Die Erstellung einer interaktiven Benutzeroberfläche mit Go kann eine Herausforderung sein, da Go ein integriertes GUI-Toolkit benötigt und Pakete von Drittanbietern die Komplexität Ihres Projekts erhöhen.

Das Gleichzeitigkeitsmodell von Go kann für Anfänger eine Herausforderung sein

Das Gleichzeitigkeitsmodell von Go kann für Anfänger schwierig zu verstehen und effektiv zu nutzen sein. Go verwendet Goroutinen und Kanäle für die Gleichzeitigkeit, die leistungsstarke Werkzeuge sind, aber schwer zu verstehen sein können. Sie müssen lernen, Kanäle effektiv zu nutzen, um Deadlocks oder Race Conditions zu vermeiden.

Das Gleichzeitigkeitsmodell von Go erfordert auch ein anderes Denken in Bezug auf Codestruktur und -entwurf. Dies wird Ihnen schwerfallen, wenn Sie an sequenzielle Programmiermodelle gewöhnt sind.

Weniger ausgereiftes Bibliotheksökosystem im Vergleich zu anderen Sprachen

Die Standardbibliothek von Golang ist zwar umfangreich und verfügt über die meisten Funktionen, die Sie zum Erstellen von Go-Anwendungen benötigen, aber sie ist weniger ausgereift als Bibliotheken in Sprachen wie Java oder Python.

Golang ist eine relativ neue Programmiersprache; einige beliebte Bibliotheken sind noch nicht verfügbar. Dies kann für bestimmte Projekte eine Einschränkung darstellen, insbesondere für solche, die eine speziellere Funktionalität erfordern.

Außerdem sind die Bibliotheken von Drittanbietern für Golang weniger verbreitet als die für andere Sprachen, und Sie müssen einige Funktionen selbst implementieren, was zeitaufwändig sein kann.

Golang-Bereitstellungsoptionen

Nachdem Sie Anwendungen in Go erstellt haben, stehen Ihnen mehrere Bereitstellungsoptionen zur Verfügung, die jeweils ihre Vor- und Nachteile haben.

Sie haben eine breite Palette von Möglichkeiten, von IaaS-Diensten wie AWS, PaaS-Diensten wie Heroku, BaaS-Diensten wie Back4app & Google Firebase und CaaS-Diensten wie Back4App Containers.

Infrastruktur als Dienstleistung (IaaS) wie AWS

Anbieter von Infrastructure as a Service (IaaS) wie Amazon Web Services (AWS) bieten Funktionen für die Bereitstellung und Verwaltung eigener virtueller Maschinen in der Cloud.

Mit AWS können Sie Services wie Elastic Compute Cloud (EC2) nutzen, um Ihre Golang-Anwendung auf einer virtuellen Maschine unter Linux oder Windows bereitzustellen. Sie können auch Dienste wie Elastic Container Service (ECS) verwenden, um Ihre Anwendung in einem Container bereitzustellen.

Ein Vorteil der Nutzung eines IaaS-Dienstes wie AWS ist, dass Sie die vollständige Kontrolle über die zugrunde liegende Infrastruktur haben. Sie können die virtuelle Maschine so konfigurieren, dass sie Ihre spezifischen Anforderungen erfüllt. Allerdings sind Sie für die Verwaltung und Wartung der virtuellen Maschine verantwortlich, was technisch sehr aufwändig sein kann.

Andere IaaS-Plattformen sind:

• Linode
• Microsoft Azure
• Rackspace
• Amazon Web Services (AWS)
• DigitalOcean
• Google Compute Engine (GCE)

Plattform-as-a-Service (PaaS) wie Heroku

Anbieter von Platform as a Service (PaaS) wie Heroku bieten eine Plattform für die Bereitstellung von Golang-Anwendungen, ohne die zugrunde liegende Infrastruktur zu beeinträchtigen.

Heroku bietet eine einfache Befehlszeilenschnittstelle, über die Sie Ihre Anwendung mit nur wenigen Befehlen bereitstellen können. Heroku unterstützt auch die automatische Skalierung und den Lastausgleich, so dass ein hoher Datenverkehr für Ihre Anwendung leicht zu bewältigen ist.

Ein Vorteil der Nutzung eines PaaS-Dienstes wie Heroku ist, dass Sie sich auf die Entwicklung Ihrer Anwendung konzentrieren können, ohne sich um die Infrastruktur kümmern zu müssen. Heroku kümmert sich um die gesamte Verwaltung und Wartung der Infrastruktur, wodurch Sie Zeit und Ressourcen sparen.

Das bedeutet aber auch, dass Sie weniger Kontrolle über die Infrastruktur haben und mit den Einschränkungen der Plattform arbeiten müssen.

Andere PaaS-Anbieter sind:

• Render
• AWS Elastic Beanstalk
• Microsoft Azure App Service
• DigitalOcean App Platform
• The Fly Platform

Backend as a Service (BaaS) wie Back4app

Backend-as-a-Service-Anbieter (BaaS) wie Google Firebase und Back4app bieten eine komplette Backend-Lösung für Ihre Anwendung, einschließlich Datenbank, Authentifizierung und Hosting. Firebase unterstützt mehrere Programmiersprachen, darunter Golang, und bietet eine einfache API, mit der Sie auf seine Dienste zugreifen können.

Ein Vorteil der Nutzung eines BaaS-Dienstes wie Firebase ist, dass Sie schnell und einfach ein Backend für Ihre Anwendung einrichten können, ohne eine Infrastruktur zu verwalten. Firebase bietet eine Reihe von Funktionen und Diensten, allerdings benötigen Sie mehr Kontrolle über die Infrastruktur.

Andere BaaS-Plattformen sind:

• AWS Amplify
• Cloudkit
• Backendless
• Back4App
• Pocketbase

Containerisierung als Service wie bei Back4app Containers

Die Containerisierung ist für die Bereitstellung von Anwendungen sehr beliebt. Mit der Containerisierung können Sie Ihre Anwendung und ihre Abhängigkeiten in einen Container packen, den Sie schnell auf jeder Plattform bereitstellen können, die die Containertechnologie unterstützt.

Back4App ist ein Anbieter von Containerisierung als Service, mit dem Sie Ihre Golang-Anwendung in einem Container bereitstellen und verwalten können.

Einer der Vorteile der Containerisierung als Service-Provider wie Back4App ist, dass Sie Ihre Anwendung auf jeder Plattform bereitstellen können, die Container unterstützt, ohne sich um die zugrunde liegende Infrastruktur kümmern zu müssen.

Der CaaS-Anbieter kümmert sich um die gesamte Container-Verwaltung und -Wartung, wodurch Sie Zeit und Ressourcen sparen. Allerdings müssen Sie möglicherweise innerhalb der Grenzen der Containerisierungsplattform arbeiten, ohne Zugriff auf die Infrastruktur zu haben.

Andere CaaS-Plattformen sind:

• AWS Container Service
• Azure Container Service
• Docker Enterprise
• Google Container Engine
• IBM Kubernetes Service
• Oracle Container Service

Golang-Bereitstellungsprozess

Hier erfahren Sie , wie Sie Ihre Golang-App auf der CaaS-Plattform von Back4app bereitstellen können.

Was ist Back4app?

Back4app ist ein Cloud-Angebot, mit dem Sie Backend-Services für Ihre mobilen und Web-Anwendungen erstellen und bereitstellen können.

Sie können die CaaS-Funktion von Back4app nutzen, um benutzerdefinierte Container auf den Backend-Servern von Back4app bereitzustellen und auszuführen. Sie können Ihrer App mithilfe Ihrer Container-Images eine eigene Logik hinzufügen, ohne Ihre Server-Infrastruktur verwalten zu müssen.

In diesem Abschnitt lernen Sie, wie Sie eine einfache CRUD-RESTful-API in Go erstellen, Go-Programme containerisieren und den Container auf Back4app bereitstellen.

Einrichten Ihrer Entwicklungsumgebung

Nachdem Sie Go von der Download-Seite auf Ihrem Rechner installiert haben, können Sie ein neues Verzeichnis erstellen und ein neues Go-Projekt für Ihre Go-Anwendung initialisieren.

Führen Sie den folgenden Befehl aus, um ein neues Verzeichnis für Ihr Projekt zu erstellen.

mkdir deployAPI && cd deployAPI

Führen Sie den Befehl mod init aus, um ein neues Projekt in Ihrem aktuellen Arbeitsverzeichnis mit dem Go-Tool zu initialisieren.

Etwa so:

go mod init

Sie werden die RESTful API mit dem Gorilla Mux-Paket erstellen.

Führen Sie den folgenden Befehl aus, um das Gorilla Mux-Paket als Abhängigkeit für Ihr Projekt zu installieren.

go get -u github.com/gorilla/mux

Der nächste Schritt ist die Erstellung der RESTful-API. Der erste Schritt bei der Erstellung einer RESTful-API mit Gorilla Mux ist das Importieren der erforderlichen Pakete in Ihre Go-Datei.

Hier ist die Liste der Importe, die Sie für das Projekt benötigen.

import (
	"encoding/json"
	"log"
	"net/http"
	"strconv"

	"github.com/gorilla/mux"
)

Nachdem Sie Ihre Importe aufgelistet haben, müssen Sie eine Datenbank für Ihre Anwendung einrichten. Der Einfachheit halber werden wir eine Map zum Speichern und Abrufen von Daten verwenden.

Sie können die Karte wie folgt zu Ihrer Anwendung hinzufügen:

var users = map[int]string{}

Da die Karte leer ist, müssen Sie die Daten mit einer POST-Anfrage eingeben.

Die Funktion POST Request Handler

Ihre POST-Anforderung sollte Daten vom Client erhalten, sie analysieren und im Kartendatenspeicher speichern.

Fügen Sie den Codeblock in Ihre Anwendung ein, um den POST Request Handler zu implementieren:

func createUserHandler(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	id, err := strconv.Atoi(vars["id"])
	if err != nil {
		w.WriteHeader(http.StatusBadRequest)
		return
	}

	var data map[string]string

	err = json.NewDecoder(r.Body).Decode(&data)
	if err != nil {
		w.WriteHeader(http.StatusBadRequest)
		return
	}

	users[id] = data["name"]

	w.WriteHeader(http.StatusCreated)
}

Die Handler-Funktion createUserHandler nimmt die Daten vom Client (JSON) entgegen, parst das JSON und speichert die Daten in der Map. Wenn der Handler die Daten erfolgreich zur Map hinzufügt, schreibt er den Erfolgscode "StatusCreated" an den Client.

Die GET-Anfrage

Sie lesen Daten aus dem Datenspeicher mit einer GET-Anforderung. Ihre GET-Request-Handler-Funktion ruft eine ID vom Client ab, sucht und gibt die Daten an den Client zurück.

Fügen Sie den Codeblock in Ihre Anwendung ein, um den GET-Request-Handler zu implementieren:

func readUserHandler(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	id, err := strconv.Atoi(vars["id"])
	if err != nil {
		w.WriteHeader(http.StatusBadRequest)
		return
	}

	name, ok := users[id]
	if !ok {
		w.WriteHeader(http.StatusNotFound)
		return
	}

	data := map[string]string{"name": name}

	jsonData, err := json.Marshal(data)
	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusOK)
	w.Write(jsonData)
}

Die Funktion readUserHandler ruft die ID mit der Funktion Vars des mux-Pakets ab und durchsucht die Map nach den Daten, bevor sie die Daten als JSON an den Client zurückgibt, zusammen mit einem StatusOk-Erfolgscode.

Die PUT Request Handler Funktion

Sie aktualisieren die Daten in Ihrem Datenspeicher mit einer PUT-Anforderung. Ihr PUT-Request-Handler akzeptiert die ID und ein JSON-Feld für den Aktualisierungsprozess.

func updateUserHandler(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	id, err := strconv.Atoi(vars["id"])
	if err != nil {
		w.WriteHeader(http.StatusBadRequest)
		return
	}

	var data map[string]string

	err = json.NewDecoder(r.Body).Decode(&data)
	if err != nil {
		w.WriteHeader(http.StatusBadRequest)
		return
	}

	users[id] = data["name"]

	w.WriteHeader(http.StatusOK)
}

Die Funktion updateUserHandler nimmt die ID mit der Variablen vars auf, dekodiert das JSON aus dem Request Body und aktualisiert das Feld oder die ID mit den JSON-Daten aus dem Request Body.

Die DELETE-Anfrage-Handler-Funktion

Ihre DELETE-Request-Handler-Funktion übernimmt die Feld-ID aus der Anfrage und löscht das Feld aus dem Datenspeicher.

Fügen Sie den Codeblock zu Ihrer Anwendung hinzu, um den DELETE-Request-Handler zu implementieren:

func deleteUserHandler(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	id, err := strconv.Atoi(vars["id"])
	if err != nil {
		w.WriteHeader(http.StatusBadRequest)
		return
	}

	delete(users, id)

	w.WriteHeader(http.StatusOK)
}

Die Funktion deleteUserHandler löscht das Feld mit der Funktion delete, die den Namen der Karte und die ID aufnimmt und den StatusOk-Code an den Client zurückgibt.

Einbindung der Handlerfunktionen in Routen

Nachdem Sie die Endpunkte Ihrer Anwendung definiert haben, müssen Sie die Handler-Funktionen den Routen zuweisen. Die Routen sind die öffentliche Schnittstelle Ihrer API.

func main() {
	r := mux.NewRouter()

	r.HandleFunc("/users/{id}", createUserHandler).Methods(http.MethodPost)
	r.HandleFunc("/users/{id}", readUserHandler).Methods(http.MethodGet)
	r.HandleFunc("/users/{id}", updateUserHandler).Methods(http.MethodPut)
	r.HandleFunc("/users/{id}", deleteUserHandler).Methods(http.MethodDelete)

	log.Fatal(http.ListenAndServe(":8080", r))
}

In der Hauptfunktion ist r eine Instanz eines neuen mux-Routers, und die HandleFunc-Methode nimmt eine Route und eine Handler-Funktion auf. Die Funktion Methods legt die HTTP-Methoden für die Routen fest.

Containerisierung von Go-Anwendungen mit Docker

Docker ist eine der beliebtesten Containerisierungstechnologien. Docker wurde mit Go entwickelt, und Sie können Ihre Go-Anwendungen zur Portabilität mit Docker containerisieren.

Sie müssen ein neues Dockerfile erstellen, in dem Sie die Bauanweisungen angeben.

Führen Sie den folgenden Befehl aus, um eine Dockerdatei im Arbeitsverzeichnis Ihres Projekts zu erstellen.

touch Dockerfile

Öffnen Sie das Dockerfile und fügen Sie diese Build-Anweisungen ein, um Ihre Go-App mit Docker zu containerisieren.

# Use an official Golang runtime as a parent image
FROM golang:latest

# Set the working directory to /app
WORKDIR /app

# Copy the current directory contents into the container at /app
COPY . /app

# Download and install any required dependencies
RUN go mod download

# Build the Go app
RUN go build -o main .

# Expose port 8080 for incoming traffic
EXPOSE 8080

# Define the command to run the app when the container starts
CMD ["/app/main"]

Die Bauanweisungen im Dockerfile geben die Go-Version für das Projekt, das Arbeitsverzeichnis, die Dateien für die Anwendung und die Bauanweisungen für das Dockerfile an.

Hier ist eine Aufschlüsselung des Dockerfiles:

• Die Datei beginnt mit FROM golang: latest, was angibt, dass Sie die neueste Version des offiziellen Golang-Images als Basis-Image für Ihren Docker-Container verwenden möchten.
• Die Zeile WORKDIR /app setzt das Arbeitsverzeichnis für Ihren Container auf das Verzeichnis /app.
• Der Befehl COPY . /app kopiert den Inhalt Ihres aktuellen Verzeichnisses in das /app-Verzeichnis des Containers.
• Der RUN go mod download lädt die erforderlichen Abhängigkeiten für Ihre Anwendung herunter.
• Der RUN go build -o main . kompiliert Ihre Go-Anwendung und erstellt eine ausführbare Datei namens main im Verzeichnis /app.
• Die Zeile EXPOSE 8080 weist Docker an, Port 8080 freizugeben, den Port, an dem Ihre Go-Anwendung auf eingehende Anfragen wartet.
• Die CMD-Zeile ["/app/main"] gibt den Befehl an, der beim Starten des Containers ausgeführt werden soll (in diesem Fall die ausführbare Datei main ).

Wenn das Dockerfile ausgeführt wird, erstellt Docker das App-Image und stellt die App auf Port 8080 bereit.

Der Befehl startet den Container und ordnet Port 8080 auf dem Host-Rechner dem Port 8080 im Container zu, und Sie sollten in der Lage sein, auf die API auf [http://localhost:8080](http://localhost:8080) zuzugreifen .

Bereitstellen des Containers auf Back4app

Für die Bereitstellung von Containern müssen Sie ein Konto bei Back4app erstellen (falls Sie noch keines haben).

Hier sind die Schritte zur Erstellung eines Kontos bei Back4app.

1. Besuchen Sie die Back4app-Website.
2. Klicken Sie auf die Schaltfläche Anmelden in der oberen rechten Ecke der Landing Page, um ein neues Konto zu erstellen.
3. Füllen Sie schließlich das Anmeldeformular aus und schicken Sie es ab.

Nachdem Sie Ihr Back4app-Konto erstellt haben, melden Sie sich bei Ihrem Konto an und klicken Sie auf die Schaltfläche NEUE APP in der oberen rechten Ecke der Benutzeroberfläche.

Über die Schaltfläche NEUE APP gelangen Sie zu einer Seite, auf der Sie auswählen können, wie Sie Ihre App bereitstellen möchten. Da Sie einen Container bereitstellen, wählen Sie die Option “Container als Dienst”.

Als nächstes verbinden Sie Ihr GitHub-Konto mit Ihrem Back4app-Konto. Sie können Back4app Zugriff auf den Quellcode aller Repositories in Ihrem Konto oder auf ein bestimmtes Projektverzeichnis geben.

Wählen Sie die Anwendung aus, die Sie bereitstellen möchten, in diesem Fall die Anwendung, die Sie in diesem Tutorial erstellt haben, und klicken Sie dann auf Auswählen.

Wenn Sie auf die Schaltfläche “Auswählen” klicken, gelangen Sie auf eine Seite, auf der Sie die Informationen zu Ihrer Anwendung eingeben, vom Namen über die Verzweigung und das Stammverzeichnis bis hin zu den Umgebungsvariablen.

Stellen Sie sicher, dass Sie alle für Ihre Anwendung erforderlichen Umgebungsvariablen ausfüllen. Nachdem Sie die erforderlichen Details ausgefüllt haben, klicken Sie auf App erstellen.

Wenn Sie auf diese Schaltfläche klicken, wird der Bereitstellungsprozess für Ihre Go-Anwendung gestartet, wie in der folgenden Abbildung dargestellt.

Schlussfolgerung

Sie haben gelernt, wie Sie eine containerisierte Go-App auf Back4app bereitstellen können. Wenn Sie die Schritte in diesem Tutorial befolgt haben, sollten Sie eine Go-API auf Back4app laufen haben.

Die Bereitstellung Ihrer Anwendungen auf Back4app ist eine großartige Möglichkeit, die Verwaltung der Backend-Infrastruktur zu vereinfachen. Back4App bietet leistungsstarke Tools für die Verwaltung Ihrer Daten, die Skalierung Ihrer Anwendung und die Überwachung ihrer Leistung. Es ist eine ausgezeichnete Wahl für Entwickler, die großartige Anwendungen erstellen möchten, anstatt Server zu verwalten.

FAQ