GitOps 部署实战指南(CICD)

一、基本认识和简单介绍

DevOps 和 GitOps 的关系：

          DevOps：开发 + 运维一体化思想，目标快速、稳定交付，范围大：CI/CD、自动化、监控、协作、流水线全都算。常用的软件：Jenkins、GitLab CI。

         GitOps：用 Git 仓库做唯一数据源，管控集群、部署、配置，属于DevOps 子集，范围小：只聚焦 K8s 容器交付，以 Git 为唯一可信源，GitOps 是容器云原生场景下标准化的 DevOps。常用的软件：ArgoCD、Tekton。

          DevOps → GitOps →ArgoCD（GitOps 首选工具）企业多用ArgoCD，ArgoCD 是完全开源、免费使用的。个人、公司、商业项目均可免费使用、修改、分发，可用于生产环境，无功能限制、无隐藏收费。

ArgoCD 简介:

           ArgoCD是Kubernetes 专用的 GitOps 持续部署工具，属于GitOps最主流落地工具，专门管K8s 集群应用自动发布、同步、回滚，所有部署配置都存在Git 仓库，集群主动拉取配置，自动更新服务。

支持多种配置管理/模板工具（Kustomize、Helm、Jsonnet、纯 YAML）。

ArgoCD官网：

https://argoproj.github.io/

ArgoCD 官方文档：

https://argo-cd.readthedocs.io/en/stable/

ArgoCD代码仓库:

https://github.com/argoproj/argo-cd

当前最新版本:

v3.4.2

二、Argo CD部署环境准备

       需要一个Kubernetes集群，单节点，多节点，高可用集群都可以，当前演示的是基于Kubernetes v1.35.1，如果不会部署K8S的可以参考：kubernetes_v1.35.1高可用集群部署实战 。

三、Argo CD代码仓库结构剖析

https://github.com/argoproj/argo-cd

3.1、argo-cd的结构：

argo-cd/
├── .github/                    # GitHub CI/CD 配置、Issue模板
├── applicationset/             # ApplicationSet 控制器的完整代码（批量管理多应用）
├── assets/                     # 静态资源文件（UI图标、文档图片等）
├── cmd/                        # 各组件的可执行入口（和之前说的一致）
│   ├── argocd-server/
│   ├── argocd-repo-server/
│   └── …
├── cmpserver/                  # 配置管理插件（CMP）服务的实现
├── committerserver/            # Git提交服务，负责同步Git仓库状态
├── common/                     # 全项目通用的工具函数、常量、数据结构
├── controller/                 # 应用控制器的核心逻辑（ reconcile 循环）
├── docs/                       # 官方文档源码
├── examples/                   # 场景化使用示例
├── gitops-engine/              # 核心的GitOps引擎（差异计算、同步逻辑）
├── hack/                       # 构建/发布脚本
├── manifests/                  # 安装部署的YAML清单（你之前用的install.yaml就在这！）
├── notification_controller/    # 通知控制器，处理Webhook、邮件等告警
├── notifications_catalog/      # 通知模板、渠道配置的目录
├── overrides/partials/language/ # 文档的语言/主题覆盖配置
├── pkg/                        # 核心业务逻辑库（大部分功能实现）
├── renovate-presets/           # 依赖自动更新工具Renovate的配置
├── reposerver/                 # Repo Server 组件的完整实现
├── resource_customizations/    # 自定义资源的健康检查、同步策略配置
├── server/                     # ArgoCD API Server 和 UI 服务的实现
├── test/                       # 端到端（E2E）测试代码
├── tools/cmd-docs/             # 命令行工具的文档生成脚本
├── ui/                         # 前端UI代码（React）
├── util/                       # 通用工具函数库
└── 根目录文件（Dockerfile、Makefile、go.mod等）

3.2、核心组件源码目录：

每个子目录对应一个独立的 Kubernetes Pod，你可以用 命令查看：

kubectl get pods -n argocd
cmd/
├── argocd-server/               # API 服务器 + UI 前端（用户请求入口）
├── argocd-application-controller/ # 核心控制器：负责应用同步、状态检查、回滚
├── argocd-repo-server/          # Git 仓库服务器：拉取/解析 Helm/Kustomize 配置
├── argocd-dex-server/           # SSO 身份验证服务（支持 OIDC/LDAP 登录）
├── argocd-redis/                # 缓存服务（HA 模式下为 Redis 哨兵集群）
├── argocd-cmp-server/           # 配置管理插件（CMP）服务：扩展 Helm/Kustomize 能力
└── argocd-util/                 # 工具命令：调试/维护 ArgoCD 用（如重置 admin 密码）

3.3、安装部署核心manifests目录：

