微服务 on Yison's Blog

何以服务熔断及负载均衡

Sun, 29 Aug 2021 00:00:00 +0000

本文是个人在学习书籍《Go 语言高并发与微服务实战》第10章内容过程中，动手做的小实验，涉及 Hystrix 相关知识，仅供参考。

服务熔断机制

三种状态

┌─────────────────────────────────────────────────────────────┐
│ 熔断器状态机 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────┐ 失败率超过阈值 ┌──────────┐ │
│ │ CLOSED │ ───────────────────────▶│ OPEN │ │
│ │ 关闭 │ │ 打开 │ │
│ └──────────┘ └────┬─────┘ │
│ ▲ │ │
│ │ │ 超时后 │
│ │ 检测成功 │ 半开 │
│ │ ▼ │
│ │ ┌──────────┐ │
│ └──────────────────────────────│HALF-OPEN │ │
│ 恢复关闭 │ 半开 │ │
│ └──────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘

状态	说明
Closed（关闭）	正常状态，请求正常通过；失败达到阈值时切换到 Open
Open（打开）	熔断状态，所有请求直接失败，快速返回
Half-Open（半开）	尝试恢复状态，放行部分请求；成功则关闭，失败则重新打开

Hystrix 配置参数

参数	默认值	说明
`sleepWindow`	5000ms	熔断打开后多久尝试半开
`requestVolumeThreshold`	20	熔断器打开的最小请求数
`errorPercentThreshold`	50%	错误百分比阈值
`maxConcurrentRequests`	10	最大并发请求数

负载均衡算法

常见算法

算法	说明	适用场景
随机	随机选择服务实例	请求较少、无状态服务
轮询（Round Robin）	依次选择每个实例	请求均匀、实例性能相近
加权轮询	按权重比例分配请求	实例性能不均
Hash	根据请求特征 Hash	会话保持、缓存友好
一致性 Hash	环状 Hash 分布	分布式缓存
最小连接数	选择连接数最少的	长连接服务

一致性 Hash 原理

 ┌─────────────┐
 │ 节点 A │◀── Hash(A)
 ┌───────────│ 192.168.1.1│
 │ └─────────────┘
 │ ▲
 │ │ 顺时针找
 Hash环 │ 最近的节点
 │ │
 ▼ │
┌───────────────┐ │
│ 节点 C │───────────┘
│ 192.168.1.3 │◀── Hash(C)
└───────────────┘
 ▲
 │
 │
┌───────────────┐
│ 节点 B │
│ 192.168.1.2 │◀── Hash(B)
└───────────────┘

Hystrix Go 使用

安装

go get github.com/afex/hystrix-go/hystrix

基本用法

package main

import (
 "fmt"
 "time"
 
 "github.com/afex/hystrix-go/hystrix"
)

func main() {
 // 配置 Command
 hystrix.ConfigureCommand("my_command", hystrix.CommandConfig{
 Timeout: 1000, // 超时时间 ms
 MaxConcurrentRequests: 10, // 最大并发数
 SleepWindow: 5000, // 熔断后尝试恢复的时间
 RequestVolumeThreshold: 20, // 熔断器打开的最小请求数
 ErrorPercentThreshold: 50, // 错误百分比阈值
 })
 
 // 使用熔断器执行
 err := hystrix.Do("my_command", func() error {
 // 这里是实际要执行的业务逻辑
 return callService()
 }, func(err error) error {
 // 这里是降级处理
 fmt.Println("服务调用失败，执行降级逻辑")
 return fallback()
 })
 
 if err != nil {
 fmt.Println("请求失败:", err)
 }
}

func callService() error {
 // 模拟服务调用
 time.Sleep(100 * time.Millisecond)
 return nil
}

func fallback() error {
 // 降级逻辑
 fmt.Println("执行降级返回")
 return nil
}

异步调用

// 返回 chan
resultChan := make(chan string, 1)
errorChan := hystrix.Go("my_command", func() error {
 // 异步执行
 go func() {
 result, _ := callServiceAsync()
 resultChan <- result
 }()
 return nil
}, nil)

// 等待结果
select {
case result := <-resultChan:
 fmt.Println("结果:", result)
case <-time.After(time.Second * 5):
 fmt.Println("超时")
}

监控

import "github.com/afex/hystrix-go/hystrix/metric_collector"

func init() {
 // 开启监控
 hystrix.RegisterReporter("console", &HystrixConsoleReporter{})
}

完整示例：微服务调用

服务端（string-service）

// service/main.go
package main

import (
 "flag"
 "fmt"
 "log"
 "net/http"
 "time"
)

var port = flag.Int("port", 10086, "service port")

func main() {
 flag.Parse()
 
 http.HandleFunc("/echo", func(w http.ResponseWriter, r *http.Request) {
 msg := r.URL.Query().Get("msg")
 fmt.Printf("收到请求: %s\n", msg)
 time.Sleep(time.Millisecond * 100)
 w.Write([]byte("响应: " + msg))
 })
 
 log.Printf("服务启动，端口: %d", *port)
 log.Fatal(http.ListenAndServe(fmt.Sprintf(":%d", *port), nil))
}

