Golang on Leon的小屋

Go微服务网关开发（3）：负载均衡功能的实现

Tue, 14 Oct 2025 00:00:00 +0000

Go微服务网关开发（3）：负载均衡功能的实现

本章在Day1路由转发的基础上，实现了负载均衡功能，支持轮询算法分发请求到多个后端服务

完整项目地址(已开发80%的功能)

30天开发地址(将项目分为30天开发，附详细技术文档与代码解析)

欢迎star✨

什么是负载均衡功能

负载均衡功能是指一个服务有多个实例，当有请求过来时，网关会根据负载均衡算法（如轮询）将请求分发到不同的实例上，以实现负载均衡和高可用性。

负载均衡功能示意图

与路由转发的区别：路由转发是将请求匹配到相应的服务，而负载均衡则是将请求分发到同一服务的不同实例上。（可避免一个服务实例过载或者故障导致整个服务不可用）

实现第一步：理解Day2的架构变化

Day2在Day1的基础上新增了以下模块

负载均衡器接口和实现
后端服务管理模块
多目标路由配置支持

之所以负载均衡器采用接口的方式而非直接实现，是为了解耦和可扩展性**，既未来可以方便地替换其他负载均衡算法。**

Day2的文件结构变化

在internal/core添加了loadbalancer

backend.go：定义后端服务管理模块
loadbalancer.go：定义负载均衡器接口和轮询实现
round_robin.go：实现轮询负载均衡算法

实现第二步：实现负载均衡功能

1.负载均衡器主要功能就是选择一个后端服务实例来处理请求，因此首先定义后端服务管理模块（backend.go），用于存储和管理后端服务实例。

定义结构体，包括后端服务实例的ID、URL、状态（是否存活）和互斥锁（用于处理并发）。

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



type Backend struct {

 ID string

 URL *url.URL

 mu sync.Mutex

 Alive bool

}

定义两个方法，一个用于设置后端服务实例的存活状态，另一个用于获取后端服务实例的存活状态。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22



func (b *Backend) SetAlive(alive bool) {

 b.mu.Lock()

 defer b.mu.Unlock()

 b.Alive = alive

}



func (b *Backend) IsAlive() bool {

 b.mu.Lock()

 defer b.mu.Unlock()

 return b.Alive

}

2.定义负载均衡器接口（loadbalancer.go），包括添加后端服务实例、删除后端服务实例、选择后端服务实例等方法。

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



type LoadBalancer interface {

 GetNextTarget() *Backend // 获取下一个目标后端服务实例

 AddBackend(backend *Backend) // 添加后端服务实例

 RemoveBackend(backend *Backend) // 删除后端服务实例

 GetBackends() []*Backend // 获取所有后端服务实例

}

3.开始实现轮询负载均衡算法（round_robin.go），即按顺序选择下一个活着的后端服务实例。

定义结构体，主要包括后端服务实例列表、当前选择的后端索引（打上标记便于选择下一个）和互斥锁（用于处理并发）。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10



type RoundRobinLoadBalancer struct {

 backends []*Backend

 current int

 mutex sync.Mutex

}

开始实现具体的方法

实现构造函数，用于创建一个新的轮询负载均衡器实例。
实现获取下一个目标后端服务实例的方法，按顺序选择下一个活着的后端服务实例。
实现添加后端服务实例的方法，将新的后端服务实例添加到列表中。
实现删除后端服务实例的方法，将指定的后端服务实例从列表中移除。
实现获取所有后端服务实例的方法，返回当前所有后端服务实例的列表。

 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
75
76
77
78
79
80
81
82
83
84
85
86
87
88



func NewRoundRobinLoadBalancer() *RoundRobinLoadBalancer {

 return &RoundRobinLoadBalancer{

 backends: make([]*Backend, 0),

 current: -1,

 }

}



// 跳转到下一个可用的后端

