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.
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.
La mise en œuvre du centre de configuration distribué doit prendre en compte les aspects suivants :
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 :
Obligatoire pour utiliser go-zero Installez d'abord les dépendances pertinentes :
go get -u github.com/tal-tech/go-zero
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;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.
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)
}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)
}
}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
}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!
Ce qui est distribué
La différence entre les services distribués et les microservices
Comment résoudre le problème de l'écran noir après avoir allumé l'ordinateur et impossible d'accéder au bureau
l'explorateur Windows a cessé de fonctionner
Comment résoudre l'échec de la résolution DNS
Les principaux composants qui composent le CPU
geforce 940mx
solution de panique du noyau
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