manifests/
├── install.yaml           # 单副本「非高可用版」完整安装清单（你第一次用的文件）
├── namespace-install.yaml # 轻量版：仅创建 argocd 命名空间 + 基础 RBAC
├── crds/                  # 所有 ArgoCD CRD 的 YAML 文件（Application/AppProject 等）
│   └── *.yaml
├── base/                  # Kustomize 基础配置（非 HA 模式的原始模块）
│   ├── argocd-cm.yaml     # ArgoCD 核心配置 ConfigMap
│   ├── argocd-secret.yaml # 初始密钥（admin 密码、Git 凭证等）
│   ├── kustomization.yaml # Kustomize 合并规则
│   └── …（Deployment/Service/RBAC 等基础资源）
├── ha/                   # 高可用（HA）模式的专属配置（你第二次用的文件就在这！）
│   ├── install.yaml      # HA 模式完整安装清单
│   └── base/             # HA 模式的 Kustomize 叠加配置（多副本、Redis 哨兵等）
└── …（其他场景：低权限模式、开发者模式等）

   install.yaml与 ha/install.yaml 的本质：它们是通过 kustomize build 命令合并 base/ 目录的配置生成的「完整清单」，包含了所有 Deployment、Service、RBAC、CRD 资源。非 HA 版默认单副本，HA 版默认 3 副本控制器 + Redis 哨兵集群，无单点故障。

   –server-side –force-conflicts 参数的作用：因为 manifests/crds/ 里的 CRD 定义可能随版本更新，使用服务端应用（Server-side Apply）可以避免旧版本 CRD 字段冲突，确保安装成功。

3.4、核心业务逻辑库pkg目录

pkg/
├── application/    # 应用管理核心：资源差异计算（Diff）、同步逻辑
├── controller/    # 控制器 reconcile 循环：持续监听 Git 与集群状态
├── rbac/           # 细粒度权限控制（RBAC 策略验证）
├── git/            # Git 仓库交互逻辑（拉取、分支同步、凭证管理）
├── kube/           # Kubernetes API 交互逻辑（资源增删改查）
├── diff/           # 资源差异计算（含 v3.x 新增的「服务端 Diff」优化）
└── …（metrics/健康检查/缓存等通用模块）

3.5、场景化使用示例examples目录

examples/
├── k8s-rbac/argocd-server-applications/  # Argo CD自身的RBAC权限配置示例
├── known-hosts/                          # SSH known_hosts配置示例
├── plugins/helm/                         # Helm配置管理插件(CMP)示例
├── dashboard-legacy.json                 # 旧版Grafana监控仪表盘
└── dashboard.json                        # 最新版Argo CD控制器遥测仪表盘

四、安装Argo CD服务端

Argo CD服务端部署

五、部署Traefikv3.7.1版本访问argocd web

部署Traefikv3.7.1版本访问web(k8s)

https://argocd.dashboard.com/

admin / QVpFeGl9cfezIfnA

六、更改argocd web的登录密码

目的：不用每次都去查询，直接设置一个密码进行登录：

https://argocd.dashboard.com/ admin / Admin@2026#

七、Argo CD客户端工具安装和使用

ArgoCD客户端工具安装和使用

经过客户端修改后的密码:

https://argocd.dashboard.com/
admin / Admin@2026##
[root@master1 argocd-ns]# argocd cluster list
SERVER                          NAME        VERSION  STATUS      MESSAGE  PROJECT
https://kubernetes.default.svc  in-cluster  1.35.1   Successful           
[root@master1 argocd-ns]# 

八、K8S集群集成Harbor 

8.1、修改Docker的全局配置文件(所有节点执行)

cat > /etc/docker/daemon.json << EOF
{
 "data-root":"/datah/docker",
 "exec-opts": ["native.cgroupdriver=systemd"],
 "insecure-registries": ["192.168.1.20"],
 "bip":"170.64.0.1/16",
 "registry-mirrors": [
    "https://docker.registry.cyou",
    "https://docker-cf.registry.cyou",
    "https://dockercf.jsdelivr.fyi",
    "https://docker.jsdelivr.fyi",
    "https://dockertest.jsdelivr.fyi",
    "https://mirror.aliyuncs.com",
    "https://dockerproxy.com",
    "https://mirror.baidubce.com",
    "https://docker.m.daocloud.io",
    "https://docker.nju.edu.cn",
    "https://docker.mirrors.sjtug.sjtu.edu.cn",
    "https://docker.mirrors.ustc.edu.cn",
    "https://mirror.iscas.ac.cn",
    "https://docker.rainbond.cc"
  ],
 "max-concurrent-downloads":10,
 "log-driver":"json-file",
 "log-level":"warn",
 "log-opts": {
   "max-size":"10m",
   "max-file":"3"
  }
}
EOF

8.2、删除本地代理后面有需要的时候再添加

cd /etc/systemd/system/docker.service.d
rm -f http-proxy.conf

