title: Argo Rollouts实战：基于ArgoCD的渐进式发布完整指南 date: 2025-08-12 23:11:08 categories:

devops/argo tags:
devops
argo
ArgoRollout
Kubernetes
GitOps disableNunjucks: true

Argo Rollouts实战：基于ArgoCD的渐进式发布完整指南#

概述#

Argo Rollouts是一个Kubernetes控制器和一组CRD，用于提供高级部署能力，如蓝绿部署、金丝雀发布和渐进式交付。与Kubernetes原生的Deployment相比，Argo Rollouts提供了更细粒度的流量控制和发布策略，能够显著降低应用发布风险。

本文将详细介绍如何在生产环境中部署和使用Argo Rollouts，结合ArgoCD实现GitOps工作流下的自动化渐进式发布。

核心优势#

渐进式发布：支持分阶段逐步切换流量，降低发布风险
流量控制：支持基于权重和请求头的精细流量分割
自动化回滚：发布失败时可快速回滚到稳定版本
可视化监控：提供直观的发布状态和流量分布视图
GitOps集成：与ArgoCD无缝集成，实现声明式部署管理

一、环境准备#

1.1 ArgoCD部署#

准备域名及SSL证书#

配置域名解析

在/etc/hosts中添加域名解析，将ArgoCD域名解析到Ingress的外部IP：

1
x.x.x.x argo-devops.hua-ri.cn

创建TLS密钥

创建用于HTTPS访问的TLS Secret：

1
kubectl create namespace argo
2
kubectl create secret tls argocd-server-tls -n argo \
3
  --cert=/Users/king/hua-ri.cn.pem \
4
  --key=/Users/king/hua-ri.cn.key

验证Secret创建成功：

1
kubectl get secrets -n argo

部署ArgoCD#

获取IngressClass

1
kubectl get ingressclass

期望输出：

1
NAME        CONTROLLER                   PARAMETERS   AGE
2
ack-nginx   k8s.io/ack-ingress-nginx     <none>       50d

配置Helm Values

创建customs.yaml配置文件：

1
## Globally shared configuration
2
global:
3
  domain: argo-devops.hua-ri.cn
4

5
## Server
6
server:
7
  replicas: 1
8
  ingress:
9
    enabled: true
10
    controller: generic
11
    ingressClassName: "ack-nginx"
12
    hostname: "argo-devops.hua-ri.cn"
13
    path: /
14
    pathType: Prefix
15
    annotations:
16
      nginx.ingress.kubernetes.io/backend-protocol: "HTTPS"
17
      nginx.ingress.kubernetes.io/ssl-redirect: "true"
18
      nginx.ingress.kubernetes.io/force-ssl-redirect: "true"
19
    tls: true

使用Helm部署

1
helm upgrade --install argocd argo/argo-cd --version 7.3.5 \
2
  --namespace argo \
3
  --create-namespace \
4
  -f customs.yaml

访问ArgoCD

获取初始密码：

1
kubectl get secret -n argo argocd-initial-admin-secret \
2
  -o jsonpath="{.data.password}" | base64 -d

使用CLI登录：

1
argocd login argo-devops.hua-ri.cn --grpc-web

1.2 Argo Rollouts部署#

1
kubectl create namespace argo-rollouts
2
kubectl apply -n argo-rollouts \
3
  -f https://github.com/argoproj/argo-rollouts/releases/latest/download/install.yaml

验证部署成功：

1
kubectl get pods -n argo-rollouts

二、应用架构设计#

2.1 测试应用设计#

为了演示Argo Rollouts的金丝雀发布功能，我们设计一个简单的HTTP服务，通过不同的版本返回不同的响应内容。

应用特性

提供HTTP接口/api/check，返回当前版本信息
v1版本返回{"message": "v1"}
v2版本返回{"message": "v2"}
通过修改镜像标签实现版本切换

2.2 应用代码实现#

main.go#

1
package main
2

3
import (
4
    "bytes"
5
    "compress/gzip"
6
    "context"
7
    "crypto/tls"
8
    "encoding/json"
9
    "fmt"
10
    "io"
11
    "io/ioutil"
12
    "log"
13
    "net/http"
14
    "net/http/httputil"
15
    "net/url"
16
    "strings"
17
    "time"
18

19
    argocdclient "github.com/argoproj/argo-cd/v2/pkg/apiclient"
20
    applicationpkg "github.com/argoproj/argo-cd/v2/pkg/apiclient/application"
21
    argoio "github.com/argoproj/argo-cd/v2/util/io"
22
    "github.com/gin-contrib/cors"
23
    "github.com/gin-gonic/gin"
24
)
25