客户端（带熔断）

// client/main.go
package main

import (
 "flag"
 "fmt"
 "io/ioutil"
 "log"
 "net/http"
 "strings"
 "time"
 
 "github.com/afex/hystrix-go/hystrix"
)

var (
 servicePort = flag.Int("port", 10086, "service port")
 serviceHost = flag.String("host", "localhost", "service host")
)

func main() {
 flag.Parse()
 
 // 配置熔断器
 hystrix.ConfigureCommand("string_service", hystrix.CommandConfig{
 Timeout: 1000,
 MaxConcurrentRequests: 10,
 SleepWindow: 5000,
 RequestVolumeThreshold: 5,
 ErrorPercentThreshold: 40,
 })
 
 // 模拟多次请求
 for i := 0; i < 20; i++ {
 err := hystrix.Do("string_service", func() error {
 return callService(fmt.Sprintf("请求 %d", i))
 }, func(err error) error {
 fmt.Printf("降级处理: %v\n", err)
 return nil
 })
 
 if err != nil {
 fmt.Printf("第 %d 次请求失败: %v\n", i, err)
 }
 
 time.Sleep(200 * time.Millisecond)
 }
}

func callService(msg string) error {
 url := fmt.Sprintf("http://%s:%d/echo?msg=%s", 
 *serviceHost, *servicePort, strings.TrimSpace(msg))
 
 resp, err := http.Get(url)
 if err != nil {
 return err
 }
 defer resp.Body.Close()
 
 body, _ := ioutil.ReadAll(resp.Body)
 log.Printf("响应: %s", string(body))
 return nil
}

运行示例

# 1. 启动 Consul（服务发现）
consul agent -dev

# 2. 启动多个服务实例
go run service/main.go -port 10086
go run service/main.go -port 10089

# 3. 启动客户端
go run client/main.go

# 4. 人为制造失败（例如停掉下游服务）观察熔断打开与降级日志，再恢复服务确认 Half-Open 恢复

熔断与负载均衡往往一起出现：负载均衡决定请求打到哪台实例，熔断在实例不健康时快速失败并触发降级，避免线程与连接池被拖垮。结合服务发现（Consul / K8s Endpoints）可在实例上下线时自动更新负载均衡目标。

跟我一起玩微服务网关

Thu, 26 Aug 2021 00:00:00 +0000

本文是个人在学习书籍《Go 语言高并发与微服务实战》第9章内容过程中，动手做的小实验，涉及 Consul、go-kit、Kong、JWT、Zipkin 相关知识。

微服务网关概述

┌─────────────────────────────────────────────────────────────┐
│ 微服务网关架构 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ API Gateway │ │
│ ├──────────────────────────────────────────────────────┤ │
│ │ 路由转发 │ 负载均衡 │ 限流熔断 │ 认证鉴权 │ 监控日志 │ │
│ └──────────────────────────────────────────────────────┘ │
│ │ │
│ ┌──────────┬───────────┼───────────┬──────────┐ │
│ │ │ │ │ │ │
│ ▼ ▼ ▼ ▼ ▼ │
│ ┌─────────┐┌─────────┐┌─────────┐┌─────────┐┌─────────┐ │
│ │User Svc ││Order Svc││Product ││Payment ││Search │ │
│ │ ││ ││Service ││Service ││Service │ │
│ └─────────┘└─────────┘└─────────┘└─────────┘└─────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘

网关核心功能

功能	说明
路由转发	根据请求路径转发到后端服务
负载均衡	多实例流量分发
限流熔断	保护后端服务
认证鉴权	JWT/Session 验证
监控日志	请求追踪和日志记录

简易网关 Go 实现

项目结构

gateway/
├── main.go # 主程序
├── proxy.go # 反向代理
├── discovery.go # 服务发现
├── limiter.go # 限流器
├── circuitbreaker.go # 熔断器
└── auth.go # 认证中间件

主程序

// gateway/main.go
package main

import (
 "flag"
 "fmt"
 "log"
 "math/rand"
 "net/http"
 "net/http/httputil"
 "os"
 "os/signal"
 "strings"
 "syscall"
 "time"
 
 "github.com/go-kit/kit/log"
 "github.com/hashicorp/consul/api"
)

