Einführung in die Gesamtarchitektur des Go-Microservice-Frameworks go-micro

Ein kleines Projekt im Produktmund, von der Projektgründung bis zur Entwicklung und Einführung, da Zeit und Nachfrage weiter steigen, wird es immer komplexer und wird zu einem großen Projekt. Wenn die Architektur des frühen Projekts nicht gut gestaltet ist, wird der Code immer aufgeblähter und schwieriger zu warten. Jede weitere Produktiteration wirkt sich auf das gesamte System aus.

Microservice-basierte Projekte und lose gekoppelte Beziehungen zwischen Modulen sind eine gute Wahl. Auch wenn dadurch die Wartungskosten steigen, lohnt es sich dennoch.

Neben der Stabilität von Microservice-Projekten machen mir persönlich mehrere Themen mehr Sorgen:

1: Die Effizienz und Sicherheit der Datenübertragung zwischen Diensten .

Zweitens: Dynamische Erweiterung von Diensten, dh Dienstregistrierung und -erkennung sowie Dienstclustering.

Drei: Microservice-Funktionen können angepasst werden, da nicht alle Funktionen Ihren Anforderungen entsprechen. Es ist unvermeidlich, dass Sie einige Funktionen entsprechend Ihren eigenen Anforderungen entwickeln müssen.

go-micro ist ein gutes RPC-Microservice-Framework unter der go-Sprache . Es verfügt über perfekte Funktionen und hat mehrere Probleme gelöst, die mir Sorgen bereiten:

1: Das Das Übertragungsformat zwischen Diensten ist Protobuf, das äußerst effizient, sehr schnell und sicher ist.

2: Die Serviceregistrierung und -erkennung von go-micro ist vielfältig. Ich persönlich bevorzuge die Diensterkennung und -registrierung von etcdv3.

Drei: Die Hauptfunktionen verfügen über entsprechende Schnittstellen. Solange die entsprechenden Schnittstellen implementiert sind, können Sie das Plug-In an Ihre eigenen Bedürfnisse anpassen.

In meiner Freizeit habe ich den Quellcode von go-micro systematisch gelesen. Je mehr ich las, desto mehr hatte ich das Gefühl, dass dieses Framework gut geschrieben war, und ich habe viel daraus gelernt. Ich möchte nur eine Reihe von Beiträgen zusammenstellen und meine Erfahrungen beim Erlernen von Go-Micro mit allen teilen.

Der Kommunikationsprozess von go-micro ist wie folgt

Der Server überwacht die Anrufe des Clients und verarbeitet die von Brocker übermittelten Informationen. Und der Server muss seine Existenz oder seinen Tod im Register registrieren, damit der Client seinen Status erfahren kann.

Registrierungserkennung des Registerdienstes.

Der Client ruft die Serverinformationen aus dem Register ab und wählt dann basierend auf dem Algorithmus für jeden Anruf einen Server für die Kommunikation aus. Natürlich erfordert die Kommunikation eine Reihe von Prozessen wie Kodierung/Dekodierung und Auswahl eines Übertragungsprotokolls .

Wenn Sie alle Server benachrichtigen müssen, können Sie Brocker verwenden, um Informationen zu übertragen.

Die Brocker-Informationswarteschlange empfängt und veröffentlicht Informationen.

Der Grund, warum go-micro in hohem Maße anpassbar ist, ist untrennbar mit seiner Framework-Struktur verbunden. Jede Schnittstelle kann entsprechend ihren eigenen Anforderungen neu implementiert werden bilden auch die Rahmenstruktur von go-micro.

Diese Schnittstellen go-micir haben ihre eigenen Standardimplementierungen, und es gibt auch ein Go-Plugin, das eine Alternative zur Implementierung dieser Schnittstellen darstellt. Sie können auch eigene Plug-Ins entsprechend Ihren Anforderungen implementieren.

Dieser Beitrag dient hauptsächlich dazu, Ihnen die Hauptstruktur von go-micro und die Funktionen dieser Schnittstellen vorzustellen. Auf die spezifischen Details werden wir in zukünftigen Artikeln eingehen:

Transort

Schnittstelle zur Kommunikation zwischen Diensten. Das heißt, die endgültige Implementierung des Sendens und Empfangens von Diensten wird durch diese Schnittstellen angepasst.

Quellcode:

type Socket interface {
    Recv(*Message) error
    Send(*Message) error
    Close() error
}

type Client interface {
    Socket
}

type Listener interface {
    Addr() string
    Close() error
    Accept(func(Socket)) error
}

type Transport interface {
    Dial(addr string, opts ...DialOption) (Client, error)
    Listen(addr string, opts ...ListenOption) (Listener, error)
    String() string
}

Die Listen-Methode von Transport wird im Allgemeinen vom Server aufgerufen. Sie lauscht auf einen Port und wartet auf den Anruf des Clients.

Transport’s Dial ist die Methode, mit der der Client eine Verbindung zum Dienst herstellt. Es gibt eine Client-Schnittstelle zurück, die eine Client-Schnittstelle zurückgibt. Die Methoden dieser Schnittstelle dienen zum spezifischen Senden und Empfangen von Kommunikationsinformationen.