26
const (
27
    ARGOCD_HOST  = "https://bkce7-dev.hua-ri.cn:8080/"
28
    ARGOCD_TOKEN = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJhcmdvY2QiLCJzdWIiOiJxaXlhbjphcGlLZXkiLCJuYmYiOjE3NDU4Mzc1NjgsImlhdCI6MTc0NTgzNzU2OCwianRpIjoiNDM1NDgwY2ItNjliYy00Y2Q2LTk3NjYtMGU0ZDA0MzU5MWFhIn0.F-1ZZThXCqFnG_Kgxgy6z11Hmgl6g7mcEitaKQPyP8k"
29
)
30

31
type JSONResponse struct {
32
    Code   int    `json:"code"`
33
    Result bool   `json:"result"`
34
    Msg    string `json:"message"`
35
}
36

37
type successResponse struct {
38
    JSONResponse
39
    Data interface{} `json:"data"`
40
}
41

42
type ERRresponse struct {
43
    Error string `json:"message" example:"message"`
44
}
45

46
func Error(message string) ERRresponse {
47
    return ERRresponse{Error: message}
48
}
49

50
func ArgoCDErrorResponse(argocderr ArgoCDError) ERRresponse {
51
    return ERRresponse{Error: argocderr.Message}
52
}
53

54
type ArgoCDError struct {
55
    Error   error  `json:"error"`
56
    Message string `json:"message"`
57
    Code    int    `json:"code"`
58
}
59

60
func BuildArgoCDError(body []byte) (argocderr ArgoCDError, err error) {
61
    err = json.Unmarshal(body, &argocderr)
62
    if err != nil {
63
       return ArgoCDError{
64
          Message: string(body),
65
       }, nil
66
    }
67
    return
68
}
69

70
func wrapResponse(r *http.Response) (err error) {
71
    if strings.Contains(r.Request.URL.Path, "api/v1/secrets") {
72
       return nil
73
    }
74
    body, err := readBody(r)
75
    if err != nil {
76
       return
77
    }
78
    switch r.StatusCode {
79
    case http.StatusOK:
80
       var newbody interface{}
81
       err = json.Unmarshal(body, &newbody)
82
       if err != nil {
83
          return
84
       }
85
       resp := successResponse{
86
          JSONResponse: JSONResponse{
87
             Code:   0,
88
             Result: true,
89
          },
90
          Data: newbody,
91
       }
92
       err = writeBody(r, resp)
93
    default:
94
       argocderr, err := BuildArgoCDError(body)
95
       if err != nil {
96
          err = writeBody(r, Error(string(body)))
97
       } else {
98
          err = writeBody(r, ArgoCDErrorResponse(argocderr))
99
       }
100
    }
101
    return
102
}
103

104
func readBody(r *http.Response) (body []byte, err error) {
105
    if r.Header.Get("Content-Encoding") == "gzip" {
106
       reader, err := gzip.NewReader(r.Body)
107
       if err != nil {
108
          log.Print("create reader content[gzip] failed")
109
       }
110
       defer reader.Close()
111
       body, err = io.ReadAll(reader)
112
       if err != nil {
113
          fmt.Printf("read gzip body failed,status:%s,error:%s", r.Status, err.Error())
114
       }
115
       r.Header.Del("Content-Encoding")
116
    } else {
117
       body, err = ioutil.ReadAll(r.Body)
118
       if err != nil {
119
          fmt.Printf("read body failed,status:%s,error:%s", r.Status, err.Error())
120
       }
121
    }
122
    return
123
}
124

125
func writeBody(r *http.Response, res interface{}) error {
126
    updatedBody, err := json.Marshal(&res)
127
    if err != nil {
128
       fmt.Printf("unmarshal new gitops response body failed,body:%v,error:%s", res, err.Error())
129
    }
130
    buf := bytes.NewBuffer(updatedBody)
131
    r.Body = ioutil.NopCloser(buf)
132
    r.Header["Content-Length"] = []string{fmt.Sprint(buf.Len())}
133
    return nil
134
}
135