func main() {
 // 解析命令行参数
 var (
 consulHost = flag.String("consul.host", "127.0.0.1", "consul server host")
 consulPort = flag.String("consul.port", "8500", "consul server port")
 gatewayPort = flag.String("gateway.port", "9090", "gateway port")
 )
 flag.Parse()
 
 // 创建日志组件
 var logger log.Logger
 {
 logger = log.NewLogfmtLogger(os.Stderr)
 logger = log.With(logger, "ts", log.DefaultTimestampUTC)
 logger = log.With(logger, "caller", log.DefaultCaller)
 }
 
 // 创建 Consul 客户端
 consulConfig := api.DefaultConfig()
 consulConfig.Address = fmt.Sprintf("http://%s:%s", *consulHost, *consulPort)
 consulClient, err := api.NewClient(consulConfig)
 if err != nil {
 logger.Log("err", err)
 os.Exit(1)
 }
 
 // 创建处理器
 discovery := NewDiscovery(consulClient, logger)
 handler := NewProxyHandler(discovery, logger)
 
 // 创建 HTTP 服务器
 server := &http.Server{
 Addr: fmt.Sprintf(":%s", *gatewayPort),
 Handler: handler,
 }
 
 // 启动服务器
 go func() {
 logger.Log("gateway", "starting", "port", *gatewayPort)
 if err := server.ListenAndServe(); err != nil {
 logger.Log("gateway", "exit", "err", err)
 }
 }()
 
 // 优雅退出
 ch := make(chan os.Signal, 1)
 signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM)
 logger.Log("signal", <-ch)
 
 ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 defer cancel()
 
 if err := server.Shutdown(ctx); err != nil {
 logger.Log("shutdown", err)
 }
}

服务发现

// gateway/discovery.go
package main

import (
 "context"
 "github.com/go-kit/kit/log"
 "github.com/hashicorp/consul/api"
 "math/rand"
)

type Discovery struct {
 client consul.Client
 logger log.Logger
}

func NewDiscovery(client consul.Client, logger log.Logger) *Discovery {
 return &Discovery{
 client: client,
 logger: logger,
 }
}

// GetService 获取服务实例
func (d *Discovery) GetService(ctx context.Context, serviceName string) (*api.ServiceEntry, error) {
 entries, _, err := d.client.Health().Service(serviceName, "", true, nil)
 if err != nil {
 return nil, err
 }
 
 if len(entries) == 0 {
 return nil, fmt.Errorf("no available instances for %s", serviceName)
 }
 
 // 负载均衡：随机选择
 index := rand.Intn(len(entries))
 return &entries[index], nil
}

// GetServices 获取所有服务实例
func (d *Discovery) GetServices(ctx context.Context, serviceName string) ([]*api.ServiceEntry, error) {
 entries, _, err := d.client.Health().Service(serviceName, "", true, nil)
 if err != nil {
 return nil, err
 }
 return entries, nil
}

反向代理

// gateway/proxy.go
package main

import (
 "context"
 "fmt"
 "github.com/go-kit/kit/log"
 "net/http"
 "net/http/httputil"
 "strings"
)

type ProxyHandler struct {
 discovery *Discovery
 logger log.Logger
}

func NewProxyHandler(discovery *Discovery, logger log.Logger) *ProxyHandler {
 return &ProxyHandler{
 discovery: discovery,
 logger: logger,
 }
}

func (h *ProxyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 // 解析请求路径：/service-name/path
 path := r.URL.Path
 parts := strings.SplitN(path, "/", 3)
 if len(parts) < 3 {
 http.Error(w, "invalid path", http.StatusBadRequest)
 return
 }
 
 serviceName := parts[1]
 targetPath := "/" + parts[2]
 
 // 获取服务实例
 instance, err := h.discovery.GetService(r.Context(), serviceName)
 if err != nil {
 h.logger.Log("service", serviceName, "err", err)
 http.Error(w, "service unavailable", http.StatusServiceUnavailable)
 return
 }
 
 // 构建代理请求
 targetURL := fmt.Sprintf("http://%s:%d%s", 
 instance.Service.Address, 
 instance.Service.Port, 
 targetPath)
 
 proxyReq, err := http.NewRequest(r.Method, targetURL, r.Body)
 if err != nil {
 http.Error(w, "proxy error", http.StatusInternalServerError)
 return
 }
 
 // 复制请求头
 for key, values := range r.Header {
 for _, value := range values {
 proxyReq.Header.Add(key, value)
 }
 }
 
 // 执行代理
 client := &http.Client{}
 resp, err := client.Do(proxyReq)
 if err != nil {
 h.logger.Log("proxy", err)
 http.Error(w, "proxy error", http.StatusBadGateway)
 return
 }
 defer resp.Body.Close()
 
 // 复制响应
 for key, values := range resp.Header {
 for _, value := range values {
 w.Header().Add(key, value)
 }
 }
 w.WriteHeader(resp.StatusCode)
 w.Write([]byte(fmt.Sprintf("Proxy to: %s", targetURL)))
}

// 反向代理实现
func newSingleHostReverseProxy(target string) *httputil.ReverseProxy {
 return httputil.NewSingleHostReverseProxy(target)
}

Kong 网关

Kong 简介

Kong 是一个云原生、可扩展、统一 API 层（API Gateway）。

Docker 部署

下面给出「单机演示」的常见步骤：创建网络 → 启动数据库 → （按所用 Kong 镜像文档执行）数据库迁移 → 启动 Kong。具体镜像名与启动参数请以你选用的 Kong 发行版 README 为准，不同主版本 CLI 与环境变量略有差异。

docker network create kong-net

docker run -d --name kong-db \
 --network kong-net \
 -p 5432:5432 \
 -e POSTGRES_USER=kong \
 -e POSTGRES_PASSWORD=kong \
 -e POSTGRES_DB=kong \
 postgres:13

