golang框架中如何进行负载均衡之负载均衡与服务发现

import (
    "context"
    "fmt"

    "github.com/go-kit/endpoint"
)

type UserService interface {
    Get(ctx context.Context, id string) (string, error)
}

func main() {
    // 定义后端服务地址
    backends := []string{"localhost:8081", "localhost:8082"}

    // 创建负载均衡端点
    lb := endpoint.NewLoadBalancedEndpoint(backends, endpoint.RoundRobin{})

    // 实现服务处理逻辑
    var get func(ctx context.Context, id string) (string, error)
    get = func(ctx context.Context, id string) (string, error) {
        fmt.Printf("Received request for id: %s\n", id)
        return "Value for id " + id, nil
    }

    // 封装端点为中间件
    getEndpoint := endpoint.Chain(get, lb)

    // 处理请求
    result, err := getEndpoint(context.Background(), "1")
    if err != nil {
        fmt.Printf("Error: %s\n", err)
    } else {
        fmt.Printf("Result: %s\n", result)
    }
}

import (
    "context"
    "fmt"

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

func main() {
    // 创建 Consul 客户端
    client, err := consul.NewClient(consul.DefaultConfig())
    if err != nil {
        fmt.Printf("Error creating Consul client: %s\n", err)
        return
    }

    // 查询名为 "my-service" 的服务
    services, err := client.Health().Service("my-service", "", true, &consul.QueryOptions{})
    if err != nil {
        fmt.Printf("Error querying service: %s\n", err)
        return
    }

    // 打印服务地址
    for _, service := range services {
        fmt.Printf("Found service at: %s:%d", service.Service.Address, service.Service.Port)
    }
}

package main

import (
    "context"
    "fmt"
    "log"
    "net/http"
    "time"

    consul "github.com/hashicorp/consul/api"
    "github.com/gin-gonic/gin"
    "github.com/go-kit/endpoint"
    "github.com/go-kit/log/level"
)

// 注册服务
func registerServiceWithConsul() error {
    client, err := consul.NewClient(consul.DefaultConfig())
    if err != nil {
        return err
    }

    registration := &consul.AgentServiceRegistration{
        ID:      "my-service-1",
        Name:    "my-service",
        Address: "localhost",
        Port:    8080,
        Check: &consul.AgentServiceCheck{
            TTL: "10s",
        },
    }

    // 注册服务
    if err := client.Agent().ServiceRegister(registration); err != nil {
        return err
    }

    log.Println("Service registered with Consul")

    return nil
}

// 从服务注册表中获取服务端点
func getEndpointsFromConsul() ([]string, error) {
    client, err := consul.NewClient(consul.DefaultConfig())
    if err != nil {
        return nil, err
    }

    services, err := client.Health().Service("my-service", "", true, &consul.QueryOptions{})
    if err != nil {
        return nil, err
    }

    endpoints := []string{}
    for _, service := range services {
        endpoints = append(endpoints, fmt.Sprintf("%s:%d", service.Service.Address, service.Service.Port))
    }

    return endpoints, nil
}

func main() {
    // 注册服务到 Consul
    if err := registerServiceWithConsul(); err != nil {
        log.Fatal(err)
    }

    // 创建 Gin 服务器
    r := gin.Default()

    // 获取后端服务端点
    endpoints, err := getEndpointsFromConsul()
    if err != nil {
        log.Fatal(err)
    }

    // 创建负载均衡端点
    lb := endpoint.NewLoadBalancedEndpoint(endpoints, endpoint.RoundRobin{})

    // 实现服务处理逻辑
    var get func(ctx context.Context, id string) (string, error)
    get = func(ctx context.Context, id string) (string, error) {
        log.Println("Received request for id:", id)
        time.Sleep(100 * time.Millisecond) // 模拟后端处理
        return fmt.Sprintf("Value for id %s", id), nil
    }

    // 封装端点为 Gin 处理器
    getEndpoint := endpoint.Chain(get, lb)
    r.GET("/get", func(c *gin.Context) {
        result, err := getEndpoint(context.Background(), c.Param("id"))
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        } else {
            c.JSON(http.StatusOK, gin.H{"result": result})
        }
    })

    // 启动 Gin 服务器
    r.Run(":8080")
}