Consul

Consul adalah solusi yang memungkinkan tim untuk mengelola koneksi jaringan untuk layanan di seluruh lingkungan on-premise dan multi-cloud dengan aman. Ini menyediakan penemuan layanan, service mesh, tata kelola lalu lintas, pembaruan otomatis infrastruktur jaringan, dan serangkaian fitur lainnya.

Dokumentasi Resmi: Consul by HashiCorp

Repositori Sumber Terbuka: hashicorp/consul

Consul adalah alat penemuan dan pendaftaran layanan yang di-open-source-kan oleh HashiCorp. Ini menggunakan algoritma pemilihan Raft dan dikembangkan dalam Go, membuat penyebaran sangat ringan. Consul memiliki fitur-fitur berikut:

Penemuan Layanan
Pendaftaran Layanan
Pemeriksaan Kesehatan
Penyimpanan Key-Value
Dukungan Multi-Datacenter

Faktanya, Consul dapat melakukan lebih dari sekadar penemuan layanan; ini juga dapat digunakan sebagai pusat konfigurasi terdistribusi. Ada banyak alat open-source serupa, seperti ZooKeeper dan Nacos, yang tidak akan dibahas secara detail di sini.

Instalasi

Untuk Ubuntu, jalankan perintah berikut untuk menginstal menggunakan apt:

$ wget -O- https://apt.releases.hashicorp.com/gpg | sudo gpg --dearmor -o /usr/share/keyrings/hashicorp-archive-keyring.gpg
$ echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list
$ sudo apt update && sudo apt install consul

Atau, Anda dapat mengunduh paket instalasi yang sesuai dari situs web resmi Install Consul. Karena Consul dikembangkan dalam Go, paket instalasi itu sendiri hanyalah satu file biner yang dapat dieksekusi, membuat instalasi cukup mudah. Setelah instalasi berhasil, jalankan perintah berikut untuk memeriksa versi:

$ consul version

Output normal menunjukkan tidak ada masalah:

Consul v1.16.1
Revision e0ab4d29
Build Date 2023-08-05T21:56:29Z
Protocol 2 spoken by default, understands 2 to 3 (agent will automatically use protocol >2 when speaking to compatible agents)

Memulai dengan Cepat

Berikut ini menjelaskan cara cepat menyiapkan cluster Consul satu node. Umumnya, satu node digunakan untuk pengujian selama pengembangan. Jika satu node berfungsi tanpa masalah, cluster multi-node kemungkinan besar juga akan berfungsi. Menyiapkan satu node sangat sederhana dan hanya memerlukan satu perintah:

$ consul agent -dev -bind=192.168.48.141 -data-dir=/tmp/consul -ui -node=dev01

Output tipikal adalah sebagai berikut:

==> Starting Consul agent...
               Version: '1.16.1'
            Build Date: '2023-08-05 21:56:29 +0000 UTC'
               Node ID: 'be6f6b8d-9668-f7ff-8709-ed57c72ffdec'
             Node name: 'dev01'
            Datacenter: 'dc1' (Segment: '<all>')
                Server: true (Bootstrap: false)
           Client Addr: [127.0.0.1] (HTTP: 8500, HTTPS: -1, gRPC: 8502, gRPC-TLS: 8503, DNS: 8600)
          Cluster Addr: 192.168.48.141 (LAN: 8301, WAN: 8302)
     Gossip Encryption: false
      Auto-Encrypt-TLS: false
           ACL Enabled: false
     Reporting Enabled: false
    ACL Default Policy: allow
             HTTPS TLS: Verify Incoming: false, Verify Outgoing: false, Min Version: TLSv1_2
              gRPC TLS: Verify Incoming: false, Min Version: TLSv1_2
      Internal RPC TLS: Verify Incoming: false, Verify Outgoing: false (Verify Hostname: false), Min Version: TLSv1_2
