Implémentation d'une gestion de configuration distribuée à l'aide du framework Web Iris de Golang

Avec le développement rapide et la popularité d'Internet, de plus en plus d'entreprises et de particuliers ont commencé à développer et à maintenir diverses applications Web. Ces applications doivent généralement être déployées et exécutées dans différents environnements, tels qu'un environnement de production, un environnement de test, un environnement de développement, etc. Dans ces différents environnements, les configurations des applications peuvent varier et ces configurations peuvent devoir être continuellement ajustées et mises à jour pour répondre aux besoins de l'entreprise et aux besoins des utilisateurs. La gestion de la configuration est donc devenue un enjeu très important.

La gestion de la configuration peut être considérée comme une sorte de gestion des données, qui implique principalement comment stocker, obtenir et modifier les données de configuration. Afin de mettre en œuvre un système de gestion de configuration fiable et efficace, nous pouvons utiliser un outil de gestion de configuration distribué tel que etcd ou consul. Ces outils peuvent fournir des fonctionnalités telles que la haute disponibilité, la cohérence des données et la tolérance aux pannes, ainsi que des systèmes de stockage kv complexes, offrant ainsi un soutien solide à notre gestion de configuration.

Dans cet article, nous présentons principalement comment utiliser le framework Web Iris de Golang pour implémenter la gestion de configuration distribuée. Iris est un framework Web performant et facile à utiliser qui prend en charge le mode MVC, la gestion du routage, l'injection de dépendances et de nombreuses autres fonctions. Il contient également certains packages, tels que config, session et logger, qui peuvent faciliter la gestion de la configuration, la gestion des sessions et les opérations de journalisation. Ici, nous utiliserons Iris pour implémenter un système de gestion de configuration simple capable d'obtenir et de modifier les données de configuration dans un magasin KV distribué et de les mettre à jour sur d'autres serveurs.

Tout d'abord, nous devons installer les outils Iris et etcd-cli. Comme Iris s'appuie sur la bibliothèque standard du langage Go, nous devons d'abord installer l'environnement du langage Go. Ensuite, nous pouvons utiliser l'outil de ligne de commande Go pour installer Iris :

go get -u github.com/kataras/iris

De même, nous devons également installer l'outil etcd-cli afin de pouvoir gérer le cluster etcd dans la ligne de commande. Vous pouvez télécharger les binaires et les utiliser directement dans la solution officielle d'etcd :

wget https://github.com/etcd-io/etcd/releases/download/v3.5.0/etcd-v3.5.0-linux-amd64.tar.gz
tar xzf etcd-v3.5.0-linux-amd64.tar.gz
cd etcd-v3.5.0-linux-amd64

Ensuite, nous pouvons exécuter le cluster etcd et y ajouter des paires clé-valeur. Le service etcd peut être démarré à l'aide de la commande suivante :

./etcd --name node1 --initial-advertise-peer-urls http://127.0.0.1:2380 
  --listen-peer-urls http://127.0.0.1:2380 
  --listen-client-urls http://127.0.0.1:2379,http://127.0.0.1:4001 
  --advertise-client-urls http://127.0.0.1:2379,http://127.0.0.1:4001 
  --initial-cluster-token etcd-cluster-1 
  --initial-cluster node1=http://127.0.0.1:2380,node2=http://127.0.0.1:2381,node3=http://127.0.0.1:2382 
  --initial-cluster-state new

Ici, nous avons démarré un cluster etcd avec 3 nœuds, avec l'un des nœuds (node1) comme leader. Les nœuds communiquent entre eux via le port 2380 et le client etcd peut se connecter au nœud via le port 2379 ou le port 4001. Une description détaillée de ces paramètres peut être trouvée dans la documentation officielle d'etcd.

Ensuite, nous pouvons utiliser l'outil etcd-cli pour ajouter des paires clé-valeur au stockage distribué. Par exemple, nous pouvons ajouter un répertoire nommé "app_config", qui contient des données de configuration :

./etcdctl --endpoints http://127.0.0.1:2379 put /app_config/database_url "mysql://root:123456@localhost:3306/test_db"

Cela ajoutera une donnée au cluster etcd, où "/app_config/database_url" est la clé, et "mysql : / /root:123456@localhost:3306/test_db" est la valeur. Ces données sont accessibles et modifiables sur n'importe quel nœud, permettant une gestion de configuration distribuée.

Maintenant, nous pouvons commencer à utiliser le framework Iris pour construire notre système de gestion de configuration. Tout d'abord, nous devons référencer le framework Iris et la bibliothèque etcd dans le programme et créer une application Iris :

package main

import (
    "context"
    "github.com/coreos/etcd/client"
    "github.com/kataras/iris/v12"
    "github.com/kataras/iris/v12/middleware/logger"
    "github.com/kataras/iris/v12/middleware/recover"
)

var app *iris.Application
var etcdEndpoints []string

func main() {
    app = iris.New()
    app.Use(recover.New())
    app.Use(logger.New())
    app.Get("/config", getConfigHandler)
    app.Put("/config", updateConfigHandler)
    app.Run(iris.Addr(":8080"), iris.WithoutServerError(iris.ErrServerClosed))
}

