consul理解与简单使用

2021-06-25 本文已影响0人董小贱

1. 服务发现是什么？

我们在做微服务开发的时候，客户端的一个接口可能需要调用N个服务，客户端必须知道所有服务的网络位置（ip+port），如下图所示

传统模式.png

以往的做法是把服务的地址放在配置文件活数据库中，这样就有以下几个问题：

需要配置N个服务的网络位置，加大配置的复杂性
服务的网络位置变化，需要改变每个调用者的配置
集群的情况下，难以做负载（反向代理的方式除外）

总结起来一句话：服务多了，配置很麻烦，问题一大堆

所以现在就选择服务发现来解决这些问题。我们来看一下，服务发现如何解决这个问题，具体设计如下：

服务发现模式.png

与之前解决方法不同的是，加了个服务发现模块。服务端把当前自己的网络位置注册到服务发现模块（这里注册的意思就是告诉），服务发现就以K-V的方式记录下，K一般是服务名，V就是IP:PORT。服务发现模块定时的轮询查看这些服务能不能访问的了（这就是健康检查）。客户端在调用服务A-N的时候，就跑去服务发现模块问下它们的网络位置，然后再调用它们的服务。这样的方式是不是就可以解决上面的问题了呢？客户端完全不需要记录这些服务的网络位置，客户端和服务端完全解耦！

常见的服务发现框架有：Etcd、Eureka、Consul、Zookeeper

这里我们选择go-micro默认的服务发现框架consul来做一个详细介绍。

2. consul相关

consul架构图：

consul-arch.png

Consul集群是有N个SERVER,加上M个CLIENT组成的。而不管是SERVER还是CLIENT，都是CONSUL的一个节点，所有的服务都可以注册到这些节点上，正是通过这些节点实现服务注册信息的共享。

CLIENT：client表示consul的client模式，就是客户端模式。这种模式下，所有注册到当前节点的服务会被转发到SERVER【通过HTTP和DNS接口请求SERVER】,本身是不持久化这些信息，

SERVER: server表示consul的server模式，表明此consul是个server，这种模式下，功能和client都一样，唯一不同的是，它会把所有的信息持久化到本地。遇到故障，信息是可以被保留并溯源。

SERVER-LEADER： 表明这个server是leader，它和其他server不一样的一点是，它需要负责同步注册的信息给其他的server，同时也要负责各个节点的健康监测。

2.1 consul关键特性:

服务发现：consul通过DNS或者HTTP接口使服务注册和服务发现变的很容易，一些外部服务，例如saas提供的也可以一样注册。

健康检查:Cousul的client可以提供任意数量的健康检查，既可以给定的服务相关联(webserver是否返回200)，也可以与本地节点相关联(内存利用率是都低于90%)。操作员可以使用这些信息来检测集群的健康状况，服务发现组件可以使用这些信息将流量从不健康的主路由出去。健康检测使consul可以快速的告警在集群中的操作。和服务发现的集成，可以防止服务转发到故障的服务上面。(心跳机制)

键/值存储：一个用来存储动态配置的系统。提供简单的HTTP接口，可以在任何地方操作。

安全服务通信：Consul可以为服务生成和分发TLS证书，以建立项目的TLS连接。意图可用于定义允许哪些服务通信。服务分割可以很容易地进行管理，其目的是可以实时更改的，而不是使用复杂的网络拓扑和静态防火墙规则。

多数据中心：无需复杂的配置，即可支持任意数量的区域。

官方建议：最好是三台或者三台以上的consul在运行，同名服务最好是三台或三台以上，默认可以搭建集群

.2 下载：

https://www.consul.io/downloads.html

2.3 consul简单使用

首先我们要运行consul，运行有两种模式，分别是==server==和==client==，通过下面的命令开启：

consul agent -server  # server运行模式

consul agent  # client 运行模式

每个数据中心至少必须拥有一个server。

一个client是一个非常轻量级的进程，用于注册服务,运行健康检查和转发对server的查询.

agent必须在集群中的每个主机上运行.

server模式启动

$ consul agent -server -bootstrap-expect 1 -data-dir /tmp/consul -node=n1 -bind=192.168.6.108 -ui -rejoin -config-dir=/etc/consul.d/ -client 0.0.0.0

需要先在/etc/下面创建consul.d目录

-server ：定义agent运行在server模式

-bootstrap-expect ：在一个datacenter中期望提供的server节点数目，当该值提供的时候，<u>consul一直等到达到指定sever数目的时候才会引导整个集群，</u>该标记不能和bootstrap共用

-bind：该地址用来在集群内部的通讯，集群内的所有节点到地址都必须是可达的，默认是0.0.0.0