136
func argocdProxy(c *gin.Context) {
137
    request := c.Request
138
    writer := c.Writer
139

140
    proxyURL, err := url.Parse(ARGOCD_HOST)
141
    if err != nil {
142
       return
143
    }
144
    proxyTarget := *proxyURL
145
    proxy := httputil.NewSingleHostReverseProxy(proxyURL)
146
    proxy.ModifyResponse = wrapResponse
147

148
    request.Host = proxyTarget.Host
149
    request.URL.Scheme = proxyTarget.Scheme
150
    request.URL.Host = proxyTarget.Host
151
    request.Header.Set("Authorization", "Bearer "+ARGOCD_TOKEN)
152

153
    request.URL.Path = strings.Replace(request.URL.Path, "/gitops", "", 1)
154
    request.URL.RawPath = strings.Replace(request.URL.RawPath, "/gitops", "", 1)
155

156
    tr := &http.Transport{
157
       TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
158
    }
159
    proxy.Transport = tr
160
    proxy.ServeHTTP(writer, request)
161
}
162

163
func testCall() interface{} {
164
    ctx := context.Background()
165
    clientOpts := argocdclient.ClientOptions{
166
       ServerAddr:      "bkce7-dev.hua-ri.cn:8080",
167
       Insecure:        true,
168
       GRPCWebRootPath: "/",
169
       Headers: []string{
170
          "Authorization: Bearer " + ARGOCD_TOKEN,
171
          "username: qiyan",
172
       },
173
       AuthToken: ARGOCD_TOKEN,
174
    }
175
    client, _ := argocdclient.NewClient(&clientOpts)
176

177
    conn, appIf := client.NewApplicationClientOrDie()
178
    defer argoio.Close(conn)
179
    app, err := appIf.List(ctx, &applicationpkg.ApplicationQuery{
180
       Projects: []string{"default"},
181
    })
182
    if err != nil {
183
       return err.Error()
184
    }
185
    return app
186
}
187

188
func main() {
189
    r := gin.Default()
190
    r.GET("/api/check", func(c *gin.Context) {
191
       c.JSON(http.StatusOK, gin.H{
192
          "message": "v1",
193
       })
194
    })
195
    r.GET("/user", func(c *gin.Context) {
196
       c.JSON(http.StatusOK, map[string]interface{}{
197
          "code":   0,
198
          "result": true,
199
          "data": map[string]string{
200
             "username": "qiyan",
201
             "type":     "bk",
202
          },
203
       })
204
    })
205
    r.GET("/argocd/applications", func(c *gin.Context) {
206
       c.JSON(http.StatusOK, map[string]interface{}{
207
          "code":   0,
208
          "result": true,
209
          "data":   testCall(),
210
       })
211
    })
212
    gitopsrouter := r.Group("gitops")
213
    gitopsrouter.Use(cors.New(cors.Config{
214
       AllowOrigins:     []string{"http://bkce7-dev.hua-ri.cn:8888", "http://power.hua-ri.cn:5000"},
215
       AllowFiles:       true,
216
       AllowWebSockets:  true,
217
       AllowMethods:     []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
218
       AllowHeaders:     []string{"Origin", "Authorization", "x-token", "x-csrftoken", "Content-Type"},
219
       ExposeHeaders:    []string{"Content-Length", "Content-Type"},
220
       AllowCredentials: true,
221
       MaxAge:           12 * time.Hour,
222
    }))
223
    gitopsrouter.Any("*subpath", argocdProxy)
224

225
    r.Run()
226
}

核心接口说明

1
r.GET("/api/check", func(c *gin.Context) {
2
   c.JSON(http.StatusOK, gin.H{
3
      "message": "v1",
4
   })
5
})

这个接口是版本标识的关键，通过修改返回的message值来区分不同版本。

Dockerfile#

1
# builder
2
FROM public-registry-vpc.cn-hangzhou.cr.aliyuncs.com/public/golang:v1.22.2_20240416 AS builder
3

4
WORKDIR /src
5
USER root
6
COPY . .
7

8
RUN go env -w GOPROXY="https://goproxy.cn,direct"
9
RUN go env -w GOSUMDB="off"
10
RUN go mod download
11
RUN go build -o demo main.go
12

13
# runtime
14
FROM public-registry-vpc.cn-hangzhou.cr.aliyuncs.com/public/alpine:3.14
15

16
ENV LANG en_US.UTF-8
17
ENV TZ Asia/Shanghai
18

19
WORKDIR /app
20
COPY --from=builder /src/demo /app/demo
21
ENTRYPOINT ["/app/demo"]

Makefile#

