Créez des systèmes distribués à l'aide du framework de microservices Golang

Créez un système distribué à l'aide du framework de microservices Golang : installez Golang, sélectionnez un framework de microservices (tel que Gin) pour créer un microservice Gin, ajoutez des points de terminaison pour déployer le microservice, créez et exécutez l'application pour créer des microservices de commande et d'inventaire, utilisez des points de terminaison pour traiter les commandes et l'inventaire Utilisez des systèmes de messagerie comme Kafka pour connecter des microservices Utilisez la bibliothèque sarama pour produire et consommer des informations sur les commandes

Créez un système distribué à l'aide du framework de microservices Golang

Dans cet article, nous vous guiderons étape par étape pour créer une distribution à l'aide du système de formule du framework de microservices Golang. Nous fournirons également un exemple pratique montrant comment créer une application réelle à l'aide du modèle de microservices.

Prérequis

• Golang installé et configuré sur votre système
• Connaissances de base de Golang

Introduction aux microservices

L'architecture des microservices est une approche de conception logicielle qui divise les applications en modules indépendants. Chaque microservice gère une fonction spécifique et peut être déployé, mis à l'échelle et maintenu indépendamment.

Golang Microservices Framework

Il existe de nombreux frameworks de microservices disponibles pour Golang, parmi les plus populaires figurent :

• Gin : un framework web simple et efficace
• Echo : un framework web performant et facile à utiliser -utiliser le framework Web utilisé
• Fiber : Un framework Web rapide et léger

Dans ce guide, nous utiliserons le framework Gin pour démontrer le processus de création de microservices.

Créez un microservice Gin

Tout d'abord, créez un nouveau module Go :

go mod init microservice

Ensuite, installez le framework Gin :

go get github.com/gin-gonic/gin

Créez un nouveau routeur Gin :

package main

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

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

Ajoutez des points de terminaison

Pour ajouter au point de terminaison du microservice, veuillez utilisez Gin.RouterGroup Objet : Gin.RouterGroup 对象：

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

部署微服务

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

go build .
./microservice

实战案例：订单管理系统

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

创建订单微服务

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

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) {
        // 获取产品的库存数量
    })
}

连接微服务

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

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

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 {
        // 处理错误
    }
}

• 在库存微服务中，使用 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
          }
      }
  }

  Déploiement de microservices

  Pour déployer des microservices, construisez et exécutez l'application :

  rrreee

  Cas pratique : Système de gestion des commandes

  🎜Créons un système de gestion des commandes qui contient un microservice qui gère les commandes des utilisateurs. 🎜🎜🎜Créer un microservice de commande🎜🎜🎜Utilisez les mêmes étapes pour créer un nouveau microservice Gin et ajouter les points de terminaison suivants : 🎜rrreee🎜🎜Créer un microservice d'inventaire 🎜🎜🎜Le microservice d'inventaire suivra la disponibilité des produits. Créez un nouveau microservice Gin en suivant les mêmes étapes et ajoutez les points de terminaison suivants : 🎜rrreee🎜🎜Connexion des microservices🎜🎜🎜Pour que les microservices communiquent entre eux, nous devons utiliser un système de messagerie. Dans cet exemple, nous utiliserons Kafka. 🎜🎜🎜Installer Kafka : brew install kafka🎜🎜Créer un sujet Kafka : kafka-topics --create --topicorders🎜🎜Dans le microservice de commande, utilisez sarama : 🎜🎜rrreee🎜🎜Dans le microservice d'inventaire, utilisez l'ordre de consommation de la bibliothèque sarama : 🎜🎜rrreee🎜Résumé🎜🎜En utilisant le framework de microservice Golang, vous pouvez créer des systèmes facilement. En suivant les étapes de cet article, vous pourrez créer un système de gestion des commandes qui utilise la messagerie pour coordonner les microservices. 🎜

  Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!