Go 应用性能优化的 8 个最佳实践，快速提升资源利用效率！

作者｜Ifedayo Adesiyan

翻译｜Seal 软件

链接｜https://earthly.dev/blog/optimize-golang-for-kubernetes/

优化服务器负载对于确保运行在 Kubernetes 上的 Golang 应用程序的高性能和可扩展性至关重要。随着企业越来越多地采用容器化的方式和 Kubernetes 来部署和管理应用程序，采取减少服务器负载的最佳实践势在必行，进而达到最佳的资源利用效率、成本效益并改善用户体验。 

运行 Golang 应用程序的多个容器可以放在一个 Kubernetes 集群内，并部署在多个节点上。每个容器可以使用 CPU、内存以及存储等系统资源。如果这些资源没有被高效地管理起来，可能会导致服务器负载不断增加，从而降低性能并增加支出。 

因此，针对 Kubernetes 的 Golang 应用优化对于完成有效的资源利用、降低服务器负载以及保证应用在生产环境中顺利运行至关重要。 

在本文中，我们将研究在 Kubernetes 上优化 Golang 应用的最佳方法，重点是降低服务器负载。我们会讨论一些方法，包括用 readiness 和 liveness 探针进行监控，利用弹性伸缩等功能来优化资源利用。 

通过采取这些最佳实践，可以提高在 Kubernetes 上运行的 Golang 应用的性能和可扩展性，这将改善用户体验、节约成本，并提升运维效率。 

本文中所有代码示例可以访问下方网址查看：

https://github.com/theifedayo/earthly.dev/tree/main/01-optimizing-go-k8s 

前期准备

本文需要你对 Go 和 Kubernetes 有中等程度的了解。此外，需要你已经安装 Go、Docker 和 Kubernetes （及其他运行 Kubernetes 的工具，如 kubectl）并且已经在系统内配置完毕。 

你可以通过终端输入以下命令验证是否已经安装 Go：

go version 

如果已经安装，应该返回以下内容：

go version go1.19.3 darwin/amd64 

使用以下命令可以验证 Docker 是否安装：

docker --version 

输出应为（或其他类似的内容）：

Docker version 20.10.22, build 3a2c30b 

验证 Kubernetes 是否安装也是类似的方法。 

理解 Golang 应用程序和 Kubernetes

谷歌开发了 Golang，也称“Go”，其目标是高效、多并发和可扩展。它对创建高性能软件很有效，特别是对需要并发处理的应用，如网络服务器、网络软件和分布式系统。 

容器化应用的部署、扩展和管理都可以由开源容器编排引擎 Kubernetes 自动化。通过抽象化底层基础设施的细节，并促进有效的资源利用率、可扩展性和容错率，它提供了一个灵活和可扩展的框架，用于部署和管理跨节点集群的容器化应用程序。 

Docker 容器 

当 Golang 应用程序被部署到 Kubernetes 上时，它们通常被打包为 Docker 容器。这些独立的、轻量级的环境隔离了程序及其所有的依赖项。这些容器可以通过 Kubernetes 简单地部署和管理，实现有效的资源利用并且能够根据应用程序的要求进行弹性伸缩。 

Dockerfile 到 Kubernetes pod 的生命周期 

运行在 Kubernetes 上的 Golang 应用能够利用几个特性来提升性能、可扩展性以及可靠性。例如，Kubernetes 能够在不同的集群节点上部署同一应用程序的多个实例，以分散负载并提升可用性。Golang 程序的部署、维护和可扩展性也可以通过 Kubernetes 中的负载均衡、服务发现和滚动更新工具来加强。 

为了确保资源效率，防止资源争夺或无节制使用，Golang 应用程序还可以利用 Kubernetes 的内置资源管理功能，包括 CPU 和内存限制、资源配额和资源剖析等。 

此外，Kubernetes 提供了日志和监控能力，以了解 Golang 程序的功能运转和健康状况，高效推动问题解决和 debug。 

