

 **帮助改进此页面** 

要帮助改进本用户指南，请选择位于每个页面右侧窗格中的**在 GitHub 上编辑此页面**链接。

# 使用 Argo CD 持续部署
<a name="argocd"></a>

Argo CD 是一款适用于 Kubernetes 的声明式 GitOps 持续交付工具。借助 Argo CD，您可以跨多个集群和环境自动部署应用程序并管理其生命周期。Argo CD 支持多种来源类型，包括 Git 存储库、Helm 注册表（HTTP 和 OCI）和 OCI 映像，为具有不同安全和合规要求的组织提供了灵活性。

得益于 EKS 功能，Argo CD 完全由 AWS 托管，无需您在集群上安装、维护和扩展 Argo CD 控制器及其依赖项。

## Argo CD 的工作原理
<a name="_how_argo_cd_works"></a>

Argo CD 遵循 GitOps 模式，其中您的应用程序源（Git 存储库、Helm 注册表或 OCI 映像）是用于定义所需应用程序状态的事实来源。在创建 Argo CD `Application` 资源时，需要指定包含应用程序清单的源以及目标 Kubernetes 集群和命名空间。Argo CD 持续监控集群中的源状态和实时状态，并且自动同步所有更改以确保集群状态与所需状态保持一致。

**注意**  
借助适用于 Argo CD 的 EKS 功能，Argo CD 软件可在 AWS 控制面板上运行，而不是在 Worker 节点上运行。这意味着您的 Worker 节点不需要直接访问 Git 存储库或 Helm 注册表：此功能可处理来自 AWS 账户的源访问。

Argo CD 提供三种主要资源类型：
+  **Application**：定义从 Git 存储库到目标集群的部署
+  **ApplicationSet**：根据用于多集群部署的模板生成多个应用程序
+  **AppProject**：为应用程序提供逻辑分组和访问权限控制

 **示例：创建 Argo CD 应用程序** 

以下示例说明了如何创建 Argo CD `Application` 资源：

```
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: guestbook
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://github.com/argoproj/argocd-example-apps.git
    targetRevision: HEAD
    path: guestbook
  destination:
    name: in-cluster
    namespace: guestbook
  syncPolicy:
    automated:
      prune: true
      selfHeal: true
```

**注意**  
将 `destination.name` 用于您注册集群时使用的集群名称（如适用于本地集群的 `in-cluster`）。`destination.server` 字段也适用于 EKS 集群 ARN，但为了提高可读性，建议使用集群名称。

## Argo CD 的优势
<a name="_benefits_of_argo_cd"></a>

Argo CD 实施 GitOps 工作流程，在该工作流程中，您可以在 Git 存储库中定义应用程序配置，然后 Argo CD 会自动同步您的应用程序，以便与预期状态保持一致。这种以 Git 为中心的方法可提供对所有更改的完整审计跟踪记录，实现轻松回滚，并且可以自然地与您现有的代码审查和批准流程集成。Argo CD 会自动检测和协调 Git 中所需状态与集群中实际状态之间的偏差，确保您的部署与声明的配置保持一致。

借助 Argo CD，您可以从单个 Argo CD 实例跨多个集群部署和管理应用程序，从而简化多集群和多区域环境中的操作。Argo CD 用户界面提供可视化和监控功能，允许您查看应用程序的部署状态、运行状况和历史记录。用户界面与 AWS Identity Center（原 AWS SSO）集成，可实现无缝身份验证和授权，使您能够使用现有的身份管理基础设施控制访问权限。

作为 EKS 托管功能的一部分，Argo CD 完全由 AWS 管理，无需安装、配置和维护 Argo CD 基础设施。AWS 负责扩展、修补和操作管理，让您的团队能够专注于应用程序交付而不是工具维护。

## 与 AWS Identity Center 集成
<a name="integration_with_shared_aws_identity_center"></a>

EKS 托管功能提供 Argo CD 与 AWS Identity Center 之间的直接集成，为您的用户提供无缝身份验证和授权。启用 Argo CD 功能后，您可以将 AWS Identity Center 集成配置为将 Identity Center 组和用户映射到 Argo CD RBAC 角色，从而控制谁可以访问和管理 Argo CD 中的应用程序。

## 与其他 EKS 托管功能集成
<a name="_integration_with_other_eks_managed_capabilities"></a>

Argo CD 可与其他 EKS 托管功能集成。
+  **AWS Controllers for Kubernetes（ACK）**：使用 Argo CD 跨多个集群管理 ACK 资源的部署，为 AWS 基础设施启用 GitOps 工作流程。
+  **kro（Kube Resource Orchestrator）**：使用 Argo CD 在多个集群中部署 kro 组合，从而在整个 Kubernetes 资产中实现一致的资源组合。

## 开始使用 Argo CD
<a name="_getting_started_with_argo_cd"></a>

要开始使用适用于 Argo CD 的 EKS 功能，请执行以下操作：

1. 创建和配置 IAM 功能角色，该角色具有必要权限，能让 Argo CD 访问您的源和管理应用程序。

1.  通过 AWS 控制台、AWS CLI 或偏好的基础设施即代码工具，在 EKS 集群上[创建 Argo CD 功能资源](create-argocd-capability.md)。

1. 配置存储库访问权限并注册集群，进行应用程序部署。

1. 创建应用程序资源，以从声明式源部署应用程序。

# 创建 Argo CD 功能
<a name="create-argocd-capability"></a>

本主题旨在介绍如何在 Amazon EKS 集群上创建 Argo CD 功能。

## 先决条件
<a name="_prerequisites"></a>

创建 Argo CD 功能之前，确保满足以下条件：
+ 运行受支持 Kubernetes 版本的现有 Amazon EKS 集群（标准支持与扩展支持范围内的所有版本均适用）
+  **AWS Identity Center 已配置**：此为 Argo CD 身份验证所需（不支持本地用户）
+ 具有 Argo CD 操作权限的 IAM 功能角色
+ 可在 EKS 集群上创建功能资源的充足 IAM 权限
+  已配置 `kubectl` 以与集群通信
+ （可选）已安装 Argo CD CLI，以便更便捷地进行集群与存储库管理
+ （适用于 CLI/eksctl）已安装并配置相应 CLI 工具