==> Log data will now stream in as it occurs:
2023-08-25T17:23:33.763+0800 [DEBUG] agent.grpc.balancer: switching server: target=consul://dc1.be6f6b8d-9668-f7ff-8709-ed57c72ffdec/server.dc1 from=<none> to=<none>
2023-08-25T17:23:33.767+0800 [INFO]  agent.server.raft: initial configuration: index=1 servers="[{Suffrage:Voter ID:be6f6b8d-9668-f7ff-8709-ed57c72ffdec Address:192.168.48.141:8300}]"

Penjelasan singkat parameter:

agent adalah subperintah dan perintah inti Consul. consul agent menjalankan agen Consul baru, di mana setiap node adalah agen.
dev adalah mode berjalan agen. Ada tiga mode: dev, client, dan server.
bind adalah alamat komunikasi LAN, dengan port default 8301. Nilai ini biasanya alamat IP internal server.
advertise adalah alamat komunikasi WAN, dengan port default 8302. Nilai ini biasanya alamat IP eksternal server.
data-dir adalah direktori penyimpanan data.
config-dir adalah direktori penyimpanan konfigurasi. Consul membaca semua file JSON di direktori ini.
bootstrap menandai bahwa server saat ini memasuki mode bootstrap dan memilih dirinya sendiri selama pemilihan Raft. Hanya boleh ada satu server dalam mode ini di cluster.
bootstrap-expect adalah jumlah server yang diharapkan di cluster. Sampai jumlah yang ditentukan tercapai, cluster tidak akan memulai pemilihan. Tidak dapat digunakan bersamaan dengan bootstrap.
retry-join menentukan bahwa agen akan terus mencoba bergabung dengan node yang ditentukan setelah startup. Ini juga mendukung metode penemuan layanan berikut:
```
aliyun aws azure digitalocean gce hcp k8s linode mdns os packet scaleway softlayer tencentcloud triton vsphere
```
ui menjalankan antarmuka web.
node adalah nama node eksekusi, yang harus unik di cluster.

TIP

Untuk penjelasan parameter agen lebih lanjut, kunjungi Agents - CLI Reference | Consul | HashiCorp Developer. Perhatikan bahwa beberapa parameter hanya tersedia di versi enterprise.

Setelah berhasil menjalankan, kunjungi 127.0.0.1:8500 untuk menjelajahi antarmuka web.

Ikon dev01 adalah bintang, menunjukkan bahwa itu adalah node leader.

Saat keluar, untuk memungkinkan node lain merasakan keluarnya node saat ini, tidak disarankan untuk mematikan proses secara paksa. Sebaliknya, gunakan perintah:

consul leave

Atau:

consul force-leave

Anda juga dapat menekan ctrl+c untuk membiarkan agen Consul keluar dengan anggun.

Konsep

Ini adalah diagram cluster Consul, dibagi menjadi dua bagian: control plane dan data plane. Consul hanya bertanggung jawab atas control plane, yang terdiri dari cluster layanan dan klien. Cluster layanan selanjutnya dibagi menjadi follower dan leader. Secara keseluruhan, cluster Consul dalam diagram merupakan data center. Di bawah ini adalah penjelasan beberapa terminologi:

Agent (Proksi): Atau lebih tepatnya disebut node. Setiap agen adalah proses daemon yang berjalan lama yang mengekspos antarmuka HTTP dan DNS, bertanggung jawab atas pemeriksaan kesehatan dan sinkronisasi layanan.
Server (Proksi Layanan): Sebagai server Consul, tanggung jawabnya termasuk berpartisipasi dalam pemilihan Raft, memelihara status cluster, menanggapi kueri, bertukar data dengan data center lain, dan meneruskan kueri ke leader dan data center lain.
Client (Proksi Klien): Klien tidak memiliki status dibandingkan dengan server. Mereka tidak berpartisipasi dalam pemilihan Raft dan hanya meneruskan semua permintaan ke server. Satu-satunya tugas terkait latar belakang yang mereka ikuti adalah LAN gossip pooling.
Leader: Leader adalah kepala semua server, dan hanya boleh ada satu leader. Leader dipilih melalui algoritma pemilihan Raft. Setiap leader memiliki masa jabatannya sendiri, dan selama masa jabatan, setiap permintaan yang diterima oleh server lain harus diteruskan ke leader, sehingga data leader adalah yang paling mutakhir.
Gossip: Consul dibangun di atas Serf (produk lain dari perusahaan) dan menggunakan protokol gossip, yang dirancang untuk komunikasi acak antar node, mirip dengan UDP. Consul menggunakan protokol ini untuk saling pemberitahuan dalam cluster layanan.
Data Center: Cluster Consul dalam LAN disebut data center. Consul mendukung beberapa data center, dan metode komunikasi antar beberapa data center adalah WAN gossip.

TIP

Untuk kosakata dan terminologi lebih lanjut, kunjungi Glossary | Consul | HashiCorp Developer.

Dalam cluster Consul, jumlah server harus dikontrol secara ketat karena mereka langsung berpartisipasi dalam LAN gossip dan WAN gossip, pemilihan Raft, dan menyimpan data. Lebih banyak server berarti biaya komunikasi lebih tinggi. Jumlah klien dapat lebih besar tanpa masalah karena mereka hanya meneruskan permintaan dan tidak berpartisipasi dalam pemilihan, mengonsumsi sangat sedikit sumber daya. Dalam cluster yang ditunjukkan dalam diagram, berbagai layanan mendaftarkan diri mereka sendiri ke server melalui klien. Jika server mati, klien akan secara otomatis menemukan server lain yang tersedia.

Contoh Penyiapan Cluster

Berikut ini menunjukkan penyiapan cluster Consul multi-node sederhana. Pertama, siapkan empat mesin virtual:

Di antara empat mesin virtual, tiga adalah server dan satu adalah klien. Rekomendasi resmi adalah bahwa jumlah server harus ganjil dan sebaiknya setidaknya tiga. Di sini, vm00-vm02 berfungsi sebagai server, dan vm03 berfungsi sebagai klien.

Untuk server, jalankan perintah berikut untuk membuat agen server:

consul agent -server -bind=vm_address -client=0.0.0.0 -data-dir=/tmp/consul/ -node=agent_name -ui

Untuk klien, jalankan perintah berikut untuk membuat agen klien:

consul agent -client=0.0.0.0  -bind=vm_address -data-dir=/tmp/consul/ -node=agent_name -ui

Perintah yang dieksekusi adalah sebagai berikut:

# vm00
consul agent -server -bind=192.168.48.138 -client=0.0.0.0 -data-dir=/tmp/consul/ -node=agent01 -ui -bootstrap

# vm01
consul agent -server -bind=192.168.48.139 -client=0.0.0.0 -data-dir=/tmp/consul/ -node=agent02 -ui -retry-join=192.168.48.138

# vm02
consul agent -server -bind=192.168.48.140 -client=0.0.0.0 -data-dir=/tmp/consul/ -node=agent03 -ui -retry-join=192.168.48.138

# vm03
consul agent -bind=192.168.48.140 -client=0.0.0.0 -data-dir=/tmp/consul/ -node=agent03 -ui -retry-join=192.168.48.138

Penjelasan parameter:

client: 0.0.0.0 mengizinkan permintaan dari semua sumber. Jika hanya parameter client yang ada tanpa parameter server, agen akan berjalan dalam mode klien.

Setelah semua agen berjalan, parameter retry-join bertindak seperti secara otomatis mengeksekusi perintah join, terus mencoba saat gagal. Interval retry default adalah 30 detik:

$ consul join 192.168.48.138