8.3、重新加载配置并重启

systemctl daemon-reload
systemctl restart docker

8.4、docker 登录harbor

docker login http://192.168.1.20 -u admin -p Harbor12345

8.5、把Argo CD的镜像推送到私有仓库

docker pull ghcr.io/dexidp/dex:v2.45.0
docker tag ghcr.io/dexidp/dex:v2.45.0 192.168.1.20/dexidp/dex:v2.45.0
docker push 192.168.1.20/dexidp/dex:v2.45.0

docker pull public.ecr.aws/docker/library/redis:8.2.3-alpine
docker tag public.ecr.aws/docker/library/redis:8.2.3-alpine 192.168.1.20/docker/library/redis:8.2.3-alpine
docker push 192.168.1.20/docker/library/redis:8.2.3-alpine

docker pull quay.io/argoproj/argocd:v3.4.2
docker tag quay.io/argoproj/argocd:v3.4.2 192.168.1.20/argoproj/argocd:v3.4.2
docker push 192.168.1.20/argoproj/argocd:v3.4.2

8.6、替换镜像并升级应用使用私有镜像

备份原始文件：

cp install.yaml install.yaml.bak

一键替换所有镜像前缀为你的私有仓库：

sed -i 's|quay.io/argoproj/argocd|192.168.1.20/argoproj/argocd|g' install.yaml
sed -i 's|ghcr.io/dexidp/dex|192.168.1.20/dexidp/dex|g' install.yaml
sed -i 's|public.ecr.aws/docker/library/redis|192.168.1.20/docker/library/redis|g' install.yaml

查看修改后的镜像地址：

grep -E 'image:|repository:' install.yaml | grep -E '192.168.1.20|quay.io|ghcr.io|public.ecr.aws'

执行升级（和安装时保持同样的命令）：

kubectl apply -n argocd –server-side –force-conflicts -f install.yaml

验证升级结果：

watch -n 2 'kubectl get pod -n argocd'

查看新 Pod 使用的镜像地址：

kubectl get pod -n argocd -l app.kubernetes.io/name=argocd-server -o jsonpath='{.items[0].spec.containers[0].image}'

目的：现在都是使用的私有镜像了，不存在外部网络问题。

九、Argo CD快速实践

        提前用jenkins构建了三个版本的镜像：v0.0.1，v0.0.2，v0.0.3，Argo CD主要是CD的过程不在CI构建镜像的过程。Jenkins 流水线构建vue前端项目

v0.0.1

docker pull 192.168.1.20/toolbox/toolbox-web:v0.0.1

v0.0.2

docker pull 192.168.1.20/toolbox/toolbox-web:v0.0.2

v0.0.3

docker pull 192.168.1.20/toolbox/toolbox-web:v0.0.3

9.1、先把之前用jenkins部署的 toolbox-bigdata删除掉

[root@master1 ~]# kubectl get pod -n toolbox-bigdata 
NAME                                    READY   STATUS    RESTARTS   AGE
toolbox-web-platform-66987fff5f-6fzj6   1/1     Running   0          10m
toolbox-web-platform-66987fff5f-hjtgc   1/1     Running   0          10m
[root@master1 ~]# kubectl delete ns toolbox-bigdata
namespace "toolbox-bigdata" deleted

9.2、在前端项目toolbox-web下之前已经创建好了包含应用的yaml文件

先把image: ${IMAGE} 替换成：

image: 192.168.1.20/toolbox/toolbox-web:v0.0.1

apiVersion: apps/v1
kind: Deployment
metadata:
  name: toolbox-web-platform
  labels:
    app: toolbox-web-platform
    version: v1
spec:
  replicas: 2
  selector:
    matchLabels:
      app: toolbox-web-platform
  template:
    metadata:
      labels:
        app: toolbox-web-platform
        version: v1
    spec:
      containers:
        – name: toolbox-web-platform
          image: 192.168.1.20/toolbox/toolbox-web:v0.0.1
          imagePullPolicy: IfNotPresent
          ports:
            – name: http
              containerPort: 80
              protocol: TCP
          resources:
            requests:
              cpu: 100m
              memory: 128Mi
            limits:
              cpu: 500m
              memory: 512Mi
          livenessProbe:
            httpGet:
              path: /
              port: http
            initialDelaySeconds: 10
            periodSeconds: 5
            timeoutSeconds: 3
            failureThreshold: 3
          readinessProbe:
            httpGet:
              path: /
              port: http
            initialDelaySeconds: 5
            periodSeconds: 5
            timeoutSeconds: 3
            failureThreshold: 3
apiVersion: v1
kind: Service
metadata:
  name: toolbox-web-platform-service
  labels:
    app: toolbox-web
spec:
  type: NodePort
  selector:
    app: toolbox-web-platform
  ports:
    – name: http
      port: 8080
      targetPort: http
      protocol: TCP
      nodePort: 30080

