Utiliser go-zero pour implémenter un centre de configuration distribué

Avec le développement d'Internet, l'échelle des applications d'entreprise augmente progressivement et les configurations requises pour différents scénarios commerciaux deviennent de plus en plus complexes. La gestion et la maintenance des configurations sont souvent un processus fastidieux et sujet aux erreurs. Afin de résoudre ces problèmes, le centre de configuration distribué a vu le jour.

Le centre de configuration distribué est une conception modulaire qui centralise les informations de configuration de toutes les applications et fournit une interface d'exploitation conviviale pour permettre aux gestionnaires de modifier et de publier les informations de configuration. En gérant de manière centralisée les informations de configuration, les pannes système causées par des problèmes de configuration peuvent être efficacement réduites.

Cet article expliquera comment utiliser go-zero pour implémenter un centre de configuration distribué simple.

Qu'est-ce que le go-zéro ?

Go-Zero est un framework de microservices du langage Go. Il présente les caractéristiques de hautes performances, d'évolutivité facile et de facilité d'utilisation. C'est l'un des frameworks préférés des développeurs de langage Go pour créer rapidement des applications de microservices hautes performances, évolutives et fiables. .

En plus de fournir des fonctions liées aux microservices telles que l'enregistrement des services, le contrôle de santé, le disjoncteur de limite de courant, la gestion des connexions longues et la gouvernance des services, Go-Zero fournit également de nombreux outils d'aide au développement, tels que l'outil de génération Rpc, la génération d'API http. outil, centre de configuration, bibliothèque de journaux, bibliothèque de cache, etc.

Principe de mise en œuvre du centre de configuration distribué

La mise en œuvre du centre de configuration distribué doit prendre en compte les aspects suivants :

1. Stockage de base de données : une base de données relationnelle (telle que MySQL, PostgreSQL, etc.) doit être utilisée pour stocker les informations de configuration. pour assurer la configuration Stockage persistant des informations.
2. Gestion backend : il est nécessaire de fournir un système de gestion backend grâce auquel les administrateurs peuvent ajouter, supprimer, modifier, vérifier et publier des informations de configuration.
3. Chargement des fichiers de configuration : une interface de chargement des fichiers de configuration doit être fournie pour les appels d'application afin de garantir que les applications peuvent obtenir les dernières informations de configuration.
4. Actualisation programmée : il est nécessaire de mettre en œuvre la fonction d'actualisation régulière des informations de configuration pour garantir une mise à jour rapide des données.
5. Cohérence distribuée : lors du déploiement de plusieurs nœuds, la cohérence des informations de configuration doit être prise en compte pour éviter les erreurs causées par une désynchronisation des nœuds.

Utilisez go-zero pour implémenter un centre de configuration distribué

Cet article présentera brièvement le processus d'utilisation du framework go-zero pour implémenter un centre de configuration distribué. Les étapes spécifiques sont les suivantes :

1. zero

Obligatoire pour utiliser go-zero Installez d'abord les dépendances pertinentes :

go get -u github.com/tal-tech/go-zero

2 Créez une base de données

Créez d'abord une base de données et créez une table. La structure de la table est la suivante :