Setelah join selesai, semua node menyadari keberadaan satu sama lain. Karena vm00 menentukan mode bootstrap, itu menjadi leader default. Jika mode bootstrap tidak ditentukan, node yang ditentukan selama join menjadi leader default. Sebelum leader dipilih, cluster tidak dapat berfungsi dengan benar; mengakses antarmuka web akan mengembalikan 500, dan beberapa perintah tidak akan berfungsi dengan benar. Jika sebuah node di cluster menentukan mode bootstrap, tidak ada node lain di cluster yang boleh menentukan mode bootstrap, dan node lain tidak boleh menggunakan parameter bootstrap-expect. Jika digunakan, itu akan secara otomatis dinonaktifkan.

Pada titik ini, jalankan perintah berikut pada node leader (sebenarnya, Anda dapat memeriksa dari node mana pun pada titik ini) untuk melihat informasi anggota data center:

$ consul members
Node      Address              Status  Type    Build   Protocol  DC   Partition  Segment
agent01   192.168.48.138:8301  alive   server  1.16.1  2         dc1  default    <all>
agent02   192.168.48.139:8301  alive   server  1.16.1  2         dc1  default    <all>
agent03   192.168.48.140:8301  alive   server  1.16.1  2         dc1  default    <all>
client01  192.168.48.141:8301  alive   client  1.16.1  2         dc1  default    <default>

Node: Nama node
Address: Alamat komunikasi
Status: alive menunjukkan online, left menunjukkan offline
Type: Jenis agen, mode server dan klien
Build: Versi Consul yang digunakan oleh node. Consul dapat bekerja dengan node versi berbeda dalam rentang tertentu.
Protocol: Mengacu pada versi protokol Raft yang digunakan. Protokol ini harus konsisten di semua node.
DC: Data Center. Semua node dalam output milik data center dc1.
Partition: Partisi tempat node berada, fitur enterprise. Setiap node hanya dapat berkomunikasi dengan node dalam partisi yang sama.
Segment: Segmen jaringan tempat node berada, fitur enterprise.

Demikian pula, jika Anda ingin node keluar, Anda harus menggunakan consul leave untuk membiarkan node keluar dengan anggun dan memberi tahu node lain tentang keluarnya yang akan datang. Untuk skenario multi-node, keluar node dengan anggun sangat penting karena berkaitan dengan konsistensi data.

TIP

Dalam demonstrasi, semua firewall dimatikan pada mesin virtual. Dalam lingkungan produksi aktual, firewall harus diaktifkan untuk pertimbangan keamanan. Oleh karena itu, Anda harus memperhatikan semua port yang digunakan oleh Consul: Required Ports | Consul | HashiCorp Developer.

Selanjutnya, mari kita uji konsistensi data secara singkat. Tambahkan data berikut pada mesin virtual vm00:

$ consul kv put sys_confg {"name":"consul"}
Success! Data written to: sys_confg

Setelah menyimpan, akses node lain melalui HTTP API untuk menemukan bahwa data juga ada (nilai dienkripsi base64):

$ curl http://192.168.48.138:8500/v1/kv/sys_confg
[{"LockIndex":0,"Key":"sys_confg","Flags":0,"Value":"ewogICJuYW1lIjoiY29uc3VsIgp9","CreateIndex":2518,"ModifyIndex":2518}]
$ curl http://192.168.48.139:8500/v1/kv/sys_confg
[{"LockIndex":0,"Key":"sys_confg","Flags":0,"Value":"ewogICJuYW1lIjoiY29uc3VsIgp9","CreateIndex":2518,"ModifyIndex":2518}]
$ curl http://192.168.48.140:8500/v1/kv/sys_confg
[{"LockIndex":0,"Key":"sys_confg","Flags":0,"Value":"ewogICJuYW1lIjoiY29uc3VsIgp9","CreateIndex":2518,"ModifyIndex":2518}]