1
# Go parameters
2
IMAGE_REPO=dev-registry-vpc.cn-hangzhou.cr.aliyuncs.com/ops/qiyan
3
IMAGE_TAG=v1
4

5
all:: server
6

7
server::
8
    go run main.go
9

10
build::
11
    go build main.go
12

13
test::
14
    go test ./...
15

16
build-image:
17
    docker build --platform=linux/amd64 -t ${IMAGE_REPO}:${IMAGE_TAG} -f Dockerfile . --push

2.3 镜像构建#

构建v1版本

修改Makefile和main.go：

1
IMAGE_REPO=dev-registry-vpc.cn-hangzhou.cr.aliyuncs.com/ops/qiyan
2
IMAGE_TAG=v1

1
r.GET("/api/check", func(c *gin.Context) {
2
   c.JSON(http.StatusOK, gin.H{
3
      "message": "v1",
4
   })
5
})

执行构建：

1
make build-image

构建v2版本

修改Makefile和main.go：

1
IMAGE_REPO=dev-registry-vpc.cn-hangzhou.cr.aliyuncs.com/ops/qiyan
2
IMAGE_TAG=v2

1
r.GET("/api/check", func(c *gin.Context) {
2
   c.JSON(http.StatusOK, gin.H{
3
      "message": "v2",
4
   })
5
})

执行构建：

1
make build-image

三、Helm Chart设计#

3.1 Chart结构#

1
charts/ingress/
2
├── Chart.yaml
3
├── values.yaml
4
├── templates/
5
│   ├── ingress.yaml
6
│   ├── rollout.yaml
7
│   └── service.yaml
8
└── .helmignore

3.2 配置文件详解#

values.yaml（顶级）#

1
ingress:
2
  enabled: true

这是Helm Chart的顶级开关，控制整个应用的启用状态。

charts/ingress/values.yaml#

1
enabled: false
2
lb: lb-bp1r1dsywnqktp1hxih38
3
replicaCount: 1
4
image: dev-registry-vpc.cn-hangzhou.cr.aliyuncs.com/ops/qiyan
5
imageTag: v2
6
port: 9999

关键配置说明

enabled：控制ingress子chart的启用状态
imageTag：控制要部署的镜像版本，这是测试Argo Rollouts时的关键参数
port：服务端口，需要与容器端口对应

charts/ingress/Chart.yaml#

1
apiVersion: v2
2
name: ingress
3
description: A Helm chart for Kubernetes
4
type: application
5
version: 0.1.0
6
appVersion: "1.16.0"

charts/ingress/.helmignore#

1
.DS_Store
2
.git/
3
.gitignore
4
.bzr/
5
.bzrignore
6
.hg/
7
.hgignore
8
.svn/
9
*.swp
10
*.bak
11
*.tmp
12
*.orig
13
*~
14
.project
15
.idea/
16
*.tmproj
17
.vscode/

3.3 模板文件详解#

templates/ingress.yaml#

1
{{- if .Values.enabled }}
2
apiVersion: networking.k8s.io/v1
3
kind: Ingress
4
metadata:
5
  name: rollouts-demo-stable
6
  namespace: {{ .Release.Namespace }}
7
spec:
8
  ingressClassName: ack-nginx
9
  rules:
10
    - host: bkce7-dev.hua-ri.cn
11
      http:
12
        paths:
13
          - backend:
14
              service:
15
                name: rollouts-demo-stable
16
                port:
17
                  number: 9999
18
            path: /
19
            pathType: Prefix
20
{{- end }}

配置要点

ingressClassName: ack-nginx：使用阿里云ACK托管的nginx ingress
host: bkce7-dev.hua-ri.cn：访问域名
backend.port: 9999：必须与Service的port字段一致

templates/service.yaml#

1
{{- if .Values.enabled }}
2
apiVersion: v1
3
kind: Service
4
metadata:
5
  name: rollouts-demo-stable
6
  namespace: {{ .Release.Namespace }}
7
spec:
8
  ports:
9
  - name: tcp
10
    port: {{ .Values.port }}
11
    protocol: TCP
12
    targetPort: 8080
13
  selector:
14
    app: argocd-demo
15
  sessionAffinity: None
16
  type: ClusterIP
17

18
---
19
apiVersion: v1
20
kind: Service
21
metadata:
22
  name: rollouts-demo-canary
23
  namespace: {{ .Release.Namespace }}
24
spec:
25
  ports:
26
  - name: tcp
