Application et bonnes pratiques du go-zero dans la gouvernance des microservices

En tant que framework de microservices léger en langage Go, l'application go-zero et les meilleures pratiques en matière de gouvernance des microservices sont devenues un élément important qui ne peut être ignoré dans le développement actuel.

Le langage Go utilise généralement le modèle d'architecture de microservice lors du développement d'applications distribuées. Dans une architecture de microservices, la communication entre les services est très importante. Pour garantir la fiabilité et l’efficacité de la communication entre les services, la gouvernance des microservices doit être optimisée. Cet article explorera l'application et les meilleures pratiques du go-zero dans la gouvernance des microservices, en vue de fournir aux développeurs des conseils et une inspiration pratiques.

1. Présentation

go-zero est un framework de microservices léger et performant avec les avantages de la sécurité des threads et d'une concurrence élevée. Ses scénarios d'application sont très larges, incluant mais sans s'y limiter : système de recommandation, file d'attente de messages, gestion des logs, passerelle API, etc. Dans le même temps, go-zero prend en charge très complètement la gouvernance des microservices, y compris la découverte de services, l'équilibrage de charge, la dégradation des disjoncteurs, la limitation de courant, etc.

2. Découverte de services

La découverte de services est un élément important de la gouvernance des microservices. go-zero prend en charge plusieurs centres d'enregistrement de services tels que etcd et consul, et implémente l'intégration avec d'autres outils de découverte de services compatibles go-micro via l'interface de découverte de services de go-micro.

Nous pouvons réaliser l'intégration de go-zero et etcd grâce au code suivant :

import (

    "github.com/go-zero/go-zero/core/discov"

    "github.com/go-zero/go-zero/core/stores/etcd"

    )

    //构建etcd连接
    client := etcd.NewClient([]string{"localhost:2379"})
    //创建Discovery服务
    d := discov.NewDiscovery(client, "hello")
    //获取服务列表
    services, err := d.GetServices()

Avec le code ci-dessus, nous avons intégré avec succès etcd et go-zero et obtenu la liste de services.

3. Équilibrage de charge

L'équilibrage de charge est un moyen important pour garantir la haute disponibilité des services. go-zero prend en charge plusieurs méthodes d'équilibrage de charge, notamment l'interrogation, l'aléatoire, l'interrogation pondérée, l'aléatoire pondéré, etc. Habituellement, nous déployons plusieurs instances de service sur différentes machines, ce qui nécessite l'ajout de facteurs de sélection de machine à l'algorithme d'équilibrage de charge.

Dans l'exemple de code suivant, nous utilisons l'algorithme RoundRobin pour réaliser l'équilibrage de charge et définir le poids pour chaque instance de service.

import (
    "github.com/stretchr/testify/assert"
    "github.com/go-zero/go-zero/core/balance"
    )
    
    //定义服务列表
    nodes, _ := balance.NewRoundRobin("/",
        balance.WithNodes(
            &balance.WeightNode{
                Weight: 10,
                Node: balance.NewNode("127.0.0.1", 8000),
            },
            &balance.WeightNode{
                Weight: 20,
                Node: balance.NewNode("127.0.0.2", 8000),
            },
        ))
    // 从服务列表中选择下一个节点进行调用
    next, err := nodes.Next()

Le code ci-dessus montre comment utiliser le composant d'équilibre fourni par go-zero, utiliser l'algorithme RoundRobin pour réaliser l'équilibrage de charge et définir différentes valeurs de poids pour chaque instance de service.

4. Déclassement du disjoncteur et limitation de courant

Dans les scénarios de concurrence élevée, les appels de service peuvent être anormaux pour diverses raisons, ce qui nécessite l'utilisation de stratégies de déclassement du disjoncteur et de limitation de courant. go-zero met en œuvre des stratégies telles que la dégradation des disjoncteurs et la limitation du courant via des composants hystrix.

Dans l'exemple de code ci-dessous, nous utilisons le composant hystrix pour limiter la vitesse et la simultanéité des appels de service dans des scénarios à forte simultanéité.

import (
    "net/http"
    "github.com/go-zero/go-zero/core/hystrix"
    )
    
    //定义熔断降级回调函数
    fallbackFunc := func(err error) bool {
        //判断回调错误类型
        e := hystrix.ExtractHTTPError(err)
        if e == nil || e.Code != http.StatusNotFound {
            // 返回true触发熔断降级
            return true
        }
        //返回false
        return false
    }
    //实例化Hystrix方法
    hystrix.Do(ctx, "test", func(ctx context.Context) error {
        //执行服务
        resp, err := http.Get("https://example.com/")
        if err != nil {
            return err
        }
        defer resp.Body.Close()
        return nil
    }, hystrix.WithFallback(fallbackFunc))

Dans le code ci-dessus, nous utilisons la méthode Do dans le composant hystrix pour implémenter des restrictions sur les appels de service, les coupures de circuit et les appels anormaux rétrogradés dans des scénarios à haute concurrence, et implémentons le filtrage des types d'erreurs via des fonctions de rappel. De cette façon, nous pouvons réduire efficacement l’impact des appels anormaux sur le système.

5. Résumé

Cet article traite de l'application et des meilleures pratiques du go-zero dans la gouvernance des microservices. Grâce à des explications approfondies sur des technologies telles que la découverte de services, l'équilibrage de charge, la dégradation des disjoncteurs et la limitation de courant, il vise à fournir aux développeurs des idées et des conseils pratiques. Je pense que lors du prochain développement de microservices, nous pourrons mieux utiliser le cadre go-zero pour améliorer les performances et la fiabilité du système.

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!