# 数据库就绪后，在同一网络内执行 kong migrations bootstrap（命令随镜像而异），再启动 kong 网关与管理端口。
# 典型端口：8000（代理）、8443（HTTPS）、8001（Admin API）。正式环境请改用编排模板并开启 TLS / RBAC。

本地体验也可使用 Kong Ingress Controller（Kubernetes）或云端托管网关服务；本节重点在于：网关前面负责 TLS、路由、插件（鉴权、限流、熔断），后面的微服务仍可沿用前文自定义代理或 Istio Linkerd 等服务网格。

小结

网关层把「路由、观测、防护」收口在一处：开发阶段可用 Nginx / 手写反向代理入门，业务量上升后再引入 Kong / APISIX / Envoy 等平台化能力。

微服务配置中心小实验

Sun, 25 Jul 2021 00:00:00 +0000

本文是个人在学习书籍《Go 语言高并发与微服务实战》第8章内容过程中，动手做的小实验，涉及 Spring Cloud Config 和 YAML 相关知识。

配置中心概念

┌─────────────────────────────────────────────────────────────┐
│ 配置中心架构 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────┐ │
│ │ 配置中心 │ │
│ │ Config Server│◀──── Git/SVN/Nacos │
│ └──────┬───────┘ │
│ │ │
│ │ 拉取/推送 │
│ ▼ │
│ ┌─────────────────────────────────────────┐ │
│ │ 微服务集群 │ │
│ │ ┌─────────┐ ┌─────────┐ ┌─────────┐│ │
│ │ │Service A│ │Service B│ │Service C││ │
│ │ └─────────┘ └─────────┘ └─────────┘│ │
│ └─────────────────────────────────────────┘ │
│ │
│ 特性： │
│ • 配置集中管理 │
│ • 配置热更新 │
│ • 环境隔离（dev/staging/prod） │
│ • 版本控制 │
│ │
└─────────────────────────────────────────────────────────────┘

Spring Cloud Config 简介

Spring Cloud Config 为分布式系统的外部配置提供了服务端和客户端支持。

核心特性

特性	说明
配置集中管理	所有配置存储在 Git 仓库
环境隔离	dev、test、prod 环境分离
配置加密	支持敏感配置加密存储
动态刷新	无需重启即可更新配置
高可用	支持集群部署

准备 Spring Boot 环境

macOS 安装

# 使用 Homebrew 安装
brew tap spring-io/tap
brew install spring-boot

# 或安装 Spring CLI
brew install springboot

快速开始

创建 app.groovy：

@RestController
class ThisWillActuallyRun {
 @RequestMapping("/")
 String home() {
 "Hello World!"
 }
}

运行：

spring run app.groovy

创建配置中心服务端

项目结构

config-server/
├── pom.xml
├── src/main/java/com/example/configserver/
│ └── ConfigServerApplication.java
└── config/
 └── application.yml

Maven 依赖 (pom.xml)

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>
 
 <parent>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-parent</artifactId>
 <version>2.5.2</version>
 </parent>
 
 <dependencies>
 <!-- Spring Cloud Config Server -->
 <dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-config-server</artifactId>
 </dependency>
 
 <!-- Eureka 服务发现（可选）-->
 <dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
 </dependency>
 </dependencies>
 
 <dependencyManagement>
 <dependencies>
 <dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-dependencies</artifactId>
 <version>2020.0.2</version>
 <type>pom</type>
 <scope>import</scope>
 </dependency>
 </dependencies>
 </dependencyManagement>
</project>

启动类

@SpringBootApplication
@EnableConfigServer
public class ConfigServerApplication {
 public static void main(String[] args) {
 SpringApplication.run(ConfigServerApplication.class, args);
 }
}

配置文件

# application.yml
server:
 port: 8888

spring:
 application:
 name: config-server
 cloud:
 config:
 server:
 git:
 uri: https://github.com/your-org/config-repo
 search-paths: config/{application}
 username: your-github-username
 default-label: main

配置仓库结构

config-repo/
├── config/
│ ├── user-service/
│ │ ├── application.yml # 默认配置
│ │ ├── application-dev.yml # 开发环境
│ │ ├── application-test.yml # 测试环境
│ │ └── application-prod.yml # 生产环境
│ └── order-service/
│ └── application.yml
└── README.md

示例配置

# user-service/application.yml
server:
 port: ${PORT:8080}

spring:
 application:
 name: user-service
 datasource:
 url: jdbc:mysql://localhost:3306/user_db
 username: root
 password: ${DB_PASSWORD}
 redis:
 host: ${REDIS_HOST:localhost}
 port: ${REDIS_PORT:6379}

# 用户服务配置
user:
 cache:
 ttl: 3600
 max-size: 1000
 rate-limit:
 qps: 100

# user-service/application-dev.yml
spring:
 datasource:
 url: jdbc:mysql://localhost:3306/user_db_dev
 password: dev_password
 redis:
 host: localhost

user:
 rate-limit:
 qps: 10 # 开发环境限流放宽

Go 客户端接入

安装依赖

go get github.com/spf13/viper
go get github.com/go-laoji/go-config

Viper 配置

