Golang 中使用 Consul

Consul 是 HashiCorp 公司开发的一个服务网格解决方案，提供服务发现、配置和分段功能。在 Go 语言中使用 Consul 可以实现服务注册与发现、健康检查、KV存储等功能。

基本使用

1. 安装 Consul Go SDK

go get github.com/hashicorp/consul/api

2. 连接到 Consul

package main

import (
	"fmt"
	"log"

	"github.com/hashicorp/consul/api"
)

func main() {
	// 创建客户端
	config := api.DefaultConfig()
	config.Address = "localhost:8500" // Consul server地址
	
	client, err := api.NewClient(config)
	if err != nil {
		log.Fatal("Consul client error: ", err)
	}
	
	fmt.Println("Connected to Consul")
}

服务注册与发现

服务注册

func registerService(client *api.Client) {
	registration := &api.AgentServiceRegistration{
		Name:    "my-service",
		ID:      "my-service-1",
		Port:    8080,
		Address: "localhost",
		
        // Health check
        Check: &api.AgentServiceCheck{
            HTTP:     "http://localhost:8080/health",
            Interval: "10s",
            Timeout:  "5s",
        },
    }

	err := client.Agent().ServiceRegister(registration)
	if err != nil {
	    log.Fatal("Failed to register service:", err)
    }
    
    fmt.Println("Service registered successfully")
}

服务发现

func discoverServices(client *api.Client) {
    services, _, err := client.Catalog().Services(nil)
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Println("Available services:")
    for name := range services {
        fmt.Println("-", name)
    }
    
    // Get specific service entries
    entries, _, err := client.Health().Service("my-service", "", true, nil)
    if err != nil {
        log.Fatal(err)
    }
    
    for _, entry := range entries {
        fmt.Printf("Found %s at %s:%d\n", 
            entry.Service.Service,
            entry.Service.Address,
            entry.Service.Port)
    }
}

KV存储操作

func kvOperations(client *api.Client) {
	pair := &api.KVPair{
	    Key:   "config/myapp/setting1",
	    Value: []byte("value1"),
	    Flags: 0,
	    Session: "",
   }

   // Put key-value pair
   _, err := client.KV().Put(pair, nil)
   if err != nil {
       log.Fatal(err)
   }

   // Get value by key
   kvPair, _, err := client.KV().Get("config/myapp/setting1", nil)
   if err != nil || kvPair == nil {
       log.Fatal(err)
   }
   
   fmt.Printf("%s = %s\n", kvPair.Key, string(kvPair.Value))
   
   // Delete key
   _, err = client.KV().Delete("config/myapp/setting1", nil)
}

Watch机制示例

func watchKeyChanges(client *api.Client) {
	qOpts := &api.QueryOptions{WaitIndex: 0}

	for {		
    	pair, meta, err := client.KV().Get("config/myapp/watchkey", qOpts.WithContext(context.Background()))
    	if err != nil || pair == nil && meta.LastIndex <= qOpts.WaitIndex {			
        	continue		
    	}		    

    	fmt.Printf("Key changed! New value is %q (index=%d)\n", 
        	string(pair.Value), meta.LastIndex)

    	qOpts.WaitIndex = meta.LastIndex	
}}

gRPC集成示例（可选）

如果你使用gRPC，可以结合Consul实现负载均衡：

import (
	resolver "github.com/hashicorp/consul/api"
)

// Register consul resolver for gRPC before dialing:
resolver.Register(&consulResolverBuilder{client})

conn, _ = grpc.Dial(
	fmt.Sprintf("%s://%s/service-name", 
	resolver.GetScheme(), consulAddr),
grpc.WithDefaultServiceConfig(`{"loadBalancingPolicy":"round_robin"}`),
grpc.WithTransportCredentials(insecure.NewCredentials()),
})

以上是Go语言中集成Consul的基本用法。根据你的具体需求，还可以探索ACL、多数据中心等高级功能。

内容由零声教学AI助手提供，问题来源于学员提问