func (r *RoundRobinLoadBalancer) GetNextTarget() *Backend {

 r.mutex.Lock()

 defer r.mutex.Unlock()



 if len(r.backends) == 0 {

 return nil

 }

 r.current = (r.current + 1) % len(r.backends)

 for !r.backends[r.current].IsAlive() {

 r.current = (r.current + 1) % len(r.backends)

 }

 return r.backends[r.current]

}

// 添加后端服务实例

func (r *RoundRobinLoadBalancer) AddBackend(backend *Backend) {

 r.mutex.Lock()

 defer r.mutex.Unlock()

 r.backends = append(r.backends, backend)

}

// 删除后端服务实例

func (r *RoundRobinLoadBalancer) RemoveBackend(backend *Backend) {

 r.mutex.Lock()

 defer r.mutex.Unlock()

 for i, b := range r.backends {

 if b.ID == backend.ID {

 r.backends = append(r.backends[:i], r.backends[i+1:]...)

 return

 }

 }

}

// 获取所有后端服务实例

func (r *RoundRobinLoadBalancer) GetBackends() []*Backend {

 r.mutex.Lock()

 defer r.mutex.Unlock()

 return r.backends

}

实现第三步，修改其他部分使整个项目可以运行

修改路由模块（route.go），添加负载均衡器字段，用于选择后端服务实例。

 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



routes:

 # 路由service-a

 - id: service-a

 path: /service-a

 targets:

 - http://localhost:8081

 - http://localhost:8082

 # 路由service-b

 - id: service-b

 path: /service-b

 targets:

 - http://localhost:8083

 - http://localhost:8084

对比Day1,可以看到仅仅是每个服务从一个target变成了多个target，这是为了支持负载均衡功能。

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



routes:

 # 路由service-a

 - id: service-a

 path: /service-a

 target: http://localhost:8081



 # 路由service-b

 - id: service-b

 path: /service-b

 target: http://localhost:8082

修改config.go,使其正确映射（修改Route结构体即可）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10



type Route struct {

 ID string `yaml:"id"`

 Path string `yaml:"path"`

 Targets []string `yaml:"targets"`

}

3.修改proxy.go,添加负载均衡器字段，用于选择后端服务实例。

首先在结构体里面添加一个字段，用于存储每个服务的负载均衡器实例。

1
2
3
4
5
6



type Proxy struct {

 loadbalancers map[string]loadbalancer.LoadBalancer

}

实现构造函数，用于创建一个新的代理实例（初始化负载混衡器并将所有后端服务实例添加到负载混衡器中）。

 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



func NewProxy(backends []*config.Route) *Proxy {

 loadbalancers := make(map[string]loadbalancer.LoadBalancer)

 for _, backend := range backends {

 lb := loadbalancer.NewRoundRobinLoadBalancer()

 for _, target := range backend.Targets {

 backendURL, _ := url.Parse(target)

 lb.AddBackend(&loadbalancer.Backend{

 ID: backend.ID,

 URL: backendURL,

 Alive: true,

 })

 }

 loadbalancers[backend.ID] = lb

 }

 return &Proxy{

 loadbalancers: loadbalancers,

 }

}

修改ServeHTTP方法，使用负载均衡器选择后端服务实例。

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



 //修改点

 backend := p.loadbalancers[route.ID].GetNextTarget()

 if backend == nil {

 http.Error(w, "无可用后端服务", http.StatusServiceUnavailable)

 return

 }

 // 创建反向代理

 proxy := httputil.NewSingleHostReverseProxy(backend.URL)

 //后面一样

此时应该已经可以正确运行，若有报错大家自行修改，应该只是些类似于传参的低级错误，因为文章不便讲解每个修改的部分，但已将重要的修改点都标注出来了，其中一些低级的错误大家可以自己修改，若实在有问题也可以参考完整项目（已完成测试）或者联系作者。

最后一步测试网关

首先启动8081,8082,8083,8084端口的服务端，然后启动网关（8080），最后使用curl或postman测试网关是否正常工作。(注意：大家先勿过度测试，确保负载均衡功能可以正常运行即可，还有很多问题接下来会一一解决。)