// config/config.go
package config

import (
 "fmt"
 "github.com/spf13/viper"
)

type Config struct {
 App AppConfig `mapstructure:"app"`
 Database DatabaseConfig `mapstructure:"database"`
 Redis RedisConfig `mapstructure:"redis"`
 User UserConfig `mapstructure:"user"`
}

type AppConfig struct {
 Name string `mapstructure:"name"`
 Port int `mapstructure:"port"`
}

type DatabaseConfig struct {
 Host string `mapstructure:"host"`
 Port int `mapstructure:"port"`
 Username string `mapstructure:"username"`
 Password string `mapstructure:"password"`
 Name string `mapstructure:"name"`
}

type RedisConfig struct {
 Host string `mapstructure:"host"`
 Port int `mapstructure:"port"`
 Password string `mapstructure:"password"`
 DB int `mapstructure:"db"`
}

type UserConfig struct {
 Cache CacheConfig `mapstructure:"cache"`
 RateLimit RateLimitConfig `mapstructure:"rate-limit"`
}

type CacheConfig struct {
 TTL int `mapstructure:"ttl"`
 MaxSize int `mapstructure:"max-size"`
}

type RateLimitConfig struct {
 QPS int `mapstructure:"qps"`
}

var GlobalConfig *Config

func LoadConfig(configServer, appName, profile string) (*Config, error) {
 v := viper.New()
 
 // 设置配置中心地址
 configURL := fmt.Sprintf("http://%s/%s/%s", configServer, appName, profile)
 v.SetConfigType("yaml")
 
 // 从配置中心获取配置
 if err := v.SafeGetConfigFile(configURL); err != nil {
 // 尝试直接读取
 v.SetConfigFile(fmt.Sprintf("config/%s.yml", profile))
 if err := v.ReadInConfig(); err != nil {
 return nil, err
 }
 }
 
 var cfg Config
 if err := v.Unmarshal(&cfg); err != nil {
 return nil, err
 }
 
 GlobalConfig = &cfg
 return &cfg, nil
}

// 本地配置（备用）
func LoadLocalConfig() (*Config, error) {
 v := viper.New()
 
 v.SetConfigName("config")
 v.SetConfigType("yaml")
 v.AddConfigPath("./config")
 
 if err := v.ReadInConfig(); err != nil {
 return nil, err
 }
 
 var cfg Config
 if err := v.Unmarshal(&cfg); err != nil {
 return nil, err
 }
 
 GlobalConfig = &cfg
 return &cfg, nil
}

若配置中心不可用，LoadLocalConfig() 可作为本地开发与灾备兜底；关键是保证 profile、密钥与 环境变量注入 在流水线与运行时一致。

微服务注册发现小实验

Tue, 20 Jul 2021 00:00:00 +0000

本文是个人在学习书籍《Go 语言高并发与微服务实战》第6章内容过程中，动手做的小实验，涉及 Consul 和 go-kit 相关知识。

Consul 简介

┌─────────────────────────────────────────────────────────────┐
│ Consul 架构 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ Consul │ │ Consul │ │ Consul │ │
│ │ Server │ │ Server │ │ Server │ │
│ │ (Leader)│ │(Follow) │ │(Follow) │ │
│ └────┬────┘ └────┬────┘ └────┬────┘ │
│ └───────────┴───────────┘ │
│ │ │
│ ┌─────────┴─────────┐ │
│ │ │ │
│ ┌────▼────┐ ┌────▼────┐ │
│ │ Consul │ │ Consul │ │
│ │ Agent │ │ Agent │ │
│ │ (Node1) │ │ (Node2) │ │
│ └────┬────┘ └────┬────┘ │
│ │ │ │
│ ┌────▼────┐ ┌────▼────┐ │
│ │ Service │ │ Service │ │
│ └─────────┘ └─────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘

安装 Consul

下载安装

# macOS
brew install consul

# Linux
curl -fsSL https://apt.releases.hashicorp.com/gpg | sudo apt-key add -
sudo apt-add-repository "deb [arch=amd64] https://apt.releases.hashicorp.com $(lsb_release -cs) main"
sudo apt-get update && sudo apt-get install consul

# Docker
docker run -d --name=consul consul agent -dev -client=0.0.0.0

验证安装

consul --version
# Consul v1.10.0

Consul 基本操作

单机启动

# 开发模式启动
consul agent -dev

# 访问 UI
# http://127.0.0.1:8500/ui

集群启动

# 机器 1：主节点
consul agent -server \n -bootstrap-expect=1 \n -data-dir=/tmp/consul \n -node=consul-server-1 \n -bind=10.0.0.52 \n -ui

# 机器 2：加入集群
consul agent \n -data-dir=/tmp/consul \n -node=consul-server-2 \n -bind=10.0.0.53

# 在机器 2 执行加入
consul join 10.0.0.52

注册服务

# 注册服务（通过 HTTP API）
curl -X PUT -d '{
 "ID": "user-service-1",
 "Name": "user-service",
 "Tags": ["v1", "go"],
 "Address": "127.0.0.1",
 "Port": 8080,
 "Check": {
 "HTTP": "http://127.0.0.1:8080/health",
 "Interval": "10s",
 "Timeout": "5s"
 }
}' http://127.0.0.1:8500/v1/agent/service/register