-node：节点在集群中的名称，在一个集群中必须是唯一的，默认是该节点的主机名

-ui：启动web界面 :8500

-rejoin：使consul忽略先前的离开，在再次启动后仍旧尝试加入集群中。

-config-dir：配置文件目录，里面所有以.json结尾的文件都会被加载(需要先创建/etc/consul.d这个目录)

-client：consul服务监听地址，这个地址提供HTTP、DNS、RPC等服务，默认是127.0.0.1所以不对外提供服务，如果你要对外提供服务改成0.0.0.0

--data-dir：提供一个目录用来存放agent的状态，所有的agent允许都需要该目录，该目录必须是稳定的，系统重启后都继续存在

client模式启动

consul agent -data-dir /tmp/consul -node=n2 -bind=192.168.137.82 -config-dir /etc/consul.d -rejoin -join 192.168.137.81

运行cosnul agent以client模式，-join 加入到已有的集群中去。

停止Agent

可以使用 Ctrl-C来关闭Agent，中断Agent之后你可以看到他离开了集群应关闭。

在退出中，Consul提醒其他集群成员，这个节点离开了。如果强行杀掉进程，集群的其他成员应该能检测到这个节点失效了。当一个成员离开，他的服务和检测也会从目录中移除。当一个成员失效了，他的健康状况被简单的标记为危险。但是不会从目录中移除，Consul会自动对失效的节点进行重连。允许他从某些网络条件下恢复过来，离开的节点则不再继续联系。

此外，如果一个agent作为一个服务器，一个优雅的离开是很重要的，可以避免潜在的可用性故障，影响达成一致性协议。

consul leave # consul优雅退出命令

注册服务

搭建好consul集群后，用户或者程序就能到consul中查询或注册服务。可以通过提供服务定义文件或者调用HTTP API来注册一个服务。

需要注意的是，要先为consul配置创建一个目录 /etc/consul.d， consul会载入配置文件件里的所有以.json为后缀的配置文件。

mkdir /etc/consul.d

web.json

{
    "service": {
        "ID":"S1", 
        "name": "test",
        "tags": ["001", "002"], // 标签
        "port": 8989,
        "address":"127.0.0.1",
        "checks":[
            {
                "http":"http://127.0.0.1:8989/consul", // 健康检查的请求
                "timeout":"3s",  //timeout设置
                "interval":"1s"  // 心跳时间
            }
        ]
    }
}

保存文件并重启服务即可。

然后启动一个简易的go服务：

package main

import (
    "fmt"
    "net/http"
)

func main(){
    http.HandleFunc("/consul", func(writer http.ResponseWriter, request *http.Request) {
        fmt.Println("来自consul的健康问候...")
    })

    http.ListenAndServe(":8989", nil)
}

会看到不停的打印 来自consul的健康问候... ,consul 进行健康检查，根据配置的心跳时间，不停的访问http://127.0.0.1:8989/consul

查询服务

此时可以到ui界面localhost:8500查看服务的状态
使用命令：dig @127.0.0.1 -p 8600 test.service.consul srv

请思考一个问题： consul中的client模式把请求转向server，那么client的作用是什么？


首先server端的网络连接资源有限。对于一个分布式系统，一般情况下的访问量还是很大的。如果用用户不能通过client直接访问数据中心，那么数据中心必然要为每个用户提供一个单独的连接资源，那么server端的负担会非常大。随意很有必要用大量的client端来分散连接请求，在client端先统一整合用户的服务请求，然后一次性的通过单一的链接发送大量的的请求给server端，能够大量减少server端的网络负担。 

其次，在client端可以对用户的请求进行一些处理来提高服务的效率，比如将相同的请求合并成同一个查询，再比如将之前的查询通过cookie的形式缓存下来。但是这些功能都需要消耗不少的计算和存储资源。 如果在server端提供这些功能，必然加重server端的负担，使得server端更加不稳定。而通过client端来进行这些服务就没有这些问题了，移位client端不提供实际服务，有充足的计算资源来处理这些工作。

最后一点，consul规定只要介入一个client就将自己注册到一个网络服务当中。这些结构使得系统的拓展性非常强，网络的拓扑变化可以特别灵活。这也依赖于client-server结构的。如果系统中只有几个数据中心存在，那网络的扩张也无从谈起。

参考文档：http://www.liangxiansen.cn/tags/Consul/

3. consul+grpc

参考文档：https://www.consul.io/api/agent/check
健康检查参考文档：https://www.consul.io/docs/discovery/checks

1. 安装包

go get -u -v github.com/hashicorp/consul