启动8081,8082,8083,8084端口的服务端的命令

1
2
3
4
5
6
7
8



python3 -m http.server 8081

python3 -m http.server 8082

python3 -m http.server 8083

python3 -m http.server 8084

启动网关开始测试

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22



# 启动网关

cd /home/leon/GoCode/30daysGateway/day2

go run cmd/main.go



# 在另一个终端测试路由转发

curl http://localhost:8080/service-a

curl http://localhost:8080/service-a

curl http://localhost:8080/service-a

curl http://localhost:8080/service-b

curl http://localhost:8080/service-b

curl http://localhost:8080/service-b

可见第一次访问http://localhost:8080/service-a，返回了8081端口的响应，第二次访问返回了8082端口的响应，第三次访问返回了8081端口的响应，说明负载均衡功能正常工作。service-b也同理。

本章结束。

Go微服务网关（2）：路由转发功能的实现

Fri, 10 Oct 2025 00:00:00 +0000

Go微服务网关开发（2）：路由转发功能的实现

本章实现了API网关的路由转发功能

完整项目地址(已开发80%的功能)

30天开发地址(将项目分为30天开发，附详细技术文档与代码解析)

欢迎star✨

什么是路由转发功能

路由转发功能是指API网关将客户端请求转发到后端服务的功能。

直观理解就是访问API网关端口（8080），会将请求转发到后端服务端口（8081、8082）等。

路由转发功能示例图

实现第一步：搭好文件结构

首先，我们需要知道网关分为以下模块

配置文件
解析配置文件模块
网关核心模块
- 反向代理模块
- 路由模块
服务器模块

其次，我们需要了解Go的常见架构

├── cmd

├── internal

└── pkg

cmd：负责网关的入口

internal：负责网关的内部模块，不暴露给外部使用

pkg：负责暴露给外部使用的模块

最后，我们结合上面的模块与Go的常见架构，搭好文件结构

├── cmd

│ 　└── main.go //网关的入口

├── configs

│ 　└── config.yaml //网关的配置文件

├── internal

│ 　├── config

│ 　│ 　└── config.go //解析配置文件模块

│ 　└── core //核心模块

│ 　　　├── gateway.go //网关核心模块

│ 　　　├── proxy.go //反向代理模块

│ 　　　├── route.go //路由模块

│ 　　　└── server.go //服务器模块

├── go.mod

├── go.sum

└── 文档

实现第二步：理解程序运行过程

首先，先加载配置文件（config.yaml）并保存（这里命名为cfg）
根据cfg配置网关核心模块（这里命名为gw）
根据cfg和gw配置服务器（这里命名为srv）
启动服务器
运行服务
优雅关闭服务器

流程图

实现第三步：开始用代码实现

首先，我们需要写好配置文件（config.yaml）

思路为声明客户端端口并声明路由转发规则并配置要转发的路由路径与目标服务端口（本项目采用yaml文件配置，如果第一次接触可以花十分钟先去了解一下）

 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



# 配置文件



server:

 port: 8080 # 网关客户端的端口



# 路由配置

routes:

 # 路由service-a

 - id: service-a # 路由service-a的ID

 path: /service-a # 路由service-a的路径

 target: http://localhost:8081 # 路由service-a的目标服务端口



 # 路由service-b

 - id: service-b

 path: /service-b

 target: http://localhost:8082



# 通过上述配置，我们可以实现以下路由转发功能

# 当访问http://localhost:8080/service-a时，会将请求转发到http://localhost:8081/service-a

# 当访问http://localhost:8080/service-b时，会将请求转发到http://localhost:8082/service-b

其次，我们需要写解析配置文件模块（config.go）来解析配置文件（config.yaml）

思路为定义结构体并利用yaml标签映射配置文件中的字段，然后写LoadConfig函数根据传入的配置文件地址参数来解析配置文件（解析方法采用yaml.v3库）

定义结构体并利用yaml标签映射配置文件中的字段

 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