# 注销服务
curl -X PUT http://127.0.0.1:8500/v1/agent/service/deregister/user-service-1

服务发现

# 查找服务
curl http://127.0.0.1:8500/v1/catalog/service/user-service

# DNS 查询
# user-service.service.consul

# 健康检查
curl http://127.0.0.1:8500/v1/health/service/user-service?passing=true

Go 微服务注册发现

项目结构

consul-demo/
├── main.go # 主程序
├── user/ # 用户服务
│ └── user.go
├── discovery/ # 服务发现封装
│ └── consul.go
└── go.mod

安装依赖

go get github.com/go-kit/kit/sd/consul
go get github.com/hashicorp/consul

Consul 客户端封装

// discovery/consul.go
package discovery

import (
 "fmt"
 "time"
 
 "github.com/go-kit/kit/sd"
 "github.com/go-kit/kit/sd/consul"
 "github.com/go-kit/kit/sd/lazy"
 "github.com/go-kit/kit/endpoint"
 "github.com/hashicorp/consul/api"
)

type Client struct {
 client consul.Client
 instancer *consul.Instancer
}

func NewConsulClient(consulAddr string) (*Client, error) {
 // 创建 Consul 客户端
 config := api.DefaultConfig()
 config.Address = consulAddr
 
 consulClient, err := api.NewClient(config)
 if err != nil {
 return nil, err
 }
 
 // 创建服务注册实例化工具
 client, err := consul.NewClient(consulClient)
 if err != nil {
 return nil, err
 }
 
 return &Client{client: client}, nil
}

// 注册服务
func (c *Client) Register(serviceName, serviceID string, addr string, port int) error {
 // 健康检查
 check := api.AgentServiceCheck{
 HTTP: fmt.Sprintf("http://%s:%d/health", addr, port),
 Interval: "10s",
 Timeout: "5s",
 Notes: "Health check for " + serviceName,
 }
 
 // 服务注册信息
 registration := api.AgentServiceRegistration{
 ID: serviceID,
 Name: serviceName,
 Tags: []string{"v1"},
 Address: addr,
 Port: port,
 EnableTagOverride: false,
 Check: &check,
 }
 
 return c.client.Register(&registration)
}

// 注销服务
func (c *Client) Deregister(serviceName, serviceID string) error {
 return c.client.Deregister(&api.AgentServiceRegistration{
 ID: serviceID,
 Name: serviceName,
 })
}

// 创建服务实例化工具
func (c *Client) GetInstancer(serviceName string) sd.Instancer {
 return consul.NewInstancer(c.client, nil, serviceName, []string{}, true)
}

// 工厂函数创建 endpoint
func instanceFactory(serviceURL string) endpoint.Endpoint {
 return func(ctx context.Context, request interface{}) (interface{}, error) {
 // 调用远程服务
 return nil, nil
 }
}

// 创建端点订阅器
func (c *Client) GetEndpointer(serviceName string) sd.Endpointer {
 instancer := c.GetInstancer(serviceName)
 return lazy.NewEndpointer(instancer, instanceFactory, nil)
}

服务端实现

// user/server.go（演示：注册到 Consul + 提供 /health）
package main

import (
 "context"
 "encoding/json"
 "fmt"
 stdlog "log"
 "net"
 "net/http"
 "os"
 "os/signal"
 "syscall"
 "time"

 kitlog "github.com/go-kit/kit/log"
 "github.com/hashicorp/consul/api"
)

const (
 ServiceName = "user-service"
 ServicePort = 8080
)

type UserService struct{}

func (s *UserService) GetUser(ctx context.Context, id int64) (*User, error) {
 return &User{
 ID: id,
 Name: fmt.Sprintf("User-%d", id),
 Age: 20 + int(id%30),
 }, nil
}

type User struct {
 ID int64 `json:"id"`
 Name string `json:"name"`
 Age int `json:"age"`
}

func pickAdvertiseIP() string {
 addrs, err := net.InterfaceAddrs()
 if err != nil {
 return "127.0.0.1"
 }
 for _, a := range addrs {
 ipnet, ok := a.(*net.IPNet)
 if !ok || ipnet.IP.IsLoopback() {
 continue
 }
 if v4 := ipnet.IP.To4(); v4 != nil {
 return v4.String()
 }
 }
 return "127.0.0.1"
}