27
    port: {{ .Values.port }}
28
    protocol: TCP
29
    targetPort: 8080
30
  selector:
31
    app: argocd-demo
32
  sessionAffinity: None
33
  type: ClusterIP
34
{{- end }}

关键配置

生成两个ClusterIP Service：
- rollouts-demo-stable：稳定版本服务，金丝雀结束后的流量终点
- rollouts-demo-canary：金丝雀版本服务，只接收按权重或header分流的流量
targetPort: 8080：必须与容器的containerPort一致
selector: app: argocd-demo：必须与rollout.yaml中的label匹配

templates/rollout.yaml#

1
{{- if .Values.enabled }}
2
apiVersion: argoproj.io/v1alpha1
3
kind: Rollout
4
metadata:
5
  name: rollouts-demo
6
  namespace: {{ .Release.Namespace }}
7
spec:
8
  replicas: 5
9
  strategy:
10
    canary:
11
      canaryService: rollouts-demo-canary
12
      stableService: rollouts-demo-stable
13
      trafficRouting:
14
        nginx:
15
          stableIngress: rollouts-demo-stable
16
          additionalIngressAnnotations:
17
            canary-by-header: X-Canary
18
            canary-by-header-value: iwantsit
19
      steps:
20
        - setCanaryScale:
21
            replicas: 1
22
        - pause: { }
23
        - setWeight: 20
24
        - pause: { }
25
        - setWeight: 40
26
        - pause: { }
27
        - setWeight: 60
28
        - pause: { }
29
  revisionHistoryLimit: 2
30
  selector:
31
    matchLabels:
32
      app: argocd-demo
33
  template:
34
    metadata:
35
      labels:
36
        app: argocd-demo
37
    spec:
38
      containers:
39
        - name: rollouts-demo
40
          image: {{ .Values.image}}:{{ .Values.imageTag | default .Chart.AppVersion }}
41
          imagePullPolicy: Always
42
          ports:
43
            - name: http
44
              containerPort: 8080
45
              protocol: TCP
46
          resources:
47
            requests:
48
              memory: 32Mi
49
              cpu: 5m
50
          securityContext:
51
            privileged: false
52
          terminationMessagePath: /dev/termination-log
53
          terminationMessagePolicy: File
54
      dnsPolicy: ClusterFirst
55
      restartPolicy: Always
56
      schedulerName: default-scheduler
57
      securityContext: { }
58
      terminationGracePeriodSeconds: 30
59
      imagePullSecrets:
60
        - name: dev-registry
61
{{- end }}

Rollout核心配置详解

Rollout是Argo Rollouts的核心CRD，功能等价于Deployment + 渐进式发布策略。

1. 基础配置

1
apiVersion: argoproj.io/v1alpha1
2
kind: Rollout
3
metadata:
4
  name: rollouts-demo
5
  namespace: {{ .Release.Namespace }}
6
spec:
7
  replicas: 5
8
  revisionHistoryLimit: 2
9
  selector:
10
    matchLabels:
11
      app: argocd-demo

replicas: 5：期望副本数
revisionHistoryLimit: 2：保留的ReplicaSet数量，用于回滚
selector.matchLabels：必须与template.metadata.labels匹配

2. 金丝雀策略

1
strategy:
2
  canary:
3
    canaryService: rollouts-demo-canary
4
    stableService: rollouts-demo-stable
5
    trafficRouting:
6
      nginx:
7
        stableIngress: rollouts-demo-stable
8
        additionalIngressAnnotations:
9
          canary-by-header: X-Canary
10
          canary-by-header-value: iwantsit

canaryService：金丝雀服务名称
stableService：稳定服务名称
trafficRouting.nginx：使用nginx-ingress进行流量拆分
- stableIngress：必须指向已存在的Ingress
- additionalIngressAnnotations：自定义灰度规则
  - canary-by-header: X-Canary：基于请求头的流量路由
  - canary-by-header-value: iwantsit：只有携带X-Canary: iwantsit的请求才会路由到金丝雀版本

3. 灰度步骤

1
steps:
2
  - setCanaryScale:
3
      replicas: 1
4
  - pause: { }
5
  - setWeight: 20
6
  - pause: { }
7
  - setWeight: 40
8
  - pause: { }
9
  - setWeight: 60
10
  - pause: { }

灰度步骤详解：