9.3、Argo CD添加仓库地址

        Argo CD添加仓库地址，Settings → Repositories，点击 CONNECT REPO 按钮添加仓库，填写以下信息：

Choose your connection method: 【选择http方式🔗 】

VIA HTTP/HTTPS

Type: 【选择git 】

git

Name: 【仓库名称】

toolbox-web

Project: 【所属项目】

default

Repository URL:【代码仓库地址】

http://192.168.1.50:8980/aiops-team/toolbox-web.git

Username (optional)：【Git 仓库的账号】

root

Password (optional)：【个人访问令牌】

glpat-QEehDmbcU92LUzCnh10V-W86MQp1OjUH.01.0w08fdg81

点击链接：

🔗代码仓库连接成功：

  如果集群连接失败，检查argocd-repo-server日志，是否可以正常访问 git 仓库，账号密码是否正确，是否有权限访问仓库。

kubectl logs -n argocd argocd-repo-server-ff5578b69-nd5mn -f

9.4、代码创库连成功后：创建应用

Application Name：【应用名称】

toolbox-web

Project Name: 【所属项目】

default

Sync Policy：【同步策略】

两种策略：

Manual（手动同步）：只有你手动点击同步按钮，ArgoCD 才会拉取 Git 里的最新配置，并应用到集群。

Automatic（自动同步）：当 Git 仓库里的配置发生变化时，ArgoCD 会自动拉取并同步到集群。

Automatic

Revision：【代码分支选择开发分支】

develop

Path：【资源所在路径】

ArgoCD 会在仓库里的 k8s/ 目录下，寻找 Kubernetes 的 文件（Deployment、Service、Ingress 等 YAML），并把它们部署到集群里。

argocd

Cluster URL: [选择要部署的集群]

https://kubernetes.default.svc

Namespace: [部署到对应的空间下]

toolbox-bigdata

创建完后界面显示：

并且立马开启了首次部署：

9.5、验证应用部署情况

[root@master1 ~]# kubectl get pod -n toolbox-bigdata
NAME                                    READY   STATUS    RESTARTS   AGE
toolbox-web-platform-567ffdd95c-bkgl4   1/1     Running   0          4m51s
toolbox-web-platform-567ffdd95c-vjj7b   1/1     Running   0          4m51s
[root@master1 ~]# kubectl get svc -n toolbox-bigdata
NAME                           TYPE       CLUSTER-IP     EXTERNAL-IP   PORT(S)          AGE
toolbox-web-platform-service   NodePort   10.96.187.25   <none>        8080:30080/TCP   4m57s
[root@master1 ~]# 

访问web页面验证：

http://192.168.100.200:30080/

9.6、提交代码，验证更新应用

把代码仓库代码的将镜像版本v0.0.1 修改到  v0.0.2：

ArgoCD 默认每 3 分钟（180 秒） 检查一次 Git 仓库的配置是否有变化：

访问web页面，发现已经完成了发布工作：

再次提交代码更新：把代码仓库代码的将镜像版本v0.0.2 修改到  v0.0.3

访问web页面，发现 v0.0.3 发布工作：

9.7、如何完成版本回退

点击History and rollback查看应用的所有发布记录，可以选择指定版本进行回退操作。

在历史版本中选择要回退的版本：

再次访问发现已经回退到v0.0.2版本

9.8、手动点击立即同步代码仓库进行发布

选项

含义

适用场景

SKIP SCHEMA VALIDATION：跳过 Kubernetes 资源的 Schema 校验，适合非标准 / CRD 资源。

APPLY OUT OF SYNC ONLY：只同步状态为 OutOfSync的资源，跳过已经和 Git 一致的资源。

SERVER-SIDE APPLY：使用 Kubernetes 服务端合并模式应用配置，避免客户端本地状态不一致问题。

AUTO-CREATE NAMESPACE：如果目标 Namespace 不存在，自动创建它。

RESPECT IGNORE DIFFERENCES：尊重应用里配置的「忽略差异」规则，同步时跳过指定字段的变更。

PRUNE LAST：先创建 / 更新新资源，最后再删除旧资源，避免服务中断。

十、Jenkins 和 ArgoCD 实现标准GitOps流程

        Jenkins 只做 前端打包 → 构建镜像 → 推送 Harbor → 提交更新镜像标签的 YAML 到 Git。

         ArgoCD 监听 Git 仓库，自动拉取 YAML 并同步到 K8s，不再让 Jenkins 直接操作 kubectl apply。

10.1、ArgoCD CLI客户端的下载地址

目的：可以在Jenkins 里面监听ArgoCD 同步相关的状态。

ArgoCD私有地址：

https://argocd.dashboard.com/
admin / Admin@2026##

下载客户端工具包