type Config struct {

    Server Server   `yaml:"server"`

    Routes []*Route `yaml:"routes"`

}



type Server struct {

    Port string `yaml:"port"`

}



type Route struct {

    ID     string `yaml:"id"`

    Path   string `yaml:"path"`

    Target string `yaml:"target"`

}

LoadConfig函数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22



func LoadConfig(config string) (*Config, error) {

    var cfg Config

    data, err := os.ReadFile(config)

    if err != nil {

        return nil, err

    }

    if err := yaml.Unmarshal(data, &cfg); err != nil {

        return nil, err

    }

    return &cfg, nil

}

3.然后，我们需要写网关核心模块（gateway.go）、反向代理模块（proxy.go）和路由模块（route.go）

我们需要知道反向代理模块和路由模块的都是网关的核心功能，但为了代码的可维护性，我们将它们分别写在不同的文件中，通过依赖注入的方式将它们注入到网关核心模块中。

先写route.go

只需要定义Route结构体，其中routes为所有所要转发的路由，并写一个NewRoute函数用于创建结构体，再写一个FindRoute用于查找匹配路由（可采用字典树查询方式，本项目先采用遍历的方式。）

定义结构体并写出NewRoute函数

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



type Router struct {

    routes []*config.Route

}



func NewRouter(routes []*config.Route) *Router {

    return &Router{

        routes: routes,

    }

}

FindRoute函数

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



func (r *Router) FindRoute(path string) *config.Route {

    // 遍历查找匹配的路由

    for _, route := range r.routes {

        // 检查路径是否匹配

        if strings.HasPrefix(path, route.Path) {

            return route

        }

    }

    return nil

}

再写proxy.go

定义结构体并写出NewProxy函数(目前未额外添加其他功能，只是将结构分离便于拓展)，并实现ServeHTTP方法使其成为一个Handler。

定义结构体并写出NewProxy函数

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



type Proxy struct {

}



func NewProxy() *Proxy {

    return &Proxy{}

}

实现反向代理的核心功能 - ServeHTTP方法（核心）

ServeHTTP是Go语言中http.Handler接口的核心方法，它是HTTP请求处理的入口点，实现了ServeHTTP方法就相当于把对象变成了Handler。

 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



func (p *Proxy) ServeHTTP(w http.ResponseWriter, r *http.Request, route *config.Route) {

    // 解析目标服务URL

    targetURL, err := url.Parse(route.Target)

    if err != nil {

        http.Error(w, "无效的目标服务地址", http.StatusInternalServerError)

        return

    }



    // 创建反向代理

    proxy := httputil.NewSingleHostReverseProxy(targetURL)



    // 保存原始路径用于日志记录

    originalPath := r.URL.Path



    // 设置反向代理的Director

    proxy.Director = func(req *http.Request) {

        // 设置目标服务的协议和主机

        req.URL.Scheme = targetURL.Scheme

        req.URL.Host = targetURL.Host

        // 处理路径映射

        req.URL.Path = targetURL.Path + strings.TrimPrefix(req.URL.Path, route.Path)

    }



    // 记录转发日志

    log.Printf("转发请求: %s %s -> %s://%s%s", r.Method, originalPath, targetURL.Scheme, targetURL.Host, r.URL.Path)



    // 转发请求

    proxy.ServeHTTP(w, r)

}

最后，我们需要将反向代理模块和路由模块注入到网关核心模块中。

定义Gateway结构体并注入反向代理模块和路由模块，并写出NewGateway函数，同时实现ServeHTTP方法使其成为一个Handler。

定义结构体并注入反向代理模块和路由模块

 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



type Gateway struct {

    config *config.Config

    router *Router

    proxy  *Proxy

}



func NewGateway(config *config.Config) *Gateway {

    return &Gateway{

        config: config,

        router: NewRouter(config.Routes),

        proxy:  NewProxy(),

    }

}

实现网关核心功能 - ServeHTTP方法（核心）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22