setCanaryScale(replicas: 1)：先扩1个新版本Pod
pause{}：人工卡点，需要手动promote
setWeight: 20：20%流量切换到新版本
pause{}：人工卡点
setWeight: 40：40%流量切换到新版本
pause{}：人工卡点
setWeight: 60：60%流量切换到新版本
pause{}：人工卡点，完成后自动切换到100%

4. Pod模板

1
template:
2
  metadata:
3
    labels:
4
      app: argocd-demo
5
  spec:
6
    containers:
7
      - name: rollouts-demo
8
        image: {{ .Values.image}}:{{ .Values.imageTag | default .Chart.AppVersion }}
9
        imagePullPolicy: Always
10
        ports:
11
          - name: http
12
            containerPort: 8080
13
            protocol: TCP

image：使用Helm values中的image和imageTag
containerPort: 8080：容器端口
imagePullPolicy: Always：总是拉取最新镜像

四、实战测试：v1到v2的渐进式发布#

4.1 初始状态：v1版本全量运行#

配置

修改charts/ingress/values.yaml：

1
imageTag: v1

部署

通过ArgoCD同步配置，观察Rollout状态：

1
kubectl get rollout -n <namespace>
2
kubectl get pods -n <namespace>

验证

测试接口返回：

1
curl http://bkce7-dev.hua-ri.cn/api/check

预期返回：{"message":"v1"}

4.2 版本变更：v1到v2#

配置变更

修改charts/ingress/values.yaml：

1
imageTag: v2

同时修改rollout.yaml中的steps.setCanaryScale.replicas为2：

1
steps:
2
  - setCanaryScale:
3
      replicas: 2
4
  - pause: { }
5
  - setWeight: 20
6
  - pause: { }
7
  - setWeight: 40
8
  - pause: { }
9
  - setWeight: 60
10
  - pause: { }

同步配置

通过ArgoCD同步配置，观察Rollout状态变化。

4.3 灰度步骤一：金丝雀Pod启动#

状态描述

创建新的ReplicaSet，镜像版本为v2
启动2个v2版本的Pod
v1版本的5个Pod继续运行
流量全部路由到v1版本

验证测试

不带请求头测试：

1
for i in {1..50}; do curl http://bkce7-dev.hua-ri.cn/api/check; done

结果：全部返回{"message":"v1"}

带请求头测试：

1
for i in {1..50}; do curl http://bkce7-dev.hua-ri.cn/api/check -H 'X-Canary: iwantsit'; done

结果：全部返回{"message":"v2"}

错误请求头测试：

1
for i in {1..50}; do curl http://bkce7-dev.hua-ri.cn/api/check -H 'X-Canary: huari'; done

结果：全部返回{"message":"v1"}

说明

不带X-Canary请求头：流量全部到v1版本
带X-Canary: iwantsit请求头：流量全部到v2版本
带X-Canary: huari请求头：流量全部到v1版本（header值不匹配）

4.4 灰度步骤二：20%流量到新版本#

状态描述

Pod数量不变：v1版本5个，v2版本2个
通过nginx-ingress的流量权重配置，20%流量路由到v2版本

验证测试

不带请求头测试：

1
for i in {1..50}; do curl http://bkce7-dev.hua-ri.cn/api/check; done

结果示例：

1
{"message":"v1"}{"message":"v1"}{"message":"v1"}{"message":"v1"}{"message":"v1"}
2
{"message":"v1"}{"message":"v1"}{"message":"v1"}{"message":"v1"}{"message":"v1"}
3
{"message":"v1"}{"message":"v1"}{"message":"v1"}{"message":"v1"}{"message":"v2"}
4
{"message":"v1"}{"message":"v1"}{"message":"v1"}{"message":"v1"}{"message":"v2"}
5
...

统计：v2版本占比约9/50（18%），与20%的权重基本一致

带请求头测试：

1
for i in {1..50}; do curl http://bkce7-dev.hua-ri.cn/api/check -H 'X-Canary: iwantsit'; done

结果：全部返回{"message":"v2"}

说明

不带请求头：按权重分配流量，约20%到v2版本
带正确请求头：流量全部到v2版本（header优先级高于权重）

4.5 灰度步骤三：40%流量到新版本#

状态描述

Pod数量不变
流量权重调整为40%

验证测试

不带请求头测试：

1
for i in {1..50}; do curl http://bkce7-dev.hua-ri.cn/api/check; done

统计：v2版本占比约21/50（42%），与40%的权重基本一致

带请求头测试：

