Pratique du centre de configuration dynamique basé sur le go-zero

Avec le développement continu des applications et des systèmes Internet, la gestion de la configuration est devenue une tâche de plus en plus importante. Dans le passé, nous utilisions souvent une configuration manuelle ou des solutions de fichiers de configuration simples, mais ces méthodes ne peuvent plus répondre aux besoins métier en évolution rapide. Par conséquent, dans l’architecture moderne des microservices, un centre de configuration dynamique est devenu une nécessité.

Dans cet article, nous présenterons la pratique du centre de configuration dynamique basé sur un framework go-zero.

go-zero introduction

go-zero est un framework simple, efficace et facile à utiliser pour créer des microservices évolutifs et performants. Il dispose d'une riche chaîne d'outils et de plug-ins pour prendre en charge une variété d'applications Internet modernes.

go-zero prend non seulement en charge le développement de modèles commerciaux, mais prend également en charge une série de solutions de modèles non commerciaux, telles que les systèmes de mise en cache, les files d'attente de messages, la découverte de services, les journaux, la migration de bases de données, etc. Ceux-ci peuvent fournir davantage d’assistance aux développeurs et les aider à créer des applications de haute qualité.

Pratique du centre de configuration dynamique

Dans cet article, nous nous concentrerons sur la pratique du centre de configuration dynamique du framework go-zero. Dynamic Configuration Center est un service qui gère les informations de configuration des applications. Grâce au centre de configuration dynamique, nous pouvons facilement gérer différentes versions de l'application tout en prenant en charge les changements rapides et la restauration des configurations.

Structure des données de configuration

Tout d'abord, considérons les structures de données utilisées pour résoudre les problèmes de configuration. Nous pouvons définir une structure Config pour enregistrer les éléments de configuration.

type Config struct {
    Name      string `json:"name"`
    Version   string `json:"version"`
    Endpoint  string `json:"endpoint"`
    AccessKey string `json:"access_key"`
    SecretKey string `json:"secret_key"`
}

Dans l'application, nous pouvons ajouter plus d'éléments de configuration en fonction de nos besoins.

Gestion de la configuration

Dans le framework go-zero, nous pouvons utiliser etcd ou zookeeper comme backend de stockage pour la gestion de la configuration. Nous supposons qu'etcd est utilisé comme backend de stockage et que les outils de gestion de configuration fournis par le framework go-zero sont utilisés pour faire fonctionner etcd.

Tout d'abord, nous devons définir la structure ConfigManager pour enregistrer le client etcd.

type ConfigManager struct {
    cli *clientv3.Client
}

Dans la fonction d'initialisation, nous pouvons créer un client etcd et l'enregistrer dans ConfigManager.

func NewConfigManager(endpoints []string) (*ConfigManager, error) {
    cli, err := clientv3.New(clientv3.Config{
        Endpoints: endpoints,
    })
    if err != nil {
        return nil, err
    }
    return &ConfigManager{
        cli: cli,
    }, nil
}

Ensuite, nous pouvons définir une fonction SaveConfig pour enregistrer les éléments de configuration dans etcd.

func (m *ConfigManager) SaveConfig(cfg Config) error {
    ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
    defer cancel()

    data, err := json.Marshal(cfg)
    if err != nil {
        return err
    }

    _, err = m.cli.Put(ctx, "/config/"+cfg.Name, string(data))
    if err != nil {
        return err
    }

    return nil
}

Enfin, nous pouvons définir une fonction GetConfig pour obtenir l'élément de configuration avec le nom spécifié depuis etcd et l'analyser dans une structure Config.

func (m *ConfigManager) GetConfig(name string) (*Config, error) {
    ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
    defer cancel()

    resp, err := m.cli.Get(ctx, "/config/"+name)
    if err != nil {
        return nil, err
    }

    if len(resp.Kvs) == 0 {
        return nil, fmt.Errorf("config not found")
    }

    var cfg Config
    err = json.Unmarshal(resp.Kvs[0].Value, &cfg)
    if err != nil {
        return nil, err
    }

    return &cfg, nil
}

Avec ces outils, nous pouvons facilement gérer les éléments de configuration. Voyons maintenant comment utiliser ces éléments de configuration dans notre application.

Utilisation de l'application

Dans le framework go-zero, nous pouvons utiliser des fichiers de configuration pour gérer les informations de configuration de l'application. Les fichiers de configuration nous permettent de charger des éléments de configuration au démarrage de l'application. Cependant, il existe des situations dans lesquelles nous avons besoin d’une solution plus flexible et en temps réel.

Le framework go-zero fournit le plug-in ConfigCenter pour charger les éléments de configuration de l'application à partir du centre de configuration distant. Il suffit de configurer simplement le plug-in ConfigCenter pour réaliser une configuration dynamique.

func main() {
    c := &cli.App{
        Commands: []*cli.Command{
            {
                Name:  "serve",
                Usage: "start server",
                Flags: []cli.Flag{
                    &cli.StringFlag{
                        Name:  "config",
                        Usage: "config file path",
                    },
                },
                Action: func(ctx *cli.Context) error {
                    var cfg Config
                    err := config.LoadFromEtcd(cfg.Name, cfg)
                    if err != nil {
                        log.Fatal(err)
                    }
                    log.Println(cfg)

                    // start server
                    return nil
                },
            },
        },
    }
    err := c.Run(os.Args)
    if err != nil {
        log.Fatal(err)
    }
}

Dans le code ci-dessus, nous utilisons la fonction config.LoadFromEtcd pour charger l'élément de configuration avec le nom spécifié depuis etcd. Si vous devez mettre à jour des éléments de configuration, vous pouvez les modifier manuellement dans etcd. Lorsque nous redémarrons l'application, elle chargera les derniers éléments de configuration.

Sécurité

Lors de la mise en place d'un centre de configuration dynamique, la sécurité est un point très important. Parce que les éléments de configuration contiennent souvent des informations sensibles, telles que les informations d'identification de la base de données, les clés API, etc. Ainsi, dans notre pratique, nous devons prêter attention aux points suivants :

• Assurer la sécurité d'etcd et des autres services associés.
• Ne stockez pas de mots de passe en texte clair ou d'informations sensibles dans etcd. Les informations sensibles peuvent être protégées par cryptage ou par l'utilisation de solutions de stockage sécurisées.
• Authentifiez etcd et les applications et autorisez-les à accéder et à modifier les éléments de configuration.

Conclusion

Le centre de configuration dynamique fait partie intégrante des applications modernes. Il nous offre un moyen flexible, rapide et sécurisé de gérer les informations de configuration des applications. Dans cet article, nous présentons la pratique du centre de configuration dynamique basé sur un framework go-zero. Grâce à ces pratiques, nous pouvons facilement gérer les éléments de configuration, implémenter une configuration dynamique et les utiliser dans des applications.

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!