Introduction à l'architecture globale du framework go microservice go-micro

Un petit projet dans la bouche du produit, de l'établissement du projet au développement et au lancement, à mesure que le temps et la demande continuent d'augmenter, il deviendra de plus en plus complexe et se transformera en un grand projet. Si le premier projet Si l'architecture n'est pas bien conçue, le code deviendra de plus en plus volumineux et difficile à maintenir. Chaque itération ultérieure du produit affectera l'ensemble du système.

Les projets basés sur des microservices et les relations faiblement couplées entre les modules sont un bon choix. Même si cela augmente les coûts de maintenance, cela en vaut toujours la peine.

En plus de la stabilité des projets de microservices, je suis personnellement plus préoccupé par plusieurs problématiques :

1 : L'efficacité et la sécurité de la transmission des données entre services .

Deux : expansion dynamique des services, c'est-à-dire l'enregistrement et la découverte des services, ainsi que le clustering des services.

Trois : les fonctions du microservice peuvent être personnalisées, car toutes les fonctions ne répondront pas à vos besoins. Il est inévitable que vous deviez développer certaines fonctions en fonction de vos propres besoins.

go-micro est un bon framework de microservices rpc sous le go langage Il a des fonctions parfaites et a résolu plusieurs problèmes qui me préoccupent :

1 : Le. le format de transmission entre services est protobuf, qui est extrêmement efficace, très rapide et sûr.

2 : l’inscription et la découverte des services go-micro sont diverses. Personnellement, je préfère la découverte et l'enregistrement du service etcdv3.

Trois : les fonctions principales ont des interfaces correspondantes. Tant que les interfaces correspondantes sont implémentées, vous pouvez personnaliser les plug-ins en fonction de vos propres besoins.

Dans mes temps libres, je lisais systématiquement le code source de go-micro. Plus je lisais, plus je sentais que ce framework était bien écrit, et j'en apprenais beaucoup. Je veux juste compiler une série d'articles et partager mon expérience d'apprentissage du go-micro avec tout le monde.

Le processus de communication de go-micro est le suivant

Le serveur surveille les appels du client et traite les informations transmises par Brocker. Et le serveur doit enregistrer son existence ou son décès auprès du Registre afin que le client puisse connaître son statut.

Découverte des inscriptions du service Register.

Le client obtient les informations du serveur à partir du registre, puis sélectionne un serveur pour la communication en fonction de l'algorithme pour chaque appel. Bien entendu, la communication nécessite une série de processus tels que l'encodage/décodage et la sélection d'un protocole de transmission. .

Si vous devez notifier tous les serveurs, vous pouvez utiliser Brocker pour transmettre des informations.

La file d'attente d'informations Brocker reçoit et publie des informations.

La raison pour laquelle go-micro peut être hautement personnalisé est indissociable de sa structure de framework. go-micro se compose de 8 interfaces clés. Chaque interface peut être réimplémentée en fonction de vos propres besoins. constituent également la structure-cadre de go-micro.

Ces interfaces go-micir ont leurs propres implémentations par défaut, et il existe également des go-plugins qui sont une alternative à l'implémentation de ces interfaces. Vous pouvez également implémenter vos propres plug-ins selon vos besoins.

Cet article a principalement pour but de vous présenter la structure principale de go-micro et les fonctions de ces interfaces. Nous parlerons des détails spécifiques dans les prochains articles :

Transort

Interface de communication entre services. Autrement dit, la mise en œuvre finale de l'envoi et de la réception des services est personnalisée par ces interfaces.

Code source :

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
}

La méthode Listen de Transport est généralement appelée par le serveur. Elle écoute un port et attend que le client appelle.

Transport's Dial est la méthode utilisée par le client pour se connecter au service. Il renvoie une interface client, qui renvoie une interface client. Ce client est intégré dans l'interface Socket. Les méthodes de cette interface servent spécifiquement à envoyer et recevoir des informations de communication.

Le transport http est le mécanisme de communication synchrone par défaut de go-micro. Bien sûr, il existe de nombreux autres plug-ins : grpc, nats, tcp, udp, Rabbitmq, nats, qui ont tous été implémentés jusqu'à présent. Vous pouvez le trouver dans go-plugins.

Codec

Avec la méthode de transmission, la prochaine chose à résoudre est le problème d'encodage et de décodage de la transmission. Go-micro a de nombreuses méthodes d'encodage et de décodage par défaut. est protobuf, bien sûr, il existe d'autres méthodes d'implémentation, telles que json, protobuf, jsonrpc, mercury, etc.

Code source

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
}

La méthode Write de l'interface Codec est le processus d'encodage, et les deux lectures sont le processus de décodage.

Registre

Enregistrement et découverte du service, consul actuellement implémenté, mdns, etcd, etcdv3, zookeeper, kubernetes., etc.,

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
}

À en termes simples, le service s'enregistre et le client utilise la méthode de surveillance pour la surveillance Lorsqu'un service est ajouté ou supprimé, cette méthode sera déclenchée pour rappeler au client de mettre à jour les informations du service.

L'enregistrement et la découverte du service par défaut sont consul, mais je ne le recommande pas car vous ne pouvez pas utiliser directement le cluster consul

我个人比较喜欢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
}

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!