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、手动点击立即同步代码仓库进行发布

选项	含义	适用场景
PRUNE	修剪：删除集群中存在、但 Git 仓库里已经没有的资源	当你在 Git 里删除了某个资源（比如旧的 Deployment），勾选后 ArgoCD 会自动把集群里的对应资源删掉
DRY RUN	试运行：只模拟同步过程，不实际修改集群	想先看看同步会做哪些变更，确认没问题再执行
APPLY ONLY	仅应用：只创建 / 更新资源，不做删除 / 替换操作	避免误删资源，只保证 Git 里的资源在集群里存在
FORCE	强制同步：绕过部分冲突检查，强制覆盖集群状态	资源状态卡住、常规同步失败时使用，有风险

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}"
            }
        }

    }
}