func main() {
 logger := kitlog.NewLogfmtLogger(os.Stderr)
 logger = kitlog.With(logger, "ts", kitlog.DefaultTimestampUTC)

 cfg := api.DefaultConfig()
 cfg.Address = "127.0.0.1:8500"

 client, err := api.NewClient(cfg)
 if err != nil {
 stdlog.Fatalf("consul client: %v", err)
 }

 addr := pickAdvertiseIP()
 serviceID := fmt.Sprintf("%s-%d", ServiceName, ServicePort)

 reg := &api.AgentServiceRegistration{
 ID: serviceID,
 Name: ServiceName,
 Address: addr,
 Port: ServicePort,
 Check: &api.AgentServiceCheck{
 HTTP: fmt.Sprintf("http://%s:%d/health", addr, ServicePort),
 Interval: "10s",
 },
 }

 if err := client.Agent().ServiceRegister(reg); err != nil {
 stdlog.Fatalf("register: %v", err)
 }

 svc := &UserService{}
 mux := http.NewServeMux()
 mux.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
 w.WriteHeader(http.StatusOK)
 _, _ = w.Write([]byte("ok"))
 })
 mux.HandleFunc("/user/", func(w http.ResponseWriter, r *http.Request) {
 u, err := svc.GetUser(r.Context(), 1)
 if err != nil {
 http.Error(w, err.Error(), http.StatusInternalServerError)
 return
 }
 w.Header().Set("Content-Type", "application/json")
 _ = json.NewEncoder(w).Encode(u)
 })

 srv := &http.Server{
 Addr: fmt.Sprintf(":%d", ServicePort),
 Handler: mux,
 }

 go func() {
 _ = logger.Log("msg", "listening", "port", ServicePort)
 if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
 stdlog.Fatal(err)
 }
 }()

 quit := make(chan os.Signal, 1)
 signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
 <-quit

 ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 defer cancel()
 _ = srv.Shutdown(ctx)
 _ = client.Agent().ServiceDeregister(serviceID)
}

进程退出前注销服务，可避免 Consul 里留下僵尸实例；生产环境还需配置正确的 健康检查 URL、ACL Token 与 多实例 ID。

GRPC一点通

Sat, 17 Jul 2021 00:00:00 +0000

gRPC 是一个高性能、开源和通用的 RPC 框架，面向移动和 HTTP/2 设计。带来双向流、流控、头部压缩、单 TCP 连接上的多复用请求等特性。

什么是 gRPC

┌─────────────────────────────────────────────────────────────┐
│ gRPC 架构 │
├─────────────────────────────────────────────────────────────┤
│ │
│ Client Server │
│ │ │ │
│ │ ─────── HTTP/2 ───────────▶ │ │
│ │ Protobuf 序列化 │ │
│ │ │ │
│ │◀─────── Protobuf ───────────│ │
│ │ │ │
│ │
│ 特性： │
│ • HTTP/2 传输 │
│ • Protobuf 序列化 │
│ • 多语言支持 │
│ • 双向流 │
│ • 强类型定义 │
│ │
└─────────────────────────────────────────────────────────────┘

环境准备

安装 Protobuf 编译器

# macOS
brew install protobuf

# Linux
apt install protobuf-compiler

# Windows
# 下载 https://github.com/protocolbuffers/protobuf/releases

安装 Go 工具

# gRPC 核心库
go get -u google.golang.org/grpc

# Protobuf 插件
go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest

# gRPC Gateway（HTTP 转 gRPC）
go install github.com/grpc-ecosystem/grpc-gateway/v2/cmd/protoc-gen-grpc-gateway@latest

# 添加到 PATH
export PATH="$PATH:$(go env GOPATH)/bin"

定义服务

创建项目

mkdir grpc-demo && cd grpc-demo
go mod init grpc-demo
mkdir helloworld

编写 Proto 文件

// helloworld/simple.proto
syntax = "proto3";

option go_package = "grpc-demo/helloworld";

package helloworld;

// Greeting 服务定义
service Greeter {
 // 简单 RPC
 rpc SayHello (HelloRequest) returns (HelloReply) {}
 
 // 服务端流式 RPC
 rpc SayHelloServerStream (HelloRequest) returns (stream HelloReply) {}
 
 // 客户端流式 RPC
 rpc SayHelloClientStream (stream HelloRequest) returns (HelloReply) {}
 
 // 双向流式 RPC
 rpc SayHelloBidirectionalStream (stream HelloRequest) returns (stream HelloReply) {}
}

// 请求消息
message HelloRequest {
 string name = 1;
 int32 age = 2;
}

// 响应消息
message HelloReply {
 string message = 1;
 string timestamp = 2;
}

生成 Go 代码

# 生成 gRPC 代码
protoc --go_out=. --go_opt=paths=source_relative \n --go-grpc_out=. --go-grpc_opt=paths=source_relative \n helloworld/simple.proto

# 查看生成的文件
ls -la helloworld/
# simple.pb.go - Protobuf 消息定义
# simple_grpc.pb.go - gRPC 服务定义

实现 gRPC 服务

// helloworld/server.go
package main

import (
 "context"
 "fmt"
 "log"
 "net"
 
 "google.golang.org/grpc"
 pb "grpc-demo/helloworld"
)

type server struct {
 pb.UnimplementedGreeterServer
}

// 简单 RPC 实现
func (s *server) SayHello(ctx context.Context, req *pb.HelloRequest) (*pb.HelloReply, error) {
 return &pb.HelloReply{
 Message: fmt.Sprintf("Hello, %s! You are %d years old.", req.Name, req.Age),
 Timestamp: fmt.Sprintf("%d", time.Now().Unix()),
 }, nil
}