Faktanya, fitur penemuan dan pendaftaran layanan Consul disiarkan ke node lain melalui protokol gossip. Ketika node mana pun bergabung dengan data center saat ini, semua node akan merasakan perubahan ini.

Contoh Penyiapan Multi-Datacenter

Siapkan lima mesin virtual. vm00-vm02 adalah cluster dari contoh sebelumnya, milik data center dc1, dan kita tidak akan menyentuhnya. vm03-vm04 milik data center dc2. Data center default adalah dc1 saat agen dimulai.

TIP

Untuk tujuan demonstrasi, hanya server yang disiapkan di sini, menghilangkan klien.

Pertama, mulai vm03 sebagai leader default:

$ consul agent -server -datacenter=dc2 -bind=192.168.48.141 -client=0.0.0.0 -data-dir=/tmp/consul/ -node=agent04 -ui -bootstrap

Mulai vm04 dan biarkan itu secara otomatis bergabung dengan node vm03:

$ consul agent -server -datacenter=dc2 -bind=192.168.48.142 -client=0.0.0.0 -data-dir=/tmp/consul/ -node=agent05 -ui -retry-join=192.168.48.141

Pada titik ini, periksa anggota pada vm00 dan vm03 masing-masing:

# vm00-vm02
$ consul members
Node      Address              Status  Type    Build   Protocol  DC   Partition  Segment
agent01   192.168.48.138:8301  alive   server  1.16.1  2         dc1  default    <all>
agent02   192.168.48.139:8301  alive   server  1.16.1  2         dc1  default    <all>
agent03   192.168.48.140:8301  alive   server  1.16.1  2         dc1  default    <all>

# vm03-vm04
$ consul members
Node     Address              Status  Type    Build   Protocol  DC   Partition  Segment
agent04  192.168.48.141:8301  alive   server  1.16.1  2         dc2  default    <all>
agent05  192.168.48.142:8301  alive   server  1.16.1  2         dc2  default    <all>

Anda dapat melihat bidang DC berbeda. Karena ini adalah demonstrasi mesin virtual, mereka semua berada dalam segmen jaringan yang sama. Dalam kenyataannya, dua data center mungkin cluster server di lokasi yang berbeda. Selanjutnya, biarkan node mana pun di dc1 bergabung dengan node mana pun di dc2. Di sini, biarkan vm01 bergabung dengan vm03:

$ consul join -wan 192.168.48.141
Successfully joined cluster by contacting 1 nodes.

Setelah join berhasil, jalankan perintah untuk melihat anggota WAN:

$ consul members -wan
Node         Address              Status  Type    Build   Protocol  DC   Partition  Segment
agent01.dc1  192.168.48.138:8302  alive   server  1.16.1  2         dc1  default    <all>
agent02.dc1  192.168.48.139:8302  alive   server  1.16.1  2         dc1  default    <all>
agent03.dc1  192.168.48.140:8302  alive   server  1.16.1  2         dc1  default    <all>
agent04.dc2  192.168.48.141:8302  alive   server  1.16.1  2         dc2  default    <all>
agent05.dc2  192.168.48.142:8302  alive   server  1.16.1  2         dc2  default    <all>

$ consul catalog datacenters
dc2
dc1

Selama node mana pun di dc1 bergabung dengan node mana pun di dc2, semua node di kedua data center akan merasakan perubahan ini. Saat melihat anggota, Anda juga dapat melihat node dari kedua data center.

Selanjutnya, coba tambahkan entri data KV pada node vm00:

$ consul kv put name consul
Success! Data written to: name

Coba baca data pada node vm01. Anda dapat melihat bahwa data dalam data center yang sama disinkronkan:

$ consul kv get name
consul

Kemudian coba baca data pada vm03 di data center yang berbeda. Anda akan menemukan bahwa data di seluruh data center yang berbeda tidak disinkronkan:

$ consul kv get name
Error! No key exists at: name