func (g *Gateway) ServeHTTP(w http.ResponseWriter, r *http.Request) {

    // 查找匹配的路由

    route := g.router.FindRoute(r.URL.Path)

    if route == nil {

        http.Error(w, "路由未找到", http.StatusNotFound)

        return

    }



    // 转发请求

    g.proxy.ServeHTTP(w, r, route)

}

4.上述实现完成后我们开始写服务器

写服务器的思路很直接，就是定义一个Server结构体（其中封装了一个http.Server）并给出NewServer函数用于创建结构体，同时定义一个Start方法用于启动服务器。

定义结构体并写出NewServer函数

 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



type Server struct {

    httpServer *http.Server

}



func NewServer(addr string, handler http.Handler) (*Server, error) {

    srv := &http.Server{

        Addr:    addr,

        Handler: handler,

    }

    return &Server{

        httpServer: srv,

    }, nil

}

实现启动服务器的Start方法（重点在于优雅关闭）

服务器启动时，我们需要在一个goroutine中启动服务器以便能监听中断信号，同时在主goroutine中等待中断信号，收到信号后我们需要优雅关闭服务器（优雅关闭确保服务器立即停止接收新连接请求，但会等待所有已建立的连接和正在处理的请求正常完成，避免用户请求被强制中断和数据丢失，同时设置30秒超时保护机制，超时后强制关闭以保证系统资源能够及时释放）。

 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



func (s *Server) Start() error {

    // 在goroutine中启动服务器以便能监听中断信号

    go func() {

        if err := s.httpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {

            log.Fatalf("服务器启动失败: %v", err)

        }

    }()



    log.Printf("服务器正在监听地址 %s", s.httpServer.Addr)



    // 等待中断信号

    quit := make(chan os.Signal, 1)

    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)

    <-quit



    log.Println("正在关闭服务器...")



    // 优雅关闭

    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)

    defer cancel()



    if err := s.httpServer.Shutdown(ctx); err != nil {

        log.Fatal("服务器关闭错误:", err)

    }



    log.Println("服务器已关闭")

    return nil

}

5.最后，我们在main函数中创建网关、路由模块、反向代理模块、服务器模块，并启动服务器即可。

顺序为：加载配置 -> 创建网关 -> 创建服务器 -> 启动服务器

 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
75
76
77
78



package main



import (

    "gateway/internal/config"

    "gateway/internal/core"

    "log"

)



func main() {

    // 加载配置

    log.Println("开始加载配置")

    cfg, err := config.LoadConfig("configs/config.yaml")

    if err != nil {

        log.Fatal("加载配置失败:", err)

    }

    log.Println("加载配置成功")



    // 创建网关

    log.Println("开始创建网关")

    gw := core.NewGateway(cfg)

    log.Println("网关创建成功")



    // 创建服务器

    log.Println("开始创建服务器")

    // 修复：确保端口地址格式正确

    addr := ":" + cfg.Server.Port

    srv, err := core.NewServer(addr, gw)

    if err != nil {

        log.Fatal("创建服务器失败:", err)

    }

    log.Println("服务器创建成功")



    // 启动服务器

    log.Printf("服务器正在监听端口 %s", cfg.Server.Port)

    if err := srv.Start(); err != nil {

        log.Fatal("服务器启动失败:", err)

    }

    log.Println("服务器已启动")

}

最后一步测试网关

首先启动8081和8082端口的服务端，然后启动网关（8080），最后使用curl或postman测试网关是否正常工作。

启动8081和8082端口的命令

1
2
3
4



python3 -m http.server 8081

python3 -m http.server 8082

启动网关开始测试

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



# 启动网关

cd /home/leon/GoCode/30daysGateway/day1

go run cmd/main.go



# 在另一个终端测试路由转发

curl http://localhost:8080/service-a

curl http://localhost:8080/service-b

可见输入访问http://localhost:8080/service-a，返回了8081端口的响应，访问http://localhost:8080/service-b也返回了8082端口的响应，说明网关正常工作。

本章结束。