Ici, nous définissons les règles de routage de l'application Iris, où "/config" est l'API pour obtenir et mettre à jour les données de configuration. interface. Nous avons également utilisé deux middlewares, un pour la récupération des erreurs et un pour la journalisation. Ces middlewares peuvent nous aider à optimiser les performances et la fiabilité de nos applications.

Ensuite, nous devons créer un client etcd pour pouvoir nous connecter au cluster etcd et effectuer la gestion de la configuration. Vous pouvez utiliser le code suivant pour créer un client etcd :

    etcdEndpoints = []string{"http://127.0.0.1:2379"}

    cfg := client.Config{
        Endpoints: etcdEndpoints,
    }
    etcdClient, err := client.New(cfg)
    if err != nil {
        panic(err)
    }

Ici, nous spécifions l'adresse du cluster etcd et utilisons client.Config pour initialiser un client etcd. Nous pouvons également définir d'autres options de configuration telles que le certificat TLS, le nom d'utilisateur et le mot de passe, etc.

Maintenant, nous pouvons implémenter la logique de getConfigHandler et updateConfigHandler pour obtenir et mettre à jour facilement les données de configuration. L'implémentation de getConfigHandler est la suivante :

func getConfigHandler(ctx iris.Context) {
    key := ctx.URLParam("key")
    if key == "" {
        ctx.StatusCode(iris.StatusBadRequest)
        ctx.JSON(map[string]string{
            "error": "missing key parameter",
        })
        return
    }

    api := client.NewKeysAPI(etcdClient)
    resp, err := api.Get(context.Background(), key, nil)
    if err != nil {
        ctx.StatusCode(iris.StatusInternalServerError)
        ctx.JSON(map[string]string{
            "error": err.Error(),
        })
        return
    }

    ctx.StatusCode(iris.StatusOK)
    ctx.JSON(resp.Node.Value)
}

Ici, nous obtenons d'abord la clé de configuration à obtenir à partir du paramètre URL, puis utilisons KeysAPI d'etcd pour obtenir les données de configuration. Si la clé correspondante n'est pas trouvée, une réponse avec le code d'état 400 contenant des informations d'erreur est renvoyée. Si les données sont obtenues avec succès, une réponse avec le code d'état 200 est renvoyée, qui contient la valeur correspondant à la clé. L'implémentation de

updateConfigHandler est la suivante :

func updateConfigHandler(ctx iris.Context) {
    key := ctx.URLParam("key")
    value := ctx.URLParam("value")
    if key == "" || value == "" {
        ctx.StatusCode(iris.StatusBadRequest)
        ctx.JSON(map[string]string{
            "error": "missing key or value parameter",
        })
        return
    }

    api := client.NewKeysAPI(etcdClient)
    _, err := api.Set(context.Background(), key, value, nil)
    if err != nil {
        ctx.StatusCode(iris.StatusInternalServerError)
        ctx.JSON(map[string]string{
            "error": err.Error(),
        })
        return
    }

    ctx.StatusCode(iris.StatusOK)
    ctx.JSON(map[string]string{
        "status": "success",
    })
}

Ici, nous obtenons la clé et la valeur de la configuration à mettre à jour à partir des paramètres de l'URL. Ensuite, nous utilisons KeysAPI d'etcd pour définir la valeur sur la clé spécifiée. Si la mise à jour réussit, une réponse avec le code d'état 200 et des données JSON contenant la clé « statut » sont renvoyées.

Enfin, nous devons exécuter l'application et utiliser des outils tels que curl pour tester la réponse de l'interface API. L'application peut être démarrée à l'aide de la commande suivante :

go run main.go

Nous pouvons utiliser curl pour tester notre interface API. Par exemple, nous pouvons utiliser la commande suivante pour obtenir les données de configuration :

curl http://localhost:8080/config?key=/app_config/database_url

Cela renverra une réponse JSON comme celle-ci :

"mysql://root:123456@localhost:3306/test_db"

Nous pouvons également utiliser la commande suivante pour mettre à jour les données de configuration :

curl -X PUT -d "value=postgresql://user:password@localhost/dbname" http://localhost:8080/config?key=/app_config/database_url

Cela renverra le Clé "/app_config/database_url" La valeur correspondante est remplacée par "postgresql://user:password@localhost/dbname". Si la mise à jour réussit, la réponse JSON suivante sera renvoyée :

{"status":"success"}

到这里，我们已经实现了一个简单的分布式配置管理系统，该系统可以方便地获取和修改分布式KV存储中的配置数据。我们使用了Iris框架的路由、中间件和JSON响应等功能，以及etcd的KeysAPI来管理分布式存储。通过这样的方式，我们可以优化我们的应用程序的可靠性和性能，并提供更好的核心功能。

当然，实际情况下，我们需要考虑更多的方面，例如数据的安全性、版本控制、配置发布和回滚等问题。但是，通过使用Iris框架和etcd工具的技术，我们可以更加容易地构建和维护分布式配置管理系统，从而更好地满足业务和用户需求。

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!