// 服务端流式 RPC 实现
func (s *server) SayHelloServerStream(req *pb.HelloRequest, stream pb.Greeter_SayHelloServerStreamServer) error {
 for i := 0; i < 5; i++ {
 msg := fmt.Sprintf("Hello %s (stream %d)", req.Name, i+1)
 if err := stream.Send(&pb.HelloReply{Message: msg}); err != nil {
 return err
 }
 time.Sleep(500 * time.Millisecond)
 }
 return nil
}

// 客户端流式 RPC 实现
func (s *server) SayHelloClientStream(stream pb.Greeter_SayHelloClientStreamServer) error {
 var names []string
 for {
 req, err := stream.Recv()
 if err == io.EOF {
 return stream.SendAndClose(&pb.HelloReply{
 Message: fmt.Sprintf("Hello %v!", names),
 })
 }
 if err != nil {
 return err
 }
 names = append(names, req.Name)
 }
}

// 双向流式 RPC 实现
func (s *server) SayHelloBidirectionalStream(stream pb.Greeter_SayHelloBidirectionalStreamServer) error {
 for {
 req, err := stream.Recv()
 if err == io.EOF {
 return nil
 }
 if err != nil {
 return err
 }
 
 msg := fmt.Sprintf("Hello %s!", req.Name)
 if err := stream.Send(&pb.HelloReply{Message: msg}); err != nil {
 return err
 }
 }
}

func main() {
 lis, err := net.Listen("tcp", ":50051")
 if err != nil {
 log.Fatalf("failed to listen: %v", err)
 }
 
 s := grpc.NewServer()
 pb.RegisterGreeterServer(s, &server{})
 
 log.Println("gRPC server started on :50051")
 if err := s.Serve(lis); err != nil {
 log.Fatalf("failed to serve: %v", err)
 }
}

实现 gRPC 客户端

// helloworld/client.go
package main

import (
 "context"
 "fmt"
 "log"
 "time"
 
 "google.golang.org/grpc"
 "google.golang.org/grpc/credentials/insecure"
 pb "grpc-demo/helloworld"
)

func main() {
 // 连接 gRPC 服务器
 conn, err := grpc.Dial(":50051", grpc.WithTransportCredentials(insecure.NewCredentials()))
 if err != nil {
 log.Fatalf("did not connect: %v", err)
 }
 defer conn.Close()
 
 client := pb.NewGreeterClient(conn)
 
 // 调用简单 RPC
 ctx, cancel := context.WithTimeout(context.Background(), time.Second)
 defer cancel()
 
 r, err := client.SayHello(ctx, &pb.HelloRequest{Name: "World", Age: 25})
 if err != nil {
 log.Fatalf("could not greet: %v", err)
 }
 log.Printf("Greeting: %s", r.GetMessage())
}

添加 HTTP Gateway

安装依赖

go get google.golang.org/grpc/proto

Gateway 服务

// gateway/main.go
package main

import (
 "context"
 "fmt"
 "net/http"
 
 "github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
 "google.golang.org/grpc"
 "google.golang.org/grpc/credentials/insecure"
 pb "grpc-demo/helloworld"
)

func main() {
 ctx := context.Background()
 ctx, cancel := context.WithCancel(ctx)
 defer cancel()
 
 mux := runtime.NewServeMux()
 opts := []grpc.DialOption{
 grpc.WithTransportCredentials(insecure.NewCredentials()),
 }
 
 err := pb.RegisterGreeterHandlerFromEndpoint(ctx, mux, ":50051", opts)
 if err != nil {
 log.Fatalf("failed to register gateway: %v", err)
 }
 
 http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 mux.ServeHTTP(w, r)
 })
 
 log.Println("HTTP Gateway started on :8080")
 http.ListenAndServe(":8080", nil)
}

启动服务

# 终端 1: 启动 gRPC 服务
go run helloworld/server.go

# 终端 2: 启动 HTTP Gateway
go run gateway/main.go

# 测试 HTTP 接口
curl -X POST http://localhost:8080/helloworld.Greeter/SayHello \n -H "Content-Type: application/json" \n -d '{"name": "World", "age": 25}'

四种 RPC 模式

模式	说明
Unary（一元）	客户端发起一次请求，服务端返回一次响应；最常见，类似普通 HTTP JSON。
Server streaming（服务端流）	客户端一次请求，服务端以流多次推送数据；适合大列表、订阅通知。
Client streaming（客户端流）	客户端多次写入流，服务端最终一次汇总响应；适合批量上传、日志汇总。
Bidirectional streaming（双向流）	两端可同时读写流；适合聊天、协作编辑、实时推送等对「管道」建模的场景。

选型上：能用 Unary 就不用流式；若业务本身是「按需拉取一块块数据」，优先考虑 Server streaming；必须在单连接上交织多条请求/响应时（如 HTTP/2 多路复用语义），再结合双向流评估。

小结

掌握四种模式后，阅读 .proto 里的 rpc 定义会更直观：stream 关键字出现在请求侧、响应侧或两侧，分别对应上述三种流式形态。