1
for i in {1..50}; do curl http://bkce7-dev.hua-ri.cn/api/check -H 'X-Canary: iwantsit'; done

结果：全部返回{"message":"v2"}

4.6 灰度步骤四：60%流量到新版本#

状态描述

Pod数量不变
流量权重调整为60%

验证测试

不带请求头测试：

1
for i in {1..50}; do curl http://bkce7-dev.hua-ri.cn/api/check; done

统计：v2版本占比约29/50（58%），与60%的权重基本一致

带请求头测试：

1
for i in {1..50}; do curl http://bkce7-dev.hua-ri.cn/api/check -H 'X-Canary: iwantsit'; done

结果：全部返回{"message":"v2"}

4.7 灰度步骤五：100%流量到新版本#

状态描述

v2版本ReplicaSet扩容到5个Pod
v1版本的5个Pod被终止
流量全部切换到v2版本

验证测试

不带请求头测试：

1
for i in {1..50}; do curl http://bkce7-dev.hua-ri.cn/api/check; done

结果：全部返回{"message":"v2"}

带请求头测试：

1
for i in {1..50}; do curl http://bkce7-dev.hua-ri.cn/api/check -H 'X-Canary: iwantsit'; done

结果：全部返回{"message":"v2"}

说明

发布完成，v2版本成为新的稳定版本
v1版本的Pod已全部清理
无论是否带请求头，流量都路由到v2版本

五、核心概念深入解析#

5.1 Rollout vs Deployment#

Deployment

原生Kubernetes资源
支持RollingUpdate和Recreate策略
流量切换是瞬间的，无法精细控制
回滚需要手动操作

Rollout

Argo Rollouts提供的CRD
支持金丝雀、蓝绿、分析等多种策略
支持基于权重和请求头的精细流量控制
支持自动化分析和回滚
与ArgoCD深度集成，支持GitOps

5.2 流量路由机制#

基于权重的流量分割

通过nginx-ingress的nginx.ingress.kubernetes.io/canary-weight注解实现：

1
annotations:
2
  nginx.ingress.kubernetes.io/canary-weight: "20"

基于请求头的流量路由

通过nginx-ingress的nginx.ingress.kubernetes.io/canary-by-header注解实现：

1
annotations:
2
  nginx.ingress.kubernetes.io/canary-by-header: "X-Canary"
3
  nginx.ingress.kubernetes.io/canary-by-header-value: "iwantsit"

优先级

请求头路由的优先级高于权重路由。如果请求匹配了header规则，将直接路由到金丝雀版本，忽略权重配置。

5.3 灰度步骤设计#

步骤类型

setCanaryScale：设置金丝雀Pod数量
setWeight：设置流量权重
pause：暂停，等待人工确认
analysis：执行分析任务
setHeaderRoute：设置基于请求头的路由

最佳实践

初始阶段：少量金丝雀Pod，观察稳定性
逐步放量：按20%、40%、60%的节奏增加流量
人工卡点：在每个阶段设置pause，确保可控
自动化分析：集成Prometheus等监控工具，自动判断是否继续

5.4 Service设计#

双Service架构

Argo Rollouts需要两个Service：

stableService：指向稳定版本的Pod
canaryService：指向金丝雀版本的Pod

流量路由

Ingress指向stableService
nginx-ingress根据权重或header规则，将部分流量转发到canaryService
金丝雀发布完成后，canaryService的Pod成为新的stableService

六、生产环境最佳实践#

6.1 监控和告警#

关键指标

Pod健康状态
流量分布比例
错误率和响应时间
资源使用情况

告警配置

金丝雀Pod启动失败
错误率超过阈值
响应时间显著增加

6.2 回滚策略#

自动回滚

配置分析任务，当指标异常时自动回滚：

1
steps:
2
  - analysis:
3
      templates:
4
      - templateName: success-rate
5
      args:
6
      - name: service-name
7
        value: my-service

手动回滚

1
kubectl rollout undo rollout rollouts-demo -n <namespace>

6.3 安全考虑#

权限控制

为Argo Rollouts配置最小权限
限制RBAC权限范围

镜像安全

使用私有镜像仓库
配置imagePullSecrets
定期扫描镜像漏洞

6.4 性能优化#

资源限制

1
resources:
2
  requests:
3
    memory: "64Mi"
4
    cpu: "10m"
5
  limits:
6
    memory: "128Mi"
7
    cpu: "100m"

Pod反亲和性