并发性、效率、简洁性、社区驱动以及与云原生原则的一致性，使 Golang 成为开发基于 Kubernetes 应用的热门选项，因为它可以让开发者创建高性能、可扩展和有弹性的应用程序，并能在容器化环境中轻松部署和管理。 

总而言之，Golang 和 Kubernetes 的结合可以提供一个高性能、可扩展以及可靠的应用程序构建和部署平台。为 Kubernetes 优化 Golang 应用，需要利用 Kubernetes 提供的功能来实现高效的资源利用、扩展、请求、响应和错误处理，以确保在容器化环境中的最佳性能和可靠性。 

优化 Golang 应用程序的最佳实践

为 Kubernetes 优化 Golang 应用程序包括利用 Kubernetes 的功能，如资源限制、服务发现和监控，以确保在容器化环境中的最佳性能和可靠性，并优化 Go 代码，如使用 Go 垃圾回收和连接池。这种优化有助于确保在 Kubernetes 上运行的 Golang 应用程序能够有效地处理高负载，动态扩展，并为用户提供可靠的服务。 

1、使用最小化和高效的容器基础镜像

容器性能和资源利用可能会受到你为 Golang 应用程序使用的基础镜像的影响。使用专门为运行容器化应用程序而创建的最小的基础镜像是至关重要的。 

最受欢迎的选择之一是 Docker Hub 提供的官方 Golang 基础镜像，它基于官方 Golang 发行版，提供基本的运行环境。你也可以考虑采用更轻量的选择，比如建立在 Alpine 是一个轻量级的 Linux 发行版，通常用于 Docker 镜像，以最小化镜像的大小进而减少攻击面。 

下方是使用官方 Golang 基础镜像的 Docker 代码的例子：

# Use the official Golang base imageFROM golang:1.16
# Set working directoryWORKDIR /app
# Copy and build the Go applicationCOPY . .RUN go build -o myapp
# Run the applicationCMD ["./myapp"]

下面的 Docker 命令使用的是基于 Alpine Linux 的官方 Go 基础镜像的一个特定版本：FROM golang:1.16-alpine 

FROM docker 语句指定了要使用的基础镜像，在本例中是 golang:1.16-alpine。 

2、优化资源分配

对于减少服务器负载和优化性能来说，高效分配资源到 Golang 容器是至关重要的。它对于提高应用性能、避免过度配置和实现可扩展性至关重要。如果资源（如 CPU 和内存）没有被有效分配，某些容器可能没有足够的资源，从而导致性能不佳。 

通过优化资源分配，可以确保所有容器都足够的资源来保证它们顺利运行，这可以提高性能。Kubernetes 提供了为容器设置资源限制和请求的机制，这可以帮助防止资源的过度分配或分配不足。根据你的 Golang 应用程序的资源需求，仔细配置这些设置非常重要。 

我们将创建一个 YAML 文件，为容器设置资源限制和请求，以演示如何优化资源分配：

#.....#   .....      containers:        - name: my-golang-container          image: my-golang-image          resources:            limits:              cpu: 500m              memory: 512Mi            requests:              cpu: 200m              memory: 256Mi

在 YAML 文件中，容器被定义了具体的资源限制和对 CPU 和内存的请求。

• resources 部分定义了 CPU、内存资源限制以及容器请求。

• limits 指定了容器消耗的最大资源量。在本例，限制为 500 milliCPU（0.5 CPU 内核）以及 512MB 内存。

• requests 指定了容器运行所需的最小资源量。在本例，限制为 200 milliCPU（0.2 CPU 内核）以及 256MB 内存。 

在 Kubernetes 中，CPU 资源被分配给容器，以确保每个容器都能获得必要的计算能力。通过设置 CPU 限制和请求，可以防止容器消耗过多的 CPU，导致其他容器没有资源。这种对 CPU 资源的有效分配有助于确保你的应用程序顺利运行，并确保服务器负载保持稳定。 