http-Transport ist der standardmäßige synchrone Kommunikationsmechanismus von go-micro. Natürlich gibt es noch viele andere Plug-Ins: grpc, nats, tcp, udp, Rabbitmq, nats, die bisher alle implementiert wurden. Sie finden es in Go-Plugins.

Codec

Bei der Übertragungsmethode muss als Nächstes das Problem der Übertragungskodierung und -dekodierung gelöst werden. Go-Micro verfügt über viele Kodierungs- und Dekodierungsmethoden Ist Protobuf, gibt es natürlich auch andere Implementierungsmethoden wie JSON, Protobuf, Jsonrpc, Mercury usw.

Quellcode

type Codec interface {
    ReadHeader(*Message, MessageType) error
    ReadBody(interface{}) error
    Write(*Message, interface{}) error
    Close() error
    String() string
}

type Message struct {
    Id     uint64
    Type   MessageType
    Target string
    Method string
    Error  string
    Header map[string]string
}

Die Write-Methode der Codec-Schnittstelle ist der Codierungsprozess und die beiden Reads sind der Decodierungsprozess.

Registrierung

Dienstregistrierung und -erkennung, derzeit implementierter Konsul, MDNS, etcd, etcdv3, Zookeeper, Kubernetes usw.,

type Registry interface {
    Register(*Service, ...RegisterOption) error
    Deregister(*Service) error
    GetService(string) ([]*Service, error)
    ListServices() ([]*Service, error)
    Watch(...WatchOption) (Watcher, error)
    String() string
    Options() Options
}

Zu Einfach ausgedrückt: Der Dienst registriert sich und der Client verwendet die Überwachungsmethode zur Überwachung. Wenn ein Dienst hinzugefügt oder gelöscht wird, wird diese Methode ausgelöst, um den Client daran zu erinnern, die Dienstinformationen zu aktualisieren.

Der Standarddienst für die Registrierung und Erkennung ist „Consul“. Ich persönlich empfehle ihn jedoch nicht, da Sie den Consul-Cluster nicht direkt verwenden können

我个人比较喜欢etcdv3集群。大家可以根据自己的喜好选择。

Selector

以Registry为基础，Selector 是客户端级别的负载均衡，当有客户端向服务发送请求时， selector根据不同的算法从Registery中的主机列表，得到可用的Service节点，进行通信。目前实现的有循环算法和随机算法，默认的是随机算法。

源码：

type Selector interface {
    Init(opts ...Option) error
    Options() Options
    // Select returns a function which should return the next node
    Select(service string, opts ...SelectOption) (Next, error)
    // Mark sets the success/error against a node
    Mark(service string, node *registry.Node, err error)
    // Reset returns state back to zero for a service
    Reset(service string)
    // Close renders the selector unusable
    Close() error
    // Name of the selector
    String() string
}

默认的是实现是本地缓存，当前实现的有blacklist,label,named等方式。

 Broker

Broker是消息发布和订阅的接口。很简单的一个例子，因为服务的节点是不固定的，如果有需要修改所有服务行为的需求，可以使服务订阅某个主题，当有信息发布时，所有的监听服务都会收到信息，根据你的需要做相应的行为。

源码

type Broker interface {
    Options() Options
    Address() string
    Connect() error
    Disconnect() error
    Init(...Option) error
    Publish(string, *Message, ...PublishOption) error
    Subscribe(string, Handler, ...SubscribeOption) (Subscriber, error)
    String() string
}

Broker默认的实现方式是http方式，但是这种方式不要在生产环境用。go-plugins里有很多成熟的消息队列实现方式，有kafka、nsq、rabbitmq、redis，等等。

 Client

Client是请求服务的接口，他封装Transport和Codec进行rpc调用，也封装了Brocker进行信息的发布。

源码

type Client interface {
    Init(...Option) error
    Options() Options
    NewMessage(topic string, msg interface{}, opts ...MessageOption) Message
    NewRequest(service, method string, req interface{}, reqOpts ...RequestOption) Request
    Call(ctx context.Context, req Request, rsp interface{}, opts ...CallOption) error
    Stream(ctx context.Context, req Request, opts ...CallOption) (Stream, error)
    Publish(ctx context.Context, msg Message, opts ...PublishOption) error
    String() string
}

当然他也支持双工通信 Stream 这些具体的实现方式和使用方式，以后会详细解说。

默认的是rpc实现方式，他还有grpc和http方式，在go-plugins里可以找到

Server

Server看名字大家也知道是做什么的了。监听等待rpc请求。监听broker的订阅信息，等待信息队列的推送等。

源码 

type Server interface {
    Options() Options
    Init(...Option) error
    Handle(Handler) error
    NewHandler(interface{}, ...HandlerOption) Handler
    NewSubscriber(string, interface{}, ...SubscriberOption) Subscriber
    Subscribe(Subscriber) error
    Register() error
    Deregister() error
    Start() error
    Stop() error
    String() string
}

 默认的是rpc实现方式，他还有grpc和http方式，在go-plugins里可以找到

Service

Service是Client和Server的封装，他包含了一系列的方法使用初始值去初始化Service和Client，使我们可以很简单的创建一个rpc服务。

源码：

type Service interface {
    Init(...Option)
    Options() Options
    Client() client.Client
    Server() server.Server
    Run() error
    String() string
}

Das obige ist der detaillierte Inhalt vonEinführung in die Gesamtarchitektur des Go-Microservice-Frameworks go-micro. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!