https://argocd.dashboard.com/download/argocd-linux-amd64

客户端工具包互联网下载地址：

https://github.com/argoproj/argo-cd/releases/download/v3.4.3/argocd-linux-amd64

10.2、Jenkins 安装ArgoCD CLI

Jenkins部署指南(docker)

mkdir -p /datah/jenkins-data/argocd
cd /datah/jenkins-data/argocd
wget https://argocd.dashboard.com/download/argocd-linux-amd64 –no-check-certificate

mv argocd-linux-amd64 argocd
chmod +x argocd 

10.3、Jenkins把ArgoCD客户端挂入容器

1、进入Jenkins程序目录

cd /usr/local/jenkins/

2、编辑docker-compose.yml新增挂载配置

vim docker-compose.yml
volumes:
      – …….原来的配置保持不变…….
      – /datah/jenkins-data/argocd/argocd:/usr/local/bin/argocd   # 挂载argocd客户端工具
    ……..
    user: "root"
    extra_hosts: # 域名解析替换成你的 ArgoCD 实际 IP
      – "argocd.dashboard.com:192.168.100.200" 

3、全量Jenkins的yaml

services:
  jenkins:
    image: 192.168.1.20/jenkins/jenkins:2.555.1-lts-jdk21
    container_name: jenkins
    hostname: jenkins
    ports:
      – "58081:8080"   # Jenkins Web UI
      – "50000:50000"  # Jenkins agent communication
    volumes:
      – /datah/jenkins-data:/var/jenkins_home:rw               # 持久化数据，避免容器重启丢失配置
      – /var/run/docker.sock:/var/run/docker.sock             # 允许 Jenkins 调用宿主机的 Docker
      – /usr/local/bin/docker:/usr/bin/docker                 # 将宿主机二进制文件挂载到jenkins容器内部
      – /etc/docker/daemon.json:/etc/docker/daemon.json       # 镜像加速文件挂载到jenkins容器内部
      – /datah/jenkins-data/kubectlv1351/kubectl:/usr/local/bin/kubectl:x   #挂载kubectl到容器的系统PATH目录
      – /datah/jenkins-data/jdk17:/usr/local/jdk17
      – /datah/jenkins-data/maven:/usr/local/maven            # 将宿主机上的 Maven 挂载到容器内部
      – /datah/jenkins-data/go:/usr/local/go                  # 将宿主机上的 golang 挂载到容器内部
      – /datah/jenkins-data/nodejs:/usr/local/nodejs          # 蒋目录下的 nodejs 挂载到容器内部
      – /datah/jenkins-data/python3:/usr/local/python3        # 蒋目录下的 python3 挂载到容器内部
      – /datah/jenkins-data/ssh:/root/.ssh                    # 将宿主机上的 .ssh 挂载到容器内部
      – /usr/bin/envsubst:/usr/local/bin/envsubst             # 命令行工具  gettext 软件包
      – /usr/bin/make:/usr/local/bin/make                     # 构建自动化工具 软件包
      – /datah/jenkins-data/argocd/argocd:/usr/local/bin/argocd   # 挂载argocd客户端工具
    environment:
      – JENKINS_OPTS=–prefix=/jenkins                        # 设置 Jenkins 的上下文路径  #http://0.0.0.0:58081/jenkins/
     #- JAVA_HOME=/usr/local/jdk17
      – JAVA_OPTS=-Dsonar.qualitygate.wait=true
      – JDK17_HOME=/usr/local/jdk17
      – MAVEN_HOME=/usr/local/maven
      – PYTHON_HOME=/usr/local/python3
      – NODE_HOME=/usr/local/nodejs
      – GOPATH=$HOME/go
      – GOROOT=/usr/local/go
      – TZ=Asia/Shanghai
    restart: always  # 容器自动重启
    privileged: true  # 允许容器内运行需要更高权限的进程（如 Docker-in-Docker）
    user: "root"  # 以 root 用户运行容器
    extra_hosts: # 域名解析替换成你的 ArgoCD 实际 IP
      – "argocd.dashboard.com:192.168.100.200" 

4、停止Jenkins

docker-compose down

5、启动Jenkins

docker-compose up -d

10.4、验证Jenkins容器的argocd客户端

1、进入容器

docker exec -it jenkins /bin/bash

2、查看客户端版本

[root@node nodejs]# docker exec -it jenkins  /bin/bash
root@jenkins:/# argocd version
argocd: v3.4.2
  BuildDate: 2026-05-12T20:34:57Z
  GitCommit: 0dc6b1b57dd5bb925d5b03c3d09419ab9fb4225e
  GitTreeState: clean
  GitTag: v3.4.2
  GoVersion: go1.26.0
  Compiler: gc
  Platform: linux/amd64
{"level":"fatal","msg":"Argo CD server address unspecified","time":"2026-05-30T18:00:21+08:00"}
root@jenkins:/# 