Jika Anda ingin sinkronisasi data multi-datacenter, Anda dapat mempelajari hashicorp/consul-replicate: Consul cross-DC KV replication daemon.

Pendaftaran dan Penemuan Layanan

Ada dua cara untuk mendaftarkan layanan di Consul: pendaftaran file konfigurasi dan pendaftaran API. Untuk kenyamanan dalam pengujian, layanan Hello World (contoh dari artikel gRPC) disiapkan di sini dan diterapkan di dua lokasi berbeda. Untuk pendaftaran file konfigurasi, kunjungi Register external services with Consul service discovery | Consul | HashiCorp Developer. Artikel ini hanya memperkenalkan pendaftaran melalui HTTP API.

TIP

Untuk layanan lokal (bersama dengan klien Consul), Anda dapat langsung menggunakan pendaftaran layanan agen. Jika tidak, Anda harus menggunakan catalog register untuk pendaftaran.

Consul menyediakan SDK untuk HTTP API. Untuk SDK dalam bahasa lain, kunjungi Libraries and SDKs - HTTP API | Consul | HashiCorp Developer. Di sini, unduh dependensi Go:

go get github.com/hashicorp/consul/api

Secara aktif mendaftarkan layanan dengan Consul saat layanan dimulai, dan membatalkan pendaftaran layanan dari Consul saat layanan dimatikan. Di bawah ini adalah contoh:

package main

import (
  consulapi "github.com/hashicorp/consul/api"
  "google.golang.org/grpc"
  "google.golang.org/grpc/credentials/insecure"
  pb "grpc_learn/helloworld/hello"
  "log"
  "net"
)

var (
  server01 = &consulapi.AgentService{
        // Harus unik
    ID:      "hello-service1",
    Service: "hello-service",
        // Diterapkan dalam dua instance, satu di port 8080, satu di port 8081
    Port:    8080,
  }
)

// Mendaftarkan layanan
func Register() {
  client, _ := consulapi.NewClient(&consulapi.Config{Address: "192.168.48.138:8500"})
  _, _ = client.Catalog().Register(&consulapi.CatalogRegistration{
    Node:    "hello-server",
    Address: "192.168.2.10",
    Service: server01,
  }, nil)
}

// Membatalkan pendaftaran layanan
func DeRegister() {
  client, _ := consulapi.NewClient(&consulapi.Config{Address: "192.168.48.138:8500"})
  _, _ = client.Catalog().Deregister(&consulapi.CatalogDeregistration{
    Node:      "hello-server",
    Address:   "192.168.2.10",
    ServiceID: server01.ID,
  }, nil)
}

func main() {
  Register()
  defer DeRegister()

  // Mendengarkan port
  listen, err := net.Listen("tcp", ":8080")
  if err != nil {
    panic(err)
  }
  // Membuat server gRPC
  server := grpc.NewServer(
    grpc.Creds(insecure.NewCredentials()),
  )
  // Mendaftarkan layanan
  pb.RegisterSayHelloServer(server, &HelloRpc{})
  log.Println("server running...")
  // Menjalankan
  err = server.Serve(listen)
  if err != nil {
    panic(err)
  }
}

Kode klien menggunakan resolver kustom Consul untuk menanyakan registry untuk layanan yang sesuai dan menyelesaikannya ke alamat nyata:

package myresolver

import (
    "fmt"
    consulapi "github.com/hashicorp/consul/api"
    "google.golang.org/grpc/resolver"
)

func NewConsulResolverBuilder(address string) ConsulResolverBuilder {
    return ConsulResolverBuilder{consulAddress: address}
}

type ConsulResolverBuilder struct {
    consulAddress string
}

func (c ConsulResolverBuilder) Build(target resolver.Target, cc resolver.ClientConn, opts resolver.BuildOptions) (resolver.Resolver, error) {
    consulResolver, err := newConsulResolver(c.consulAddress, target, cc)
    if err != nil {
       return nil, err
    }
    consulResolver.resolve()
    return consulResolver, nil
}