2. 代码相关

2.1 proto文件：

health.pb.proto 参考文档：https://github.com/grpc/grpc/blob/master/doc/health-checking.md

syntax = "proto3";

package grpc.health.v1;

option go_package="./grpc.health.v1/grpc.health.v1";

message HealthCheckRequest {
  string service = 1;
}

message HealthCheckResponse {
  enum ServingStatus {
    UNKNOWN = 0;
    SERVING = 1;
    NOT_SERVING = 2;
    SERVICE_UNKNOWN = 3;  // Used only by the Watch method.
  }
  ServingStatus status = 1;
}

service Health {
  rpc Check(HealthCheckRequest) returns (HealthCheckResponse);

  rpc Watch(HealthCheckRequest) returns (stream HealthCheckResponse);
}

people.proto

syntax = "proto3";
package pb;

option go_package="./pb;pb";

message people {
  string name = 1;
}

service SayHi {
  rpc sayHi (people) returns (people);
}

通过命令，生成对应的.proto.go文件后，开始编写client.go和sever.go

server.go

package main

import (
    "ConsulDemo/grpc.health.v1"
    "ConsulDemo/pb"
    "context"
    "fmt"
    "github.com/hashicorp/consul/api"
    "google.golang.org/grpc"
    "net"
)


type people struct {}

func (c *people) SayHi(ctx context.Context, p *pb.People) (*pb.People, error){
    fmt.Printf("hi %v", p.Name)
    return p, nil
}

// HealthImpl 健康检查实现
type HealthImpl struct{}

// Check 实现健康检查接口，这里直接返回健康状态，这里也可以有更复杂的健康检查策略，比如根据服务器负载来返回
func (h *HealthImpl) Check(ctx context.Context, req *grpc_health_v1.HealthCheckRequest) (*grpc_health_v1.HealthCheckResponse, error) {
    return &grpc_health_v1.HealthCheckResponse{
        Status: grpc_health_v1.HealthCheckResponse_SERVING,
    }, nil
}

func (*HealthImpl) Watch(*grpc_health_v1.HealthCheckRequest, grpc_health_v1.Health_WatchServer) error {
    return nil
}



func main(){
    //初始化consul配置
    consulConfig := api.DefaultConfig()
    //consulConfig.Address= "localhost:8900"

    //获取consul操作对象
    registry,err := api.NewClient(consulConfig)
    if err != nil{
        panic(err)
    }

  
    //注册服务,服务的常规配置
    registerService := api.AgentServiceRegistration{
        ID:"1",
        Tags:[]string{"sayHi"},
        Name:"sayHi",
        Port:1234,
        Address:"localhost",
        Check:&api.AgentServiceCheck{
            GRPC:  fmt.Sprintf("%v:%v/%v", "localhost", "1234", "HealthImpl"),
            Timeout:"5s",
            Interval:"5s",
        },
    }


    //注册服务到consul上
    err = registry.Agent().ServiceRegister(&registerService)

    if err != nil{
        panic(err)
    }

    //获取grpc服务端对象
    grpcServer := grpc.NewServer()
    grpc_health_v1.RegisterHealthServer(grpcServer, &HealthImpl{})


    //注册grpc服务
    pb.RegisterSayHiServer(grpcServer,new(people))

    //设置服务端监听
    lis,err := net.Listen("tcp",":1234")
    if err != nil {
        panic(err)
    }

    //在指定端口上提供grpc服务
    grpcServer.Serve(lis)
}

注意：此时需要开启一个consul agent，consul agent -dev

client.go

package main

import (
    "fmt"
    "github.com/hashicorp/consul/api"
    "google.golang.org/grpc"
    "strconv"
    "ConsulDemo/pb"
    "context"

)

func main(){
    //初始化consul配置, 客户端服务器需要一致
    consulConfig := api.DefaultConfig()
  
    //获取consul操作对象
    registerClient,_ := api.NewClient(consulConfig)
  
    //获取地址
    serviceEntry,_,_ :=registerClient.Health().Service("sayHi","sayHi",true,nil)

    fmt.Println(fmt.Sprintf("%+v",serviceEntry ))

    //和grpc服务建立连接
    conn,err := grpc.Dial(serviceEntry[0].Service.Address+":"+strconv.Itoa(serviceEntry[0].Service.Port),grpc.WithInsecure())
    if err != nil {
        panic(err)
    }

    defer conn.Close()

    client := pb.NewSayHiClient(conn)
    reply, err := client.SayHi(context.Background(),&pb.People{Name:"dongxiaojian"})
    if err != nil {
        panic(err)
    }

  fmt.Println("reply:",reply)
}