10.5、Jenkins 新增 ArgoCD 凭据

ArgoCD客户端工具安装和使用

1、在 ArgoCD CLI 中生成生成 token

在 ArgoCD 所在节点执行,集群客户端节生成 token（无过期时间），不建议直接给 admin 账号开启 apiKey，login，更安全的做法是创建一个专用的服务账号：

创建Jenkins 账号并开启 apiKey，login：

kubectl patch configmap argocd-cm -n argocd –type merge -p '{"data":{"accounts.jenkins":"apiKey, login"}}'

查看 ArgoCD 系统中所有账号的配置：

argocd account list -o wide

给jenkins账号配置 RBAC 权限（argocd-rbac-cm）：

kubectl patch configmap argocd-rbac-cm -n argocd –type merge -p '{"data":{"policy.csv":"p, jenkins, *, *, *, allow"}}'

查询权限：

kubectl get configmap argocd-rbac-cm -n argocd -o yaml | grep -A 10 "policy.csv"

* * * allow 全权限，适合测试环境，生产环境建议只给必要权限。

给在ArgoCD中的jenkins账号生成 Token （这个 Token 是永久有效的）：

argocd account generate-token –account jenkins –id jenkins-ci

# 生成的token
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJhcmdvY2QiLCJzdWIiOiJqZW5raW5zOmFwaUtleSIsIm5iZiI6MTc4MDEzNjMwNCwiaWF0IjoxNzgwMTM2MzA0LCJqdGkiOiJqZW5raW5zLWNpIn0.OY7W8IER7H2Wo5aFMuTeEKC-9vccIcCYh4hWroyzCIU

生产环境不建议使用永久 Token

argocd account generate-token –account jenkins –id jenkins-ci –expires-in 720h

–account：指定要生成 token 的 ArgoCD 账号（必填）。

–id：可选参数，给 token 设置一个标识（替代了你原本想使用的 –name 作用）。

–expires-in：可选参数，设置 token 有效期（例如 720h 代表 30 天，默认永久有效）。

重启 ArgoCD Server 使配置生效：

kubectl rollout restart deployment argocd-server -n argocd

2、用  ArgoCD CLI 命令验证

# 1. 设置 Token 环境变量（替换成你自己的 Token）
export ARGOCD_AUTH_TOKEN="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJhcmdvY2QiLCJzdWIiOiJqZW5raW5zOmFwaUtleSIsIm5iZiI6MTc4MDEzNjMwNCwiaWF0IjoxNzgwMTM2MzA0LCJqdGkiOiJqZW5raW5zLWNpIn0.OY7W8IER7H2Wo5aFMuTeEKC-9vccIcCYh4hWroyzCIU"
# 2. 直接执行 ArgoCD 命令，无需 login
argocd app get toolbox-web –grpc-web –insecure

3、在Jenkins 中新增 ArgoCD 凭据

ID：argocd-token

内容：ArgoCD-Token

4、新建一个流水线验证 ArgoCD客户端获取应用信息

argocd-test-jenkins-token

pipeline {
    agent any
    environment {
        // ArgoCD 服务器地址
        ARGOCD_SERVER = "argocd.dashboard.com"
        // 从 Jenkins 凭据库读取 Token
        ARGOCD_TOKEN = credentials('argocd-token')
    }
    stages {
        stage('验证 ArgoCD Token 与权限') {
            steps {
                script {
                    echo "=== 开始验证 ArgoCD 客户端权限 ==="
                    sh '''
                        set -e
                        # 直接用环境变量鉴权，无需 login 命令
                        export ARGOCD_AUTH_TOKEN="${ARGOCD_TOKEN}"

                        echo "✅ 1. 测试获取 ArgoCD 应用列表"
                        argocd app list –grpc-web –insecure

                        echo "✅ 2. 测试获取指定应用详情（替换成你的应用名）"
                        argocd app get toolbox-web –grpc-web –insecure

                        echo "✅ 3. 测试应用同步状态"
                        argocd app sync toolbox-web –grpc-web –insecure –timeout 60

                        echo "🎉 ArgoCD 客户端验证全部通过！"
                    '''
                }
            }
        }
    }
    post {
        always {
            echo "=== ArgoCD 客户端验证流程结束 ==="
        }
        success {
            echo "✅ 所有验证步骤均成功，Token 与权限配置正常！"
        }
        failure {
            echo "❌ 验证失败，请检查 Token、ArgoCD 地址或 RBAC 权限配置"
        }
    }
}

5、流水线新增 ArgoCD 配置完成整个过程