通过谨慎设置 CPU 和内存限制，容器内运行的应用程序的要求也会影响容器的大小。例如，如果应用需要大量内存来处理数据，可能需要相应地增加内存限制。在部署容器后，需要监控其资源使用并在必要时优化其大小。可以通过使用一些工具实现，如 Kubernetes 的 HPA 以基于资源使用状况来自动调整副本数量。 

设置资源限制和请求的完整 Kubernetes 部署配置如下所示：

apiVersion: apps/v1kind: Deploymentmetadata:  name: my-golang-appspec:  replicas: 3  selector:    matchLabels:      app: my-golang-app  template:    metadata:      labels:        app: my-golang-app    spec:      containers:        - name: my-golang-container          image: my-golang-image          resources:            limits:              cpu: 500m              memory: 512Mi            requests:              cpu: 200m              memory: 256Mi

3、优化垃圾回收

垃圾回收（GC）是 Golang 应用中内存管理的重要方面。Kubernetes 提供了垃圾回收设置的配置选项，如 GOGC 环境变量，它能够控制触发垃圾回收周期的条件。通过优化垃圾回收设置，你可以减少内存使用并优化 Golang 容器的整体性能。 

当在 Kubernetes 集群内运行 Golang app 时，未经优化的 GC 可能导致一些影响服务器性能的问题。最常见的问题是内存泄漏，进而使得 app 去消耗更多内存，从而导致更糟糕的性能和更高的服务器负载。 

以下代码在 Golang 中优化了垃圾回收设置。在代码里，我们需要导入 2 个包：“os”和“fmt”。fmt 包用于格式化输入和输出，“os”包提供一个独立于平台的操作系统功能接口：

package main
import (    "fmt"    "os")