1
affinity:
2
  podAntiAffinity:
3
    preferredDuringSchedulingIgnoredDuringExecution:
4
    - weight: 100
5
      podAffinityTerm:
6
        labelSelector:
7
          matchExpressions:
8
          - key: app
9
            operator: In
10
            values:
11
            - argocd-demo
12
        topologyKey: kubernetes.io/hostname

七、常见问题排查#

7.1 流量未按预期路由#

排查步骤

检查Ingress注解是否正确
验证nginx-ingress版本是否支持canary注解
检查Service的selector是否正确
查看nginx-ingress日志

7.2 金丝雀Pod无法启动#

排查步骤

检查镜像是否可拉取
验证资源配置是否合理
查看Pod日志
检查节点资源是否充足

7.3 发布卡在pause步骤#

解决方案

1
# 手动promote
2
kubectl argo rollouts promote rollouts-demo -n <namespace>
3

4
# 或者跳过当前步骤
5
kubectl argo rollouts promote rollouts-demo -n <namespace> --skip-current-step

八、总结#

Argo Rollouts为Kubernetes提供了强大的渐进式发布能力，通过本文的实战测试，我们验证了以下核心特性：

精细的流量控制：支持基于权重和请求头的流量分割
分阶段发布：通过steps配置实现可控的灰度过程
GitOps集成：与ArgoCD无缝集成，实现声明式部署
快速回滚：发布失败时可快速回滚到稳定版本
可视化监控：提供直观的发布状态和流量分布

适用场景#

高可用性要求：需要零停机时间的应用发布
复杂应用：需要充分测试的新功能发布
A/B测试：需要对比不同版本效果的场景
风险控制：需要逐步放量的生产环境

通过合理配置灰度步骤和监控告警，Argo Rollouts能够显著降低应用发布风险，提升系统稳定性。

九、卸载清理#

9.1 卸载ArgoCD#

1
helm uninstall argocd --namespace argo
2
kubectl delete namespace argo
3
kubectl delete clusterrole argocd-server
4
kubectl delete clusterrolebinding argocd-server
5
kubectl delete clusterrole,clusterrolebinding -l app.kubernetes.io/instance=argocd
6
kubectl delete crd applications.argoproj.io appprojects.argoproj.io applicationsets.argoproj.io

9.2 卸载Argo Rollouts#

1
kubectl delete -n argo-rollouts -f https://github.com/argoproj/argo-rollouts/releases/latest/download/install.yaml
2
kubectl delete namespace argo-rollouts
3
kubectl delete crd rollouts.argoproj.io analysisruns.argoproj.io analysistemplates.argoproj.io experiments.argoproj.io

花日の博客

Argo Rollouts实战：基于ArgoCD的渐进式发布完整指南#

概述#

核心优势#

一、环境准备#

1.1 ArgoCD部署#

准备域名及SSL证书#

部署ArgoCD#

1.2 Argo Rollouts部署#

二、应用架构设计#

2.1 测试应用设计#

2.2 应用代码实现#

main.go#

Dockerfile#

Makefile#

2.3 镜像构建#

三、Helm Chart设计#

3.1 Chart结构#

3.2 配置文件详解#

values.yaml（顶级）#

charts/ingress/values.yaml#

charts/ingress/Chart.yaml#

charts/ingress/.helmignore#

3.3 模板文件详解#

templates/ingress.yaml#

templates/service.yaml#

templates/rollout.yaml#

四、实战测试：v1到v2的渐进式发布#

4.1 初始状态：v1版本全量运行#

4.2 版本变更：v1到v2#

4.3 灰度步骤一：金丝雀Pod启动#

4.4 灰度步骤二：20%流量到新版本#

4.5 灰度步骤三：40%流量到新版本#

4.6 灰度步骤四：60%流量到新版本#

4.7 灰度步骤五：100%流量到新版本#

五、核心概念深入解析#

5.1 Rollout vs Deployment#

5.2 流量路由机制#

5.3 灰度步骤设计#

5.4 Service设计#

六、生产环境最佳实践#

6.1 监控和告警#

6.2 回滚策略#

6.3 安全考虑#

6.4 性能优化#

七、常见问题排查#

7.1 流量未按预期路由#

7.2 金丝雀Pod无法启动#

7.3 发布卡在pause步骤#

八、总结#

适用场景#

九、卸载清理#

9.1 卸载ArgoCD#

9.2 卸载Argo Rollouts#

十、参考资源#