pipeline {
    agent any
    environment {
        // 合并系统PATH和自定义工具路径，确保所有命令都能找到
        PATH = "${env.PATH}:" +
               "${env.JAVA_HOME}/bin:" +
               "${env.JDK17_HOME}/bin:" +
               "${env.MAVEN_HOME}/bin:" +
               "${env.GO_HOME}/bin:" +
               "${env.NODE_HOME}/bin:" +
               "${env.PYTHON_HOME}/bin"

        // 私有Harbor仓库配置
        HARBOR_REGISTRY = "192.168.1.20"
        HARBOR_PROJECT  = "toolbox"

        // 新增 ArgoCD 配置
        ARGOCD_SERVER = "argocd.dashboard.com"
        ARGOCD_APP_NAME = "toolbox-web"
        ARGOCD_TOKEN = credentials('argocd-token')

        // K8s配置
        KUBECONFIG_CRED = "kubeconfig-cred"
        K8SNAMESPACE = "toolbox-bigdata"

        // 应用配置
        DEPLOYMENT_NAME = "toolbox-web-platform"
        K8S_DEPLOY_FILE = "k8s/deployment.yaml"
        K8S_SERVICE_FILE = "k8s/service.yaml"
    }
    stages {
        // 验证分支是否正确获取
        stage('打印分支信息') {
            steps {
                echo "当前构建的分支是：${BRANCH}"
                echo "通过环境变量获取：${env.BRANCH}"
                echo "输入版本号：${VERSION}"
                echo "通过环境变量获取输入版本号：${env.VERSION}"
            }
        }

        stage('拉取代码') {
            steps {
                // 核心：直接使用 ${BRANCH} 引用用户选择的分支
                git(
                    url: 'http://192.168.1.50:8980/aiops-team/toolbox-web.git',
                    branch: "${BRANCH}", // 必须用双引号！
                    credentialsId: 'gitlab-group-token' // 你的凭据ID
                )
            }
        }

        stage('前端构建') {
            steps {
                sh '''
                    set -e
                    # 配置国内npm源，解决依赖下载慢/超时问题
                    npm config set registry https://registry.npmmirror.com/

                    # 验证Node/NPM版本
                    node -v
                    npm -v

                    # 安装依赖（ci比install更稳定，适合CI环境）
                    npm ci

                    # 生产环境打包
                    npm run build

                    # 验证构建产物
                    ls -la dist/
                '''
            }
        }

        stage('拷贝产物至docker目录') {
            steps {
                sh '''
                    set -e
                    # 如果docker目录不存在则自动创建
                    mkdir -p docker
                    # 递归拷贝dist全部文件到docker目录
                    cp -r dist docker/
                    # 校验拷贝结果
                    ls -la docker/
                '''
            }
        }

       stage('构建镜像并推送Harbor') {
           steps {
               withCredentials([usernamePassword(
                   credentialsId: 'harbor-creds',
                   usernameVariable: 'HARBOR_USER',
                   passwordVariable: 'HARBOR_PASS'
               )]) {
                   sh '''

                       # 进入docker目录
                       cd docker

                       echo "输入版本号：${VERSION}"
                       # 判断VERSION是否为空
                       if [ -z ${VERSION} ]; then
                            IMAGE_TAG="${HARBOR_REGISTRY}/${HARBOR_PROJECT}/toolbox-web:${BRANCH}-${BUILD_NUMBER}"
                       else
                            IMAGE_TAG="${HARBOR_REGISTRY}/${HARBOR_PROJECT}/toolbox-web:${VERSION}"
                       fi

                       # 拼接前端镜像标签：仓库/项目/应用名:分支-构建号
                       # IMAGE_TAG="${HARBOR_REGISTRY}/${HARBOR_PROJECT}/toolbox-web:${BRANCH}-${BUILD_NUMBER}"
                       echo "🔨 开始构建镜像：${IMAGE_TAG}"

                       # 构建Docker镜像
                       docker build -t "${IMAGE_TAG}" .

                       if [ $? -eq 0 ]; then
                           echo "✅ 镜像构建成功！"
                           docker images "${IMAGE_TAG}"
                       else
                           echo "❌ 镜像构建失败！"
                           exit 1
                       fi

                       # 登录Harbor仓库
                       echo "🔐 登录Harbor仓库：${HARBOR_REGISTRY}"
                       docker login "${HARBOR_REGISTRY}" -u "${HARBOR_USER}" -p "${HARBOR_PASS}"

                       if [ $? -eq 0 ]; then
                           echo "✅ Harbor登录成功！"
                       else
                           echo "❌ Harbor登录失败！"
                           exit 1
                       fi

                       # 推送镜像到Harbor
                       echo "🚀 推送镜像到Harbor：${IMAGE_TAG}"
                       docker push "${IMAGE_TAG}"

                       if [ $? -eq 0 ]; then
                           echo "✅ 镜像推送成功！"
                       else
                           echo "❌ 镜像推送失败！"
                           exit 1
                       fi

                       # 清理本地镜像，释放磁盘
                       echo "🧹 清理本地镜像"
                       docker rmi "${IMAGE_TAG}"
                       docker logout "${HARBOR_REGISTRY}"

                       echo "当前构建号：${BUILD_NUMBER}"

                       # 写入环境变量文件，供后续部署阶段读取
                       echo "IMAGE=${IMAGE_TAG}" > ../image.env
                       echo "BRANCH=${BRANCH}" >> ../image.env
                       echo "BUILD_NUMBER=${BUILD_NUMBER}" >> ../image.env
                       echo "APP_NAME=toolbox-web" >> ../image.env

                       echo "🎉 镜像构建推送完成！"
                       echo "📦 最终镜像地址：${IMAGE_TAG}"
                   '''
               }
           }
       }
        // ========== 核心阶段：更新 ArgoCD 目录下的 YAML 并提交 ==========
        stage('更新ArgoCD目录镜像配置并推送Git') {
            steps {
                script {
                    // 读取上一步生成的镜像地址
                    def imageEnv = readFile('image.env').trim()
                    def envMap = [:]
                    imageEnv.split('\\n').each { line ->
                        def parts = line.split('=', 2)
                        envMap[parts[0]] = parts[1]
                    }
                    def NEW_IMAGE = envMap['IMAGE']
                    echo "🔧 待替换镜像地址：${NEW_IMAGE}"
                    echo "📄 源YAML目录：k8s/"
                    echo "📄 目标YAML目录：argocd/"

                    sh """
                        set -e
                        # 1. 创建 argocd 目录（如果不存在）
                        mkdir -p argocd/

                        # 2. 复制 k8s/ 目录下的所有 YAML 文件到 argocd/ 目录
                        cp -r k8s/* argocd/

                        # 3. 只在 argocd/ 目录下替换镜像占位符
                        sed -i "s|\\\\\\${IMAGE}|${NEW_IMAGE}|g" argocd/deployment.yaml

                        # 4. 查看变更内容（只看 argocd/ 目录）
                        git diff argocd/ || true

                        # 5. 配置 Git 提交人信息
                        git config –global user.name "Jenkins-CI-Auto"
                        git config –global user.email "jenkins-ci@local.com"

                        # 6. 只暂存、提交 argocd/ 目录的变更
                        git add argocd/
                        git commit -m "CI: update image to ${NEW_IMAGE} | Build:${BUILD_NUMBER} | Branch:${BRANCH}"
                    """

                    // 7. 使用读写凭据推送到远端 Git 仓库
                    withCredentials([usernamePassword(
                        credentialsId: 'gitlab-group-token', // 必须是有写权限的凭据
                        usernameVariable: 'GIT_USER',
                        passwordVariable: 'GIT_PASS'
                    )]) {
                        sh """
                            set -e
                            # 推送当前分支到远端
                            git push http://${GIT_USER}:${GIT_PASS}@192.168.1.50:8980/aiops-team/toolbox-web.git ${BRANCH}
                            echo "✅ argocd/ 目录YAML已推送至 Git，ArgoCD 开始检测变更"
                        """
                    }
                }
            }
        }

        stage('等待ArgoCD同步完成') {
            steps {
                withEnv([
                    "ARGOCD_SERVER=${ARGOCD_SERVER}",
                    "ARGOCD_APP_NAME=${ARGOCD_APP_NAME}",
                    "ARGOCD_AUTH_TOKEN=${ARGOCD_TOKEN}"
                ]) {
                    sh '''
                        set -e
                        echo "🔍 直接使用Token鉴权，等待 ArgoCD 同步与应用健康…"

                        # 1. 强制刷新 ArgoCD，让它立刻感知 Git 变更
                        argocd app get ${ARGOCD_APP_NAME} –refresh –grpc-web –insecure
                        echo "✅ 已触发 ArgoCD 立即检测变更"

                        # 2. 强制触发应用同步（关键步骤！）
                        echo "🚀 强制触发应用同步…"
                        argocd app sync ${ARGOCD_APP_NAME} –grpc-web –insecure –timeout 60

                        # 3. 阻塞等待同步完成 + 应用健康
                        echo "⏳ 等待同步完成与应用健康…"
                        argocd app wait ${ARGOCD_APP_NAME} \\
                            –sync \\
                            –health \\
                            –timeout 300 \\
                            –grpc-web \\
                            –insecure

                        echo "✅ ArgoCD 同步&健康检查通过"
                    '''
                }
            }
        }

        stage('部署完成通知') {
            steps {
                echo "🎉 应用已成功部署到 K8s 集群！"
                echo "👉 ArgoCD 应用地址：http://${ARGOCD_SERVER}/applications/${ARGOCD_APP_NAME}"
            }
        }

    }
}