CREATE TABLE `config` (
    `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
    `app_name` varchar(255) DEFAULT '',
    `key_name` varchar(255) DEFAULT '',
    `value` varchar(1024) DEFAULT '',
    `create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
    `update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

3. système de gestion

Le système de gestion backend est principalement utilisé pour ajouter, supprimer, modifier et vérifier les informations de configuration et publier des opérations. Dans le framework go-zero, vous pouvez utiliser l'outil goctl pour générer rapidement du code lié au système de gestion :

goctl api new -api config -dir config/api

Le code généré se trouve dans le répertoire config/api et doit être ajusté en fonction des besoins réels.

4. Implémentez le chargement du fichier de configuration

Générez un service rpc nommé config via l'outil goctl et chargez le fichier de configuration en appelant son interface.

L'interface du service est définie comme suit :

type Config interface {
    GetConfig(ctx context.Context, req *model.GetConfigReq) (*model.GetConfigResp, error)
    WatchConfig(ctx context.Context, req *model.GetConfigReq) (*model.GetConfigResp, error)
}

5. Implémenter l'actualisation programmée

Afin d'implémenter la fonction d'actualisation programmée, vous pouvez utiliser les outils liés à etcd dans le framework go-zero.

Vous devez d'abord installer etcd :

go get -u go.etcd.io/etcd/client/v3

Ensuite, définissez l'adresse et le port d'etcd dans le fichier de configuration :

[etcd]
  null=127.0.0.1:2379

Enfin, implémentez la logique d'actualisation programmée dans le code :

func RefreshConfig() {
    etcdCli, err := clientv3.New(clientv3.Config{
        Endpoints:   *conf.Etcd,
        DialTimeout: time.Second * 3,
    })
    if err != nil {
        logx.Errorf("err: %v", err)
        return
    }
    defer etcdCli.Close()

    for {
        ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
        resp, err := etcdCli.Get(ctx, *conf.EtcdKey)
        if err != nil {
            logx.Errorf("err: %v", err)
            cancel()
            continue
        }
        if len(resp.Kvs) == 1 {
            var configMap map[string]string
            err = json.Unmarshal(resp.Kvs[0].Value, &configMap)
            if err != nil {
                logx.Errorf("err: %v", err)
            } else {
                cacheConfigMap.Lock()
                cacheConfigMap.data = configMap
                cacheConfigMap.Unlock()
                logx.Info("Refresh config success")
            }
        }
        cancel()
        time.Sleep(time.Second * 10)
    }
}

6. Atteindre la cohérence distribuée

Dans. afin d'atteindre une cohérence distribuée, il faut utiliser des outils liés à etcd dans le cadre go-zero.

Vous devez d'abord installer etcd :

go get -u go.etcd.io/etcd/client/v3

Ensuite, implémentez la logique de verrouillage distribué liée à etcd dans le code :

func Lock() error {
    etcdCli, err := clientv3.New(clientv3.Config{
        Endpoints:   *conf.Etcd,
        DialTimeout: time.Second * 3,
    })
    if err != nil {
        logx.Errorf("err: %v", err)
        return err
    }
    defer etcdCli.Close()

    var s *concurrency.Session
    var m *concurrency.Mutex
    for {
        opTimeoutCtx, cancel := context.WithTimeout(context.Background(), time.Second)
        s, err = concurrency.NewSession(etcdCli,
            concurrency.WithContext(opTimeoutCtx),
            concurrency.WithTTL(int32(*conf.LockTtl)))
        if err != nil {
            logx.Errorf("create etcd session error: %v", err)
            cancel()
            time.Sleep(time.Second)
            continue
        }

        opTimeoutCtx, cancel = context.WithTimeout(context.Background(), time.Second)
        m = concurrency.NewMutex(s, *conf.EtcdKey)
        err = m.Lock(opTimeoutCtx)
        if err != nil {
            logx.Errorf("etcd lock failed: %v", err)
            cancel()
            time.Sleep(time.Second)
            continue
        }
        break
    }

    cacheConfigMap.Lock()
    defer cacheConfigMap.Unlock()

    defer func() {
        if m != nil {
            err = m.Unlock(context.Background())
            if err != nil {
                logx.Errorf("etcd unlock failed: %v", err)
            }
        }
    }()
    defer func() {
        if s != nil {
            s.Close()
        }
    }()
    return nil
}

Conclusion

Cet article présente comment utiliser le framework go-zero pour implémenter un centre de configuration distribué simple. En utilisant les hautes performances, l'évolutivité et la facilité d'utilisation de Go-Zero, nous pouvons rapidement créer un centre de configuration distribué hautement disponible en peu de temps, nous aidant ainsi efficacement à réduire les pannes système causées par des problèmes de configuration.

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!