Verwendung von Go-Zero zur Implementierung eines verteilten Konfigurationscenters

Mit der Entwicklung des Internets nimmt der Umfang der Unternehmensanwendungen allmählich zu und die für verschiedene Geschäftsszenarien erforderlichen Konfigurationen werden immer komplexer. Die Verwaltung und Wartung von Konfigurationen ist oft ein langwieriger und fehleranfälliger Prozess. Um diese Probleme zu lösen, wurde das verteilte Konfigurationszentrum ins Leben gerufen.

Das verteilte Konfigurationscenter ist ein modulares Design, das die Konfigurationsinformationen aller Anwendungen zentralisiert und eine benutzerfreundliche Bedienoberfläche bietet, um Managern das Ändern und Veröffentlichen von Konfigurationsinformationen zu erleichtern. Durch die zentrale Verwaltung von Konfigurationsinformationen können durch Konfigurationsprobleme verursachte Systemausfälle effektiv reduziert werden.

In diesem Artikel wird erläutert, wie Sie mit Go-Zero ein einfaches verteiltes Konfigurationscenter implementieren.

Was ist Go-Zero?

Go-Zero ist ein Go-Sprach-Microservice-Framework. Es zeichnet sich durch hohe Leistung, einfache Skalierbarkeit und Benutzerfreundlichkeit aus. Es ist eines der bevorzugten Frameworks für Go-Sprachentwickler, um schnell leistungsstarke, skalierbare und zuverlässige Microservice-Anwendungen zu erstellen . .

Go-Zero bietet nicht nur Microservice-bezogene Funktionen wie Dienstregistrierung, Gesundheitsprüfung, Strombegrenzungsschalter, Verwaltung langer Verbindungen und Service-Governance, sondern auch viele Tools zur Unterstützung der Entwicklung, z. B. RPC-Generierungstool und http-API-Generierung Tool, Konfigurationscenter, Protokollbibliothek, Cache-Bibliothek usw.

Implementierungsprinzip des verteilten Konfigurationscenters

Bei der Implementierung des verteilten Konfigurationscenters müssen die folgenden Aspekte berücksichtigt werden:

1. Datenbankspeicher: Zum Speichern von Konfigurationsinformationen muss eine relationale Datenbank (wie MySQL, PostgreSQL usw.) verwendet werden um die Konfiguration sicherzustellen. Permanente Speicherung von Informationen.
2. Backend-Verwaltung: Es muss ein Backend-Verwaltungssystem bereitgestellt werden, über das Administratoren Konfigurationsinformationen hinzufügen, löschen, ändern, überprüfen und veröffentlichen können.
3. Laden von Konfigurationsdateien: Für Anwendungsaufrufe muss eine Schnittstelle zum Laden von Konfigurationsdateien bereitgestellt werden, um sicherzustellen, dass Anwendungen die neuesten Konfigurationsinformationen erhalten können.
4. Geplante Aktualisierung: Es ist notwendig, die Funktion der regelmäßigen Aktualisierung von Konfigurationsinformationen zu implementieren, um eine rechtzeitige Aktualisierung der Daten sicherzustellen.
5. Verteilte Konsistenz: Bei der Bereitstellung mehrerer Knoten muss die Konsistenz der Konfigurationsinformationen berücksichtigt werden, um Fehler zu vermeiden, die durch eine Nichtsynchronisierung der Knoten verursacht werden.

Verwenden Sie Go-Zero, um ein verteiltes Konfigurationscenter zu implementieren

In diesem Artikel wird der Prozess der Verwendung des Go-Zero-Frameworks zur Implementierung eines verteilten Konfigurationscenters kurz vorgestellt:

1. null

Erforderlich, um go-zero zu verwenden. Installieren Sie zuerst relevante Abhängigkeiten:

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

2. Erstellen Sie eine Datenbank.

Erstellen Sie zunächst eine Datenbank und erstellen Sie eine Tabelle:

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 Verwaltungssystem

Das Backend-Verwaltungssystem wird hauptsächlich zum Hinzufügen, Löschen, Ändern und Überprüfen von Konfigurationsinformationen sowie zum Veröffentlichen von Vorgängen verwendet. Im Go-Zero-Framework können Sie mit dem Tool goctl schnell Code für das Managementsystem generieren:

goctl api new -api config -dir config/api

Der generierte Code befindet sich im Verzeichnis config/api und muss entsprechend den tatsächlichen Anforderungen angepasst werden.

4. Implementieren Sie das Laden der Konfigurationsdatei

Generieren Sie einen RPC-Dienst mit dem Namen config über das Goctl-Tool und laden Sie die Konfigurationsdatei durch Aufrufen seiner Schnittstelle.

Die Serviceschnittstelle ist wie folgt definiert:

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

5. Geplante Aktualisierung implementieren

Um die geplante Aktualisierungsfunktion zu implementieren, können Sie etcd-bezogene Tools im Go-Zero-Framework verwenden.

Zuerst müssen Sie etcd installieren:

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

Dann legen Sie die Adresse und den Port von etcd in der Konfigurationsdatei fest:

[etcd]
  null=127.0.0.1:2379

Abschließend implementieren Sie die geplante Aktualisierungslogik im 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. Erreichen Sie verteilte Konsistenz

In Um verteilte Konsistenz zu erreichen, ist die Verwendung von etcd-bezogenen Tools im Go-Zero-Framework erforderlich.

Zuerst müssen Sie etcd installieren:

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

Dann implementieren Sie die etcd-bezogene verteilte Sperrlogik im 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
}

Fazit

In diesem Artikel wird erläutert, wie Sie mit dem Go-Zero-Framework ein einfaches verteiltes Konfigurationscenter implementieren. Durch die hohe Leistung, einfache Skalierbarkeit und Benutzerfreundlichkeit von Go-Zero können wir in kurzer Zeit schnell ein hochverfügbares verteiltes Konfigurationszentrum aufbauen und so Systemausfälle aufgrund von Konfigurationsproblemen effektiv reduzieren.

Das obige ist der detaillierte Inhalt vonVerwendung von Go-Zero zur Implementierung eines verteilten Konfigurationscenters. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!