有关如何创建 IAM 功能角色的说明，请参阅 [Amazon EKS 功能 IAM 角色](capability-role.md)。有关设置 Identity Center 的信息，请参阅 [AWS Identity Center 入门](https://docs.aws.amazon.com/singlesignon/latest/userguide/getting-started.html)。

**重要**  
您提供的 IAM 功能角色，将决定 Argo CD 可以访问的 AWS 资源范围。这包括通过 CodeConnections 访问 Git 存储库，以及访问 Secrets Manager 中的密钥。有关创建具备最低权限的合适角色的操作指引，请参阅 [Amazon EKS 功能 IAM 角色](capability-role.md)和 [EKS 功能的安全注意事项](capabilities-security.md)。

## 选择工具
<a name="_choose_your_tool"></a>

您可以使用AWS 管理控制台、AWS CLI 或 eksctl 创建 Argo CD 功能：
+  [使用控制台创建 Argo CD 功能](argocd-create-console.md)：使用控制台获得引导式体验
+  [使用 AWS CLI 创建 Argo CD 功能](argocd-create-cli.md)：使用 AWS CLI 进行脚本编写和自动化
+  [使用 eksctl 创建 Argo CD 功能](argocd-create-eksctl.md)：使用 eksctl 获得 Kubernetes 原生体验

## 创建 Argo CD 功能时会执行的操作
<a name="_what_happens_when_you_create_an_argo_cd_capability"></a>

创建 Argo CD 功能时：

1. EKS 在 AWS 控制面板中创建 Argo CD 功能服务

1. 自定义资源定义（CRD）将被安装到集群中

1. 系统会自动为您的 IAM 功能角色创建一个访问条目，该条目带有特定于功能的访问条目策略，这些策略会授予基本的 Kubernetes 权限（请参阅 [EKS 功能的安全注意事项](capabilities-security.md)）

1. Argo CD 开始监视其自定义资源（应用程序、ApplicationSets、AppProjects）

1. 功能状态从 `CREATING` 更改为 `ACTIVE` 

1. 可通过对应的 URL 访问 Argo CD UI

功能进入运行状态后，即可在集群中创建 Argo CD 应用程序，以通过声明式源完成部署操作。

**注意**  
自动创建的访问条目不会授予将应用程序部署到集群的权限。要部署应用程序，您必须为每个目标集群配置额外的 Kubernetes RBAC 权限。有关注册集群和配置访问权限的详细信息，请参阅 [注册目标集群](argocd-register-clusters.md)。

## 后续步骤
<a name="_next_steps"></a>

创建 Argo CD 功能后：
+  [Argo CD 概念](argocd-concepts.md)：了解 GitOps 原则、同步策略及多集群模式
+  [使用 Argo CD](working-with-argocd.md)：配置存储库访问权限、注册目标集群及创建应用程序
+  [Argo CD 注意事项](argocd-considerations.md)：探索多集群架构模式及高级配置

# 使用控制台创建 Argo CD 功能
<a name="argocd-create-console"></a>

本主题将介绍如何使用 AWS 管理控制台创建 Argo CD 功能。

## 先决条件
<a name="_prerequisites"></a>
+  **已配置 AWS Identity Center**：Argo CD 需要使用 AWS Identity Center 进行身份验证。不支持本地用户。如果您尚未设置 AWS Identity Center，请参阅[开始使用 AWS Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/getting-started.html) 以创建 Identity Center 实例，并参阅[添加用户](https://docs.aws.amazon.com/singlesignon/latest/userguide/addusers.html)和[添加组](https://docs.aws.amazon.com/singlesignon/latest/userguide/addgroups.html)以创建用于访问 Argo CD 的用户和组。

## 创建 Argo CD 功能
<a name="_create_the_argo_cd_capability"></a>

1. 从以下位置打开 Amazon EKS 控制台：https://console.aws.amazon.com/eks/home\$1/clusters。

1. 选择集群名称，打开集群详细信息页面。

1. 选择**功能**选项卡。

1. 在左侧导航栏中，选择 **Argo CD**。

1. 选择**创建 Argo CD 功能**。

1. 对于 **IAM 功能角色**：
   + 如果已有 IAM 功能角色，请从下拉列表中选择该角色
   + 如需创建角色，请选择**创建 Argo CD 角色** 

     此操作会在新选项卡中打开 IAM 控制台，其中包含预填充的信任策略和 Secrets Manager 的完全读取权限。默认情况下不会添加其他权限，但您可以根据需要自行添加。如果计划使用 CodeCommit 存储库或其他 AWS 服务，请在创建角色之前添加相应的权限。

     创建角色后，返回 EKS 控制台，系统将自动选择该角色。
**注意**  
如果计划使用与 AWS Secrets Manager 或 AWS CodeConnections 的可选集成，则需要向该角色添加权限。有关 IAM 策略示例和配置指南，请参阅[使用 AWS Secrets Manager 管理应用程序密钥](integration-secrets-manager.md)和[使用 AWS CodeConnections 连接到 Git 存储库](integration-codeconnections.md)。

1. 配置 AWS Identity Center 集成：

   1. 选择**启用 AWS Identity Center 集成**。

   1. 从下拉列表中选择 Identity Center 实例。

   1. 通过将用户或组分配给 Argo CD 角色（ADMIN、EDITOR 或 VIEWER）来配置 RBAC 的角色映射

1. 选择**创建**。

功能创建过程随即开始。

## 验证功能是否处于活动状态
<a name="_verify_the_capability_is_active"></a>

1. 在**功能**选项卡上，查看 Argo CD 功能状态。

1. 等待状态从 `CREATING` 更改为 `ACTIVE`。

1. 变为活动状态后，该功能即可使用。

有关功能状态和问题排查的信息，请参阅[使用功能资源](working-with-capabilities.md)。

## 访问 Argo CD 用户界面
<a name="_access_the_argo_cd_ui"></a>

待该功能处于活动状态后，可以访问 Argo CD 用户界面：

1. 在 Argo CD 功能页面上，选择**打开 Argo CD 用户界面**。

1. Argo CD 用户界面将在新的浏览器选项卡中打开。

1. 现在，您可以通过用户界面创建应用程序和管理部署。

## 后续步骤
<a name="_next_steps"></a>
+  [使用 Argo CD](working-with-argocd.md)：配置存储库、注册集群和创建应用程序
+  [Argo CD 注意事项](argocd-considerations.md)：多集群架构和高级配置
+  [使用功能资源](working-with-capabilities.md)：管理 Argo CD 功能资源

# 使用 AWS CLI 创建 Argo CD 功能
<a name="argocd-create-cli"></a>

本主题将介绍如何使用 AWS CLI 创建 Argo CD 功能。

## 先决条件
<a name="_prerequisites"></a>
+  **AWS CLI**：版本 `2.12.3` 或更高版本。要检查版本，请运行 `aws --version`。有关更多信息，请参阅《AWS 命令行界面用户指南》中的[安装](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html)。
+  **`kubectl`**：用于与 Kubernetes 集群结合使用的命令行工具。有关更多信息，请参阅 [设置 `kubectl` 和 `eksctl`](install-kubectl.md)。
+  **已配置 AWS Identity Center**：Argo CD 需要使用 AWS Identity Center 进行身份验证。不支持本地用户。如果您尚未设置 AWS Identity Center，请参阅[开始使用 AWS Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/getting-started.html) 以创建 Identity Center 实例，并参阅[添加用户](https://docs.aws.amazon.com/singlesignon/latest/userguide/addusers.html)和[添加组](https://docs.aws.amazon.com/singlesignon/latest/userguide/addgroups.html)以创建用于访问 Argo CD 的用户和组。

## 步骤 1：创建 IAM 功能角色
<a name="_step_1_create_an_iam_capability_role"></a>

创建信任策略文件：

```
cat > argocd-trust-policy.json << 'EOF'
{
  "Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Service": "capabilities.eks.amazonaws.com"
      },
      "Action": [
        "sts:AssumeRole",
        "sts:TagSession"
      ]
    }
  ]
}
EOF
```

创建 IAM 角色：

```
aws iam create-role \
  --role-name ArgoCDCapabilityRole \
  --assume-role-policy-document file://argocd-trust-policy.json
```

**注意**  
如果计划使用与 AWS Secrets Manager 或 AWS CodeConnections 的可选集成，则需要向该角色添加权限。有关 IAM 策略示例和配置指南，请参阅[使用 AWS Secrets Manager 管理应用程序密钥](integration-secrets-manager.md)和[使用 AWS CodeConnections 连接到 Git 存储库](integration-codeconnections.md)。

## 步骤 2：创建 Argo CD 功能
<a name="_step_2_create_the_argo_cd_capability"></a>

在集群上创建 Argo CD 功能资源。

首先，为 Identity Center 配置设置环境变量：

```
# Get your Identity Center instance ARN (replace region if your IDC instance is in a different region)
export IDC_INSTANCE_ARN=$(aws sso-admin list-instances --region [.replaceable]`region` --query 'Instances[0].InstanceArn' --output text)

# Get a user ID for RBAC mapping (replace with your username and region if needed)
export IDC_USER_ID=$(aws identitystore list-users \
  --region [.replaceable]`region` \
  --identity-store-id $(aws sso-admin list-instances --region [.replaceable]`region` --query 'Instances[0].IdentityStoreId' --output text) \
  --query 'Users[?UserName==`your-username`].UserId' --output text)

echo "IDC_INSTANCE_ARN=$IDC_INSTANCE_ARN"
echo "IDC_USER_ID=$IDC_USER_ID"
```

创建集成了 Identity Center 的功能。将 *region-code* 替换为您的集群所在的 AWS 区域，将 *my-cluster* 替换为您的集群名称，将 *idc-region-code* 替换为您配置 IAM Identity Center 所在的区域代码：

```
aws eks create-capability \
  --region region-code \
  --cluster-name my-cluster \
  --capability-name my-argocd \
  --type ARGOCD \
  --role-arn arn:aws:iam::$(aws sts get-caller-identity --query Account --output text):role/ArgoCDCapabilityRole \
  --delete-propagation-policy RETAIN \
  --configuration '{
    "argoCd": {
      "awsIdc": {
        "idcInstanceArn": "'$IDC_INSTANCE_ARN'",
        "idcRegion": "'[.replaceable]`idc-region-code`'"
      },
      "rbacRoleMappings": [{
        "role": "ADMIN",
        "identities": [{
          "id": "'$IDC_USER_ID'",
          "type": "SSO_USER"
        }]
      }]
    }
  }'
```

命令会立即返回，但是由于 EKS 正在创建所需的功能基础设施和组件，该功能需要一些时间才能变为活动状态。在创建集群时，EKS 将在集群中安装与此功能相关的 Kubernetes 自定义资源定义。

**注意**  
如果收到集群不存在或您没有权限的错误消息，请验证：  
集群名称是否正确
AWS CLI 是否针对正确的区域进行配置
您是否拥有所需的 IAM 权限

## 步骤 3：验证功能是否处于活动状态
<a name="_step_3_verify_the_capability_is_active"></a>

等待功能变为活动状态。将 *region-code* 替换为集群所在的 AWS 区域，并将 *my-cluster* 替换为集群名称。

```
aws eks describe-capability \
  --region region-code \
  --cluster-name my-cluster \
  --capability-name my-argocd \
  --query 'capability.status' \
  --output text
```

当状态显示为 `ACTIVE` 时，表示功能已准备就绪。在该状态变为 `ACTIVE` 之前，请勿继续执行下一步。

您也可以查看完整功能详细信息：

```
aws eks describe-capability \
  --region region-code \
  --cluster-name my-cluster \
  --capability-name my-argocd
```

## 步骤 4：验证自定义资源是否可用
<a name="_step_4_verify_custom_resources_are_available"></a>

待该功能处于活动状态后，验证 Argo CD 自定义资源是否已在集群中正常可用：

```
kubectl api-resources | grep argoproj.io
```

您应该会看到列出的 `Application` 和 `ApplicationSet` 资源类型。

## 后续步骤
<a name="_next_steps"></a>
+  [使用 Argo CD](working-with-argocd.md)：配置存储库、注册集群和创建应用程序
+  [Argo CD 注意事项](argocd-considerations.md)：多集群架构和高级配置
+  [使用功能资源](working-with-capabilities.md)：管理 Argo CD 功能资源

# 使用 eksctl 创建 Argo CD 功能
<a name="argocd-create-eksctl"></a>

本主题将介绍如何使用 eksctl 创建 Argo CD 功能。

**注意**  
以下步骤需要 eksctl 版本 `0.220.0` 或更高版本。要检查版本，请运行 `eksctl version`。

## 步骤 1：创建 IAM 功能角色
<a name="_step_1_create_an_iam_capability_role"></a>

创建信任策略文件：

```
cat > argocd-trust-policy.json << 'EOF'
{
  "Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Service": "capabilities.eks.amazonaws.com"
      },
      "Action": [
        "sts:AssumeRole",
        "sts:TagSession"
      ]
    }
  ]
}
EOF
```

创建 IAM 角色：

```
aws iam create-role \
  --role-name ArgoCDCapabilityRole \
  --assume-role-policy-document file://argocd-trust-policy.json
```

**注意**  
对于此基本设置，无需其他 IAM 策略。如果计划使用 Secrets Manager 管理存储库凭证或使用 CodeConnections，则需为此角色添加相应权限。有关 IAM 策略示例和配置指南，请参阅[使用 AWS Secrets Manager 管理应用程序密钥](integration-secrets-manager.md)和[使用 AWS CodeConnections 连接到 Git 存储库](integration-codeconnections.md)。

## 步骤 2：获取 AWS Identity Center 配置
<a name="step_2_get_your_shared_aws_identity_center_configuration"></a>

获取 Identity Center 实例 ARN 和用户 ID，用于 RBAC 配置：

```
# Get your Identity Center instance ARN
aws sso-admin list-instances --query 'Instances[0].InstanceArn' --output text

# Get a user ID for admin access (replace 'your-username' with your Identity Center username)
aws identitystore list-users \
  --identity-store-id $(aws sso-admin list-instances --query 'Instances[0].IdentityStoreId' --output text) \
  --query 'Users[?UserName==`your-username`].UserId' --output text
```

记下这些值，下一步将会用到。

## 步骤 3：创建 eksctl 配置文件
<a name="_step_3_create_an_eksctl_configuration_file"></a>

使用以下内容创建名为 `argocd-capability.yaml` 的文件。将占位符值替换为集群名称、集群区域、IAM 角色 ARN、Identity Center 实例 ARN、Identity Center 区域和用户 ID：

```
apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig

metadata:
  name: my-cluster
  region: cluster-region-code

capabilities:
  - name: my-argocd
    type: ARGOCD
    roleArn: arn:aws:iam::[.replaceable]111122223333:role/ArgoCDCapabilityRole
    deletePropagationPolicy: RETAIN
    configuration:
      argocd:
        awsIdc:
          idcInstanceArn: arn:aws:sso:::instance/ssoins-123abc
          idcRegion: idc-region-code
        rbacRoleMappings:
          - role: ADMIN
            identities:
              - id: 38414300-1041-708a-01af-5422d6091e34
                type: SSO_USER
```

**注意**  
您可以向 RBAC 映射添加多个用户或组。对于组，请使用 `type: SSO_GROUP` 并提供组 ID。可用角色包括 `ADMIN`、`EDITOR` 和 `VIEWER`。

## 步骤 4：创建 Argo CD 功能
<a name="_step_4_create_the_argo_cd_capability"></a>

应用配置文件：

```
eksctl create capability -f argocd-capability.yaml
```

命令会立即返回，但该功能需要一些时间才能变为活动状态。

## 步骤 5：验证功能是否处于活动状态
<a name="_step_5_verify_the_capability_is_active"></a>

检查功能状态。将 *region-code* 替换为您的集群所在的 AWS 区域，并将 *my-cluster* 替换为您的集群的名称。

```
eksctl get capability \
  --region region-code \
  --cluster my-cluster \
  --name my-argocd
```

当状态显示为 `ACTIVE` 时，表示功能已准备就绪。

## 步骤 6：验证自定义资源是否可用
<a name="_step_6_verify_custom_resources_are_available"></a>

待该功能处于活动状态后，验证 Argo CD 自定义资源是否已在集群中正常可用：

```
kubectl api-resources | grep argoproj.io
```

您应该会看到列出的 `Application` 和 `ApplicationSet` 资源类型。

## 后续步骤
<a name="_next_steps"></a>
+  [使用 Argo CD](working-with-argocd.md)：了解如何创建和管理 Argo CD 应用程序
+  [Argo CD 注意事项](argocd-considerations.md)：配置 SSO 和多集群访问权限
+  [使用功能资源](working-with-capabilities.md)：管理 Argo CD 功能资源

# Argo CD 概念
<a name="argocd-concepts"></a>

Argo CD 通过将 Git 视为应用程序部署的单一事实来源，实现了 GitOps。本主题将介绍一个实际示例，然后解释使用适用于 Argo CD 的 EKS 功能时需要了解的核心概念。

## 开始使用 Argo CD
<a name="_getting_started_with_argo_cd"></a>

创建 Argo CD 功能（请参阅[创建 Argo CD 功能](create-argocd-capability.md)）后，即可开始部署应用程序。本示例将演示如何注册集群和创建应用程序。

### 步骤 1：设置
<a name="_step_1_set_up"></a>

 **注册集群**（必需）

注册要在其中部署应用程序的集群。在本示例中，我们将注册运行 Argo CD 所在的同一集群（可以使用 `in-cluster` 作为名称，以便与大多数 Argo CD 示例兼容）：

```
# Get your cluster ARN
CLUSTER_ARN=$(aws eks describe-cluster \
  --name my-cluster \
  --query 'cluster.arn' \
  --output text)

# Register the cluster using Argo CD CLI
argocd cluster add $CLUSTER_ARN \
  --aws-cluster-name $CLUSTER_ARN \
  --name in-cluster \
  --project default
```

**注意**  
有关配置 Argo CD CLI 以使其与 EKS 中的 Argo CD 功能结合使用的信息，请参阅[将 Argo CD CLI 与托管功能结合使用](argocd-comparison.md#argocd-cli-configuration)。

或者，您也可以使用 Kubernetes Secret 注册集群（有关详细信息，请参阅[注册目标集群](argocd-register-clusters.md)）。

 **配置存储库访问权限**（可选）

此示例使用公有 GitHub 存储库，因此无需配置存储库。对于私有存储库，可使用 AWS Secrets Manager、CodeConnection 或 Kubernetes Secret 配置访问权限（有关详细信息，请参阅[配置存储库访问权限](argocd-configure-repositories.md)）。

对于 AWS 服务（用于 Helm 图表的 ECR、CodeConnections 和 CodeCommit），您可以直接在 Application 资源中引用它们，而无需创建存储库。功能角色必须具有必要的 IAM 权限。有关详细信息，请参阅 [配置存储库访问权限](argocd-configure-repositories.md)。

### 步骤 2：创建应用程序
<a name="_step_2_create_an_application"></a>

在 `my-app.yaml` 中创建以下应用程序清单：

```
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: guestbook
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://github.com/argoproj/argocd-example-apps.git
    targetRevision: HEAD
    path: guestbook
  destination:
    name: in-cluster
    namespace: guestbook
  syncPolicy:
    automated:
      prune: true
      selfHeal: true
    syncOptions:
    - CreateNamespace=true
```

应用应用程序：

```
kubectl apply -f my-app.yaml
```

应用此应用程序后，Argo CD 会执行以下操作：1. 将应用程序从 Git 同步到集群（初始部署）2. 监控 Git 存储库中的更改 3. 自动将后续更改同步到集群 4. 检测并纠正任何与预期状态的偏差 5. 在用户界面中提供运行状况状态和同步历史记录

查看应用程序状态：

```
kubectl get application guestbook -n argocd
```

您也可以使用 Argo CD CLI 或 Argo CD 用户界面（可通过 EKS 控制台中集群的“功能”选项卡访问）查看应用程序。

**注意**  
使用具有托管功能的 Argo CD CLI 时，请使用命名空间前缀指定应用程序：`argocd app get argocd/guestbook`。

**注意**  
在 `destination.name` 中使用集群名称（注册集群时使用的名称）。托管功能不支持本地的集群内默认值 (`kubernetes.default.svc`)。

## 核心概念
<a name="_core_concepts"></a>

### GitOps 原则和源类型
<a name="_gitops_principles_and_source_types"></a>

Argo CD 实现了 GitOps，应用程序源是部署的单一事实来源：
+  **声明式**：使用 YAML 清单、Helm 图表或 Kustomize 叠加层声明预期状态
+  **版本控制**：每次更改都有完整的审计跟踪记录
+  **自动化**：Argo CD 持续监控源并自动同步更改
+  **自我修复**：检测并纠正预期状态与集群实际状态之间的偏差

 **支持的源类型**：
+  **Git 存储库**：GitHub、GitLab、Bitbucket、CodeCommit（HTTPS、SSH 或 CodeConnections）
+  **Helm 注册表**：HTTP 注册表（如 `https://aws.github.io/eks-charts`）和 OCI 注册表（如 `public.ecr.aws`）
+  **OCI 映像**：包含清单或 Helm 图表的容器映像（如 `oci://registry-1.docker.io/user/my-app`）

得益于这种灵活性，组织能够选择符合其安全性和合规性要求的源。例如，限制集群访问 Git 的组织可以使用 ECR 存放 Helm 图表或 OCI 映像。

有关更多信息，请参阅 Argo CD 文档中的 [Application Sources](https://argo-cd.readthedocs.io/en/stable/user-guide/application-sources/)。

### 同步与协调
<a name="_sync_and_reconciliation"></a>

Argo CD 会持续监控源和集群，以检测并纠正偏差：

1. 轮询源以查找变更（默认：每 6 分钟一次）

1. 将预期状态与集群实际状态进行比较

1. 将应用程序标记为 `Synced` 或 `OutOfSync` 

1. 自动同步更改（如果已配置）或等待手动审批

1. 同步后监控资源运行状况

 **同步波次**使用注释控制资源创建顺序：

```
metadata:
  annotations:
    argocd.argoproj.io/sync-wave: "0"  # Default if not specified
```

按波次顺序应用资源（数字小的先执行，例如 `-1` 等负数）。如果未指定，则默认为波次 `0`。这样您就可以先创建命名空间（波次 `-1`）等依赖项，再创建部署（波次 `0`），再创建服务（波次 `1`）。

 **自我修复**会自动还原手动更改：

```
spec:
  syncPolicy:
    automated:
      selfHeal: true
```

**注意**  
托管功能使用基于注释的资源跟踪（而不是基于标签），以便更好地兼容 Kubernetes 规范和其他工具。

有关同步阶段、钩子和高级模式的详细信息，请参阅 [Argo CD 同步文档](https://argo-cd.readthedocs.io/en/stable/user-guide/sync-waves/)。

### 应用程序运行状况
<a name="_application_health"></a>

Argo CD 会监控应用程序中所有资源的运行状况：

 **运行状况**：\$1 **良好**：所有资源均按预期运行 \$1 **正在处理**：正在创建或更新资源 \$1 **已降级**：部分资源运行状况不佳 [容器组（pod）崩溃、任务失败] \$1 **已暂停**：应用程序故意暂停 \$1 **缺失**：集群中缺少 Git 中定义的资源

Argo CD 内置有针对常见 Kubernetes 资源（Deployment、StatefulSets、Jobs 等）的运行状况检查，并且支持对 CRD 进行自定义运行状况检查。

应用程序运行状况由所有资源决定，如果任何资源为 `Degraded`，则应用程序为 `Degraded`。

有关更多信息，请参阅 Argo CD 文档中的 [Resource Health](https://argo-cd.readthedocs.io/en/stable/operator-manual/health/)。

### 多集群模式
<a name="_multi_cluster_patterns"></a>

Argo CD 支持两种主要的部署模式：

 **轴辐式**：在专用的管理集群（部署到多个工作负载集群）上运行 Argo CD：\$1 集中控制和可见性 \$1 在所有集群之间保持策略一致 \$1 只需一个 Argo CD 实例即可进行管理 \$1 实行控制面板与工作负载之间的清晰分离

 **单集群**：在每个集群上运行 Argo CD，仅管理该集群的应用程序：\$1 集群分离（一个故障不会影响其他集群）\$1 联网更简单（无需跨集群通信）\$1 初始设置更轻松（无需注册集群）

对于管理许多集群的平台团队，选择轴辐式；对于独立的团队或必须完全隔离的集群，选择单集群。

有关多集群配置的详细信息，请参阅 [Argo CD 注意事项](argocd-considerations.md)。

### Projects
<a name="_projects"></a>

项目为应用程序提供逻辑分组和访问权限控制：
+  **源限制**：限制可以使用哪些 Git 存储库
+  **目标限制**：限制可以指向哪些集群和命名空间
+  **资源限制**：限制可以部署哪些 Kubernetes 资源类型
+  **RBAC 集成**：将项目映射到 AWS Identity Center 的用户和组 ID

应用程序同属一个项目。如果未指定，它们将使用 `default` 项目（默认没有任何限制）。对于生产用途，请编辑 `default` 项目以限制访问权限，并创建具有适当限制的新项目。

有关项目配置和 RBAC 模式，请参阅[配置 Argo CD 权限](argocd-permissions.md)。

### 同步选项
<a name="_sync_options"></a>

使用常用选项微调同步行为：
+  `CreateNamespace=true`：自动创建目标命名空间
+  `ServerSideApply=true`：使用服务器端应用程序以更好地解决冲突
+  `SkipDryRunOnMissingResource=true`：当 CRD 尚不存在时跳过试运行（对 kro 实例非常有用）

```
spec:
  syncPolicy:
    syncOptions:
    - CreateNamespace=true
    - ServerSideApply=true
    - SkipDryRunOnMissingResource=true
```

有关完整的同步选项列表，请参阅 [Argo CD 同步选项文档](https://argo-cd.readthedocs.io/en/stable/user-guide/sync-options/)。

## 后续步骤
<a name="_next_steps"></a>
+  [配置存储库访问权限](argocd-configure-repositories.md)：配置 Git 存储库访问权限
+  [注册目标集群](argocd-register-clusters.md)：注册用于部署的目标集群
+  [创建应用程序](argocd-create-application.md)：创建第一个应用程序
+  [Argo CD 注意事项](argocd-considerations.md)：EKS 特定模式、Identity Center 集成和多集群配置
+  [Argo CD 文档](https://argo-cd.readthedocs.io/en/stable/)：全面的 Argo CD 文档，包括同步钩子、运行状况检查和高级模式

# 配置 Argo CD 权限
<a name="argocd-permissions"></a>

Argo CD 托管功能与 AWS Identity Center 集成以进行身份验证，并使用内置的 RBAC 角色进行授权。本主题将介绍如何为用户和团队配置权限。

## Argo CD 权限的工作原理
<a name="_how_permissions_work_with_argo_cd"></a>

Argo CD 功能通过 AWS 进行身份验证，并提供三个内置的 RBAC 角色进行授权。

当用户访问 Argo CD 时：

1. 他们使用 AWS Identity Center（可以与企业身份提供者联合）进行身份验证

1.  AWS Identity Center 向 Argo CD 提供用户和组信息

1. Argo CD 会根据配置将用户和组映射到 RBAC 角色

1. 用户只能看到他们有权访问的应用程序和资源

## 内置 RBAC 角色
<a name="_built_in_rbac_roles"></a>

Argo CD 功能提供三个内置角色，您需要将其映射到 AWS Identity Center 的用户和组。这些角色是**全局范围的角色**，用于控制对项目、集群和存储库等 Argo CD 资源的访问权限。

**重要**  
全局角色控制对 Argo CD 本身的访问权限，而非对应用程序这类项目范围内的资源的访问权限。默认情况下，EDITOR 和 VIEWER 用户无法查看或管理应用程序，他们需要项目角色才能访问项目范围内的资源。有关授予对应用程序和其他项目范围内资源的访问权限的详细信息，请参阅 [项目角色和项目范围内的访问权限](#project-roles)。

 **ADMIN** 

对所有 Argo CD 资源和设置的完全访问权限：
+ 创建、更新和删除任何项目中的应用程序和 ApplicationSets
+ 管理 Argo CD 配置
+ 注册和管理部署目标集群
+ 配置存储库访问权限
+ 创建和管理项目
+ 查看所有应用程序状态和历史记录
+ 列出并访问所有集群和存储库

 **EDITOR** 

可以更新项目和配置项目角色，但无法更改全局的 Argo CD 设置：
+ 更新现有项目（无法创建或删除项目）
+ 配置项目角色和权限
+ 查看 GPG 密钥和证书
+ 无法更改全局的 Argo CD 配置
+ 无法直接管理集群或存储库
+ 若没有项目角色，则无法查看或管理应用程序

 **VIEWER** 

对 Argo CD 资源的只读访问权限：
+ 查看项目配置
+ 列出所有项目（包括该用户未被分配到的项目）
+ 查看 GPG 密钥和证书
+ 无法列出集群或存储库
+ 无法进行任何更改
+ 若没有项目角色，则无法查看或管理应用程序

**注意**  
要授予 EDITOR 或 VIEWER 用户访问应用程序的权限，ADMIN 或 EDITOR 必须创建项目角色，将 Identity Center 组映射到项目中的特定权限。

## 项目角色和项目范围内的访问权限
<a name="project-roles"></a>

全局角色（ADMIN、EDITOR、VIEWER）将控制对 Argo CD 本身的访问。项目角色控制对特定项目内的资源和功能的访问权限，包括：
+  **资源**：应用程序、ApplicationSets、存储库凭证、集群凭证
+  **功能**：日志访问、对应用程序容器组（pod）的 exec 访问权限

 **了解两级权限模型**：
+  **全局范围**：内置角色决定了用户能够对项目、集群、存储库以及 Argo CD 设置进行何种操作
+  **项目范围**：项目角色决定了用户能够对特定项目中的资源和功能进行何种操作

这意味着：
+ ADMIN 用户无需额外配置即可访问所有的项目资源和功能
+ 必须向 EDITOR 和 VIEWER 用户授予项目角色，才能访问项目资源和功能
+ EDITOR 用户可以创建项目角色，以便在他们能够更新的项目中为自己及他人授予访问权限

 **工作流示例**：

1. ADMIN 将 Identity Center 组全局映射到 EDITOR 角色

1. ADMIN 为团队创建项目

1. EDITOR 在该项目中配置项目角色，以授予团队成员访问项目范围内资源的权限

1. 团队成员（可能拥有 VIEWER 全局角色）现在可以根据其项目角色权限查看并管理该项目中的应用程序

有关配置项目角色的详细信息，请参阅 [基于项目的访问控制](#_project_based_access_control)。

## 配置角色映射
<a name="_configure_role_mappings"></a>

创建或更新功能时，将 AWS Identity Center 用户和组映射到 Argo CD 角色。

 **示例角色映射**：

```
{
  "rbacRoleMapping": {		 	 	 
    "ADMIN": ["AdminGroup", "alice@example.com"],
    "EDITOR": ["DeveloperGroup", "DevOpsTeam"],
    "VIEWER": ["ReadOnlyGroup", "bob@example.com"]
  }
}
```

**注意**  
角色名称区分大小写，必须为大写（ADMIN、EDITOR、VIEWER）。

**重要**  
EKS 功能与 AWS Identity Center 集成后，每个 Argo CD 功能可支持最多 1000 个身份。身份可以是用户或组。

 **更新角色映射**：

```
aws eks update-capability \
  --region us-east-1 \
  --cluster-name cluster \
  --capability-name capname \
  --endpoint "https://eks.ap-northeast-2.amazonaws.com" \
  --role-arn "arn:aws:iam::[.replaceable]111122223333:role/[.replaceable]`EKSCapabilityRole`" \
  --configuration '{
    "argoCd": {
      "rbacRoleMappings": {
        "addOrUpdateRoleMappings": [
          {
            "role": "ADMIN",
            "identities": [
              { "id": "686103e0-f051-7068-b225-e6392b959d9e", "type": "SSO_USER" }
            ]
          }
        ]
      }
    }
  }'
```

## 使用管理员账户
<a name="_admin_account_usage"></a>

管理员账户专为初始设置和管理任务（例如注册集群和配置存储库）而设计。

 **何时适合使用管理员账户**：
+ 初始功能设置和配置
+ 单人开发或快速演示
+ 管理任务（注册集群、配置存储库、创建项目）

 **管理员账户最佳实践**：
+ 请勿将账户令牌提交给版本控制
+ 如果令牌暴露，则立即轮换
+ 将账户令牌的使用限制在设置和管理任务
+ 设置较短的过期时间（最长 12 小时）
+ 在任何给定时间只能创建 5 个账户令牌

 **何时改用基于项目的访问**：
+ 与多个用户共享的开发环境
+ 任何与生产环境相似的环境
+ 需要有关操作执行者的审计跟踪记录时
+ 需要强制实施资源限制或访问边界时

对于生产环境和多用户场景，请使用基于项目的访问控制，并将专用 RBAC 角色映射到 AWS Identity Center 组。

## 基于项目的访问控制
<a name="_project_based_access_control"></a>

使用 Argo CD 项目（AppProject）为团队提供精细的访问控制和资源隔离。

**重要**  
在为用户或用户组分配项目特定角色之前，您必须首先在功能配置中将他们映射到全局的 Argo CD 角色（ADMIN、EDITOR 或 VIEWER）。如果没有全局角色映射，用户将无法访问 Argo CD，即使他们被分配了项目角色也是如此。  
考虑将用户全局映射到 VIEWER 角色，然后通过特定于项目的角色授予其他权限。这既提供了基础的访问权限，又能在项目层面实现精细的控制。

项目提供以下功能：
+  **源限制**：限制可以使用哪些 Git 存储库
+  **目标限制**：限制可以指向哪些集群和命名空间
+  **资源限制**：限制可以部署哪些 Kubernetes 资源类型
+  **RBAC 集成**：将项目映射到 AWS Identity Center 组或 Argo CD 角色

 **团队隔离示例项目**：

```
apiVersion: argoproj.io/v1alpha1
kind: AppProject
metadata:
  name: team-a
  namespace: argocd
spec:
  description: Team A applications

  # Required: Specify which namespaces this project watches for Applications
  sourceNamespaces:
  - argocd

  # Source restrictions
  sourceRepos:
  - https://github.com/myorg/team-a-apps

  # Destination restrictions
  destinations:
  - namespace: team-a-*
    server: arn:aws:eks:us-west-2:111122223333:cluster/production

  # Resource restrictions
  clusterResourceWhitelist:
  - group: ''
    kind: Namespace
  namespaceResourceWhitelist:
  - group: 'apps'
    kind: Deployment
  - group: ''
    kind: Service
  - group: ''
    kind: ConfigMap
```

### 源命名空间
<a name="_source_namespaces"></a>

使用 EKS Argo CD 功能时，AppProject 定义中必须包含 `spec.sourceNamespaces` 字段。此字段用于指定哪个命名空间可以包含引用此项目的应用程序或 ApplicationSets。

**重要**  
EKS Argo CD 功能仅支持应用程序和 ApplicationSets 的单个命名空间，即您在创建该功能时指定的命名空间（通常为 `argocd`）。这与支持多个命名空间的开源 Argo CD 不同。

 **AppProject 配置** 

所有 AppProjects 都必须在 `sourceNamespaces` 中包含该功能配置的命名空间：

```
apiVersion: argoproj.io/v1alpha1
kind: AppProject
metadata:
  name: team-a-project
  namespace: argocd
spec:
  description: Applications for Team A

  # Required: Specify the capability's configured namespace (configuration.argoCd.namespace)
  sourceNamespaces:
    - argocd  # Must match your capability's namespace configuration

  # Source repositories this project can deploy from
  sourceRepos:
    - 'https://github.com/my-org/team-a-*'

  # Destination restrictions
  destinations:
    - namespace: 'team-a-*'
      server: arn:aws:eks:us-west-2:111122223333:cluster/my-cluster
```

**注意**  
如果您从 `sourceNamespaces` 中省略了该功能的命名空间，则该命名空间中的应用程序或 ApplicationSets 将无法引用此项目，从而导致部署失败。

 **为用户分配项目**：

项目角色授予 EDITOR 和 VIEWER 用户访问项目资源（应用程序、ApplicationSets、存储库和集群凭证）和功能（日志、exec）的权限。如果没有项目角色，即便这些用户拥有全局角色访问权限，他们也无法访问这些资源。

ADMIN 用户无需项目角色即可访问所有应用程序。

 **示例：向团队成员授予应用程序访问权限** 

```
apiVersion: argoproj.io/v1alpha1
kind: AppProject
metadata:
  name: team-a
  namespace: argocd
spec:
  # ... project configuration ...

  sourceNamespaces:
  - argocd

  # Project roles grant Application-level access
  roles:
  - name: developer
    description: Team A developers - can manage Applications
    policies:
    - p, proj:team-a:developer, applications, *, team-a/*, allow
    - p, proj:team-a:developer, clusters, get, *, allow  # See cluster names in UI
    groups:
    - 686103e0-f051-7068-b225-e6392b959d9e  # Identity Center group ID

  - name: viewer
    description: Team A viewers - read-only Application access
    policies:
    - p, proj:team-a:viewer, applications, get, team-a/*, allow
    - p, proj:team-a:viewer, clusters, get, *, allow  # See cluster names in UI
    groups:
    - 786203e0-f051-7068-b225-e6392b959d9f  # Identity Center group ID
```

**注意**  
在项目角色中包含 `clusters, get, *, allow` 以允许用户在用户界面中查看集群名称。如果没有此权限，则目标集群将显示为“未知”。

 **了解项目角色策略**：

策略格式为：`p, proj:<project>:<role>, <resource>, <action>, <object>, <allow/deny>`

 **资源策略**：
+  `applications, , team-a/, allow`：对 team-a 项目中所有应用程序的完全访问权限
+  `applications, get, team-a/*, allow`：对应用程序的只读访问权限
+  `applications, sync, team-a/*, allow`：可以同步应用程序，但不能创建/删除
+  `applications, delete, team-a/*, allow`：可以删除应用程序（谨慎使用）
+  `applicationsets, , team-a/, allow`：对 ApplicationSets 的完全访问权限
+  `repositories, *, *, allow`：对存储库凭证的访问权限
+  `clusters, *, *, allow`：对集群凭证的访问权限

 **功能策略**：
+  `logs, , team-a/, allow`：对应用程序日志的访问权限
+  `exec, , team-a/, allow`：对应用程序容器组（pod）的 Exec 访问权限

**注意**  
EDITOR 用户可以创建项目角色，以便在他们能够更新的项目中为自己及他人授予权限。这使得团队负责人能够自行控制其团队所使用的项目范围内资源的访问权限，而无需 ADMIN 的干预。

**注意**  
在 `groups` 字段中使用 Identity Center 组 ID（不是组名称）。您也可以将 Identity Center 用户 ID 用于个人用户访问。在 AWS Identity Center 控制台中或使用 AWS CLI 查找这些 ID。

## 常见权限模式
<a name="_common_permission_patterns"></a>

 **模式 1：拥有完整访问权限的管理员团队** 

```
{
  "rbacRoleMapping": {		 	 	 
    "ADMIN": ["PlatformTeam", "SRETeam"]
  }
}
```

ADMIN 用户无需额外配置即可查看并管理所有的项目范围内资源。

 **模式 2：团队负责人管理项目，开发人员则通过项目角色进行访问** 

```
{
  "rbacRoleMapping": {		 	 	 
    "ADMIN": ["PlatformTeam"],
    "EDITOR": ["TeamLeads"],
    "VIEWER": ["AllDevelopers"]
  }
}
```

1. ADMIN 为每个团队创建项目

1. 团队负责人（EDITOR）配置项目角色，以授予其开发人员访问项目资源（应用程序、ApplicationSets、凭证）和功能（日志、exec）的权限

1. 开发人员（VIEWER）只能访问其项目角色所允许的资源和功能

 **模式 3：通过项目角色进行基于团队的访问** 

1. ADMIN 创建项目并将团队负责人全局映射到 EDITOR 角色

1. 团队负责人（EDITOR）为团队成员分配其项目中的相应项目角色

1. 团队成员只需要 VIEWER 全局角色，项目角色则提供对项目资源和功能的访问权限

```
{
  "rbacRoleMapping": {		 	 	 
    "ADMIN": ["PlatformTeam"],
    "EDITOR": ["TeamLeads"],
    "VIEWER": ["AllDevelopers"]
  }
}
```

## 最佳实践
<a name="_best_practices"></a>

 **优先使用用户组而非独立用户**：将 AWS Identity Center 用户组映射到 Argo CD 角色，而不是单个用户，以便于管理。

 **从最低权限开始**：从 VIEWER 访问权限开始，然后根据需要授予 EDITOR 或 ADMIN 权限。

 **使用项目实现团队隔离**：为不同的团队或环境创建单独的 AppProjects 以强制实施边界。

 **利用 Identity Center 联合身份验证**：配置 AWS Identity Center，以与企业身份提供者联合，从而实现集中式用户管理。

 **定期审查访问权限**：定期审查角色映射和项目分配，以确保适当的访问级别。

 **限制集群访问权限**：请记住，Argo CD RBAC 会控制 Argo CD 资源和操作的访问权限，这与 Kubernetes RBAC 无关。拥有 Argo CD 访问权限的用户可以将应用程序部署到 Argo CD 有权访问的集群。限制 Argo CD 可以访问的集群，并使用项目目标限制来控制应用程序的部署位置。

## AWS 服务权限
<a name="shared_aws_service_permissions"></a>

要在 Application 资源中直接使用 AWS 服务（而无需创建存储库资源），请将所需的 IAM 权限附加到功能角色。

 **用于 Helm 图表的 ECR**：

```
{
  "Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "ecr:GetAuthorizationToken",
        "ecr:BatchCheckLayerAvailability",
        "ecr:GetDownloadUrlForLayer",
        "ecr:BatchGetImage"
      ],
      "Resource": "*"
    }
  ]
}
```

 **CodeCommit 存储库**：

```
{
  "Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "codecommit:GitPull"
      ],
      "Resource": "arn:aws:codecommit:region:account-id:repository-name"
    }
  ]
}
```

 **CodeConnections（GitHub、GitLab、Bitbucket）**：

```
{
  "Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "codeconnections:UseConnection"
      ],
      "Resource": "arn:aws:codeconnections:region:account-id:connection/connection-id"
    }
  ]
}
```

有关使用这些集成的详细信息，请参阅[配置存储库访问权限](argocd-configure-repositories.md)。

## 后续步骤
<a name="_next_steps"></a>
+  [使用 Argo CD](working-with-argocd.md)：了解如何创建应用程序和管理部署
+  [Argo CD 概念](argocd-concepts.md)：了解 Argo CD 概念，包括项目
+  [EKS 功能的安全注意事项](capabilities-security.md)：查看针对功能的安全最佳实践

# 使用 Argo CD
<a name="working-with-argocd"></a>

通过 Argo CD 功能，您可以在 Git 存储库中定义应用程序，然后 Argo CD 会自动将它们同步到 Kubernetes 集群。此功能支持通过自动偏差检测实现声明性、版本控制的应用程序部署。

## 先决条件
<a name="_prerequisites"></a>

使用 Argo CD 之前，您需要：
+ 已创建具有 Argo CD 功能的 EKS 集群（请参阅[创建 Argo CD 功能](create-argocd-capability.md)）
+ 包含 Kubernetes 清单的 Git 存储库
+  已配置 `kubectl` 以与集群通信

## 常见任务
<a name="_common_tasks"></a>

以下主题将指导您完成常见的 Argo CD 任务：

 ** [配置存储库访问权限](argocd-configure-repositories.md) **：配置 Argo CD 以使用 AWS Secrets Manager、AWS CodeConnections 或 Kubernetes Secrets 访问您的 Git 存储库。

 ** [注册目标集群](argocd-register-clusters.md) **：注册 Argo CD 将在其中部署应用程序的目标集群。

 ** [使用 Argo CD 项目](argocd-projects.md) **：使用适用于多租户环境的项目来组织应用程序并强制实施安全边界。

 ** [创建应用程序](argocd-create-application.md) **：通过自动或手动同步策略，创建从 Git 存储库部署的应用程序。

 ** [使用 ApplicationSets](argocd-applicationsets.md) **：使用 ApplicationSets，通过模板和生成器跨多个环境或集群部署应用程序。

## 访问 Argo CD 用户界面
<a name="_access_the_argo_cd_ui"></a>

通过 EKS 控制台访问 Argo CD 用户界面：

1. 打开 Amazon EKS 控制台

1. 选择您的集群

1. 选择**功能**选项卡

1. 选择 **Argo CD** 

1. 选择 **Open Argo CD UI** 

用户界面提供可视化应用程序拓扑、同步状态和历史记录、资源运行状况和事件、手动同步控制以及应用程序管理。

## 上游文档
<a name="_upstream_documentation"></a>

有关 Argo CD 功能的详细信息：
+  [Argo CD 文档](https://argo-cd.readthedocs.io/)：完整用户指南
+  [Application Spec](https://argo-cd.readthedocs.io/en/stable/user-guide/application-specification/)：完整的应用程序 API 参考
+  [ApplicationSet Guide](https://argo-cd.readthedocs.io/en/stable/user-guide/application-set/)：ApplicationSet 模式和示例
+  [Argo CD GitHub](https://github.com/argoproj/argo-cd)：源代码和示例

# 配置存储库访问权限
<a name="argocd-configure-repositories"></a>

在部署应用程序之前，请配置 Argo CD 以访问 Git 存储库和 Helm 图表注册表。Argo CD 支持针对 GitHub、GitLab、Bitbucket、AWS CodeCommit 和 AWS ECR 的多种身份验证方法。

**注意**  
若要与 AWS 服务直接集成（ECR Helm 图表、CodeCommit 存储库和 CodeConnections），您可以直接在 Application 资源中引用它们，而无需创建存储库配置。功能角色必须具有必要的 IAM 权限。有关详细信息，请参阅 [配置 Argo CD 权限](argocd-permissions.md)。

## 先决条件
<a name="_prerequisites"></a>
+ 已创建具有 Argo CD 功能的 EKS 集群
+ Git 存储库包含 Kubernetes 清单
+  已配置 `kubectl` 以与集群通信

**注意**  
 AWS CodeConnections 可以连接到位于 AWS 云或本地的 Git 服务器。有关更多信息，请参阅 [AWS CodeConnections](https://docs.aws.amazon.com/codeconnections/latest/userguide/welcome.html)。

## 身份验证方法
<a name="_authentication_methods"></a>


| 方法 | 使用场景 | 所需的 IAM 权限 | 
| --- | --- | --- | 
|   **与 AWS 服务直接集成**   | 
|  CodeCommit  |  直接与 AWS CodeCommit Git 存储库集成。无需配置存储库。  |   `codecommit:GitPull`   | 
|  CodeConnections  |  通过托管身份验证连接到 GitHub、GitLab 或 Bitbucket。需要进行连接设置。  |   `codeconnections:UseConnection`   | 
|  ECR OCI 构件  |  直接与 AWS ECR 集成以获取 OCI Helm 图表和清单映像。无需配置存储库。  |   `arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryPullOnly`   | 
|   **使用凭证配置存储库**   | 
|   AWS Secrets Manager（用户名/令牌）  |  存储个人访问令牌或密码。无需 Kubernetes 访问即可实现凭证轮换。  |   `arn:aws:iam::aws:policy/AWSSecretsManagerClientReadOnlyAccess`   | 
|   AWS Secrets Manager（SSH 密钥）  |  使用 SSH 密钥身份验证。无需 Kubernetes 访问即可实现凭证轮换。  |   `arn:aws:iam::aws:policy/AWSSecretsManagerClientReadOnlyAccess`   | 
|   AWS Secrets Manager（GitHub 应用程序）  |  使用私有密钥对 GitHub 应用程序进行身份验证。无需 Kubernetes 访问即可实现凭证轮换。  |   `arn:aws:iam::aws:policy/AWSSecretsManagerClientReadOnlyAccess`   | 
|  Kubernetes Secret  |  使用集群内密钥的标准 Argo CD 方法  |  无（由 EKS 访问条目使用 Kubernetes RBAC 处理的权限）  | 

## 直接访问 AWS 服务
<a name="direct_access_to_shared_aws_services"></a>

对于 AWS 服务，您可以直接在 Application 资源中引用它们，而无需创建存储库配置。功能角色必须具有必要的 IAM 权限。

### CodeCommit 存储库
<a name="_codecommit_repositories"></a>

直接在应用程序中引用 CodeCommit 存储库：

```
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: my-app
  namespace: argocd
spec:
  source:
    repoURL: https://git-codecommit.region.amazonaws.com/v1/repos/repository-name
    targetRevision: main
    path: kubernetes/manifests
```

所需的功能角色权限：

```
{
  "Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "codecommit:GitPull",
      "Resource": "arn:aws:codecommit:region:account-id:repository-name"
    }
  ]
}
```

### CodeConnections
<a name="_codeconnections"></a>

通过 CodeConnections 引用 GitHub、GitLab 或 Bitbucket 存储库。存储库 URL 格式派生自 CodeConnections 连接 ARN。

存储库 URL 格式为：

```
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: my-app
  namespace: argocd
spec:
  source:
    repoURL: https://codeconnections.region.amazonaws.com/git-http/account-id/region/connection-id/owner/repository.git
    targetRevision: main
    path: kubernetes/manifests
```

所需的功能角色权限：

```
{
  "Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "codeconnections:UseConnection",
      "Resource": "arn:aws:codeconnections:region:account-id:connection/connection-id"
    }
  ]
}
```

### ECR Helm 图表
<a name="_ecr_helm_charts"></a>

ECR 将 Helm 图表存储为 OCI 构件。Argo CD 支持两种引用方式：

 **Helm 格式**（建议用于 Helm 图表）：

```
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: my-app-helm
  namespace: argocd
spec:
  source:
    repoURL: account-id.dkr.ecr.region.amazonaws.com/repository-name
    targetRevision: chart-version
    chart: chart-name
    helm:
      valueFiles:
        - values.yaml
```

注意：使用 Helm 格式时，请勿包含 `oci://` 前缀。使用 `chart` 字段指定图表名称。

 **OCI 格式**（适用于包含 Kubernetes 清单的 OCI 构件）：

```
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: my-app-oci
  namespace: argocd
spec:
  source:
    repoURL: oci://account-id.dkr.ecr.region.amazonaws.com/repository-name
    targetRevision: artifact-version
    path: path-to-manifests
```

注意：使用 OCI 格式时，请包含 `oci://` 前缀。请使用 `path` 字段而非 `chart`。

所需功能角色权限 - 附加托管策略：

```
arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryPullOnly
```

此策略包括必要的权限：`ecr:GetAuthorizationToken`、`ecr:BatchGetImage` 和 `ecr:GetDownloadUrlForLayer`。

## 使用 AWS Secrets Manager
<a name="using_shared_aws_secrets_manager"></a>

将存储库凭证存储在 Secrets Manager 中，然后在 Argo CD 存储库配置中引用它们。使用 Secrets Manager 可实现自动化的凭证轮换，且无需 Kubernetes RBAC 访问权限 – 可借助针对 Secrets Manager 的 IAM 权限来轮换凭证，而 Argo CD 会自动读取更新后的值。

**注意**  
要在多个存储库（例如，GitHub 组织下的所有存储库）中重复使用凭证，请将存储库凭证模板与 `argocd.argoproj.io/secret-type: repo-creds` 结合使用。这比单独创建每个存储库的密钥能提供更好的用户体验。有关更多信息，请参阅 Argo CD 文档中的[存储库凭证](https://argo-cd.readthedocs.io/en/stable/operator-manual/argocd-repo-creds-yaml/)。

### 用户名和令牌身份验证
<a name="_username_and_token_authentication"></a>

对于使用个人访问令牌或密码的 HTTPS 存储库：

 **在 Secrets Manager 中创建 Secret**：

```
aws secretsmanager create-secret \
  --name argocd/my-repo \
  --description "GitHub credentials for Argo CD" \
  --secret-string '{"username":"your-username","token":"your-personal-access-token"}'
```

 **可选 TLS 客户端证书字段**（适用于私有 Git 服务器）：

```
aws secretsmanager create-secret \
  --name argocd/my-private-repo \
  --secret-string '{
    "username":"your-username",
    "token":"your-token",
    "tlsClientCertData":"LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCi4uLgotLS0tLUVORCBDRVJUSUZJQ0FURS0tLS0t",
    "tlsClientCertKey":"LS0tLS1CRUdJTiBQUklWQVRFIEtFWS0tLS0tCi4uLgotLS0tLUVORCBQUklWQVRFIEtFWS0tLS0t"
  }'
```

**注意**  
`tlsClientCertData` 和 `tlsClientCertKey` 值必须采用 base64 编码。

 **创建引用 Secrets Manager 的 Repository Secret**：

```
apiVersion: v1
kind: Secret
metadata:
  name: my-repo
  namespace: argocd
  labels:
    argocd.argoproj.io/secret-type: repository
stringData:
  type: git
  url: https://github.com/your-org/your-repo
  secretArn: arn:aws:secretsmanager:us-west-2:111122223333:secret:argocd/my-repo-AbCdEf
  project: default
```

### SSH 密钥身份验证
<a name="_ssh_key_authentication"></a>

对于基于 SSH 的 Git 访问，请将私有密钥存储为纯文本（而非 JSON）：

 **创建包含 SSH 私有密钥的 Secret**：

```
aws secretsmanager create-secret \
  --name argocd/my-repo-ssh \
  --description "SSH key for Argo CD" \
  --secret-string "-----BEGIN OPENSSH PRIVATE KEY-----
b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAABlwAAAAdzc2gtcn
...
-----END OPENSSH PRIVATE KEY-----"
```

 **为 SSH 创建 Repository Secret**：

```
apiVersion: v1
kind: Secret
metadata:
  name: my-repo-ssh
  namespace: argocd
  labels:
    argocd.argoproj.io/secret-type: repository
stringData:
  type: git
  url: git@github.com:your-org/your-repo.git
  secretArn: arn:aws:secretsmanager:us-west-2:111122223333:secret:argocd/my-repo-ssh-AbCdEf
  project: default
```

### GitHub 应用程序身份验证
<a name="_github_app_authentication"></a>

对于使用私有密钥的 GitHub 应用程序身份验证：

 **创建包含 GitHub 应用程序凭证的 Secret**：

```
aws secretsmanager create-secret \
  --name argocd/github-app \
  --description "GitHub App credentials for Argo CD" \
  --secret-string '{
    "githubAppPrivateKeySecret":"LS0tLS1CRUdJTiBSU0EgUFJJVkFURSBLRVktLS0tLQouLi4KLS0tLS1FTkQgUlNBIFBSSVZBVEUgS0VZLS0tLS0=",
    "githubAppID":"123456",
    "githubAppInstallationID":"12345678"
  }'
```

**注意**  
`githubAppPrivateKeySecret` 值必须采用 base64 编码。

 **用于 GitHub Enterprise 的可选字段**：

```
aws secretsmanager create-secret \
  --name argocd/github-enterprise-app \
  --secret-string '{
    "githubAppPrivateKeySecret":"LS0tLS1CRUdJTiBSU0EgUFJJVkFURSBLRVktLS0tLQouLi4KLS0tLS1FTkQgUlNBIFBSSVZBVEUgS0VZLS0tLS0=",
    "githubAppID":"123456",
    "githubAppInstallationID":"12345678",
    "githubAppEnterpriseBaseUrl":"https://github.example.com/api/v3"
  }'
```

 **为 GitHub 应用程序创建 Repository Secret**：

```
apiVersion: v1
kind: Secret
metadata:
  name: my-repo-github-app
  namespace: argocd
  labels:
    argocd.argoproj.io/secret-type: repository
stringData:
  type: git
  url: https://github.com/your-org/your-repo
  secretArn: arn:aws:secretsmanager:us-west-2:111122223333:secret:argocd/github-app-AbCdEf
  project: default
```

### 存储库凭证模板
<a name="_repository_credential_templates"></a>

要在多个存储库（例如，GitHub 组织或用户下的所有存储库）中重复使用凭证，请将存储库凭证模板与 `argocd.argoproj.io/secret-type: repo-creds` 结合使用。这比为每个存储库单独创建存储库密钥能提供更好的用户体验。

 **创建存储库凭证模板**：

```
apiVersion: v1
kind: Secret
metadata:
  name: github-org-creds
  namespace: argocd
  labels:
    argocd.argoproj.io/secret-type: repo-creds
stringData:
  type: git
  url: https://github.com/your-org
  secretArn: arn:aws:secretsmanager:us-west-2:111122223333:secret:argocd/github-org-AbCdEf
```

此凭证模板适用于与 URL 前缀 `https://github.com/your-org` 匹配的所有存储库。然后，您可以在应用程序中引用该组织下的任何存储库，而无需创建其他密钥。

有关更多信息，请参阅 Argo CD 文档中的[存储库凭证](https://argo-cd.readthedocs.io/en/stable/operator-manual/argocd-repo-creds-yaml/)。

**重要**  
确保您的 IAM 功能角色已附加托管策略 `arn:aws:iam::aws:policy/AWSSecretsManagerClientReadOnlyAccess` 或等效权限，包括 `secretsmanager:GetSecretValue` 和 KMS 解密权限。有关 IAM 策略配置，请参阅 [Argo CD 注意事项](argocd-considerations.md)。

## 使用 AWS CodeConnections
<a name="using_shared_aws_codeconnections"></a>

有关 CodeConnections 集成，请参阅[使用 AWS CodeConnections 连接到 Git 存储库](integration-codeconnections.md)。

CodeConnections 为 GitHub、GitLab 和 Bitbucket 提供托管身份验证，无需存储凭证。

## 使用 Kubernetes Secrets
<a name="_using_kubernetes_secrets"></a>

使用标准的 Argo CD 方法，将凭证直接存储在 Kubernetes 中。

 **对于使用个人访问令牌的 HTTPS**：

```
apiVersion: v1
kind: Secret
metadata:
  name: my-repo
  namespace: argocd
  labels:
    argocd.argoproj.io/secret-type: repository
stringData:
  type: git
  url: https://github.com/your-org/your-repo
  username: your-username
  password: your-personal-access-token
```

 **对于 SSH**：

```
apiVersion: v1
kind: Secret
metadata:
  name: my-repo-ssh
  namespace: argocd
  labels:
    argocd.argoproj.io/secret-type: repository
stringData:
  type: git
  url: git@github.com:your-org/your-repo.git
  sshPrivateKey: |
    -----BEGIN OPENSSH PRIVATE KEY-----
    ... your private key ...
    -----END OPENSSH PRIVATE KEY-----
```

## CodeCommit 存储库
<a name="_codecommit_repositories_2"></a>

对于 AWS CodeCommit，授予 IAM 功能角色 CodeCommit 权限 (`codecommit:GitPull`)。

配置存储库：

```
apiVersion: v1
kind: Secret
metadata:
  name: codecommit-repo
  namespace: argocd
  labels:
    argocd.argoproj.io/secret-type: repository
stringData:
  type: git
  url: https://git-codecommit.us-west-2.amazonaws.com/v1/repos/my-repo
  project: default
```

有关详细的 IAM 策略配置，请参阅 [Argo CD 注意事项](argocd-considerations.md)。

## 验证存储库连接
<a name="_verify_repository_connection"></a>

通过 Argo CD 用户界面，在“设置 → 存储库”下检查连接状态。用户界面会显示连接状态和任何身份验证错误。

Repository Secret 不包含状态信息。

## 其他资源
<a name="_additional_resources"></a>
+  [注册目标集群](argocd-register-clusters.md)：注册用于部署的目标集群
+  [创建应用程序](argocd-create-application.md)：创建第一个应用程序
+  [Argo CD 注意事项](argocd-considerations.md)：IAM 权限和安全配置
+  [Private Repositories](https://argo-cd.readthedocs.io/en/stable/user-guide/private-repositories/)：上游存储库配置参考

# 注册目标集群
<a name="argocd-register-clusters"></a>

注册集群以允许 Argo CD 向其部署应用程序。您可以注册 Argo CD 运行所在的同一集群（本地集群），也可以注册位于不同账户或区域的远程集群。一旦集群被注册，它将一直处于未知连接状态，直到您在该集群内创建应用程序。要在集群注册后创建 Argo CD 应用程序，请参阅 [创建应用程序](argocd-create-application.md)。

## 先决条件
<a name="_prerequisites"></a>
+ 已创建具有 Argo CD 功能的 EKS 集群
+  已配置 `kubectl` 以与集群通信
+ 对于远程集群：需要适当的 IAM 权限和访问条目

## 注册本地集群
<a name="_register_the_local_cluster"></a>

要将应用程序部署到 Argo CD 运行所在的同一集群，请将其注册为部署目标。

**重要**  
Argo CD 功能不会自动注册本地集群。必须进行明确注册才能将应用程序部署到同一集群。您可以使用集群名称 `in-cluster` 以实现与线上大多数 Argo CD 示例的兼容性。

**注意**  
系统会自动为具有 Argo CD 功能角色的本地集群创建 EKS 访问条目，但默认情况下不会授予 Kubernetes RBAC 权限。这遵循最低权限的原则，您必须根据自己的使用案例明确配置 Argo CD 所需的权限。例如，如果您仅将此集群用作 Argo CD 集线器中心来管理远程集群，则它不需要任何本地部署权限。有关配置选项，请参阅下面的访问条目 RBAC 要求部分。

 **使用 Argo CD CLI**：

```
argocd cluster add <cluster-context-name> \
  --aws-cluster-name arn:aws:eks:us-west-2:111122223333:cluster/my-cluster \
  --name local-cluster
```

 **使用 Kubernetes Secret**：

```
apiVersion: v1
kind: Secret
metadata:
  name: local-cluster
  namespace: argocd
  labels:
    argocd.argoproj.io/secret-type: cluster
stringData:
  name: local-cluster
  server: arn:aws:eks:us-west-2:111122223333:cluster/my-cluster
  project: default
```

应用配置：

```
kubectl apply -f local-cluster.yaml
```

**注意**  
在 `server` 字段中使用 EKS 集群 ARN，而不是 Kubernetes API 服务器 URL。托管功能需要使用 ARN 来识别集群。不支持默认的 `kubernetes.default.svc`。

## 注册远程集群
<a name="_register_remote_clusters"></a>

要部署到远程集群：

 **步骤 1：在远程集群上创建访问条目** 

将 *region-code* 替换为远程集群所在的 AWS 区域，将 *remote-cluster* 替换为远程集群名称，然后将 ARN 替换为 Argo CD 功能角色 ARN。

```
aws eks create-access-entry \
  --region region-code \
  --cluster-name remote-cluster \
  --principal-arn arn:aws:iam::[.replaceable]111122223333:role/ArgoCDCapabilityRole \
  --type STANDARD
```

 **第 2 步：将访问策略与 Kubernetes RBAC 权限关联** 

访问条目需要 Kubernetes RBAC 权限，以便 Argo CD 能够部署应用程序。要快速入门，您可以使用 `AmazonEKSClusterAdminPolicy`：

```
aws eks associate-access-policy \
  --region region-code \
  --cluster-name remote-cluster \
  --principal-arn arn:aws:iam::[.replaceable]111122223333:role/ArgoCDCapabilityRole \
  --policy-arn arn:aws:eks::aws:cluster-access-policy/AmazonEKSClusterAdminPolicy \
  --access-scope type=cluster
```

**重要**  
`AmazonEKSClusterAdminPolicy` 提供完全的集群管理员访问权限（等同于 `system:masters`）。这便于入门，但不应在生产环境中使用。对于生产环境，通过将访问条目与自定义的 Kubernetes 组关联，并创建相应的角色或 ClusterRole 绑定，使用更严格的权限。有关最低权限配置，请参阅下面的生产设置部分。

 **步骤 3：在 Argo CD 中注册集群** 

 **使用 Argo CD CLI**：

```
argocd cluster add <cluster-context-name> \
  --aws-cluster-name arn:aws:eks:us-west-2:111122223333:cluster/remote-cluster \
  --name remote-cluster
```

 **使用 Kubernetes Secret**：

```
apiVersion: v1
kind: Secret
metadata:
  name: remote-cluster
  namespace: argocd
  labels:
    argocd.argoproj.io/secret-type: cluster
stringData:
  name: remote-cluster
  server: arn:aws:eks:us-west-2:111122223333:cluster/remote-cluster
  project: default
```

应用配置：

```
kubectl apply -f remote-cluster.yaml
```

## 跨账户集群
<a name="_cross_account_clusters"></a>

要部署到不同 AWS 账户中的集群，请执行以下操作：

1. 在目标账户中，使用来自源账户的 Argo CD IAM 功能角色 ARN 作为主体，在目标 EKS 集群上创建访问条目

1. 将访问策略与适当的 Kubernetes RBAC 权限关联

1. 使用其 EKS 集群 ARN 在 Argo CD 中注册集群

无需创建额外的 IAM 角色或配置信任策略，EKS 访问条目会处理跨账户访问。

集群 ARN 格式包括区域，因此跨区域部署与同区域部署所采用的流程相同。

## 验证集群注册
<a name="_verify_cluster_registration"></a>

查看已注册集群：

```
kubectl get secrets -n argocd -l argocd.argoproj.io/secret-type=cluster
```

或在 Argo CD 用户界面的“设置 → 集群”下查看集群状态。

## 私有集群
<a name="_private_clusters"></a>

Argo CD 功能支持对完全私有的 EKS 集群进行透明访问，无需进行 VPC 对等连接或专门的网络配置。

 AWS 会自动管理 Argo CD 功能与私有远程集群之间的连接。

只需使用其 ARN 注册私有集群，无需进行额外的联网设置。

## 访问条目 RBAC 要求
<a name="_access_entry_rbac_requirements"></a>

创建 Argo CD 功能时，系统会自动为功能角色创建 EKS 访问条目，但默认情况下不会授予 Kubernetes RBAC 权限。这种有意的设计遵循了最低权限原则，即不同的使用案例需要不同的权限。

例如：\$1 如果您仅将该集群用作 Argo CD 中心以管理远程集群，则它无需本地部署权限 \$1 如果您在本地部署应用程序，则需要在整个集群范围内拥有读取权限，并对特定命名空间拥有写入权限 \$1 如果您需要创建 CRD，则需要额外的集群管理员权限

您必须根据自己的要求明确配置 Argo CD 所需的权限。

### Argo CD 的最低权限
<a name="_minimum_permissions_for_argo_cd"></a>

Argo CD 要想正常运行且不出故障，需要两种类型的权限：

 **读取权限（集群范围）**：Argo CD 必须能够读取集群中的所有资源类型和自定义资源定义（CRD），以便：
+ 资源发现和运行状况检查
+ 检测所需状态和实际状态之间的漂移
+ 在部署之前验证资源

 **写入权限（特定于命名空间）**：Argo CD 需要创建、更新和删除应用程序中定义的资源的权限：
+ 部署应用程序工作负载（部署、服务、ConfigMaps 等）
+ 应用自定义资源（特定于您的应用程序的 CRD）
+ 管理应用程序生命周期

### 快速设置
<a name="_quick_setup"></a>

对于快速入门、测试或开发环境，请使用 `AmazonEKSClusterAdminPolicy`：

```
aws eks associate-access-policy \
  --region region-code \
  --cluster-name my-cluster \
  --principal-arn arn:aws:iam::[.replaceable]111122223333:role/ArgoCDCapabilityRole \
  --policy-arn arn:aws:eks::aws:cluster-access-policy/AmazonEKSClusterAdminPolicy \
  --access-scope type=cluster
```

**重要**  
`AmazonEKSClusterAdminPolicy` 提供完整的集群管理员访问权限（等同于 `system:masters`），包括创建 CRD、修改集群范围的资源以及部署到任何命名空间的能力。这便于开发和 POC，但不应在生产环境中使用。对于生产，请使用下面的最低权限设置。

### 具有最低权限的生产设置
<a name="_production_setup_with_least_privilege"></a>

对于生产环境，请创建授予以下权限的自定义 Kubernetes RBAC：
+ 在整个集群范围内对所有资源的读取权限（用于发现和运行状况检查）
+ 特定于命名空间的写入权限（用于部署）

 **步骤 1：将访问条目与自定义 Kubernetes 组关联** 

```
aws eks associate-access-policy \
  --region region-code \
  --cluster-name my-cluster \
  --principal-arn arn:aws:iam::[.replaceable]111122223333:role/ArgoCDCapabilityRole \
  --policy-arn arn:aws:eks::aws:cluster-access-policy/AmazonEKSEditPolicy \
  --access-scope type=namespace,namespaces=app-namespace
```

 **步骤 2：创建 ClusterRole 以获取读取访问权限** 

```
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: argocd-read-all
rules:
# Read access to all resources for discovery and health checks
- apiGroups: ["*"]
  resources: ["*"]
  verbs: ["get", "list", "watch"]
```

 **步骤 3：创建角色，以获取对应用程序命名空间的写入权限** 

```
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: argocd-deploy
  namespace: app-namespace
rules:
# Full access to deploy application resources
- apiGroups: ["*"]
  resources: ["*"]
  verbs: ["*"]
```

 **步骤 4：将角色与 Kubernetes 组绑定** 

```
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: argocd-read-all
subjects:
- kind: Group
  name: eks-access-entry:arn:aws:iam::111122223333:role/ArgoCDCapabilityRole
  apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: ClusterRole
  name: argocd-read-all
  apiGroup: rbac.authorization.k8s.io
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: argocd-deploy
  namespace: app-namespace
subjects:
- kind: Group
  name: eks-access-entry:arn:aws:iam::111122223333:role/ArgoCDCapabilityRole
  apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: Role
  name: argocd-deploy
  apiGroup: rbac.authorization.k8s.io
```

**注意**  
访问条目的组名格式为 `eks-access-entry:` 后加主体 ARN。对 Argo CD 应在其中部署应用程序的每个命名空间重复 RoleBinding 操作。

**重要**  
Argo CD 必须能够读取集群中的所有资源类型以进行运行状况检查和发现，即使它仅部署到特定的命名空间也是如此。如果没有整个集群范围的读取权限，Argo CD 将在检查应用程序运行状况时显示错误。

## 使用项目限制集群访问
<a name="_restrict_cluster_access_with_projects"></a>

使用项目控制应用程序可以部署到哪些集群和命名空间，方法是在 `spec.destinations` 中配置允许的目标集群和命名空间：

```
apiVersion: argoproj.io/v1alpha1
kind: AppProject
metadata:
  name: production
  namespace: argocd
spec:
  destinations:
  - server: arn:aws:eks:us-west-2:111122223333:cluster/prod-cluster
    namespace: '*'
  - server: arn:aws:eks:eu-west-1:111122223333:cluster/prod-eu-cluster
    namespace: '*'
  sourceRepos:
  - 'https://github.com/example/production-apps'
```

有关更多信息，请参阅 [使用 Argo CD 项目](argocd-projects.md)。

## 其他资源
<a name="_additional_resources"></a>
+  [使用 Argo CD 项目](argocd-projects.md)：组织应用程序并强制实施安全边界
+  [创建应用程序](argocd-create-application.md)：部署第一个应用程序
+  [使用 ApplicationSets](argocd-applicationsets.md)：使用 ApplicationSets 部署到多个集群
+  [Argo CD 注意事项](argocd-considerations.md)：多集群模式和跨账户设置
+  [Declarative Cluster Setup](https://argo-cd.readthedocs.io/en/stable/operator-manual/declarative-setup/#clusters)：上游集群配置参考

# 使用 Argo CD 项目
<a name="argocd-projects"></a>

Argo CD 项目（AppProject）为应用程序提供逻辑分组和访问控制。项目定义了应用程序可以使用哪些 Git 存储库、目标集群和命名空间，从而在 Argo CD 共享实例中实现多租户和安全边界。

## 何时使用项目
<a name="_when_to_use_projects"></a>

使用项目以：
+ 按团队、环境或业务部门分离应用程序
+ 限制团队可以从中部署哪些存储库
+ 限制团队可以部署到哪些集群和命名空间
+ 强制执行资源配额和允许的资源类型
+ 提供带护栏的应用程序自助部署

## 默认项目
<a name="_default_project"></a>

每个 Argo CD 功能都包含 `default` 项目，该项目允许访问所有存储库、集群和命名空间。这对于初始测试很有用，但对于生产用途，请创建具有明确限制的专用项目。

有关默认项目配置以及如何对其进行限制的详细信息，请参阅 Argo CD 文档中的 [The Default Project](https://argo-cd.readthedocs.io/en/stable/user-guide/projects/#the-default-project)。

## 创建项目
<a name="_create_a_project"></a>

通过将 `AppProject` 资源应用到集群来创建项目。

 **示例：团队特定项目** 

```
apiVersion: argoproj.io/v1alpha1
kind: AppProject
metadata:
  name: team-a
  namespace: argocd
spec:
  description: Applications for Team A

  # Source repositories this project can deploy from
  sourceRepos:
    - 'https://github.com/my-org/team-a-*'
    - 'https://github.com/my-org/shared-libs'

  # Destination clusters and namespaces
  destinations:
    - name: dev-cluster
      namespace: team-a-dev
    - name: prod-cluster
      namespace: team-a-prod

  # Allowed resource types
  clusterResourceWhitelist:
    - group: ''
      kind: Namespace

  namespaceResourceWhitelist:
    - group: 'apps'
      kind: Deployment
    - group: ''
      kind: Service
    - group: ''
      kind: ConfigMap
```

应用项目：

```
kubectl apply -f team-a-project.yaml
```

## 项目配置
<a name="_project_configuration"></a>

### 源存储库
<a name="_source_repositories"></a>

控制此项目中的应用程序可以使用哪些 Git 存储库：

```
spec:
  sourceRepos:
    - 'https://github.com/my-org/app-*'  # Wildcard pattern
    - 'https://github.com/my-org/infra'  # Specific repo
```

您可以使用通配符和否定模式（`!` 前缀）来允许或拒绝特定的存储库。有关详细信息，请参阅 Argo CD 文档中的 [Managing Projects](https://argo-cd.readthedocs.io/en/stable/user-guide/projects/#managing-projects)。

### 目标限制
<a name="_destination_restrictions"></a>

限制可以部署应用程序的位置：

```
spec:
  destinations:
    - name: prod-cluster  # Specific cluster by name
      namespace: production
    - name: '*'  # Any cluster
      namespace: team-a-*  # Namespace pattern
```

**重要**  
对于生产项目，请使用特定的集群名称和命名空间模式，而不是通配符。这样可以防止意外部署到未经授权的集群或命名空间。

您可以使用通配符和否定模式来控制目标。有关详细信息，请参阅 Argo CD 文档中的 [Managing Projects](https://argo-cd.readthedocs.io/en/stable/user-guide/projects/#managing-projects)。

### 资源限制
<a name="_resource_restrictions"></a>

控制可以部署的 Kubernetes 资源类型：

 **集群范围资源**：

```
spec:
  clusterResourceWhitelist:
    - group: ''
      kind: Namespace
    - group: 'rbac.authorization.k8s.io'
      kind: Role
```

 **命名空间范围资源**：

```
spec:
  namespaceResourceWhitelist:
    - group: 'apps'
      kind: Deployment
    - group: ''
      kind: Service
    - group: ''
      kind: ConfigMap
    - group: 's3.services.k8s.aws'
      kind: Bucket
```

使用黑名单拒绝特定资源：

```
spec:
  namespaceResourceBlacklist:
    - group: ''
      kind: Secret  # Prevent direct Secret creation
```

## 将应用程序分配给项目
<a name="_assign_applications_to_projects"></a>

创建应用程序时，在 `spec.project` 字段中指定项目：

```
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: my-app
  namespace: argocd
spec:
  project: team-a  # Assign to team-a project
  source:
    repoURL: https://github.com/my-org/my-app
    path: manifests
  destination:
    name: prod-cluster
    namespace: team-a-prod
```

未指定项目的应用程序将使用 `default` 项目。

## 项目角色和 RBAC
<a name="_project_roles_and_rbac"></a>

项目可以定义自定义角色以实现精细访问控制。在功能配置中将项目角色映射到 AWS Identity Center 用户和用户组，以控制哪些人可以同步、更新或删除应用程序。

 **示例：具有开发人员和管理员角色的项目** 

```
apiVersion: argoproj.io/v1alpha1
kind: AppProject
metadata:
  name: team-a
  namespace: argocd
spec:
  sourceRepos:
    - '*'
  destinations:
    - name: '*'
      namespace: 'team-a-*'

  roles:
    - name: developer
      description: Developers can sync applications
      policies:
        - p, proj:team-a:developer, applications, sync, team-a/*, allow
        - p, proj:team-a:developer, applications, get, team-a/*, allow
      groups:
        - team-a-developers

    - name: admin
      description: Admins have full access
      policies:
        - p, proj:team-a:admin, applications, *, team-a/*, allow
      groups:
        - team-a-admins
```

有关项目角色、用于 CI/CD 管道的 JWT 令牌以及 RBAC 配置的详细信息，请参阅 Argo CD 文档中的 [Project Roles](https://argo-cd.readthedocs.io/en/stable/user-guide/projects/#project-roles)。

## 常见模式
<a name="_common_patterns"></a>

### 基于环境的项目
<a name="_environment_based_projects"></a>

为每个环境创建单独的项目：

```
apiVersion: argoproj.io/v1alpha1
kind: AppProject
metadata:
  name: production
  namespace: argocd
spec:
  sourceRepos:
    - 'https://github.com/my-org/*'
  destinations:
    - name: prod-cluster
      namespace: '*'
  # Strict resource controls for production
  clusterResourceWhitelist: []
  namespaceResourceWhitelist:
    - group: 'apps'
      kind: Deployment
    - group: ''
      kind: Service
```

### 基于团队的项目
<a name="_team_based_projects"></a>

使用专用项目隔离团队：

```
apiVersion: argoproj.io/v1alpha1
kind: AppProject
metadata:
  name: platform-team
  namespace: argocd
spec:
  sourceRepos:
    - 'https://github.com/my-org/platform-*'
  destinations:
    - name: '*'
      namespace: 'platform-*'
  # Platform team can manage cluster resources
  clusterResourceWhitelist:
    - group: '*'
      kind: '*'
```

### 多集群项目
<a name="_multi_cluster_projects"></a>

使用一致的策略部署到多个集群：

```
apiVersion: argoproj.io/v1alpha1
kind: AppProject
metadata:
  name: global-app
  namespace: argocd
spec:
  sourceRepos:
    - 'https://github.com/my-org/global-app'
  destinations:
    - name: us-west-cluster
      namespace: app
    - name: eu-west-cluster
      namespace: app
    - name: ap-south-cluster
      namespace: app
```

## 最佳实践
<a name="_best_practices"></a>

 **从限制性项目开始**：从范围较小的权限开始，然后根据需要进行扩展，而不是一开始就授予广泛的访问权限。

 **使用命名空间模式**：在命名空间限制中使用通配符（例如 `team-a-*`），在保持边界的同时提供灵活性。

 **隔离生产项目**：为生产环境使用具有更严格控制和手动同步策略的专用项目。

 **记录项目用途**：使用 `description` 字段说明每个项目的用途以及适用人员。

 **定期审查项目权限**：定期审核项目，确保限制始终符合团队需求和安全性要求。

## 其他资源
<a name="_additional_resources"></a>
+  [配置 Argo CD 权限](argocd-permissions.md)：配置 RBAC 和 Identity Center 集成
+  [创建应用程序](argocd-create-application.md)：在项目内创建应用程序
+  [使用 ApplicationSets](argocd-applicationsets.md)：将 ApplicationSets 与项目结合使用，以进行多集群部署
+  [Argo CD Projects Documentation](https://argo-cd.readthedocs.io/en/stable/user-guide/projects/)：完整的上游参考

# 创建应用程序
<a name="argocd-create-application"></a>

应用程序代表目标集群中的部署。每个应用程序都定义了源（Git 存储库）和目标（集群和命名空间）。应用后，Argo CD 会将 Git 存储库中清单指定的资源创建到集群中的命名空间。应用程序通常用于指定工作负载部署，但它们可以管理目标集群中任何可用的 Kubernetes 资源。

## 先决条件
<a name="_prerequisites"></a>
+ 已创建具有 Argo CD 功能的 EKS 集群
+ 已配置存储库访问权限（请参阅[配置存储库访问权限](argocd-configure-repositories.md)）
+ 已注册目标集群（请参阅[注册目标集群](argocd-register-clusters.md)）
+  已配置 `kubectl` 以与集群通信

## 创建基础应用程序
<a name="_create_a_basic_application"></a>

定义从 Git 存储库部署的应用程序：

```
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: guestbook
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://github.com/argoproj/argocd-example-apps
    targetRevision: HEAD
    path: guestbook
  destination:
    name: in-cluster
    namespace: default
```

**注意**  
将 `destination.name` 用于您注册集群时使用的集群名称（如适用于本地集群的 `in-cluster`）。`destination.server` 字段也适用于 EKS 集群 ARN，但为了提高可读性，建议使用集群名称。

应用应用程序：

```
kubectl apply -f application.yaml
```

查看应用程序状态：

```
kubectl get application guestbook -n argocd
```

## 源配置
<a name="_source_configuration"></a>

 **Git 存储库**：

```
spec:
  source:
    repoURL: https://github.com/example/my-app
    targetRevision: main
    path: kubernetes/manifests
```

 **特定的 Git 标签或提交**：

```
spec:
  source:
    targetRevision: v1.2.0  # or commit SHA
```

 **Helm 图表**：

```
spec:
  source:
    repoURL: https://github.com/example/helm-charts
    targetRevision: main
    path: charts/my-app
    helm:
      valueFiles:
      - values.yaml
      parameters:
      - name: image.tag
        value: v1.2.0
```

 **带有来自外部 Git 存储库的值的 Helm 图表**（多源模式）：

```
spec:
  sources:
  - repoURL: https://github.com/example/helm-charts
    targetRevision: main
    path: charts/my-app
    helm:
      valueFiles:
      - $values/environments/production/values.yaml
  - repoURL: https://github.com/example/config-repo
    targetRevision: main
    ref: values
```

有关更多信息，请参阅 Argo CD 文档中的[来自外部 Git 存储库的 Helm 值文件](https://argo-cd.readthedocs.io/en/stable/user-guide/multiple_sources/#helm-value-files-from-external-git-repository)。

 **来自 ECR 的 Helm 图表**：

```
spec:
  source:
    repoURL: oci://account-id.dkr.ecr.region.amazonaws.com/repository-name
    targetRevision: chart-version
    chart: chart-name
```

如果功能角色具有所需的 ECR 权限，则可以直接使用该存储库，无需配置。有关详细信息，请参阅 [配置存储库访问权限](argocd-configure-repositories.md)。

 **来自 CodeCommit 的 Git 存储库**：

```
spec:
  source:
    repoURL: https://git-codecommit.region.amazonaws.com/v1/repos/repository-name
    targetRevision: main
    path: kubernetes/manifests
```

如果功能角色具有所需的 CodeCommit 权限，则可以直接使用该存储库，无需配置。有关详细信息，请参阅 [配置存储库访问权限](argocd-configure-repositories.md)。

 **来自 CodeConnections 的 Git 存储库**：

```
spec:
  source:
    repoURL: https://codeconnections.region.amazonaws.com/git-http/account-id/region/connection-id/owner/repository.git
    targetRevision: main
    path: kubernetes/manifests
```

存储库 URL 格式派生自 CodeConnections 连接 ARN。如果功能角色具有所需的 CodeConnections 权限且已配置连接，则可以直接使用该存储库，无需配置。有关详细信息，请参阅 [配置存储库访问权限](argocd-configure-repositories.md)。

 **Kustomize**：

```
spec:
  source:
    repoURL: https://github.com/example/kustomize-app
    targetRevision: main
    path: overlays/production
    kustomize:
      namePrefix: prod-
```

## 同步策略
<a name="_sync_policies"></a>

控制 Argo CD 如何同步应用程序。

 **手动同步（默认）**：

应用程序需要手动批准才能同步：

```
spec:
  syncPolicy: {}  # No automated sync
```

手动触发同步：

```
kubectl patch application guestbook -n argocd \
  --type merge \
  --patch '{"operation": {"initiatedBy": {"username": "admin"}, "sync": {}}}'
```

 **自动同步**：

检测到 Git 更改时，应用程序会自动同步：

```
spec:
  syncPolicy:
    automated: {}
```

 **自我修复**：

自动还原对集群所作的手动更改：

```
spec:
  syncPolicy:
    automated:
      selfHeal: true
```

启用后，Argo CD 会还原直接对集群所作的任何手动更改，确保 Git 始终是事实来源。

 **修剪**：

自动删除从 Git 中移除的资源：

```
spec:
  syncPolicy:
    automated:
      prune: true
```

**警告**  
修剪将从集群中删除资源。在生产环境中请谨慎使用。

 **组合式自动同步**：

```
spec:
  syncPolicy:
    automated:
      prune: true
      selfHeal: true
    syncOptions:
    - CreateNamespace=true
```

 **重试配置**：

为失败的同步配置重试行为：

```
spec:
  syncPolicy:
    retry:
      limit: 5  # Number of failed sync attempts; unlimited if less than 0
      backoff:
        duration: 5s  # Amount to back off (default unit: seconds, also supports "2m", "1h")
        factor: 2  # Factor to multiply the base duration after each failed retry
        maxDuration: 3m  # Maximum amount of time allowed for the backoff strategy
```

这对于那些必须先创建 CRD 的资源来说尤其有用，或者在处理 kro 实例时也很适用，因为在这些情况下 CRD 可能无法立即获取到。

## 同步选项
<a name="_sync_options"></a>

其他同步配置：

 **如果命名空间不存在，请创建一个**：

```
spec:
  syncPolicy:
    syncOptions:
    - CreateNamespace=true
```

 **跳过缺失资源的试运行**：

在应用依赖于尚未存在的 CRD（例如 kro 实例）的资源时，此功能非常有用：

```
spec:
  syncPolicy:
    syncOptions:
    - SkipDryRunOnMissingResource=true
```

这也可以通过在资源本身上使用标签的方式应用于特定的资源。

 **应用前验证资源**：

```
spec:
  syncPolicy:
    syncOptions:
    - Validate=true
```

 **仅应用不同步项**：

```
spec:
  syncPolicy:
    syncOptions:
    - ApplyOutOfSyncOnly=true
```

## 高级同步功能
<a name="_advanced_sync_features"></a>

Argo CD 支持用于复杂部署的高级同步功能：
+  **同步波次**：使用 `argocd.argoproj.io/sync-wave` 注释控制资源创建顺序
+  **同步钩子**：使用 `argocd.argoproj.io/hook` 注释（PreSync、PostSync、SyncFail）在同步前后运行任务
+  **资源运行状况评测**：针对特定于应用程序的资源进行自定义运行状况检查

有关详细信息，请参阅 Argo CD 文档中的 [Sync Waves](https://argo-cd.readthedocs.io/en/stable/user-guide/sync-waves/) 和 [Resource Hooks](https://argo-cd.readthedocs.io/en/stable/user-guide/resource_hooks/)。

## 忽略差异
<a name="_ignore_differences"></a>

防止 Argo CD 同步由其他控制器管理的特定字段（例如由 HPA 管理的副本）：

```
spec:
  ignoreDifferences:
  - group: apps
    kind: Deployment
    jsonPointers:
    - /spec/replicas
```

有关忽略模式和字段排除项的详细信息，请参阅 Argo CD 文档中的 [Diffing Customization](https://argo-cd.readthedocs.io/en/stable/user-guide/diffing/)。

## 多环境部署
<a name="_multi_environment_deployment"></a>

将同一应用程序部署到多个环境：

 **开发**：

```
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: my-app-dev
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://github.com/example/my-app
    targetRevision: develop
    path: overlays/development
  destination:
    name: dev-cluster
    namespace: my-app
```

 **生产环境**：

```
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: my-app-prod
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://github.com/example/my-app
    targetRevision: main
    path: overlays/production
  destination:
    name: prod-cluster
    namespace: my-app
  syncPolicy:
    automated:
      prune: true
      selfHeal: true
```

## 监控和管理应用程序
<a name="_monitor_and_manage_applications"></a>

 **查看应用程序状态**：

```
kubectl get application my-app -n argocd
```

 **访问 Argo CD 用户界面**：

通过 EKS 控制台打开 Argo CD 用户界面，查看应用程序拓扑、同步状态、资源运行状况和部署历史记录。有关用户界面访问说明，请参阅[使用 Argo CD](working-with-argocd.md)。

 **回滚应用程序**：

可以通过 Argo CD 用户界面、Argo CD CLI，或将应用程序规范中的 `targetRevision` 更新为之前的 Git 提交或标签，回滚到先前版本。

使用 Argo CD CLI：

```
argocd app rollback argocd/my-app <revision-id>
```

**注意**  
使用具有托管功能的 Argo CD CLI 时，请使用命名空间前缀指定应用程序：`namespace/appname`。

有关更多信息，请参阅 Argo CD 文档中的 [argocd 应用程序回滚](https://argo-cd.readthedocs.io/en/stable/user-guide/commands/argocd_app_rollback/)。

## 其他资源
<a name="_additional_resources"></a>
+  [使用 Argo CD 项目](argocd-projects.md)：为多租户环境使用项目组织应用程序
+  [使用 ApplicationSets](argocd-applicationsets.md)：通过模板部署到多个集群
+  [Application Specification](https://argo-cd.readthedocs.io/en/stable/user-guide/application-specification/)：完整的应用程序 API 参考
+  [Sync Options](https://argo-cd.readthedocs.io/en/stable/user-guide/sync-options/)：高级同步配置

# 使用 ApplicationSets
<a name="argocd-applicationsets"></a>

ApplicationSet 通过模板生成多个应用程序，使您能够通过单个资源定义，跨多个集群、环境或命名空间部署相同的应用程序。

## 先决条件
<a name="_prerequisites"></a>
+ 已创建具有 Argo CD 功能的 EKS 集群
+ 已配置存储库访问权限（请参阅[配置存储库访问权限](argocd-configure-repositories.md)）
+  已配置 `kubectl` 以与集群通信

**注意**  
ApplicationSets 不需要多个目标集群。您可以使用集群生成器以外的生成器（如 list、git 或 matrix 生成器），在没有远程集群的情况下部署应用程序。

## ApplicationSets 的工作原理
<a name="_how_applicationsets_work"></a>

ApplicationSets 使用生成器来生成参数，然后将这些参数应用于应用程序模板。每组生成的参数都会创建一个应用程序。

适用于 EKS 部署的常用生成器：
+  **列表生成器**：为每个环境明确定义集群和参数
+  **集群生成器**：自动部署到所有已注册的集群
+  **Git 生成器**：基于存储库结构生成应用程序
+  **矩阵生成器**：组合多个生成器以实现多维部署
+  **合并生成器**：合并来自多个生成器的参数

有关完整的生成器参考，请参阅 [ApplicationSet 文档](https://argo-cd.readthedocs.io/en/stable/user-guide/application-set/)。

## 列表生成器
<a name="_list_generator"></a>

通过明确配置部署到多个集群：

```
apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
  name: guestbook-all-clusters
  namespace: argocd
spec:
  generators:
  - list:
      elements:
      - environment: dev
        replicas: "2"
      - environment: staging
        replicas: "3"
      - environment: prod
        replicas: "5"
  template:
    metadata:
      name: 'guestbook-{{environment}}'
    spec:
      project: default
      source:
        repoURL: https://github.com/example/guestbook
        targetRevision: HEAD
        path: 'overlays/{{environment}}'
      destination:
        name: '{{environment}}-cluster'
        namespace: guestbook
      syncPolicy:
        automated:
          prune: true
          selfHeal: true
```

**注意**  
将 `destination.name` 与集群名称一起使用以提高可读性。如果需要，`destination.server` 字段还可以与 EKS 集群 ARN 配合使用。

这将创建三个应用程序：`guestbook-dev`、`guestbook-staging` 和 `guestbook-prod`。

## 集群生成器
<a name="_cluster_generator"></a>

自动部署到所有已注册的集群：

```
apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
  name: cluster-addons
  namespace: argocd
spec:
  generators:
  - clusters: {}
  template:
    metadata:
      name: '{{name}}-addons'
    spec:
      project: default
      source:
        repoURL: https://github.com/example/cluster-addons
        targetRevision: HEAD
        path: addons
      destination:
        server: '{{server}}'
        namespace: kube-system
      syncPolicy:
        automated:
          prune: true
          selfHeal: true
```

这将自动为每个已注册的集群创建应用程序。

 **筛选集群**：

使用 `matchLabels` 包含特定集群，或使用 `matchExpressions` 排除集群：

```
spec:
  generators:
  - clusters:
      selector:
        matchLabels:
          environment: production
        matchExpressions:
        - key: skip-appset
          operator: DoesNotExist
```

## Git 生成器
<a name="_git_generators"></a>

Git 生成器基于存储库结构创建应用程序：
+  **目录生成器**：将每个目录作为单独的应用程序部署（适用于微服务）
+  **文件生成器**：根据参数文件生成应用程序（适用于多租户部署）

 **示例：微服务部署** 

```
apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
  name: microservices
  namespace: argocd
spec:
  generators:
  - git:
      repoURL: https://github.com/example/microservices
      revision: HEAD
      directories:
      - path: services/*
  template:
    metadata:
      name: '{{path.basename}}'
    spec:
      project: default
      source:
        repoURL: https://github.com/example/microservices
        targetRevision: HEAD
        path: '{{path}}'
      destination:
        name: my-cluster
        namespace: '{{path.basename}}'
      syncPolicy:
        automated:
          prune: true
          selfHeal: true
        syncOptions:
        - CreateNamespace=true
```

有关 Git 生成器和基于文件的配置的详细信息，请参阅 Argo CD 文档中的 [Git Generator](https://argo-cd.readthedocs.io/en/stable/operator-manual/applicationset/Generators-Git/)。

## 矩阵生成器
<a name="_matrix_generator"></a>

组合多个生成器，以实现跨多个维度（环境 × 集群）的部署：

```
apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
  name: multi-env-multi-cluster
  namespace: argocd
spec:
  generators:
  - matrix:
      generators:
      - list:
          elements:
          - environment: dev
          - environment: staging
          - environment: prod
      - clusters:
          selector:
            matchLabels:
              region: us-west-2
  template:
    metadata:
      name: 'app-{{environment}}-{{name}}'
    spec:
      project: default
      source:
        repoURL: https://github.com/example/app
        targetRevision: HEAD
        path: 'overlays/{{environment}}'
      destination:
        name: '{{name}}'
        namespace: 'app-{{environment}}'
```

有关组合生成器的详细信息，请参阅 Argo CD 文档中的 [Matrix Generator](https://argo-cd.readthedocs.io/en/stable/operator-manual/applicationset/Generators-Matrix/)。

## 多区域部署
<a name="_multi_region_deployment"></a>

跨多个区域部署到集群：

```
apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
  name: global-app
  namespace: argocd
spec:
  generators:
  - list:
      elements:
      - clusterName: prod-us-west
        region: us-west-2
      - clusterName: prod-us-east
        region: us-east-1
      - clusterName: prod-eu-west
        region: eu-west-1
  template:
    metadata:
      name: 'app-{{region}}'
    spec:
      project: default
      source:
        repoURL: https://github.com/example/app
        targetRevision: HEAD
        path: kubernetes
        helm:
          parameters:
          - name: region
            value: '{{region}}'
      destination:
        name: '{{clusterName}}'
        namespace: app
      syncPolicy:
        automated:
          prune: true
          selfHeal: true
```

## 管理 ApplicationSets
<a name="_manage_applicationsets"></a>

 **查看 ApplicationSets 及生成的应用程序**：

```
kubectl get applicationsets -n argocd
kubectl get applications -n argocd -l argocd.argoproj.io/application-set-name=<applicationset-name>
```

 **更新 ApplicationSet**：

修改 ApplicationSet 规范并重新应用。Argo CD 会自动更新所有生成的应用程序：

```
kubectl apply -f applicationset.yaml
```

 **删除 ApplicationSet**：

```
kubectl delete applicationset <name> -n argocd
```

**警告**  
删除 ApplicationSet 会同时删除所有生成的应用程序。如果这些应用程序设置了 `prune: true`，其资源也将从目标集群中删除。  
要在删除 ApplicationSet 时保留已部署的资源，请在 ApplicationSet 规范中将 `.syncPolicy.preserveResourcesOnDeletion` 设置为 `true`。有关更多信息，请参阅 Argo CD 文档中的[应用程序修剪和资源删除](https://argo-cd.readthedocs.io/en/stable/operator-manual/applicationset/Application-Deletion/)。

**重要**  
Argo CD 的 ApplicationSets 功能存在一些安全方面的考量事项，在使用 ApplicationSets 之前您应当予以了解。有关更多信息，请参阅 Argo CD 文档中的 [ApplicationSet 安全性](https://argo-cd.readthedocs.io/en/stable/operator-manual/applicationset/Security/)。

## 其他资源
<a name="_additional_resources"></a>
+  [使用 Argo CD 项目](argocd-projects.md)：通过项目整理 ApplicationSets
+  [创建应用程序](argocd-create-application.md)：了解应用程序配置
+  [ApplicationSet Documentation](https://argo-cd.readthedocs.io/en/stable/user-guide/application-set/)：完整的生成器参考和模式
+  [Generator Reference](https://argo-cd.readthedocs.io/en/stable/operator-manual/applicationset/Generators/)：详细的生成器规范

# Argo CD 注意事项
<a name="argocd-considerations"></a>

本主题将介绍使用适用于 Argo CD 的 EKS 功能的重要注意事项，包括规划、权限、身份验证和多集群部署模式。

## 规划
<a name="_planning"></a>

在部署 Argo CD 之前，请考虑以下事项：

 **存储库策略**：确定应用程序清单的存储位置（CodeCommit、GitHub、GitLab、Bitbucket）。为不同的环境规划存储库结构和分支策略。

 **RBAC 策略**：规划哪些团队或用户应具有管理员、编辑者或查看者访问权限。将其映射到 AWS Identity Center 组或 Argo CD 角色。

 **多集群架构**：确定是否要通过单个 Argo CD 实例管理多个集群。考虑为 Argo CD 使用专用的管理集群。

 **应用程序组织**：规划如何构建 Applications 和 ApplicationSets。考虑使用项目按团队或环境组织应用程序。

 **同步策略**：决定应用程序应自动同步还是需要手动批准。开发环境通常采用自动同步，生产环境则采用手动同步。

## 权限
<a name="_permissions"></a>

有关 IAM 功能角色、信任策略和安全最佳实践的详细信息，请参阅 [Amazon EKS 功能 IAM 角色](capability-role.md)和 [EKS 功能的安全注意事项](capabilities-security.md)。

### IAM 功能角色概述
<a name="_iam_capability_role_overview"></a>

创建 Argo CD 功能资源时，您需要提供 IAM 功能角色。与 ACK 不同，Argo CD 主要管理 Kubernetes 资源，而不是直接管理 AWS 资源。但是，IAM 功能角色在以下场景是必需的：
+ 访问 CodeCommit 中的私有 Git 存储库
+ 与 AWS Identity Center 集成以进行身份验证
+ 访问 AWS Secrets Manager 中的密钥（如果已配置）
+ 跨集群部署到其他 EKS 集群

### CodeCommit 集成
<a name="_codecommit_integration"></a>

如果使用的是 CodeCommit 存储库，请附加具有读取权限的策略：

```
{
  "Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "codecommit:GitPull"
      ],
      "Resource": "*"
    }
  ]
}
```

**重要**  
对于生产用途，请将 `Resource` 字段限制为特定的存储库 ARN，而不是使用 `"*"`。  
示例：  

```
"Resource": "arn:aws:codecommit:us-west-2:111122223333:my-app-repo"
```
这限制了 Argo CD 功能对存储库的访问权限，仅允许其访问需要管理的存储库。

### Secrets Manager 集成
<a name="_secrets_manager_integration"></a>

如果要将存储库凭证存储在 Secrets Manager 中，请附加托管策略以获得读取访问权限：

```
arn:aws:iam::aws:policy/AWSSecretsManagerClientReadOnlyAccess
```

此策略包括必要的权限：`secretsmanager:GetSecretValue`、`secretsmanager:DescribeSecret` 和 KMS 解密权限。

### 基本设置
<a name="_basic_setup"></a>

对于使用公有 Git 存储库的基本 Argo CD 功能，除了信任策略外，不需要其他的 IAM 策略。

## 身份验证
<a name="_authentication"></a>

### AWS Identity Center 集成
<a name="shared_aws_identity_center_integration"></a>

Argo CD 托管功能直接与 AWS Identity Center（原 AWS SSO）集成，您能够使用现有的身份提供者进行身份验证。

配置 AWS Identity Center 集成时：

1. 用户通过 EKS 控制台访问 Argo CD 用户界面

1. 他们使用 AWS Identity Center（可以与企业身份提供者联合）进行身份验证

1.  AWS Identity Center 向 Argo CD 提供用户和组信息

1. Argo CD 会根据配置将用户和组映射到 RBAC 角色

1. 用户只能看到他们有权访问的应用程序和资源

### 使用 IAM Center 权限集简化访问管理
<a name="_simplifying_access_with_identity_center_permission_sets"></a>

 使用 Argo CD 时，AWS Identity Center 提供两种不同的身份验证路径：

 **Argo CD API 身份验证**：Identity Center 向 Argo CD 用户界面和 API 提供 SSO 身份验证。这通过 Argo CD 功能的 RBAC 角色映射进行配置。

 **EKS 集群访问权限**：Argo CD 功能使用客户提供的 IAM 角色，通过访问条目向 EKS 集群进行身份验证。可以手动配置这些访问条目以添加或移除权限。

您可以使用 [Identity Center 权限集](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtocreatepermissionset.html)来简化身份管理，允许单个身份同时访问 Argo CD 和 EKS 集群。这样一来，您只需在两个系统中管理一个身份，而无需为 Argo CD 访问和集群访问保留单独的凭证，从而减少了开销。

### RBAC 角色映射
<a name="_rbac_role_mappings"></a>

Argo CD 具有内置角色，您可以将其映射到 AWS Identity Center 用户和组：

 **ADMIN**：可以完全访问所有应用程序和设置。可以创建、更新和删除应用程序。可以管理 Argo CD 配置。

 **EDITOR**：可以创建和修改应用程序。无法更改 Argo CD 设置或删除应用程序。

 **VIEWER**：可以对应用程序进行只读访问。可以查看应用程序状态和历史记录。无法进行更改。

**注意**  
角色名称区分大小写，必须为大写（ADMIN、EDITOR、VIEWER）。

**重要**  
EKS 功能与 AWS Identity Center 集成后，每个 Argo CD 功能可支持最多 1000 个身份。身份可以是用户或组。

## 多集群部署
<a name="_multi_cluster_deployments"></a>

Argo CD 托管功能支持多集群部署，便于您通过单个 Argo CD 实例在开发、暂存和生产集群之间管理应用程序。

### 多集群工作原理
<a name="_how_multi_cluster_works"></a>

当您向 Argo CD 注册其他集群时：

1. 您需要创建集群密钥，并通过 ARN 来引用目标 EKS 集群

1. 您需要创建针对不同集群的 Applications 或 ApplicationSets

1. Argo CD 会连接到每个集群以部署和监视资源

1. 您可以通过单个 Argo CD 用户界面查看和管理所有集群

### 多集群的先决条件
<a name="_prerequisites_for_multi_cluster"></a>

在注册其他集群之前：
+ 在目标集群上，为 Argo CD 功能角色创建访问条目
+ 确保 Argo CD 功能与目标集群之间建立网络连接
+ 验证访问目标集群所需的 IAM 权限

### 注册集群
<a name="_register_a_cluster"></a>

使用 `argocd` 命名空间中的 Kubernetes Secret 注册集群。

获取目标集群 ARN。将 *region-code* 替换为目标集群所在的 AWS 区域，并将 *target-cluster* 替换为目标集群的名称。

```
aws eks describe-cluster \
  --region region-code \
  --name target-cluster \
  --query 'cluster.arn' \
  --output text
```

使用集群 ARN 创建集群密钥：

```
apiVersion: v1
kind: Secret
metadata:
  name: target-cluster
  namespace: argocd
  labels:
    argocd.argoproj.io/secret-type: cluster
type: Opaque
stringData:
  name: target-cluster
  server: arn:aws:eks:us-west-2:111122223333:cluster/target-cluster
  project: default
```

**重要**  
在 `server` 字段中使用 EKS 集群 ARN，而不是 Kubernetes API 服务器 URL。托管功能需要使用 ARN 来识别目标集群。

应用该密钥：

```
kubectl apply -f cluster-secret.yaml
```

### 在目标集群上配置访问条目
<a name="_configure_access_entry_on_target_cluster"></a>

目标集群必须具有访问条目，以授予 Argo CD 功能角色部署应用程序的权限。将 *region-code* 替换为目标集群所在的 AWS 区域，将 *target-cluster* 替换为目标集群的名称，然后将 ARN 替换为 Argo CD 功能角色 ARN。

```
aws eks create-access-entry \
  --region region-code \
  --cluster-name target-cluster \
  --principal-arn arn:aws:iam::[.replaceable]111122223333:role/ArgoCDCapabilityRole \
  --type STANDARD \
  --kubernetes-groups system:masters
```

**注意**  
对于生产用途，可以考虑使用限制性更强的 Kubernetes 组，而不使用 `system:masters`。

### 私有集群访问
<a name="_private_cluster_access"></a>

Argo CD 托管功能可以部署到完全私有的 EKS 集群，无需进行 VPC 对等连接或专门的网络配置。AWS 会自动管理 Argo CD 功能与私有远程集群之间的连接。确保您的存储库访问控制和 Argo CD RBAC 策略已正确配置。

### 跨账户部署
<a name="_cross_account_deployments"></a>

对于跨账户部署，请将源账户中的 Argo CD IAM 功能角色添加到目标集群的 EKS 访问条目中：

1. 在目标账户中的目标 EKS 集群上创建访问条目

1. 将源账户中的 Argo CD IAM 功能角色 ARN 用作主体

1. 为访问条目配置相应的 Kubernetes RBAC 权限

1. 使用其 EKS 集群 ARN 在 Argo CD 中注册目标集群

无需创建额外的 IAM 角色或配置信任策略，EKS 访问条目会处理跨账户访问。

## 最佳实践
<a name="_best_practices"></a>

 **使用声明式源作为事实来源**：将所有应用程序清单存储在声明式源（Git 存储库、Helm 注册表或 OCI 映像）中，从而实现版本控制、审计跟踪记录和协作。

 **实施适当的 RBAC**：使用 AWS Identity Center 集成来控制哪些人可以访问和管理 Argo CD 中的应用程序。Argo CD 支持对应用程序内的资源（Deployment、Pod、ConfigMap、Secret）进行精细访问控制。

 **使用 ApplicationSets 进行多环境部署**：使用 ApplicationSets 在不同集群或命名空间中以不同配置部署应用程序。

## 生命周期管理
<a name="_lifecycle_management"></a>

### 应用程序同步策略
<a name="_application_sync_policies"></a>

控制 Argo CD 如何同步应用程序：

 **手动同步**：应用程序需要手动批准才能同步更改。建议将其用于**生产**环境。

 **自动同步**：检测到 Git 更改时，应用程序会自动同步。通常用于开发和暂存环境。

 **自我修复**：自动还原对集群所作的手动更改。确保集群状态与 Git 一致。

 **修剪**：自动删除从 Git 中移除的资源。请谨慎使用，因为此操作可能会删除资源。

### 应用程序运行状况
<a name="_application_health"></a>

Argo CD 会持续监控应用程序运行状况：
+  **良好**：所有资源均按预期运行
+  **正在处理**：正在创建或更新资源
+  **已降级**：部分资源运行状况不佳
+  **已暂停**：应用程序暂停
+  **缺失**：集群中缺少资源

### 同步时段
<a name="_sync_windows"></a>

配置同步时段以控制何时可以同步应用程序：
+ 仅允许在维护时段进行同步
+ 在工作时间阻止同步
+ 为特定时间安排自动同步
+ 在需要进行更改且需要停止所有同步操作（紧急情景）的情况下，请使用同步窗口

## 配置 Webhook 以实现更快同步
<a name="_webhook_configuration_for_faster_sync"></a>

默认情况下，Argo CD 每 6 分钟轮询一次 Git 存储库以检测更改。要实现响应速度更快的部署，请配置 Git Webhook 以在推送更改时立即触发同步。

Webhook 具有以下优势：
+ 推送代码时立即同步响应（秒级而非分钟级）
+ 减少轮询开销并提高系统性能
+ 更有效地使用 API 速率限制
+ 用户体验更好，反馈更快

### Webhook 端点
<a name="_webhook_endpoint"></a>

webhook URL 遵循模式 `${serverUrl}/api/webhook`，其中 `serverUrl` 是您的 Argo CD 服务器 URL。

例如，如果您的 Argo CD 服务器 URL 是 `https://abc123.eks-capabilities.us-west-2.amazonaws.com`，则 webhook URL 是：

```
https://abc123.eks-capabilities.us-west-2.amazonaws.com/api/webhook
```

### 按 Git 提供者配置 Webhook
<a name="_configure_webhooks_by_git_provider"></a>

 **GitHub**：在存储库设置中，添加指向 Argo CD Webhook URL 的 Webhook。将内容类型设置为 `application/json`，然后选择“仅推送事件”。

 **GitLab**：在项目设置中，添加指向 Argo CD Webhook URL 的 Webhook。启用“推送事件”和“标签推送事件”（可选）。

 **Bitbucket**：在存储库设置中，添加指向 Argo CD Webhook URL 的 Webhook。选择“存储库推送”作为触发器。

 **CodeCommit**：创建 Amazon EventBridge 规则，该规则会在 CodeCommit 存储库状态更改时触发，并将通知发送到 Argo CD Webhook 端点。

有关详细的 Webhook 配置说明，请参阅 [Argo CD Webhook Configuration](https://argo-cd.readthedocs.io/en/stable/operator-manual/webhook/)。

**注意**  
Webhooks 是对轮询的补充，并不能取而代之。Argo CD 会继续轮询存储库，作为错过 Webhook 通知时的回退机制。

## 后续步骤
<a name="_next_steps"></a>
+  [使用 Argo CD](working-with-argocd.md)：了解如何创建和管理 Argo CD 应用程序
+  [排查 Argo CD 功能的问题](argocd-troubleshooting.md)：排查 Argo CD 问题
+  [使用功能资源](working-with-capabilities.md)：管理 Argo CD 功能资源

# 排查 Argo CD 功能的问题
<a name="argocd-troubleshooting"></a>

本主题提供了适用于 Argo CD 的 EKS 功能的问题排查指南，包括功能运行状况检查、应用程序同步问题、存储库身份验证和多集群部署。

**注意**  
EKS 功能完全托管，可在您的集群之外运行。您无权访问 Argo CD 服务器日志或 `argocd` 命名空间。问题排查侧重于功能运行状况、应用程序状态和配置。

## 功能已激活，但应用程序未同步
<a name="_capability_is_active_but_applications_arent_syncing"></a>

如果 Argo CD 功能显示 `ACTIVE` 状态但应用程序未同步，请检查功能运行状况和应用程序状态。

 **检查功能运行状况**：

您可以在 EKS 控制台或使用 AWS CLI 查看功能运行状况和状态问题。

 **控制台**：

1. 从以下位置打开 Amazon EKS 控制台：https://console.aws.amazon.com/eks/home\$1/clusters。

1. 选择集群名称。

1. 选择**可观测性**选项卡。

1. 选择**监控集群**。

1. 选择**功能**选项卡，查看所有功能的运行状况和状态。

 **AWS CLI**：

```
# View capability status and health
aws eks describe-capability \
  --region region-code \
  --cluster-name my-cluster \
  --capability-name my-argocd

# Look for issues in the health section
```

 **常见原因：**
+  **未配置存储库**：Git 存储库未添加到 Argo CD
+  **身份验证失败**：SSH 密钥、令牌或 CodeCommit 凭证无效
+  **未创建应用程序**：集群中不存在 Application 资源
+  **同步策略**：需要手动同步（未启用自动同步）
+  **IAM 权限**：缺少 CodeCommit 或 Secrets Manager 的权限

 **检查应用程序状态**：

```
# List applications
kubectl get application -n argocd

# View sync status
kubectl get application my-app -n argocd -o jsonpath='{.status.sync.status}'

# View application health
kubectl get application my-app -n argocd -o jsonpath='{.status.health}'
```

 **查看应用程序条件**：

```
# Describe application to see detailed status
kubectl describe application my-app -n argocd

# View application health
kubectl get application my-app -n argocd -o jsonpath='{.status.health}'
```

## 应用程序始终处于“Progressing”状态
<a name="_applications_stuck_in_progressing_state"></a>

如果应用程序显示 `Progressing` 但从未到达 `Healthy` 状态，请检查该应用程序的资源状态和事件。

 **检查资源运行状况**：

```
# View application resources
kubectl get application my-app -n argocd -o jsonpath='{.status.resources}'

# Check for unhealthy resources
kubectl describe application my-app -n argocd | grep -A 10 "Health Status"
```

 **常见原因：**
+  **部署未就绪**：容器组（pod）无法启动或就绪探测器故障
+  **资源依赖关系**：等待其他资源准备就绪的资源
+  **图片拉取错误**：无法访问容器映像
+  **资源不足**：集群缺乏用于容器组（pod）的 CPU 或内存

 **验证目标集群配置**（适用于多集群设置）：

```
# List registered clusters
kubectl get secret -n argocd -l argocd.argoproj.io/secret-type=cluster

# View cluster secret details
kubectl get secret cluster-secret-name -n argocd -o yaml
```

## 存储库身份验证失败
<a name="_repository_authentication_failures"></a>

如果 Argo CD 无法访问您的 Git 存储库，请确认身份验证配置是否正确。

 **对于 CodeCommit 存储库**：

验证 IAM 功能角色是否具有 CodeCommit 权限：

```
# View IAM policies
aws iam list-attached-role-policies --role-name my-argocd-capability-role
aws iam list-role-policies --role-name my-argocd-capability-role

# Get specific policy details
aws iam get-role-policy --role-name my-argocd-capability-role --policy-name policy-name
```

该角色需要存储库的 `codecommit:GitPull` 权限。

 **对于私有 Git 存储库**：

验证存储库凭证配置是否正确：

```
# Check repository secret exists
kubectl get secret -n argocd repo-secret-name -o yaml
```

确保密钥包含正确的身份验证凭证（SSH 密钥、令牌或用户名/密码）。

 **对于使用 Secrets Manager 的存储库**：

```
# Verify IAM Capability Role has Secrets Manager permissions
aws iam list-attached-role-policies --role-name my-argocd-capability-role

# Test secret retrieval
aws secretsmanager get-secret-value --secret-id arn:aws:secretsmanager:region-code:111122223333:secret:my-secret
```

## 多集群部署问题
<a name="_multi_cluster_deployment_issues"></a>

如果应用程序未部署到远程集群，请确认集群注册和访问配置是否正确。

 **检查集群注册**：

```
# List registered clusters
kubectl get secret -n argocd -l argocd.argoproj.io/secret-type=cluster

# Verify cluster secret format
kubectl get secret CLUSTER_SECRET_NAME -n argocd -o yaml
```

确保 `server` 字段包含 EKS 集群 ARN，而不是 Kubernetes API URL。

 **验证目标集群访问入口**：

在目标集群上，检查 Argo CD 功能角色是否具有访问条目：

```
# List access entries (run on target cluster or use AWS CLI)
aws eks list-access-entries --cluster-name target-cluster

# Describe specific access entry
aws eks describe-access-entry \
  --cluster-name target-cluster \
  --principal-arn arn:aws:iam::[.replaceable]111122223333:role/my-argocd-capability-role
```

 **检查跨账户的 IAM 权限**：

对于跨账户部署，请验证 Argo CD 功能角色在目标集群上是否有访问条目。托管功能使用 EKS 访问条目进行跨账户访问，而不是 IAM 角色代入。

有关多集群配置的更多信息，请参阅[注册目标集群](argocd-register-clusters.md)。

## 后续步骤
<a name="_next_steps"></a>
+  [Argo CD 注意事项](argocd-considerations.md)：Argo CD 注意事项和最佳实践
+  [使用 Argo CD](working-with-argocd.md)：创建和管理 Argo CD 应用程序
+  [注册目标集群](argocd-register-clusters.md)：配置多集群部署
+  [EKS 功能问题排查](capabilities-troubleshooting.md)：一般功能问题排查指导

# 适用于 Argo CD 的 EKS 功能与自主管理型 Argo CD 的比较
<a name="argocd-comparison"></a>

适用于 Argo CD 的 EKS 功能提供了在 EKS 中运行的完全托管的 Argo CD。有关 EKS 功能与自主管理型解决方案的总体比较，请参阅 [EKS 功能和注意事项](capabilities-considerations.md)。本主题将重点介绍 Argo CD 特有的差异，包括身份验证、多集群管理及上游功能支持。

## 与上游 Argo CD 的区别
<a name="_differences_from_upstream_argo_cd"></a>

适用于 Argo CD 的 EKS 功能基于上游 Argo CD，但在访问方式、配置以及与 AWS 服务的集成方面有所不同。

 **RBAC 和身份验证**：该功能附带三个 RBAC 角色（管理员、编辑者和查看者），并使用 AWS Identity Center 进行身份验证，而不是 Argo CD 的内置身份验证。通过该功能的 `rbacRoleMapping` 参数配置角色映射，以将 Identity Center 组映射到 Argo CD 角色，而不是通过 Argo CD 的 `argocd-rbac-cm` ConfigMap 进行配置。Argo CD 用户界面通过其自身的直接 URL 托管（可在 EKS 控制台中集群的“功能”选项卡下找到），API 访问则通过 IAM 使用 AWS 身份验证和授权。

 **集群配置**：该功能不会自动配置本地集群或轴辐式拓扑。您需要自行配置部署目标集群和 EKS 访问条目。该功能仅支持将 Amazon EKS 集群作为部署目标，且必须使用 EKS 集群 ARN（而非 Kubernetes API 服务器 URL）。该功能不会自动将本地集群 (`kubernetes.default.svc`) 添加为部署目标，若要部署到创建该功能的同一集群，请使用其 ARN 明确注册该集群。

 **简化的远程集群访问**：该功能使用 EKS 访问条目来授予 Argo CD 远程集群访问权限，从而简化了多集群部署，无需配置服务账户的 IAM 角色（IRSA）或设置跨账户 IAM 角色代入。该功能还支持对完全私有的 EKS 集群进行透明访问，无需进行 VPC 对等连接或专门的网络配置，AWS 会自动管理 Argo CD 功能与私有远程集群之间的连接。

 **直接的 AWS 服务集成**：该功能通过功能角色的 IAM 权限，提供与 AWS 服务的直接集成。您可以直接在 Application 资源中引用 CodeCommit 存储库、ECR Helm 图表和 CodeConnections，而无需创建存储库配置。这简化了身份验证，无需为 AWS 服务管理单独的凭证。有关详细信息，请参阅 [配置存储库访问权限](argocd-configure-repositories.md)。

 **命名空间支持**：该功能要求您指定一个单一命名空间，在该命名空间内必须创建 Argo CD 应用程序、ApplicationSet 以及 AppProject 自定义资源。

**注意**  
此命名空间限制仅适用于 Argo CD 自己的自定义资源（应用程序、ApplicationSet、AppProject）。您的应用程序工作负载可以部署到任何目标集群中的任何命名空间中。例如，如果您使用命名空间 `argocd` 创建功能，则必须在 `argocd` 命名空间中创建所有应用程序 CR，但这些应用程序可以将工作负载部署到 `default`、`production`、`staging` 或任何其他命名空间。

**注意**  
托管功能对 CLI 的使用和 AppProject 配置有特定的要求：  
使用 Argo CD CLI 时，请使用命名空间前缀指定应用程序：`argocd app sync namespace/appname`
AppProject 资源必须指定 `.spec.sourceNamespaces`，以确定该项目可以监控应用程序的哪些命名空间（通常设置为您在创建功能时所指定的命名空间）
资源跟踪注释使用格式：`namespace_appname:group/kind:namespace/name`

 **不支持的功能**：托管功能中不提供以下功能：
+ 用于生成自定义清单的 Config 管理插件（CMP）
+ 用于资源运行状况评测的自定义 Lua 脚本（支持标准资源的内置运行状况检查）
+ 通知控制器
+ 自定义 SSO 提供者（仅支持 AWS Identity Center，包括通过 AWS Identity Center 提供的第三方联合身份）
+ 用户界面扩展和自定义横幅
+ 直接访问 `argocd-cm`、`argocd-params` 和其他配置 ConfigMaps
+ 修改同步超时（固定为 120 秒）

 **兼容性**：Applications 和 ApplicationSets 的工作方式与上游 Argo CD 完全相同，清单无需更改。该功能使用同一 Kubernetes API 和 CRD，因此 `kubectl` 等工具的使用方式将保持不变。该功能完全支持 Applications 和 ApplicationSets、带自动同步的 GitOps 工作流程、多集群部署、同步策略（自动化、修剪、自我修复）、同步波次和钩子、标准 Kubernetes 资源的运行状况评估、回滚功能、Git 存储库源（HTTPS 和 SSH）、Helm、Kustomize 和原生 YAML 清单、GitHub 应用程序凭证、用于多租户的项目，以及资源排除项和包含项。

## 将 Argo CD CLI 与托管功能结合使用
<a name="argocd-cli-configuration"></a>

对于大多数操作，Argo CD CLI 的工作方式与上游 Argo CD 相同，但身份验证和集群注册有所不同。

### 先决条件
<a name="_prerequisites"></a>

按照[上游安装说明](https://argo-cd.readthedocs.io/en/stable/cli_installation/)，安装 Argo CD CLI。

### 配置
<a name="_configuration"></a>

使用环境变量配置 CLI：

1. 从 EKS 控制台（在集群的**功能**选项卡下）或使用 AWS CLI 获取 Argo CD 服务器 URL。必须移除 `https://` 前缀：

   ```
   export ARGOCD_SERVER=$(aws eks describe-capability \
     --cluster-name my-cluster \
     --capability-name my-argocd \
     --query 'capability.configuration.argoCd.serverUrl' \
     --output text \
     --region region-code | sed 's|^https://||')
   ```

1. 从 Argo CD 用户界面（**设置** → **账户** → **管理员** → **生成新令牌**）生成账户令牌，然后将其设置为环境变量：

   ```
   export ARGOCD_AUTH_TOKEN="your-token-here"
   ```

**重要**  
此配置使用管理员账户令牌进行初始设置和开发工作流程。对于生产使用案例，为遵循最低权限原则，请使用项目作用域内的角色和令牌。有关配置项目角色和 RBAC 的更多信息，请参阅[配置 Argo CD 权限](argocd-permissions.md)。

1. 设置必需的 gRPC 选项：

   ```
   export ARGOCD_OPTS="--grpc-web"
   ```

设置这些环境变量后，无需使用 `argocd login` 命令即可使用 Argo CD CLI。

### 主要区别
<a name="_key_differences"></a>

托管功能具有以下 CLI 限制：
+  不支持 `argocd admin` 命令 [这些命令需要直接访问容器组（pod）]
+  不支持 `argocd login`（改用账户或项目令牌）
+  `argocd cluster add` 需要 `--aws-cluster-name` 标志并指定 EKS 集群 ARN

### 示例：注册集群
<a name="_example_register_a_cluster"></a>

注册 EKS 集群以进行应用程序部署：

```
# Get the cluster ARN
CLUSTER_ARN=$(aws eks describe-cluster \
  --name my-cluster \
  --query 'cluster.arn' \
  --output text)

# Register the cluster
argocd cluster add $CLUSTER_ARN \
  --aws-cluster-name $CLUSTER_ARN \
  --name in-cluster \
  --project default
```

有关完整的 Argo CD CLI 文档，请参阅 [Argo CD CLI 参考](https://argo-cd.readthedocs.io/en/stable/user-guide/commands/argocd/)。

## 迁移路径
<a name="_migration_path"></a>

您可以从自主管理型 Argo CD 迁移到托管功能：

1. 检查当前的 Argo CD 配置中是否存在不支持的功能（通知控制器、CMP、自定义运行状况检查、UI 扩展）

1. 将自主管理的 Argo CD 控制器缩减到零副本以防止冲突

1. 在集群上创建 Argo CD 功能资源

1. 导出现有的 Applications、ApplicationSets 和 AppProjects

1. 迁移存储库凭证、集群密钥和存储库凭证模板（repocreds）

1. 如果使用 GPG 密钥、TLS 证书或 SSH 已知主机，请同时迁移这些配置

1. 更新 `destination.server` 字段以使用集群名称或 EKS 集群 ARN

1. 将其应用于 Argo CD 托管实例

1. 验证应用程序是否正确同步

1. 停用自行管理型 Argo CD 安装

托管功能使用相同的 Argo CD API 和资源定义，因此只需最少的修改即可使用现有清单。

## 后续步骤
<a name="_next_steps"></a>
+  [创建 Argo CD 功能](create-argocd-capability.md)：创建 Argo CD 功能资源
+  [使用 Argo CD](working-with-argocd.md)：部署第一个应用程序
+  [Argo CD 注意事项](argocd-considerations.md)：配置 AWS Identity Center 集成