Erstellen Sie verteilte Systeme mit dem Golang-Microservices-Framework

Erstellen Sie ein verteiltes System mit dem Golang-Microservice-Framework: Installieren Sie Golang, wählen Sie ein Microservice-Framework (z. B. Gin) aus, um einen Gin-Microservice zu erstellen, fügen Sie Endpunkte hinzu, um den Microservice bereitzustellen, erstellen Sie die Anwendung und führen Sie sie aus, um Bestell- und Inventar-Microservices zu erstellen, und verwenden Sie Endpunkte um Bestellungen und Inventar zu verarbeiten. Verwenden Sie Messaging-Systeme wie Kafka, um Microservices zu verbinden. Verwenden Sie die Sarama-Bibliothek, um Bestellinformationen zu produzieren und zu konsumieren.

Erstellen Sie ein verteiltes System mit dem Golang-Microservices-Framework.

In diesem Artikel werden wir Sie Schritt für Schritt anleiten um eine Verteilung mithilfe des Golang-Microservices-Framework-Formelsystems zu erstellen. Wir werden auch ein praktisches Beispiel bereitstellen, das zeigt, wie man mithilfe des Microservices-Musters eine reale Anwendung erstellt.

Voraussetzungen

• Golang auf Ihrem System installiert und konfiguriert
• Grundlegende Golang-Kenntnisse

Einführung in Microservices

Microservices-Architektur ist ein Software-Design-Ansatz, der Anwendungen in unabhängige Module aufteilt. Jeder Microservice übernimmt eine bestimmte Funktion und kann unabhängig bereitgestellt, skaliert und gewartet werden.

Golang Microservices Framework

Es gibt viele Microservices-Frameworks für Golang. Zu den beliebtesten gehören:

• Gin: ein einfaches und effizientes Web-Framework
• Echo: ein leistungsstarkes und einfach zu bedienendes -Verwendetes Web-Framework
• Fiber: Ein schnelles und leichtes Web-Framework

In diesem Leitfaden verwenden wir das Gin-Framework, um den Prozess der Microservice-Erstellung zu demonstrieren.

Erstellen Sie einen Gin-Microservice.

Erstellen Sie zunächst ein neues Go-Modul:

go mod init microservice

.

Als nächstes installieren Sie das Gin-Framework:

go get github.com/gin-gonic/gin

Verwenden Sie Gin.RouterGroup Objekt:

package main

import (
    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()
}

Bereitstellen von Microservices

Um Microservices bereitzustellen, erstellen Sie die Anwendung und führen Sie sie aus:

func main() {
    r := gin.Default()
    r.GET("/hello", func(c *gin.Context) {
        c.JSON(200, gin.H{"message": "Hello, World!"})
    })
}

Gin.RouterGroup 对象：

go build .
./microservice

部署微服务

要部署微服务，请构建并运行应用程序：

func main() {
    r := gin.Default()
    r.GET("/orders", func(c *gin.Context) {
        // 获取所有订单
    })
    r.POST("/orders", func(c *gin.Context) {
        // 创建新订单
    })
}

实战案例：订单管理系统

让我们创建一个订单管理系统，其中包含一个处理用户订单的微服务。

创建订单微服务

使用相同的步骤创建一个新的 Gin 微服务，并添加以下端点：

func main() {
    r := gin.Default()
    r.GET("/stock/:product_id", func(c *gin.Context) {
        // 获取产品的库存数量
    })
}

创建库存微服务

库存微服务将跟踪产品可用性。使用相同的步骤创建一个新的 Gin 微服务，并添加以下端点：

import (
    "context"
    "time"

    "github.com/Shopify/sarama"
)

func main() {
    producer, err := sarama.NewSyncProducer([]string{"localhost:9092"}, nil)
    if err != nil {
        // 处理错误
    }
    msg := &sarama.ProducerMessage{
        Topic: "orders",
        Value: sarama.StringEncoder("new order"),
    }
    _, _, err = producer.SendMessage(msg)
    if err != nil {
        // 处理错误
    }
}

连接微服务

为了让微服务相互通信，我们需要使用一个消息传递系统。在本例中，我们将使用 Kafka。

• 安装 Kafka：brew install kafka
• 创建一个 Kafka 主题：kafka-topics --create --topic orders
• 在订单微服务中，使用 sarama 库生产订单：

import (
    "context"
    "log"
    "time"

    "github.com/Shopify/sarama"
)

func main() {
    consumer, err := sarama.NewConsumer([]string{"localhost:9092"}, nil)
    if err != nil {
        // 处理错误
    }
    defer consumer.Close()
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    consumer.ConsumePartition("orders", 0, sarama.OffsetNewest)
    for {
        select {
        case msg := <-consumer.Messages():
            log.Printf("Received message: %s\n", string(msg.Value))
        case err := <-consumer.Errors():
            log.Printf("Received consumer error: %s\n", err.Error())
        case <-ctx.Done():
            cancel()
            return
        }
    }
}

• 在库存微服务中，使用 saramaPraktischer Fall: Auftragsverwaltungssystem

Lassen Sie uns ein Auftragsverwaltungssystem erstellen, das Folgendes enthält: Mikroservice, der Benutzeraufträge verarbeitet.

Auftrags-Microservice erstellen

🎜🎜Verwenden Sie dieselben Schritte, um einen neuen Gin-Microservice zu erstellen und die folgenden Endpunkte hinzuzufügen: 🎜rrreee🎜🎜Inventar-Microservice erstellen 🎜🎜🎜Der Inventar-Microservice verfolgt die Produktverfügbarkeit. Erstellen Sie mit denselben Schritten einen neuen Gin-Microservice und fügen Sie die folgenden Endpunkte hinzu: 🎜rrreee🎜🎜Microservices verbinden🎜🎜🎜Damit Microservices miteinander kommunizieren können, müssen wir ein Nachrichtensystem verwenden. In diesem Beispiel verwenden wir Kafka. 🎜🎜🎜Installieren Sie Kafka: brew install kafka🎜🎜Erstellen Sie ein Kafka-Thema: kafka-topics --create --topicorders🎜🎜Verwenden Sie im Order-Microservice sarama Produktionsreihenfolge der Bibliothek: 🎜🎜rrreee🎜🎜Verwenden Sie im Inventar-Microservice die sarama-Bibliotheksverbrauchsreihenfolge: 🎜🎜rrreee🎜Zusammenfassung🎜🎜Mit dem Golang-Microservice-Framework können Sie verteilt erstellen Systeme problemlos. Wenn Sie die Schritte in diesem Artikel befolgen, können Sie ein Auftragsverwaltungssystem aufbauen, das Messaging zur Koordinierung von Microservices verwendet. 🎜

Das obige ist der detaillierte Inhalt vonErstellen Sie verteilte Systeme mit dem Golang-Microservices-Framework. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!