Go微服务网关(1): 基本概念介绍

Wed, 01 Oct 2025 00:00:00 +0000

Go微服务网关开发（1）

本章内容主要介绍了微服务网关是什么，以及微服务网关的核心功能。

完整项目地址(已开发80%的功能)

30天开发地址(将项目分为30天开发，附详细技术文档与代码解析)

欢迎star✨

什么是微服务？它有什么优势？

微服务架构介绍

官方表述：“微服务是一种架构风格，将复杂应用程序分解为一组小的、松耦合的服务，每个服务专注于单一业务功能，围绕业务能力构建，可独立部署扩展。”

通俗易懂解释：小诊所是一个整体，属于单体架构，而大型医院则将不同功能的服务分到不同科室，属于微服务架构。

单体架构图



微服务架构图



微服务的优势

官方表述：微服务适合高并发、复杂业务、多团队协作的场景，通过解耦带来极致的灵活性和扩展性，但需配套完善的DevOps体系支撑其运维复杂度。

通俗易懂解释：小诊所医生请假诊所关门便暂停服务，而医院的一个医生请假医院依旧正常运转，且小诊所医生需要掌握各种常发病的治疗方法，而医院的各个医生只需要负责对于的病症，效率更高，服务更好。

什么是微服务网关？为什么要有微服务网关？

微服务网关介绍

官方表述：微服务网关（Microservice Gateway） 是部署在微服务架构边缘的服务入口层，负责接收所有外部请求，并将其智能路由到后端对应的微服务实例。它作为服务边界的统一管控点，提供路由转发、负载均衡、安全认证、流量控制、协议转换等核心能力，是微服务架构中不可或缺的流量协调中心。

通俗易懂的解释：把一个大型项目想象成一个一所医院，医院有许多科室，每个科室都有不同的功能（微服务），而网关就是医院的前台，若没了前台，你便很难快速地找到相应的科室，且你每到一个科室都要登记，还有很大可能该科室已经有挂满号，让你空跑一趟，效率极低，而前台（网关）的出现便帮我们解决了这些痛点，护士会根据你的症状为你指引正确的科室（路由转发 ），在前台登记后你便不用再重复登记（安全认证），在挂号时尽可能将病人分配到同一功能的不同科室以防止某个科室人数过多（负载均衡），若所有科室号都已挂满便会不再挂该科室的号（流量控制），同时前台可以监控各科室的情况（日志/监控），同时前台也在负责协调各个科室之间的通信（协议转换）。

微服务网关必要性

必要性：若无微服务网关，则整个微服务项目因耦合度过低，各个模块相互独立，客户端请求一个服务需要访问多个模块，且各个模块功能交互较为混乱，微服务的优势变成了劣势。

微服务网关的核心功能

这里我们先提供一个架构图



1.统一入口（API聚合）

作用：所有客户端请求通过网关统一访问，避免直接暴露微服务细节。
场景：客户端（如前端/移动端）只需与网关交互，无需知道内部服务地址（如 /api/users → 路由到用户服务）。
实现：通过路由规则将请求分发到对应微服务。

通俗易懂理解：去医院挂号不用去各个科室挂号，前台挂号即可。

2.路由转发

