1

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

1
2
3
4
5
6
7
8

{
        "service":{
                "name":"luenci",
                "tags":["study"],
                "port":8880

        }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

root@Luenci:~# curl -s 127.0.0.1:8500/v1/catalog/service/luenci | python -m json.tool
[
    {
        "Address": "172.16.249.181",
        "CreateIndex": 44,
        "Datacenter": "dc1",
        "ID": "c3908dfa-4fdf-4a57-686f-a3fc620fc5b7",
        "ModifyIndex": 44,
        "Node": "consul1",
        "NodeMeta": {
            "consul-network-segment": ""
        },
        "ServiceAddress": "",
        "ServiceConnect": {},
        "ServiceEnableTagOverride": false,
        "ServiceID": "luenci",
        "ServiceKind": "",
        "ServiceMeta": {},
        "ServiceName": "luenci",
        "ServicePort": 8880,
        "ServiceProxy": {},
        "ServiceProxyDestination": "",
        "ServiceTags": [
            "study"
        ],
        "ServiceWeights": {
            "Passing": 1,
            "Warning": 1
        },
        "TaggedAddresses": {
            "lan": "172.16.249.181",
            "wan": "172.16.249.181"
        }
    }
]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

root@Luenci:~# cat /etc/consul.d/sweetie.json | python -m json.tool
{
    "service": {
        "check": {
            "http": "<http://172.16.249.181:8001>",
            "id": "api",
            "interval": "10s",
            "name": "check sweetie api",
            "timeout": "2s"
        },
        "name": "sweetie",
        "port": 8001,
        "tags": [
            "fast-api"
        ]
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

syntax = "proto3";
// 指定所在包名
package study.consul;

option go_package = "./proto";

message Human {
  string name = 1;
  int32 age = 2;
}

service SayName{
  rpc Hello (Human) returns (Human);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

package main

import (
   "context"
   "fmt"
   "github.com/hashicorp/consul/api"
   "google.golang.org/grpc"
   "log"
   "net"
   "study.consul/proto"
)

type Person struct {
   proto.UnimplementedSayNameServer
}

func (p *Person) Hello(ctx context.Context, args *proto.Human) (*proto.Human, error) {
   // 通过编译出来的rpc.pb.go解析String类型数据
   args.Name += " is coding!"
   args.Age += 3
   return args, nil
}

func main() {
   /* ------------------- 注册服务到consul ---------------------*/
   // 初始化consul配置
   consulConfig := api.DefaultConfig()

   // 创建consul对象
   consulClient, err := api.NewClient(consulConfig)
   if err != nil {
      fmt.Println("api NewClient err", err)
      return
   }

   // 注册服务，服务的常规信息
   regInfo := api.AgentServiceRegistration{
      ID:      "go grpc",
      Tags:    []string{"grpc", "consul"},
      Name:    "go grpc server",
      Address: "127.0.0.1",
      Port:    5001,
      Check: &api.AgentServiceCheck{
         CheckID:  "consul check grpc test",
         TCP:      "127.0.0.1:5001",
         Timeout:  "2s",
         Interval: "3s",
      },
   }

   // 注册 grpc 服务到 consul 上
   consulClient.Agent().ServiceRegister(&regInfo)

   fmt.Println("注册成功...")

   /* ------------------- grpc 远程调用 ---------------------*/
   // 初始化框架
   grpcServer := grpc.NewServer()

   // 注册服务
   proto.RegisterSayNameServer(grpcServer, new(Person))

   // 定义端口监听服务
   lis, err := net.Listen("tcp", "127.0.0.1:5001")
   if err != nil {
      log.Fatal(err)
   }
   defer lis.Close()

   fmt.Println("服务启动...")
   // 开启监听
   grpcServer.Serve(lis)

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

# -*- coding: UTF-8 -*-

# pip install python-consul
# python 编译 protoc
# python -m grpc_tools.protoc --python_out=. --grpc_python_out=. -I. rpc.proto

import consul
import grpc

import test_pb2
import test_pb2_grpc

c = consul.Consul("XX.XX.XX.XX", "port")

# print(c.catalog.service("go grpc server"))

# 从 consul 中拿到健康的服务
service = c.health.service("go grpc server")

# print(type(service))
addr = service[1][0]["Service"]["Address"]
port = service[1][0]["Service"]["Port"]

# 获取健康的服务 ip + port
health_service = str(addr) + ":" + str(port)
print(health_service)

# 连接 rpc 服务器

channel = grpc.insecure_channel(health_service)

# 调用rpc服务,通过编译出来的rpc_pb2_grpc的HelloService接口定义HelloServiceStub接口,接收来自channel的数据
stub = test_pb2_grpc.SayNameStub(channel)
print(stub)

# 通过接口的rpc获取String类型数据，并获取值
response = stub.Hello(test_pb2.Human(name='luenci', age=19))

print("Greeter client received: " + response.name)
print("Greeter client received: ", response.age)