func (c ConsulResolverBuilder) Scheme() string {
    return "consul"
}

func newConsulResolver(address string, target resolver.Target, cc resolver.ClientConn) (ConsulResolver, error) {
    var reso ConsulResolver
    client, err := consulapi.NewClient(&consulapi.Config{Address: address})
    if err != nil {
       return reso, err
    }
    return ConsulResolver{
       target: target,
       cc:     cc,
       client: client,
    }, nil
}

type ConsulResolver struct {
    target resolver.Target
    cc     resolver.ClientConn
    client *consulapi.Client
}

func (c ConsulResolver) resolve() {
    service := c.target.URL.Opaque
    services, _, err := c.client.Catalog().Service(service, "", nil)
    if err != nil {
       c.cc.ReportError(err)
       return
    }
    var adds []resolver.Address
    for _, catalogService := range services {
       adds = append(adds, resolver.Address{Addr: fmt.Sprintf(fmt.Sprintf("%s:%d", catalogService.Address, catalogService.ServicePort))})
    }

    c.cc.UpdateState(resolver.State{
       Addresses: adds,
       // Strategi round-robin
       ServiceConfig: c.cc.ParseServiceConfig(
          `{"loadBalancingPolicy":"round_robin"}`),
    })
}

func (c ConsulResolver) ResolveNow(options resolver.ResolveNowOptions) {
    c.resolve()
}

func (c ConsulResolver) Close() {

}

Daftarkan resolver saat klien dimulai:

package main

import (
    "context"
    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials/insecure"
    "google.golang.org/grpc/resolver"
    "grpc_learn/helloworld/client/myresolver"
    hello2 "grpc_learn/helloworld/hello"
    "log"
    "time"
)

func init() {
    // Mendaftarkan builder
    resolver.Register(
       // Mendaftarkan resolver Consul kustom
       myresolver.NewConsulResolverBuilder("192.168.48.138:8500"),
    )
}

func main() {

    // Membangun koneksi, tanpa verifikasi enkripsi
    conn, err := grpc.Dial("consul:hello-service",
       grpc.WithTransportCredentials(insecure.NewCredentials()),
    )
    if err != nil {
       panic(err)
    }
    defer conn.Close()
    // Membuat klien
    client := hello2.NewSayHelloClient(conn)
    for range time.Tick(time.Second) {
       // Panggilan jarak jauh
       helloRep, err := client.Hello(context.Background(), &hello2.HelloReq{Name: "client"})
       if err != nil {
          panic(err)
       }
       log.Printf("received grpc resp: %+v", helloRep.String())
    }

}

Pertama mulai server, lalu mulai klien. Ada dua server yang menyediakan layanan yang sama tetapi dengan alamat berbeda. Strategi load balancing klien adalah round-robin, yang dapat dilihat dari interval log server bahwa strategi tersebut berlaku:

2023/08/29 17:39:54 server running...
2023/08/29 21:03:46 received grpc req: name:"client"
2023/08/29 21:03:48 received grpc req: name:"client"
2023/08/29 21:03:50 received grpc req: name:"client"
2023/08/29 21:03:52 received grpc req: name:"client"
2023/08/29 21:03:54 received grpc req: name:"client"
2023/08/29 21:03:56 received grpc req: name:"client"
2023/08/29 21:03:58 received grpc req: name:"client"
2023/08/29 21:04:00 received grpc req: name:"client"

Di atas adalah kasus sederhana menggunakan Consul dikombinasikan dengan gRPC untuk mengimplementasikan pendaftaran dan penemuan layanan.

Consul ​

Instalasi ​

Memulai dengan Cepat ​

Konsep ​

Contoh Penyiapan Cluster ​

Contoh Penyiapan Multi-Datacenter ​

Pendaftaran dan Penemuan Layanan ​