作用：根据请求规则将流量精准分发到后端微服务。
核心能力：
- 路径匹配：如 /orders/* → 订单服务。
- 权重路由：按比例分配流量（如80%新版本，20%旧版本）。
- 动态路由：基于服务注册中心动态更新路由表。

通俗易懂理解：去医院看病，前台会指引你去正确的科室。

3. 安全认证

认证（Authentication）：验证请求合法性（如 JWT、OAuth2.0、API Key）。
授权（Authorization）：检查用户权限（如 VIP用户才能访问特定接口）。
限流（Rate Limiting）：防止恶意请求或流量激增（如每秒100次/用户）。
HTTPS/TLS终止：解密请求流量，减轻微服务安全负担。

通俗易懂理解：看病无需去各个科室登记身份，前台登记即可

4. 流量控制

负载均衡：在多个服务实例间均匀分配请求（轮询/最少活跃/哈希）。
熔断（Circuit Breaker）：服务故障时快速失败，避免级联崩溃（如 Hystrix/Sentinel）。
超时控制：设置请求超时，防止资源阻塞。
重试机制：对瞬态错误自动重试（如 502/503 错误）。

通俗易懂理解：若科室号已挂满，前台便停止该科室挂号服务直至该科室有空闲。

5. 协议转换

适配不同协议：将 HTTP/HTTPS 转为 WebSocket/gRPC 或其他协议。
请求/响应处理：
- 映射请求路径（如 /api/v1/ → 简化为 /）。
- 数据格式转换（如 XML → JSON）。
- 请求头修改（如添加 tracing ID）。

通俗易懂理解：不同科室之间通过前台通信，前台负责将A科室的请求转换后发送到B科室。

6. 日志监控

日志记录：统一记录请求/响应日志（含时间、路径、状态码）。
监控指标：收集延迟、QPS、错误率等数据（ Prometheus 格式）。
链路追踪：注入 trace ID（如 Zipkin/Jaeger）。

通俗易懂理解：前台可以监视各个科室发生的事件并记录。

微服务架构未来发展

目前市面上各个大厂（如阿里、字节、腾讯等）都在使用微服务架构，即使是一些老项目也在用微服务重构。

企业	核心场景	微服务价值体现
阿里云	双11大促（百万级TPS）	弹性扩容（秒级扩容1000+服务器）、故障隔离（订单宕机不影响商品浏览）
字节跳动	全球化短视频（抖音/TikTok）	跨地域部署（不同区域独立服务实例）、多语言能力（Go/Java/Rust按需求选择）
腾讯	微信生态（10亿用户+）	服务自治（支付/消息/登录独立容灾）、灰度发布（A/B测试新功能）
美团	O2O全链路（交易到配送）	复杂业务解耦（骑手调度/优惠券/商户服务独立迭代）

同时各个大厂也自研了微服务网关

企业	网关方案	技术栈	应用场景
阿里云	MSE微服务引擎	自研+Envoy+Dubbo	企业级多云混合云
字节跳动	自研高性能网关	Go+Rust+DPDK	全球化高并发
腾讯	API网关（TSF集成）	Spring Cloud+Envoy	金融级高可用
百度	智能网关Baidu Cloud Mesh（BCM）	Istio+Kubernetes	AI+大数据服务网关

微服务网关与云结合



未来已来：当网关能力完全云服务化后，企业将不再关心“网关在哪里”，只需定义“我要什么功能”——这正是云计算终极目标的体现。建议企业优先采用云厂商全托管网关服务，将精力聚焦在业务创新而非基础设施运维。

综上可见，未来微服务将是软件行业发展趋势，微服务网关与云的结合将会产生新一轮的变革。

Golang on Leon的小屋

Go微服务网关开发（3）：负载均衡功能的实现

Go微服务网关开发（3）：负载均衡功能的实现

什么是负载均衡功能

实现第一步：理解Day2的架构变化

实现第二步：实现负载均衡功能

实现第三步，修改其他部分使整个项目可以运行

最后一步 测试网关

Go微服务网关（2）：路由转发功能的实现

Go微服务网关开发（2）：路由转发功能的实现

什么是路由转发功能

实现第一步：搭好文件结构

实现第二步：理解程序运行过程

实现第三步：开始用代码实现

最后一步 测试网关

Go微服务网关(1): 基本概念介绍

Go微服务网关开发（1）

什么是微服务？它有什么优势？

微服务架构介绍

微服务的优势

什么是微服务网关？为什么要有微服务网关？

微服务网关介绍

微服务网关必要性

微服务网关的核心功能

1.统一入口（API聚合）

2.路由转发

3. 安全认证

4. 流量控制

5. 协议转换

6. 日志监控

微服务架构未来发展

最后一步测试网关

最后一步测试网关