定义 Go 程序的主要功能：func main() { 

我们决定使用 fmt.Println() 函数将 "GOGC "变量的当前值发送到控制台。GOGC 变量是一个控制 Go 中垃圾回收器的设置。

 // Get current GOGC value    gogc := os.Getenv("GOGC")    fmt.Println("Current GOGC value:", gogc);

现在，我们可以将 GOGC 变量值设置为 50。这会更改 Go 垃圾回收的行为，可能会提升程序性能：

   // Set GOGC value to 50    os.Setenv("GOGC", "50")
    // Run your Golang application    // ...}

完整代码如下：

package main
import (    "fmt"    "os")
func main() {    // Get current GOGC value    gogc := os.Getenv("GOGC")    fmt.Println("Current GOGC value:", gogc);
    // Set GOGC value to 50    os.Setenv("GOGC", "50")
    // Run your Golang application    // ...}

通过 os.Setenv("GOGC", "50") ，将 GOGC 设置为 50。GOGC 参数决定了 Go 中触发垃圾回收的 heap 的百分比。较低的值（如 50）意味着垃圾回收机制会被频繁触发，而较高的值（如 100）意味着垃圾回收机制触发次数较少。 

频繁的垃圾回收能够帮助确保程序只使用它所需要的内存，为在同一服务器上运行的其他进程释放资源。监控程序性能和在必要时调整 GOGC 值以平衡内存使用和垃圾回收十分重要。 

4、使用连接池

连接池是一种允许重复使用数据库连接的技术，无需为每个请求建立新连接。这可以大大减少建立和拆除连接的开销，从而提高性能和减少服务器负载。 

在 Kubernetes 环境中，连接池可以通过尽量减少对数据库的连接数来帮助降低服务器负载。当运行在 Kubernetes 的应用程序建立一个连接到数据库中，它使用特定资源数量，如 CPU、内存和网络带宽。这些资源是有限的，如果建立了太多连接就会被耗尽。 

Golang 提供了像“database/sql”这样的库，支持开箱即用的连接池。下面是如何在 Golang 中实现连接池的方法： 

我们首先定义 package main 语句以将此 Go 代码文件标识为主包的一部分。创建可执行程序需要主包：package main 

我们还必须导入这个 Go 程序需要的外部包的列表。我们导入了标准库包 database/sql、fmt 和 log，以及第三方包 github.com/go-sql-driver/mysql，它为 database/sql 包提供了一个 MySQL 驱动：

import (    "database/sql"    "fmt"    "log"    "time"
    _ "github.com/go-sql-driver/mysql")

我们使用 sql.Open() 函数创建新数据库连接池，它需要 2 个参数：要使用的数据库驱动程序的名称（mysql）和一个包含用户证书、主机名、端口和数据库名称的连接器字符串。如果与数据库的连接失败，该程序会记录错误信息并且使用 log.Fatal() 的方式退出。否则，程序将关闭数据库连接推迟到函数结束：

    // Create a database connection pool    db, err := sql.Open("mysql", "user:password@tcp(db-hostname:3306)/mydb")    if err != nil {        log.Fatal("Failed to connect to database:", err)    }    defer db.Close()

我们有一个连接池，但我们需要使用 db 对象上的方法来配置数据库连接池设置。SetMaxOpenConns() 方法设置了数据库的最大开放连接数（本例中为 10），而 SetMaxIdleConns() 方法设置了在池中保留的最大空闲连接数（5）。最后，SetConnMaxLifetime() 方法设置了一个连接的最大寿命（本例中为 5 分钟）：

    // Set connection pool settings    db.SetMaxOpenConns(10)    db.SetMaxIdleConns(5)    db.SetConnMaxLifetime(time.Minute * 5)
    // Use the connection pool to perform database operations    // ...}

完整代码如下：

package main
import (    "database/sql"    "fmt"    "log"    "time"
    _ "github.com/go-sql-driver/mysql")
func main() {    // Create a database connection pool    db, err := sql.Open("mysql", "user:password@tcp(db-hostname:3306)/mydb")    if err != nil {        log.Fatal("Failed to connect to database:", err)    }    defer db.Close()
    // Set connection pool settings    db.SetMaxOpenConns(10)    db.SetMaxIdleConns(5)    db.SetConnMaxLifetime(time.Minute * 5)
    // Use the connection pool to perform database operations    // ...}

确定 db.SetMaxOpenConns()、db.SetMaxIdleConns() 和 db.SetConnMaxLifetime() 方法的适当值取决于各种因素，如：

• 数据库上的预期流量和工作负载

• 预计的并发连接的数量

• 数据库服务器的容量

• 数据库查询的平均响应时间

• 其他使用同一数据库的应用程序的预期负载和性能

 总而言之，先设置这些值：

• db.SetMaxOpenConns() 应该被设置为一个小于或等于数据库服务器可以处理的最大连接数的值。这个值应该设置得足够高，以处理预期的流量和工作量，但又足够低，以避免数据库服务器不堪重负。对于大多数网络应用来说，5 到 50 之间的值通常是合理的。

• db.SetMaxIdleConns() 应该被设置为一个足以处理预期的空闲连接的值。如果应用程序经常打开和关闭连接，这个值应该设置得更高。一个在 2 到 10 之间的值通常是合理的。

• db.SetConnMaxLifetime() 应该被设置为一个大于数据库查询平均时间的值。这个值应该设置得足够高，以避免频繁的连接更换，但又要足够低，以防止长期闲置的连接不必要地消耗数据库资源。几分钟到几小时之间的值通常是合理的。

 值得注意的是，这些值应该根据不断变化的工作负载和性能要求定期审查和调整。监控数据库服务器和应用程序的性能指标可以帮助确定这些值是否需要调整。 

5、利用健康检查和 readiness 探针

健康检查和 readiness 探针 

Kubernetes 提供了健康检查和 readiness 探针，允许你监控容器的状态，并确定它们是否准备好接收流量。通过利用这些功能，你可以确保只有健康和准备好的容器才能接收流量，减少由不健康或不准备好的容器引起的服务器负载。你可以在 Golang 应用中实现自定义的健康检查和 readiness 探针，以提供关于其状态的准确信息。 

为了监控容器的状态，让我们从添加一个 readiness 探针开始：

....    ....        containers:            ....            readinessProbe:            httpGet:              path: /health              port: 8080            initialDelaySeconds: 10            periodSeconds: 5

• readinessProbe 定义容器的 readiness 探针。readiness 探针被用于检查容器是否准备好接收流量。

• httpGet 指定 readiness 探针应该使用的 HTTP GET 请求以检查容器的健康状况。

• path: /health 表示用于检查容器健康状况的 HTTP GET 请求的路径。在这种情况下，它被设置为"/health"。

• initialDelaySeconds: 10 指定在容器启动后，在启动准备状态探针之前的等待秒数。在本例中，它被设置为 10 秒。

• periodSeconds: 5 指定连续的 readiness 探针检查之间的时间间隔，单位是秒。在本例，它被设置为 5 秒。

 现在，我们可以立刻添加 liveness 探针：

....    ....        containers:            ....            readinessProbe:            .....            livenessProbe:            httpGet:              path: /health              port: 8080            initialDelaySeconds: 30            periodSeconds: 10

• livenessProbe 定义容器的 liveness 探针。liveness 探针被用于检查容器是否正常运行和健康。

• httpGet 指定 liveness 探针应该使用 HTTP GET 请求来检查容器健康状况。

• path: /health 指用于 HTTP GET 请求的路径以检查容器的健康状况。在本例中，被设置为“/health”。

• initialDelaySeconds: 10 设置了在容器启动后，liveness 探针启动之前所等待的秒数。在本例中为 10 秒。

• periodSeconds: 5 指 liveness 探针连续检查的间隔时间，单位是秒。本例为 5 秒。

 YAML 文件如下所示：

apiVersion: apps/v1kind: Deploymentmetadata:  name: my-golang-appspec:  replicas: 3  selector:    matchLabels:      app: my-golang-app  template:    metadata:      labels:        app: my-golang-app    spec:      containers:        - name: my-golang-container          image: my-golang-image          ports:            - containerPort: 8080          readinessProbe:            httpGet:              path: /health              port: 8080            initialDelaySeconds: 10            periodSeconds: 5          livenessProbe:            httpGet:              path: /health              port: 8080            initialDelaySeconds: 30            periodSeconds: 10

为 Kubernetes 优化 Golang 应用程序需要仔细考虑资源分配、垃圾回收设置、网络通信和容器健康状况。通过遵循以上最佳实践，可以在 Kubernetes 中减少服务器负载和优化 Golang 应用程序的性能。通过利用 Kubernetes 和 Golang 应用的能力，您可以构建一个专为现代云环境优化好的可扩展、高性能的容器化应用程序。 

减轻服务器负载技巧

1、实现自动弹性伸缩：自动弹性伸缩允许基于资源利用率来自动调整 pod 数量。使用 Kubernetes HPA 可以实现，该功能会基于 CPU 或内存的利用率来自动增加或减少 pod 数量。 

如上图所示，集群自动伸缩可以在 Kubernetes 集群内自动配置新节点以处理增加的负载，确保高效的资源利用并防止服务器过载。 

2、Kubernetes 的负载均衡：Kubernetes 提供内置的机制进行负载军训，如服务和 ingress。服务将 pod 暴露到网络并使用 round-robin 或 IP hash 等负载均衡算法，将进入的流量分配到多个 pod 上。 

3、缓存和利用 Kubernetes 缓存系统：Kubernetes 提供缓存系统，如 Memcached 和 Redis，它们可以被部署为 pod 并用于存储经常访问的数据，减少重复查询后端服务的需要，降低服务器负载。 

总结

总而言之，为 Kubernetes 优化 Golang 应用程序对于确保高效、可靠地在容器化环境内部署和运维至关重要。通过遵循文中提到的最佳实践，可以有效降低服务器负载，从而提升应用性能、提高成本效率。