Erstellen Sie Microservices mit Golangs Web-Framework Iris Framework und Docker

Mit der kontinuierlichen Entwicklung von Internetanwendungen wird die Microservice-Architektur zu einem immer beliebter werdenden Architekturmodell. Die Microservices-Architektur entwirft Anwendungen als kleine, voneinander unabhängige Dienste, die regelmäßig aktualisiert und bereitgestellt werden können. Mit der Entwicklung von Cloud Computing, Big Data und dem Internet der Dinge wird die Anwendung der Microservice-Architektur immer weiter verbreitet.

In diesem Artikel erfahren Sie, wie Sie Golangs Web-Framework Iris und Docker zum Erstellen von Microservices verwenden.

1. Einführung in Iris

Iris ist ein in Go geschriebenes Web-Framework, das vom Kataras-Team erstellt und gepflegt wird. Der Code von Iris ist prägnant und leicht zu lesen, weist eine hervorragende Leistung auf, unterstützt asynchrone und synchrone Programmierstile und unterstützt sowohl MVC- als auch RESTful-Architekturen. Iris ist ein aufstrebendes Web-Framework, das darauf abzielt, das „Web-Framework der nächsten Generation“ zu werden.

2. Einführung in Docker

Docker ist eine Open-Source-Containerisierungsplattform, die es Entwicklern ermöglicht, Anwendungen schnell zu erstellen, bereitzustellen und auszuführen. Mit Docker können Sie Ihre Anwendung und alle ihre Abhängigkeiten in einem einzigen Container zusammenfassen und so die Anwendungsbereitstellung einfacher und zuverlässiger machen. Docker verbessert nicht nur die Portabilität von Anwendungen, sondern reduziert auch die Ressourcennutzung und Konflikte zur Laufzeit.

3. Verwenden Sie Iris und Docker, um Microservices zu erstellen

In diesem Artikel stellen wir vor, wie Sie Iris und Docker verwenden, um einen einfachen Microservice zu erstellen. Der Dienst stellt zwei API-Endpunkte bereit: /hello und /time . Der Endpunkt /hello gibt die Nachricht „Hello, World!“ zurück und der Endpunkt /time gibt die aktuelle Uhrzeit zurück.

1. Golang-Projekt erstellen

Erstellen Sie zunächst ein Golang-Projekt. Erstellen Sie ein Iris-Projekt mit dem folgenden Befehl:

$ go get -u github.com/kataras/iris/v12

Stellen Sie sicher, dass die Umgebungsvariablen im Go-Arbeitsbereich festgelegt sind.

Erstellen Sie die Datei main.go und fügen Sie den folgenden Code hinzu:

package main

import (
    "github.com/kataras/iris/v12"
    "time"
)

func main() {
    app := iris.New()
    app.Get("/hello", func(ctx iris.Context) {
        ctx.JSON(iris.Map{"message": "Hello, World!"})
    })
    app.Get("/time", func(ctx iris.Context) {
        ctx.JSON(iris.Map{"time": time.Now().Format(time.RFC3339)})
    })
    app.Run(iris.Addr(":8080"))
}

In main.go verwenden wir iris.New(), um eine neue Iris-Anwendungsinstanz zu erstellen und verwenden die Methode app.Get(), um zwei verschiedene Router zu definieren . Der /hello-Endpunkt des Routers gibt die Nachricht „Hello, World!“ zurück und der /time-Endpunkt gibt die aktuelle Uhrzeit zurück. Führen Sie abschließend die Methode app.Run() aus, um den Dienst zu starten und auf Verbindungen am Standardport 8080 zu warten.

2. Dockerfile erstellen

Als nächstes erstellen Sie eine Datei namens Dockerfile. Eine Docker-Datei ist eine Textdatei, die eine Reihe von Anweisungen zum Erstellen eines Docker-Images enthält.

Fügen Sie den folgenden Code in die Docker-Datei ein:

FROM golang:1.16.3-alpine3.13 AS build

RUN apk update && apk upgrade && 
    apk add --no-cache bash git openssh

WORKDIR /go/src/app
COPY . .

RUN go get -d -v ./...
RUN go install -v ./...
RUN go build -o /usr/local/bin/app

FROM alpine:3.13
COPY --from=build /usr/local/bin/app /usr/local/bin/app
ENTRYPOINT ["/usr/local/bin/app"]

Diese Docker-Datei erstellt unsere Anwendung basierend auf dem Golang 1.16.3-alpine3.13-Image. Wir haben zunächst das Alpine3.13-Installationspaket aktualisiert und die erforderlichen Bash-, Git- und OpenSh-Pakete hinzugefügt. Als Nächstes definieren wir das Arbeitsverzeichnis, kopieren unseren Anwendungscode in das Arbeitsverzeichnis und laden die Abhängigkeiten herunter. Abschließend führen wir den Befehl „go build“ aus, um die ausführbare Binärdatei zu erstellen, und kopieren die ausführbare Binärdatei in das Alpine3.13-Image, um das endgültige Docker-Image zu erstellen.

3. Erstellen Sie den Container und führen Sie ihn aus.

Verwenden Sie im Dockerfile-Verzeichnis den folgenden Befehl, um das Docker-Image zu erstellen:

$ docker build -t my-app .

Dieser Befehl erstellt ein Docker-Image mit dem Namen my-app. Wir können den folgenden Befehl verwenden, um einen Docker-Container auszuführen:

$ docker run -p 8080:8080 my-app

Dieser Befehl startet den Container und ordnet den Standardport 8080 mithilfe des Flags -p dem 8080-Port des Hosts zu. Mit der öffentlichen API der Anwendung, die im Container läuft, können wir diese API mit dem folgenden Befehl testen:

$ curl http://localhost:8080/hello
{"message":"Hello, World!"}
$ curl http://localhost:8080/time
{"time":"2021-05-27T14:14:22+08:00"}

Jetzt haben wir erfolgreich einen einfachen Microservice mit Iris und Docker erstellt. In realen Anwendungen können wir den Dienst in mehrere Microservices aufteilen, um die Anwendung besser zu verwalten und zu skalieren.

Das obige ist der detaillierte Inhalt vonErstellen Sie Microservices mit Golangs Web-Framework Iris Framework und Docker. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!