

 **このページの改善にご協力ください** 

このユーザーガイドに貢献するには、すべてのページの右側のペインにある「**GitHub でこのページを編集する**」リンクを選択してください。

# Argo CD による継続的デプロイ
<a name="argocd"></a>

Argo CD は、Kubernetes 向けの宣言型 GitOps 継続的デリバリーツールです。Argo CD を使用すると、複数のクラスターと環境にわたるアプリケーションのデプロイとライフサイクルを自動的に管理できます。Argo CD は、Git リポジトリ、Helm レジストリ (HTTP および OCI)、OCI イメージなど複数のソースタイプをサポートしており、セキュリティとコンプライアンスの要件がさまざまに異なる組織に柔軟に対応できます。

AWS では EKS の機能を使用して Argo CD を完全に管理できるため、クラスターに Argo CD コントローラーとその依存関係をインストールしてメンテナンスおよびスケールする必要がありません。

## Argo CD の仕組み
<a name="_how_argo_cd_works"></a>

Argo CD は GitOps パターンに従い、アプリケーションソース (Git リポジトリ、Helm レジストリ、または OCI イメージ) を、目的のアプリケーション状態を定義するための信頼できるソースとします。Argo CD `Application` リソースを作成するときは、アプリケーションマニフェストが含まれているソースと、ターゲットとなる Kubernetes クラスターおよび名前空間を指定します。Argo CD は、クラスター内のソース状態とライブ状態の両方を継続的にモニタリングし、変更が加えられたら自動的に同期して、クラスターの状態が目的の状態と一致するようにします。

**注記**  
EKS Capability for Argo CD では、Argo CD ソフトウェアはワーカーノードではなく AWS コントロールプレーンで動作します。つまり、ワーカーノードが Git リポジトリや Helm レジストリに直接アクセスする必要はありません。この機能は、AWS アカウントからのソースアクセスを処理します。

Argo CD には、主に 3 つのリソースタイプがあります。
+  **Application**: Git リポジトリからターゲットクラスターへのデプロイを定義します。
+  **ApplicationSet**: 複数のクラスターにデプロイできるように、テンプレートから複数の Application を生成します
+  **AppProject**: Application を論理的にグループ化し、アクセスコントロールを付与できます。

 **例: Argo CD Application を作成する** 

次の例は、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>

GitOps ワークフローを実装しているため、Git リポジトリにアプリケーション設定を定義できます。また、目的の状態に合わせてアプリケーションを自動的に同期する機能も備えています。この Git 中心のアプローチにより、すべての変更が漏れなく監査証跡に残され、ロールバックが容易になり、既存のコードレビューおよび承認プロセスと必然的に統合されます。Argo CD は、Git の目的の状態とクラスターの実際の状態との間のドリフトを自動的に検出して調整し、デプロイと宣言された設定との整合性が確保されるようにします。

Argo CD を使用すると、単一の Argo CD インスタンスから複数のクラスターにアプリケーションをデプロイして管理できるため、マルチクラスター環境とマルチリージョン環境でのオペレーションがシンプルになります。Argo CD UI に可視化とモニタリングの機能が用意されているため、アプリケーションのデプロイステータス、ヘルス、履歴を確認できます。この UI は AWS アイデンティティセンター (以前の AWS SSO) と統合されており、認証と認可をシームレスに進めて、既存の ID 管理インフラストラクチャを使用してアクセスを制御できます。

AWS では、Argo CD が EKS マネージド機能の一部として完全に管理されるため、Argo CD インフラストラクチャを導入、設定、メンテナンスする必要がありません。AWS がスケール、パッチ適用、運用管理を行うので、チームはツールのメンテナンスではなくアプリケーションの配信に集中できます。

## AWS アイデンティティセンターとの統合
<a name="integration_with_shared_aws_identity_center"></a>

EKS マネージド機能により、Argo CD と AWS アイデンティティセンターを直接統合して、ユーザーの認証と認可をシームレスに進めることができます。Argo CD 機能を有効にすると、アイデンティティセンターのグループとユーザーを Argo CD RBAC ロールにマッピングするように AWS アイデンティティセンターの統合を設定して、Argo CD で誰がアプリケーションにアクセスおよび管理できるかを制御できます。

## 他の EKS マネージド機能との統合
<a name="_integration_with_other_eks_managed_capabilities"></a>

Argo CD は、他の EKS マネージド機能と統合されています。
+  **Kubernetes 用 AWS コントローラー (ACK)**: Argo CD を使用すると、複数のクラスターにまたがる ACK リソースのデプロイを管理して、AWS インフラストラクチャの GitOps ワークフローを有効にできます。
+  **kro (Kube Resource Orchestrator)**: Argo CD を使用すると、複数のクラスターに kro コンポジションをデプロイして、Kubernetes エステート全体で一貫性のあるリソース構成を実現できます。

## Argo CD の使用を開始する
<a name="_getting_started_with_argo_cd"></a>

EKS Capability for Argo CD の使用を開始するには:

1. IAM 機能ロールを作成し、Argo CD がソースにアクセスしてアプリケーションを管理できるように必要なアクセス許可を設定します。

1.  AWS コンソール、AWS CLI、または任意の Infrastructure as Code ツールを使用して、EKS クラスターに [Argo CD 機能リソースを作成](create-argocd-capability.md)します。

1. アプリケーションをデプロイするために、リポジトリアクセスを設定し、クラスターを登録します。

1. Application リソースを作成して、宣言型ソースからアプリケーションをデプロイします。

# Argo CD 機能を作成する
<a name="create-argocd-capability"></a>

このトピックでは、Amazon EKS クラスターに Argo CD 機能を作成する方法について説明します。

## 前提条件
<a name="_prerequisites"></a>

Argo CD 機能を作成する前に、以下の点を確認してください。
+ サポート対象の Kubernetes バージョン (標準サポートと延長サポートのすべてのバージョンがサポート対象) を実行している Amazon EKS クラスターが存在する
+  **AWS アイデンティティセンターが設定されている** - Argo CD の認証に必要 (ローカルユーザーはサポート対象外)
+ Argo CD に対するアクセス許可が付与された IAM 機能ロールがある
+ EKS クラスターに機能リソースを作成するための十分な IAM アクセス許可がある
+  クラスターと通信できるように `kubectl` が設定されていること
+ (オプション) Argo CD CLI をインストールしてクラスターとリポジトリの管理を容易にしている
+ (CLI/eksctl の場合) 適切な CLI ツールがインストールおよび設定されている

IAM 機能ロールを作成する手順については、「[Amazon EKS 機能 IAM ロール](capability-role.md)」を参照してください。アイデンティティセンターのセットアップについては、「[AWS アイデンティティセンターの使用を開始する](https://docs.aws.amazon.com/singlesignon/latest/userguide/getting-started.html)」を参照してください。

**重要**  
Argo CD でどの AWS リソースにアクセスできるかは、どの IAM 機能ロールを使用するかによって決まります。例えば、Git リポジトリへのアクセスには CodeConnections を利用し、シークレットへのアクセスには 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) - Kubernetes ネイティブの操作をする場合は eksctl を使用します。

## Argo CD 機能を作成するとどうなるか
<a name="_what_happens_when_you_create_an_argo_cd_capability"></a>

Argo CD 機能を作成すると、次のようになります。

1. EKS が AWS コントロールプレーンに Argo CD 機能サービスを作成します。

1. カスタムリソース定義 (CRD) がクラスターにインストールされます。

1. Kubernetes のベースラインアクセス許可を付与する機能固有のアクセスエントリポリシーを使用して、IAM 機能ロールのアクセスエントリを自動的に作成します (「[EKS 機能のセキュリティに関する考慮事項](capabilities-security.md)」を参照)。

1. Argo CD がカスタムリソース (Application、ApplicationSet、AppProject) の監視を開始します。

1. 機能のステータスが `CREATING` から `ACTIVE` に変わります。

1. Argo CD UI が URL 経由でアクセス可能になります。

機能がアクティブになったら、宣言型ソースからデプロイするようにクラスターに Argo CD Application を作成できます。

**注記**  
自動的に作成されるアクセスエントリは、アプリケーションをクラスターにデプロイするアクセス許可を付与しません。アプリケーションをデプロイするには、ターゲットクラスターごとに追加の 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) - リポジトリアクセスを設定し、ターゲットクラスターを登録して、Application を作成する
+  [Argo CD に関する考慮事項](argocd-considerations.md) - マルチクラスターアーキテクチャパターンと高度な設定を探る

# コンソールを使用して Argo CD 機能を作成する
<a name="argocd-create-console"></a>

このトピックでは、AWS マネジメントコンソール を使用して Argo CD 機能を作成する方法について説明します。

## 前提条件
<a name="_prerequisites"></a>
+  **AWS アイデンティティセンターが設定されていること** – Argo CD での認証には AWS アイデンティティセンターが必要です。ローカルユーザーはサポートされていません。AWS アイデンティティセンターをセットアップしていない場合は、「[AWS アイデンティティセンターの使用を開始する](https://docs.aws.amazon.com/singlesignon/latest/userguide/getting-started.html)」を参照してアイデンティティセンターインスタンスを作成し、「[ユーザーを追加する](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. https://console.aws.amazon.com/eks/home\$1/clusters で Amazon EKS コンソールを開きます。

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 アイデンティティセンターの統合を設定します。

   1. **[AWS アイデンティティセンターの統合を有効にする]** を選択します。

   1. ドロップダウンからアイデンティティセンターインスタンスを選択します。

   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 UI にアクセスする
<a name="_access_the_argo_cd_ui"></a>

機能がアクティブになったら、以下の手順で Argo CD UI にアクセスできます。

1. Argo CD 機能のページで、**[Argo CD UI を開く]** を選択します。

1. Argo CD UI がブラウザの新しいタブに開かれます。

1. アプリケーションの作成とデプロイの管理を UI から行えるようになりました。

## 次のステップ
<a name="_next_steps"></a>
+  [Argo CD の使用](working-with-argocd.md) - リポジトリを設定し、クラスターを登録し、Application を作成する
+  [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 アイデンティティセンターが設定されていること** – Argo CD での認証には AWS アイデンティティセンターが必要です。ローカルユーザーはサポートされていません。AWS アイデンティティセンターをセットアップしていない場合は、「[AWS アイデンティティセンターの使用を開始する](https://docs.aws.amazon.com/singlesignon/latest/userguide/getting-started.html)」を参照してアイデンティティセンターインスタンスを作成し、「[ユーザーを追加する](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 機能リソースを作成します。

まず、アイデンティティセンターを設定するための環境変数を設定します。

```
# 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"
```

アイデンティティセンター統合で機能を作成します。*region-code* をクラスターがある AWS リージョンに、*my-cluster* をクラスター名に、*idc-region-code* をお使いの IAM アイデンティティセンターが設定されているリージョンコードに置き換えます。

```
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) - リポジトリを設定し、クラスターを登録し、Application を作成する
+  [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 ポリシーは必要ありません。リポジトリ認証情報や CodeConnections に Secrets Manager を使用する場合は、ロールにアクセス許可を追加する必要があります。IAM ポリシーの例と設定ガイダンスについては、「[AWS Secrets Manager を使用してアプリケーションシークレットを管理する](integration-secrets-manager.md)」および「[AWS CodeConnections を使用して Git リポジトリに接続する](integration-codeconnections.md)」を参照してください。

## ステップ 2: AWS アイデンティティセンター設定を取得する
<a name="step_2_get_your_shared_aws_identity_center_configuration"></a>

RBAC 設定用にアイデンティティセンターインスタンス ARN とユーザー ID を取得します。

```
# 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、アイデンティティセンターインスタンス ARN、アイデンティティセンターリージョン、およびユーザー 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 Application を作成および管理する方法を学ぶ
+  [Argo CD に関する考慮事項](argocd-considerations.md) - SSO とマルチクラスターアクセスを設定する
+  [機能リソースの使用](working-with-capabilities.md) - Argo CD 機能リソースを管理する

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

Argo CD は、Git をアプリケーションデプロイの信頼できる単一のソースとして扱うことで GitOps を実装します。このトピックでは、実践的な例を取り上げ、EKS Capability for Argo CD を使用する際に知っておくべきコアとなる概念について説明します。

## Argo CD の使用を開始する
<a name="_getting_started_with_argo_cd"></a>

Argo CD 機能を作成したら (「[Argo CD 機能を作成する](create-argocd-capability.md)」を参照)、アプリケーションのデプロイを開始できます。この例では、クラスターの登録と Application の作成を取り上げます。

### ステップ 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
```

**注記**  
EKS で Argo CD 機能を使用するように Argo CD CLI を設定する方法については、「[マネージド機能で Argo CD CLI を使用する](argocd-comparison.md#argocd-cli-configuration)」を参照してください。

あるいは、Kubernetes シークレットを使用してクラスターを登録します (詳細については、「[ターゲットクラスターを登録する](argocd-register-clusters.md)」を参照)。

 **リポジトリアクセスを設定する** (任意)

この例では、パブリック GitHub リポジトリを使用しているため、リポジトリの設定は不要です。プライベートリポジトリの場合は、AWS Secrets Manager、CodeConnections、または Kubernetes シークレットを使用してアクセスを設定します (詳細については、「[リポジトリアクセスを設定する](argocd-configure-repositories.md)」を参照)。

AWS サービス (ECR Helm チャート、CodeConnections、および CodeCommit) の場合、リポジトリを作成しなくても、Application リソースで直接参照できます。機能ロールには、IAM アクセス許可が必要です。詳細については、「[リポジトリアクセスを設定する](argocd-configure-repositories.md)」を参照してください。

### ステップ 2: アプリケーションの作成
<a name="_step_2_create_an_application"></a>

`my-app.yaml` でこの 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
    syncOptions:
    - CreateNamespace=true
```

Application を適用します。

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

この Application を適用したら、Argo CD で次の手順を実行します。1. Git からクラスターにアプリケーションを同期します (初期デプロイ)。2. Git リポジトリに対する変更をモニタリングします。3. 今後変更があればクラスターに自動的に同期します。4. 目的の状態からのドリフトを検出して修正します。5. UI でヘルスステータスと同期履歴を提供します。

アプリケーションのステータスを表示します。

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

Argo CD CLI または Argo CD UI (クラスターの [機能] タブの 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 アクセスを制限する場合は、Helm チャートや OCI イメージに ECR を使用できます。

詳細は、Argo CD ドキュメントの「[Application ソース](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 **低下** - 一部のリソースが正常でない (ポッドのクラッシュやジョブの失敗) \$1 **中断** - アプリケーションが意図的に一時停止している \$1 **欠落** - Git に定義されたリソースがクラスターに存在しない

よく使用される Kubernetes リソース (デプロイ、StatefulSet、ジョブなど) に対しては組み込みのヘルスチェックで対処し、CRD に対してはカスタムヘルスチェックをサポートしています。

アプリケーションのヘルスは、アプリケーションのすべてのリソースによって決まります。いずれかのリソースが `Degraded` であれば、アプリケーションも `Degraded` です。

詳細については、Argo CD ドキュメントの「[リソースのヘルス](https://argo-cd.readthedocs.io/en/stable/operator-manual/health/)」を参照してください。

### マルチクラスターパターン
<a name="_multi_cluster_patterns"></a>

Argo CD は、主に 2 つのデプロイパターンをサポートしています。

 **ハブアンドスポーク** - 複数のワークロードクラスターにデプロイする専用の管理クラスターで Argo CD を実行します。\$1 一元管理と可視性 \$1 すべてのクラスターで一貫したポリシー \$1 Argo CD インスタンスを 1 つ管理 \$1 コントロールプレーンとワークロードとの明確な分離

 **クラスターあたり** - 各クラスターで Argo CD を実行して、そのクラスターのアプリケーションのみを管理します。\$1 クラスターの分離 (あるクラスターの障害が他のクラスターに影響を与えない) \$1 シンプルなネットワーク (クラスター間の通信なし) \$1 シンプルな初期セットアップ (クラスターの登録なし)

プラットフォームチームが多数のクラスターを管理する場合はハブアンドスポークを選択し、チームが独立している場合やクラスターを完全に分離する必要がある場合はクラスターあたりを選択します。

マルチクラスター設定の詳細については、「[Argo CD に関する考慮事項](argocd-considerations.md)」を参照してください。

### プロジェクト
<a name="_projects"></a>

Project を使用すると、Application を論理的にグループ化して、アクセスコントロールを付与できます。
+  **ソースの制限** - 使用できる Git リポジトリを制限します。
+  **送信先の制限** - ターゲットにできるクラスターと名前空間を制限します。
+  **リソースの制限** - デプロイできる Kubernetes リソースタイプを制限します。
+  **RBAC の統合** - Project を AWS アイデンティティセンターのユーザー ID とグループ ID にマッピングします。

Application は単一の Project に属します。指定しない場合は、`default` プロジェクトが使用されます。これにはデフォルトの制限はありません。本番稼働用の場合は、`default` プロジェクトを編集してアクセスを制限し、適切な制限で新しいプロジェクトを作成します。

Project の設定と 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) - デプロイ用にターゲットクラスターを登録する
+  [Application を作成する](argocd-create-application.md) - 最初の Application を作成する
+  [Argo CD に関する考慮事項](argocd-considerations.md) - EKS 固有のパターン、アイデンティティセンター統合、マルチクラスター設定
+  [Argo CD ドキュメント](https://argo-cd.readthedocs.io/en/stable/) - 同期フック、ヘルスチェック、高度なパターンなどについて説明した包括的な Argo CD ドキュメント

# Argo CD アクセス許可を設定する
<a name="argocd-permissions"></a>

Argo CD マネージド機能は、AWS アイデンティティセンターとの統合により認証を実施し、組み込みの RBAC ロールを使用して認可を行います。このトピックでは、ユーザーとチームに対するアクセス許可を設定する方法について説明します。

## Argo CD によるアクセス許可の仕組み
<a name="_how_permissions_work_with_argo_cd"></a>

Argo CD 機能は、AWS アイデンティティセンターを使用して認証を実施し、組み込みの 3 つの RBAC ロールを使用して認可を行います。

ユーザーが Argo CD にアクセスすると、次のようになります。

1. AWS アイデンティティセンターを使用してユーザーが認証されます (社内の ID プロバイダーにフェデレーションできます)。

1.  AWS アイデンティティセンターは、ユーザーとグループの情報を Argo CD に提供します。

1. Argo CD は、現在の設定に基づいてユーザーとグループを RBAC ロールにマッピングします。

1. ユーザーには、自分がアクセス許可を持つアプリケーションとリソースのみが表示されます。

## 組み込みの RBAC ロール
<a name="_built_in_rbac_roles"></a>

Argo CD 機能には、AWS アイデンティティセンターのユーザーとグループにマッピングする組み込みのロールが 3 つあります。これらは、プロジェクト、クラスター、リポジトリなどの Argo CD リソースへのアクセスを制御する**グローバルスコープのロール**です。

**重要**  
グローバルロールは、Application などのプロジェクトスコープのリソースではなく、Argo CD 自体へのアクセスを制御します。EDITOR ユーザーおよび VIEWER ユーザーは、デフォルトでは Application を表示または管理できません。プロジェクトスコープのリソースにアクセスするには、プロジェクトロールが必要です。Application およびその他のプロジェクトスコープのリソースへのアクセス許可の詳細については、「[プロジェクトロールとプロジェクトスコープのアクセス](#project-roles)」を参照してください。

 **ADMIN** 

すべての Argo CD リソースと設定へのフルアクセス:
+ 任意のプロジェクト内の Application と ApplicationSet を作成、更新、削除する
+ Argo CD 設定を管理する
+ デプロイターゲットクラスターを登録して管理する
+ リポジトリアクセスを設定する
+ プロジェクトを作成および管理する
+ すべてのアプリケーションのステータスと履歴を表示する
+ すべてのクラスターとリポジトリを一覧表示してアクセスする

 **EDITOR** 

プロジェクトを更新してプロジェクトロールを設定できますが、グローバル Argo CD 設定を変更することはできません。
+ 既存のプロジェクトを更新する (プロジェクトの新規作成および削除はできません)
+ プロジェクトロールとアクセス許可を設定する
+ GPG キーと証明書を表示する
+ グローバル Argo CD 設定を変更できない
+ クラスターとリポジトリを直接管理できない
+ プロジェクトロールがないと Application を表示または管理できない

 **VIEWER** 

Argo CD リソースへの読み取り専用アクセス:
+ プロジェクト設定を表示する
+ すべてのプロジェクト (ユーザーが割り当てられていないプロジェクトを含む) を一覧表示する
+ GPG キーと証明書を表示する
+ クラスターまたはリポジトリを一覧表示できない
+ 変更を加えることはできない
+ プロジェクトロールがないと Application を表示または管理できない

**注記**  
EDITOR ユーザーまたは VIEWER ユーザーに Application へのアクセス権を付与するには、ADMIN または EDITOR が、アイデンティティセンターグループをプロジェクト内の特定のアクセス許可にマッピングするプロジェクトロールを作成する必要があります。

## プロジェクトロールとプロジェクトスコープのアクセス
<a name="project-roles"></a>

グローバルロール (ADMIN、EDITOR、VIEWER) は、Argo CD 自体へのアクセスを制御します。プロジェクトロールは、以下を含む特定のプロジェクト内のリソースと機能へのアクセスを制御します。
+  **リソース**: Application、ApplicationSet、リポジトリ認証情報、クラスター認証情報
+  **機能**: アプリケーションポッドへのログアクセスと実行アクセス

 **2 レベルのアクセス許可モデルについて**:
+  **グローバルスコープ**: 組み込みロールは、ユーザーがプロジェクト、クラスター、リポジトリ、および Argo CD 設定で何ができるかを決定します
+  **プロジェクトスコープ**: プロジェクトロールは、ユーザーが特定のプロジェクト内のリソースと機能で何ができるかを決定します

つまり、次のようになります。
+ ADMIN ユーザーは、追加の設定なしですべてのプロジェクトリソースと機能にアクセスできます
+ EDITOR ユーザーおよび VIEWER ユーザーには、プロジェクトのリソースと機能にアクセスするためのプロジェクトロールを付与する必要があります
+ EDITOR ユーザーは、更新できるプロジェクト内で、自分やそれ以外のユーザーにアクセス権を付与するプロジェクトロールを作成できます。

 **ワークフローの例**:

1. ADMIN は、アイデンティティセンターグループを EDITOR ロールにグローバルにマッピングします。

1. ADMIN がチームのプロジェクトを作成する

1. EDITOR は、そのプロジェクト内のプロジェクトロールを設定して、チームメンバーにプロジェクトスコープのリソースへのアクセス権を付与します。

1. チームメンバー (VIEWER グローバルロールを持つ可能性がある) は、プロジェクトロールのアクセス許可に基づいて、そのプロジェクトの Application を表示および管理できるようになりました。

プロジェクトロールの設定の詳細については、「[Project ベースのアクセスコントロール](#_project_based_access_control)」を参照してください。

## ロールマッピングを設定する
<a name="_configure_role_mappings"></a>

機能の作成時や更新時に、AWS アイデンティティセンターのユーザーとグループを Argo CD ロールにマッピングします。

 **ロールマッピングの例**:

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

**注記**  
ロール名は、大文字と小文字が区別され、大文字 (ADMIN、EDITOR、VIEWER) にする必要があります。

**重要**  
EKS 機能と AWS アイデンティティセンターが統合されている場合、Argo CD 機能あたり最大 1,000 個の ID がサポートされます。ユーザーやグループを ID にすることができます。

 **ロールマッピングを更新する**:

```
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>

管理者アカウントは、クラスターの登録やリポジトリの設定など、初期セットアップと管理タスク向けに設計されています。

 **どのような場合に管理者アカウントが適切か**:
+ 機能の初期セットアップと設定
+ 単独開発や迅速なデモンストレーション
+ 管理タスク (クラスターの登録、リポジトリの設定、Project の作成)

 **管理者アカウントのベストプラクティス**:
+ アカウントトークンをバージョン管理にコミットしない
+ トークンが漏洩したらすぐにローテーションさせる
+ アカウントトークンの用途をセットアップと管理タスクに制限する
+ 有効期限を短くする (最大 12 時間)
+ 一度に作成できるアカウントトークンを 5 つまでとする

 **どのような場合に Project ベースのアクセスを使用するか**:
+ 複数のユーザーと開発環境を共有する場合
+ いずれの環境も本番稼働と同様にする場合
+ 誰がアクションを実行したかを監査証跡に残す場合
+ リソース制限やアクセス境界を設ける場合

本番稼働環境とマルチユーザーシナリオでは、専用の RBAC ロールを AWS アイデンティティセンターグループにマッピングして、Project ベースのアクセスコントロールを使用します。

## Project ベースのアクセスコントロール
<a name="_project_based_access_control"></a>

Argo CD Project (AppProject) を使用すると、チームを対象にアクセスコントロールとリソース分離をきめ細かく設定できます。

**重要**  
ユーザーまたはグループをプロジェクト固有のロールに割り当てる前に、まず機能設定でグローバル Argo CD ロール (ADMIN、EDITOR、または VIEWER) にマッピングする必要があります。ユーザーは、プロジェクトロールに割り当てられていても、グローバルロールマッピングなしで Argo CD にアクセスすることはできません。  
ユーザーを VIEWER ロールにグローバルにマッピングし、プロジェクト固有のロールを通じて追加のアクセス許可を付与することを検討してください。これにより、ベースラインアクセスが可能になり、プロジェクトレベルでのきめ細かな制御が可能になります。

Project でできることは以下のとおりです。
+  **ソースの制限**: 使用できる Git リポジトリを制限します。
+  **送信先の制限**: ターゲットにできるクラスターと名前空間を制限します。
+  **リソースの制限**: デプロイできる Kubernetes リソースタイプを制限します。
+  **RBAC の統合**: Project を AWS アイデンティティセンターグループまたは Argo CD ロールにマッピングします。

 **チームを分離する Project の例**:

```
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` フィールドが必要です。このフィールドは、このプロジェクトを参照する Application または ApplicationSet を含めることができる名前空間を指定します。

**重要**  
EKS Argo CD 機能は、Application と ApplicationSet 向けに一つの名前空間のみをサポートします。具体的には、機能の作成時に指定した名前空間になります (通常は `argocd`)。これは、複数の名前空間をサポートするオープンソースの Argo CD とは異なります。

 **AppProject の設定** 

すべての AppProject は、その機能の設定済み名前空間を `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` に含めないと、その名前空間の Application または ApplicationSet はこのプロジェクトを参照できず、デプロイが失敗します。

 **ユーザーを Project に割り当てる**:

プロジェクトロールは、EDITOR ユーザーおよび VIEWER ユーザーにプロジェクトリソース (Application、ApplicationSet、リポジトリ、クラスター認証情報) と機能 (ログ、実行) へのアクセスを許可します。プロジェクトロールがないと、これらのユーザーは、グローバルロールアクセスを持っていてもこれらのリソースにアクセスできません。

ADMIN ユーザーは、プロジェクトロールを必要とせずに、すべての Application にアクセスできます。

 **例: チームメンバーに Application へのアクセスを許可する** 

```
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` を含めることで、ユーザーが UI でクラスター名を表示できるようにします。このアクセス許可がない場合、送信先クラスターは「Unknown」として表示されます。

 **プロジェクトロールポリシーについて**:

ポリシーの形式は次のとおりです: `p, proj:<project>:<role>, <resource>, <action>, <object>, <allow/deny>` 

 **リソースポリシー**:
+  `applications, , team-a/, allow` – team-a プロジェクト内のすべての Application にフルアクセスできます
+  `applications, get, team-a/*, allow` – Application に読み取り専用でアクセスできます
+  `applications, sync, team-a/*, allow` – Application を同期できますが、作成/削除することはできません
+  `applications, delete, team-a/*, allow` – Application を削除できます (注意して使用すること)
+  `applicationsets, , team-a/, allow` – ApplicationSet にフルアクセスできます
+  `repositories, *, *, allow` – リポジトリ認証情報にアクセスできます
+  `clusters, *, *, allow` – クラスター認証情報にアクセスできます

 **機能ポリシー**:
+  `logs, , team-a/, allow` – アプリケーションログにアクセスできます
+  `exec, , team-a/, allow` – アプリケーションポッドへの実行アクセス

**注記**  
EDITOR ユーザーは、更新できるプロジェクト内で、自分やそれ以外のユーザーにアクセス許可を付与するプロジェクトロールを作成できます。これにより、チームリーダーは ADMIN の介入を必要とせずに、チームのプロジェクトスコープのリソースへのアクセスを制御できます。

**注記**  
`groups` フィールドでアイデンティティセンターグループ ID (グループ名ではない) を使用します。個別のユーザーアクセスにアイデンティティセンターユーザー ID を使用することもできます。AWS アイデンティティセンターコンソール内、または 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) は、開発者にプロジェクトリソース (Application、ApplicationSet、認証情報) と機能 (ログ、実行) へのアクセスを許可するようにプロジェクトロールを設定する

1. 開発者 (VIEWER) は、プロジェクトロールで許可されているリソースと機能にのみアクセスできる

 **パターン 3: プロジェクトロールを使用したチームベースのアクセス** 

1. ADMIN はプロジェクトを作成し、チームリーダーを EDITOR ロールにグローバルにマッピングする

1. チームリーダー (EDITOR) は、チームメンバーをプロジェクト内のプロジェクトロールに割り当てる

1. チームメンバーには VIEWER グローバルロールのみが必要 – プロジェクトロールはプロジェクトリソースと機能へのアクセスを提供する

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

## ベストプラクティス
<a name="_best_practices"></a>

 **個々のユーザーではなくグループを使用する**: AWS アイデンティティセンターグループを個々のユーザーではなく Argo CD ロールにマッピングして、管理を容易にします。

 **最小特権から開始する**: VIEWER アクセスから開始し、必要に応じて EDITOR または ADMIN を付与します。

 **Project を使用してチームを分離する**: チームや環境ごとに AppProject を作成して、境界を確立します。

 **アイデンティティセンターのフェデレーションを活用する**: 社内の ID プロバイダーとフェデレーションするように AWS アイデンティティセンターを設定して、ユーザー管理を一元化します。

 **アクセスを定期的に見直す**: ロールのマッピングと Project の割り当てを定期的に見直して、適切なアクセスレベルを確保します。

 **クラスターへのアクセスを制限する**: Argo CD RBAC は Argo CD リソースとオペレーションへのアクセスを制御しますが、Kubernetes RBAC には対応していないことに注意してください。Argo CD にアクセスできるユーザーは、Argo CD がアクセスできるクラスターにアプリケーションをデプロイできます。Argo CD がアクセスできるクラスターを制限し、Project の宛先制限を使用して、アプリケーションをデプロイできる場所を制御します。

## AWS サービスのアクセス許可
<a name="shared_aws_service_permissions"></a>

Repository リソースを作成することなく Application リソースで AWS サービスを直接使用するには、必要な IAM アクセス許可を機能ロールにアタッチします。

 **ECR Helm チャート**:

```
{
  "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) - Project など 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 を使用する前に、以下が必要です。
+ EKS クラスターに Argo CD 機能が作成されていること (「[Argo CD 機能を作成する](create-argocd-capability.md)」を参照)
+ Git リポジトリに Kubernetes マニフェストが含まれていること
+  クラスターと通信できるように `kubectl` が設定されていること

## 一般的なタスク
<a name="_common_tasks"></a>

以下のトピックでは、一般的な Argo CD タスクについて説明します。

 ** [リポジトリアクセスを設定する](argocd-configure-repositories.md) ** - AWS Secrets Manager、AWS CodeConnections、または Kubernetes Secrets を使用して、Git リポジトリにアクセスするように Argo CD を設定します。

 ** [ターゲットクラスターを登録する](argocd-register-clusters.md) ** - Argo CD がアプリケーションをデプロイするターゲットクラスターを登録します。

 ** [Argo CD Project を操作する](argocd-projects.md) ** - マルチテナント環境向けにプロジェクトを使用してアプリケーションを整理し、セキュリティ境界を適用します。

 ** [Application を作成する](argocd-create-application.md) ** - 自動または手動の同期ポリシーを使用して、Git リポジトリからデプロイするアプリケーションを作成します。

 ** [ApplicationSet を使用する](argocd-applicationsets.md) ** - テンプレートとジェネレーターを使用して、複数の環境またはクラスターにアプリケーションをデプロイするために ApplicationSets を使用します。

## Argo CD UI にアクセスする
<a name="_access_the_argo_cd_ui"></a>

EKS コンソールから Argo CD UI にアクセスします。

1. Amazon EKS コンソールを開きます。

1. クラスターを選択します。

1. **[機能]** タブを選択します。

1. **[Argo CD]** を選択します。

1. **[Argo CD UI を開く]** を選択します。

UI は、アプリケーションのトポロジを視覚的に表示し、同期のステータスと履歴、リソースのヘルスとイベント、手動同期コントロール、アプリケーション管理を提供します。

## アップストリームドキュメント
<a name="_upstream_documentation"></a>

Argo CD 機能の詳細については、以下を参照してください。
+  [Argo CD ドキュメント](https://argo-cd.readthedocs.io/) - 完全なユーザーガイド
+  [アプリケーション仕様](https://argo-cd.readthedocs.io/en/stable/user-guide/application-specification/) - フルアプリケーション API リファレンス
+  [ApplicationSet ガイド](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>

アプリケーションをデプロイする前に、Git リポジトリおよび Helm チャートレジストリにアクセスするように Argo CD を設定します。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>
+ EKS クラスターに Argo CD 機能が作成されていること
+ Git リポジトリに Kubernetes マニフェストが含まれていること
+  クラスターと通信できるように `kubectl` が設定されていること

**注記**  
 AWS CodeConnections は、AWS クラウドまたはオンプレミスにある Git サーバーに接続できます。詳細については、「[AWS CodeConnections](https://docs.aws.amazon.com/codeconnections/latest/userguide/welcome.html)」を参照してください。

## 認証方法
<a name="_authentication_methods"></a>


| Method | ユースケース | 必要な IAM アクセス許可 | 
| --- | --- | --- | 
|   **AWS サービスとの直接統合**   | 
|  CodeCommit  |  AWS CodeCommit Git リポジトリとの直接統合。リポジトリ設定は不要です。  |   `codecommit:GitPull`   | 
|  CodeConnections  |  マネージド認証で GitHub、GitLab、または Bitbucket に接続します。接続のセットアップが必要です。  |   `codeconnections:UseConnection`   | 
|  ECR OCI アーティファクト  |  AWS ECR for 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 シークレット  |  クラスター内シークレットを使用した標準の Argo CD 方法  |  なし (Kubernetes RBAC を使用した EKS アクセスエントリによって処理されるアクセス許可)  | 

## AWS サービスへの直接アクセス
<a name="direct_access_to_shared_aws_services"></a>

AWS サービスの場合、リポジトリ設定を作成しなくても、Application リソースで直接参照できます。機能ロールには、IAM アクセス許可が必要です。

### CodeCommit リポジトリ
<a name="_codecommit_repositories"></a>

Application 内で直接 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 では、次の 2 つの方法でそれらを参照できます。

 **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://` プレフィックスを含めてください。`chart` ではなく `path` フィールドを使用します。

必要な機能ロールのアクセス許可 – マネージドポリシーをアタッチします。

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

このポリシーには、必要な ECR アクセス許可である `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` でリポジトリ認証情報テンプレートを使用します。これにより、個別のリポジトリシークレットを作成するよりも UX が向上します。詳細については、Argo CD ドキュメントの「[Repository Credentials](https://argo-cd.readthedocs.io/en/stable/operator-manual/argocd-repo-creds-yaml/)」を参照してください。

### ユーザー名とトークンの認証
<a name="_username_and_token_authentication"></a>

HTTPS リポジトリに個人用アクセストークンやパスワードが含まれている場合:

 **Secrets Manager にシークレットを作成する**:

```
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 を参照するリポジトリシークレットを作成する**:

```
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 プライベートキーでシークレットを作成する**:

```
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 用にリポジトリシークレットを作成する**:

```
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 アプリ認証情報でシークレットを作成する**:

```
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 アプリ用にリポジトリシークレットを作成する**:

```
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` でリポジトリ認証情報テンプレートを使用します。これにより、リポジトリごとに個別のリポジトリシークレットを作成するよりも UX が向上します。

 **リポジトリ認証情報テンプレートを作成します**。

```
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` に一致するすべてのリポジトリに適用されます。その後、追加のシークレットを作成せずに、この組織内の任意のリポジトリを Application で参照できます。

詳細については、Argo CD ドキュメントの「[Repository Credentials](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 シークレットを使用する
<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 UI の [設定] → [リポジトリ] から接続ステータスを確認します。UI には、接続ステータスと、認証エラーがあればそれも表示されます。

リポジトリシークレットにステータス情報は含まれません。

## その他のリソース
<a name="_additional_resources"></a>
+  [ターゲットクラスターを登録する](argocd-register-clusters.md) - デプロイ用にターゲットクラスターを登録する
+  [Application を作成する](argocd-create-application.md) - 最初の Application を作成する
+  [Argo CD に関する考慮事項](argocd-considerations.md) - IAM アクセス許可とセキュリティ設定
+  [プライベートリポジトリ](https://argo-cd.readthedocs.io/en/stable/user-guide/private-repositories/) - アップストリームリポジトリ設定リファレンス

# ターゲットクラスターを登録する
<a name="argocd-register-clusters"></a>

クラスターを登録すると、Argo CD がアプリケーションをそのクラスターにデプロイできるようになります。Argo CD が動作しているのと同じクラスター (ローカルクラスター) を登録することも、別のアカウントやリージョンのリモートクラスターを登録することもできます。クラスターが新規登録されると、そのクラスター内にアプリケーションが作成されるまで、クラスターの接続ステータスは「不明」のままになります。クラスターの登録後に Argo CD アプリケーションを作成するには、「[Application を作成する](argocd-create-application.md)」を参照してください。

## 前提条件
<a name="_prerequisites"></a>
+ EKS クラスターに Argo CD 機能が作成されていること
+  クラスターと通信できるように `kubectl` が設定されていること
+ リモートクラスターの場合: 適切な IAM アクセス許可およびアクセスエントリ

## ローカルクラスターを登録する
<a name="_register_the_local_cluster"></a>

Argo CD が動作しているのと同じクラスターにアプリケーションをデプロイするには、そのクラスターをデプロイターゲットとして登録します。

**重要**  
Argo CD 機能は、ローカルクラスターを自動的には登録しません。アプリケーションを同じクラスターにデプロイするには、そのクラスターを明示的に登録する必要があります。クラスター名 `in-cluster` を使用して、ほとんどのオンラインの Argo CD の例と互換性を持たせることができます。

**注記**  
EKS アクセスエントリは、Argo CD 機能ロールを持つローカルクラスターに対して自動的に作成されますが、デフォルトでは 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 シークレットを使用する**:

```
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
```

**注記**  
Kubernetes API サーバー URL ではなく、`server` フィールドで EKS クラスター ARN を使用します。マネージド機能では、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 アクセス許可に関連付ける** 

アクセスエントリには、Argo CD がアプリケーションをデプロイするための Kubernetes RBAC アクセス許可が必要です。すぐに開始するには、`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 グループに関連付け、適切なロールバインディングまたはクラスターロールバインディングを作成することで、より制限の厳しいアクセス許可を使用してください。最小特権の設定については、以下の本番環境設定セクションを参照してください。

 **ステップ 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 シークレットを使用する**:

```
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 UI の [設定] → [クラスター] でクラスターステータスを確認します。

## プライベートクラスター
<a name="_private_clusters"></a>

Argo CD 機能では、VPC ピアリングや特殊なネットワーク設定を施すことなく、完全にプライベートな EKS クラスターに透過的にアクセスできます。

 AWS は、Argo CD 機能とプライベートリモートクラスターとの接続を自動的に管理します。

単に ARN を使用してプライベートクラスターを登録するだけで、別途ネットワークをセットアップする必要はありません。

## アクセスエントリの RBAC 要件
<a name="_access_entry_rbac_requirements"></a>

Argo CD 機能を作成すると、機能ロールに対して EKS アクセスエントリが自動的に作成されますが、デフォルトでは Kubernetes RBAC アクセス許可は付与されません。この設計は、最小特権の原則に従った意図的なものです。異なるユースケースには、異なるアクセス許可が必要となります。

例: \$1クラスターを Argo CD ハブとしてのみ使用してリモートクラスターを管理する場合、ローカルデプロイのアクセス許可は必要ありません。\$1アプリケーションをローカルにデプロイする場合は、クラスター全体の読み取りアクセスと特定の名前空間への書き込みアクセスが必要です。\$1CRD を作成する必要がある場合は、追加のクラスター管理者アクセス許可が必要です。

要件に基づいて Argo CD に必要なアクセス許可を明示的に設定する必要があります。

### Argo CD の最小アクセス許可
<a name="_minimum_permissions_for_argo_cd"></a>

Argo CD には、エラーなしで機能するために 2 種類のアクセス許可が必要です。

 **読み取りアクセス許可 (クラスター全体)**: Argo CD は以下のために、クラスター全体のすべてのリソースタイプとカスタムリソース定義 (CRD) を読み取ることができる必要があります。
+ リソース検出とヘルスチェック
+ 目的の状態と実際の状態の間のドリフトの検出
+ デプロイ前のリソースの検証

 **書き込みアクセス許可 (名前空間固有)**: Argo CD には、Application で定義されたリソースの作成、更新、削除のアクセス許可が必要です。
+ アプリケーションワークロード (デプロイ、サービス、ConfigMaps など) をデプロイする
+ カスタムリソースの適用 (アプリケーション固有の CRD)
+ アプリケーションのライフサイクルを管理する

### Quick Setup
<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: 読み取りアクセス用のクラスターロールを作成する** 

```
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 がアプリケーションをデプロイする名前空間ごとに、このロールバインド手順を繰り返します。

**重要**  
Argo CD は、特定の名前空間にのみデプロイする場合でも、ヘルスチェックと検出のためにクラスター全体のすべてのリソースタイプを読み取ることができる必要があります。クラスター全体の読み取りアクセスがないと、アプリケーションの状態をチェックするときに Argo CD にエラーが表示されます。

## Project でクラスターアクセスを制限する
<a name="_restrict_cluster_access_with_projects"></a>

プロジェクトを使用して、`spec.destinations` で許可されるターゲットクラスターと名前空間を設定することで、Application がデプロイできるクラスターと名前空間を制御します。

```
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 Project を操作する](argocd-projects.md)」を参照してください。

## その他のリソース
<a name="_additional_resources"></a>
+  [Argo CD Project を操作する](argocd-projects.md) - Application を整理し、セキュリティ境界を確立する
+  [Application を作成する](argocd-create-application.md) - 最初のアプリケーションをデプロイする
+  [ApplicationSet を使用する](argocd-applicationsets.md) - ApplicationSet で複数のクラスターにデプロイする
+  [Argo CD に関する考慮事項](argocd-considerations.md) - マルチクラスターパターンとクロスアカウントセットアップ
+  [宣言型クラスターセットアップ](https://argo-cd.readthedocs.io/en/stable/operator-manual/declarative-setup/#clusters) - アップストリームクラスター設定リファレンス

# Argo CD Project を操作する
<a name="argocd-projects"></a>

Argo CD Project (AppProject) では、Application を論理的にグループ化して、アクセスコントロールを付与できます。Project は、Application が使用できる Git リポジトリ、ターゲットクラスター、名前空間を定義して、共有 Argo CD インスタンスにマルチテナンシーとセキュリティの境界を確立します。

## どのような場合に Project を使用するか
<a name="_when_to_use_projects"></a>

Project を使用すると、以下のことが行えます。
+ チーム、環境、またはビジネスユニットごとに Application を分離します。
+ チームがどのリポジトリからデプロイできるかを制限します。
+ チームがどのクラスターと名前空間にデプロイできるかを制限します。
+ リソースクォータと許可されたリソースタイプを適用します。
+ ガードレールに沿ってセルフサービスアプリケーションをデプロイします。

## default Project
<a name="_default_project"></a>

すべての Argo CD 機能に `default` Project があり、すべてのリポジトリ、クラスター、名前空間へのアクセスを許可する設定になっています。初期テストには有用ですが、本番稼働に使用する場合は制限を明記した専用の Project を作成します。

default Project の設定とその制限方法の詳細については、Argo CD ドキュメントの「[default Project ](https://argo-cd.readthedocs.io/en/stable/user-guide/projects/#the-default-project)」を参照してください。

## プロジェクトの作成
<a name="_create_a_project"></a>

Project を作成するには、クラスターに `AppProject` リソースを適用します。

 **例: チーム固有の Project** 

```
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
```

Project を適用します。

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

## プロジェクトの設定
<a name="_project_configuration"></a>

### ソースリポジトリ
<a name="_source_repositories"></a>

この Project の Application が使用できる Git リポジトリを制御します。

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

ワイルドカードと否定パターン (`!` プレフィックス) を使用すると、特定のリポジトリを許可または拒否できます。詳細については、Argo CD ドキュメントの「[Project の管理](https://argo-cd.readthedocs.io/en/stable/user-guide/projects/#managing-projects)」を参照してください。

### 送信先の制限
<a name="_destination_restrictions"></a>

Application がデプロイできる場所を制限します。

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

**重要**  
本番稼働の Project では、ワイルドカードではなく、特定のクラスター名と名前空間パターンを使用します。これにより、不正なクラスターや名前空間が偶発的にデプロイされるのを防ぐことができます。

ワイルドカードと否定パターンを使用して、送信先を制御できます。詳細については、Argo CD ドキュメントの「[Project の管理](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
```

## Project に Application を割り当てる
<a name="_assign_applications_to_projects"></a>

Application を作成するときは、`spec.project` フィールドに 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
```

Application に Project を指定しないと、`default` Project が使用されます。

## Project のロールと RBAC
<a name="_project_roles_and_rbac"></a>

Project では、カスタムロールを定義して、アクセスコントロールをきめ細かく設定できます。機能設定で Project のロールを AWS アイデンティティセンターのユーザーとグループにマッピングすると、アプリケーションを同期、更新、または削除できるユーザーを制御できます。

 **例: Project に開発者ロールと管理者ロールを付与する** 

```
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
```

Project のロール、CI/CD パイプラインの JWT トークン、および RBAC 設定の詳細については、Argo CD ドキュメントの「[Project のロール](https://argo-cd.readthedocs.io/en/stable/user-guide/projects/#project-roles)」を参照してください。

## 一般的なパターン
<a name="_common_patterns"></a>

### 環境ベースの Project
<a name="_environment_based_projects"></a>

環境ごとに Project を作成します。

```
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
```

### チームベースの Project
<a name="_team_based_projects"></a>

専用の Project でチームを分離します。

```
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: '*'
```

### マルチクラスターの Project
<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>

 **制限のある Project から始める**: 最初から幅広いアクセスを付与するのではなく、絞り込んだアクセス許可から始め、必要に応じて拡張します。

 **名前空間パターンを使用する**: 名前空間の制限 (`team-a-*` など) にワイルドカードを活用して、境界を維持しながら柔軟性を確保します。

 **本番稼働用の Project を分離する**: 本番稼働専用の Project を使用する場合は、制御を厳格にし、手動同期ポリシーを実施します。

 **Project の目的を文書化する**: `description` フィールドを使用して、各 Project の目的と誰が使用すべきかを説明します。

 **Project のアクセス許可を定期的に見直す**: Project を定期的に監査して、制限がチームのニーズとセキュリティ要件に沿っていることを確認します。

## その他のリソース
<a name="_additional_resources"></a>
+  [Argo CD アクセス許可を設定する](argocd-permissions.md) - RBAC とアイデンティティセンターとの統合を設定する
+  [Application を作成する](argocd-create-application.md) - Project 内に Application を作成する
+  [ApplicationSet を使用する](argocd-applicationsets.md) - Project で ApplicationSet を使用してマルチクラスターデプロイを実施する
+  [Argo CD Project ドキュメント](https://argo-cd.readthedocs.io/en/stable/user-guide/projects/) - 詳細なアップストリームリファレンス

# Application を作成する
<a name="argocd-create-application"></a>

Application は、ターゲットクラスター内のデプロイを表します。Application ごとに、ソース (Git リポジトリ) と宛先 (クラスターと名前空間) を定義します。適用すると、Argo CD は Git リポジトリのマニフェストで指定されたリソースをクラスター内の名前空間に作成します。Application では、ワークロードのデプロイを指定することが多くなるものの、送信先クラスターで使用可能な Kubernetes リソースを管理することもできます。

## 前提条件
<a name="_prerequisites"></a>
+ EKS クラスターに Argo CD 機能が作成されていること
+ リポジトリアクセスが設定されていること (「[リポジトリアクセスを設定する](argocd-configure-repositories.md)」を参照)
+ ターゲットクラスターが登録されていること (「[ターゲットクラスターを登録する](argocd-register-clusters.md)」を参照)
+  クラスターと通信できるように `kubectl` が設定されていること

## 基本的な Application を作成する
<a name="_create_a_basic_application"></a>

Git リポジトリからデプロイする Application を定義します。

```
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 でも機能しますが、読みやすくするためにクラスター名を使用することをお勧めします。

Application を適用します。

```
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 ドキュメントの「[Helm Value Files from External Git Repository](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 に依存するリソースや、CRD がすぐに利用できない可能性がある kro インスタンスを操作する場合に特に便利です。

## 同期オプション
<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 ドキュメントの「[同期ウェーブ](https://argo-cd.readthedocs.io/en/stable/user-guide/sync-waves/)」と「[リソースフック](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 ドキュメントの「[差分比較のカスタマイズ](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
```

## Application をモニタリングおよび管理する
<a name="_monitor_and_manage_applications"></a>

 **アプリケーションのステータスを表示する**:

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

 **Argo CD UI にアクセスする**:

EKS コンソールから Argo CD UI を開いて、アプリケーションのトポロジ、同期ステータス、リソースヘルス、デプロイ履歴を表示します。UI アクセスの手順については、「[Argo CD の使用](working-with-argocd.md)」を参照してください。

 **Application をロールバックする**:

以前のリビジョンにロールバックするには、Argo CD UI、Argo CD CLI を使用するか、Application 仕様の `targetRevision` を以前の Git コミットまたはタグに更新します。

Argo CD CLI を使用する:

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

**注記**  
マネージド機能で Argo CD CLI を使用する場合は、名前空間プレフィックス `namespace/appname` を使用してアプリケーションを指定します。

詳細は、Argo CD ドキュメントの「[argocd app rollback](https://argo-cd.readthedocs.io/en/stable/user-guide/commands/argocd_app_rollback/)」を参照してください。

## その他のリソース
<a name="_additional_resources"></a>
+  [Argo CD Project を操作する](argocd-projects.md) - Project でマルチテナント環境向けの Application を整理する
+  [ApplicationSet を使用する](argocd-applicationsets.md) - テンプレートで複数のクラスターにデプロイする
+  [Application 仕様](https://argo-cd.readthedocs.io/en/stable/user-guide/application-specification/) - 詳細なアプリケーション API リファレンス
+  [同期オプション](https://argo-cd.readthedocs.io/en/stable/user-guide/sync-options/) - 高度な同期設定

# ApplicationSet を使用する
<a name="argocd-applicationsets"></a>

ApplicationSet によりテンプレートから複数の Application が生成されるため、単一のリソース定義で複数のクラスター、環境、または名前空間に同じアプリケーションをデプロイできます。

## 前提条件
<a name="_prerequisites"></a>
+ EKS クラスターに Argo CD 機能が作成されていること
+ リポジトリアクセスが設定されていること (「[リポジトリアクセスを設定する](argocd-configure-repositories.md)」を参照)
+  クラスターと通信できるように `kubectl` が設定されていること

**注記**  
ApplicationSet には複数のターゲットクラスターは必要ありません。クラスタージェネレーター以外のジェネレーター (リスト、git、マトリックスジェネレーターなど) を使用して、リモートクラスターなしでアプリケーションをデプロイできます。

## ApplicationSet の仕組み
<a name="_how_applicationsets_work"></a>

ApplicationSet は、ジェネレーターを使用してパラメータを生成し、生成したパラメータを Application テンプレートに適用します。生成したパラメータのセットごとに Application が 1 つ作成されます。

EKS のデプロイによく使用されるジェネレーター:
+  **リストジェネレーター** - 環境ごとにクラスターとパラメータを明示的に定義します。
+  **クラスタージェネレーター** - 登録されたすべてのクラスターに自動的にデプロイします。
+  **Git ジェネレーター** - リポジトリ構造から Application を生成します。
+  **マトリックスジェネレーター** - 多次元デプロイ用にいくつかジェネレーターを組み合わせます。
+  **マージジェネレーター** – 複数のジェネレーターからのパラメータをマージします。

ジェネレーターの詳細なリファレンスについては、「[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` の 3 つの Application が作成されます。

## クラスタージェネレーター
<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
```

これにより、登録済みのクラスターごとに Application が自動的に作成されます。

 **クラスターをフィルタリングする**:

`matchLabels` を使用して特定のクラスターを含めるか、`matchExpressions` を使用してクラスターを除外します。

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

## Git ジェネレーター
<a name="_git_generators"></a>

Git ジェネレーターは、リポジトリ構造に基づいて Application を作成します。
+  **ディレクトリジェネレーター** - 各ディレクトリを個別の Application としてデプロイします (マイクロサービスに有用です)。
+  **ファイルジェネレーター** - パラメータファイルから Application を生成します (マルチテナントデプロイに有用です)。

 **例: マイクロサービスのデプロイ** 

```
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 ジェネレーター](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 ドキュメントの「[マトリックスジェネレーター](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
```

## ApplicationSet を管理する
<a name="_manage_applicationsets"></a>

 **ApplicationSet と生成された Application を表示する**:

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

 **ApplicationSet を更新する**:

ApplicationSet の仕様を変更して再適用します。Argo CD は、生成したすべての Application を自動的に更新します。

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

 **ApplicationSet を削除する**:

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

**警告**  
ApplicationSet を削除すると、生成されたすべての Application も削除されます。削除対象の Application に `prune: true` がある場合、そのリソースもターゲットクラスターから削除されます。  
ApplicationSet を削除するときにデプロイされたリソースを保持するには、ApplicationSet 仕様で `.syncPolicy.preserveResourcesOnDeletion` を `true` に設定します。詳細は、Argo CD ドキュメントの「[Application Pruning & Resource Deletion](https://argo-cd.readthedocs.io/en/stable/operator-manual/applicationset/Application-Deletion/)」を参照してください。

**重要**  
Argo CD の ApplicationSet 機能には、ApplicationSet を使用する前に注意すべきセキュリティ上の考慮事項があります。詳細は、Argo CD ドキュメントの「[ApplicationSet Security](https://argo-cd.readthedocs.io/en/stable/operator-manual/applicationset/Security/)」を参照してください。

## その他のリソース
<a name="_additional_resources"></a>
+  [Argo CD Project を操作する](argocd-projects.md) - Project で ApplicationSet を整理する
+  [Application を作成する](argocd-create-application.md) - Application 設定を理解する
+  [ApplicationSet ドキュメント](https://argo-cd.readthedocs.io/en/stable/user-guide/application-set/) - ジェネレーターの詳細なリファレンスとパターン
+  [ジェネレーターのリファレンス](https://argo-cd.readthedocs.io/en/stable/operator-manual/applicationset/Generators/) - ジェネレーターの詳細な仕様

# Argo CD に関する考慮事項
<a name="argocd-considerations"></a>

このトピックでは、EKS Capability for Argo CD を使用する際の重要な考慮事項を示します。具体的には、計画、アクセス許可、認証、マルチクラスターデプロイパターンなどです。

## 計画
<a name="_planning"></a>

Argo CD をデプロイする前に、以下の点を考慮してください。

 **リポジトリ戦略**: アプリケーションマニフェストの保存場所を決定します (CodeCommit、GitHub、GitLab、Bitbucket)。異なる環境ごとにリポジトリ構造と分岐戦略を計画します。

 **RBAC 戦略**: どのチームやユーザーが管理者、編集者、またはビューワーのアクセス権を持つべきかを計画します。これらを AWS アイデンティティセンターグループまたは Argo CD ロールにマッピングします。

 **マルチクラスターアーキテクチャ**: 単一の Argo CD インスタンスから複数のクラスターを管理するかどうかを決定します。Argo CD に専用の管理クラスターを使用することを検討してください。

 **Application の編成**: Application と ApplicationSet をどのように構造化するかを計画します。Project を使用してチームや環境ごとに Application を編成することを検討してください。

 **同期ポリシー**: アプリケーションを自動的に同期するか、手動で承認するかを決定します。開発環境では自動同期が一般的ですが、本番稼働環境では手動で同期します。

## アクセス許可
<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 アイデンティティセンターと統合する場合
+ 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>

基本的な Argo CD 機能にパブリック Git リポジトリがある場合、信頼ポリシー以外に追加の IAM ポリシーは必要ありません。

## 認証
<a name="_authentication"></a>

### AWS アイデンティティセンターの統合
<a name="shared_aws_identity_center_integration"></a>

Argo CD マネージド機能を AWS アイデンティティセンター (以前の AWS SSO) と直接統合すると、認証に既存の ID プロバイダーを使用できます。

AWS アイデンティティセンター統合を設定した場合:

1. ユーザーは、EKS コンソールから Argo CD UI にアクセスします。

1. AWS アイデンティティセンターを使用してユーザーが認証されます (社内の ID プロバイダーにフェデレーションできます)。

1.  AWS アイデンティティセンターは、ユーザーとグループの情報を Argo CD に提供します。

1. Argo CD は、現在の設定に基づいてユーザーとグループを RBAC ロールにマッピングします。

1. ユーザーには、自分がアクセス許可を持つアプリケーションとリソースのみが表示されます。

### アイデンティティセンターアクセス許可セットでアクセスをシンプルにする
<a name="_simplifying_access_with_identity_center_permission_sets"></a>

 AWS アイデンティティセンターでは、Argo CD を使用する際に以下の 2 種類の認証パスを利用できます。

 **Argo CD API 認証**: アイデンティティセンターにより、Argo CD UI と API から SSO 認証を行うことができます。これを設定するには、Argo CD 機能の RBAC ロールマッピングを使用します。

 **EKS クラスターアクセス**: Argo CD 機能は、お客様提供の IAM ロールを使用して、アクセスエントリを基に EKS クラスターで認証します。こうしたアクセスエントリは、アクセス許可を追加または削除するように手動で設定できます。

[アイデンティティセンターアクセス許可セット](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtocreatepermissionset.html)を使用すると、単一の ID で Argo CD クラスターと EKS クラスターの両方にアクセスできるため、ID 管理がシンプルになります。Argo CD アクセス用とクラスターアクセス用の認証情報を別々に維持するのではなく、両方のシステムで 1 つの ID だけを管理すればよいので、オーバーヘッドが軽減されます。

### RBAC ロールマッピング
<a name="_rbac_role_mappings"></a>

Argo CD には、AWS アイデンティティセンターのユーザーとグループにマッピングできるロールが組み込まれています。

 **ADMIN**: すべてのアプリケーションと設定にフルアクセスできます。アプリケーションの作成、デプロイ、更新、削除が可能です。Argo CD の設定を管理できます。

 **EDITOR**: アプリケーションを作成および変更できます。Argo CD の設定を変更したり、アプリケーションを削除したりすることはできません。

 **VIEWER**: アプリケーションに読み取り専用でアクセスできます。アプリケーションのステータスおよび履歴を表示できます。変更を加えることはできません。

**注記**  
ロール名は、大文字と小文字が区別され、大文字 (ADMIN、EDITOR、VIEWER) にする必要があります。

**重要**  
EKS 機能と AWS アイデンティティセンターが統合されている場合、Argo CD 機能あたり最大 1,000 個の ID がサポートされます。ユーザーやグループを ID にすることができます。

## マルチクラスターデプロイ
<a name="_multi_cluster_deployments"></a>

Argo CD マネージド機能は、マルチクラスターデプロイをサポートしているため、単一の Argo CD インスタンスから開発、ステージング、本番稼働のクラスター全体にわたってアプリケーションを管理できます。

### マルチクラスターの仕組み
<a name="_how_multi_cluster_works"></a>

Argo CD に追加でクラスターを登録する場合:

1. ARN でターゲット EKS クラスターを参照するクラスターシークレットを作成します。

1. ターゲットが異なるクラスターごとに Application または ApplicationSet を作成します。

1. Argo CD は、各クラスターに接続してデプロイし、リソースを監視する

1. 単一の Argo CD UI からすべてのクラスターを表示して管理します。

### マルチクラスターの前提条件
<a name="_prerequisites_for_multi_cluster"></a>

追加でクラスターを登録する前に:
+ ターゲットクラスターで Argo CD 機能ロールのアクセスエントリを作成すること
+ Argo CD 機能とターゲットクラスターとの間にネットワーク接続を確保すること
+ ターゲットクラスターにアクセスするための IAM アクセス許可を検証すること

### クラスターを登録する
<a name="_register_a_cluster"></a>

Kubernetes シークレットを使用して `argocd` 名前空間にクラスターを登録します。

ターゲットクラスター ARN を取得します。*region-code* はターゲットクラスターがある AWS リージョンに置き換え、*my-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
```

**重要**  
Kubernetes API サーバー URL ではなく、`server` フィールドで EKS クラスター ARN を使用します。マネージド機能では、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
```

**注記**  
本番稼働で使用する場合は、`system:masters` ではなくより制限の厳しい Kubernetes グループを使用することを検討してください。

### プライベートクラスターアクセス
<a name="_private_cluster_access"></a>

Argo CD マネージド機能では、VPC ピアリングや特殊なネットワーク設定を施すことなく、完全にプライベートな EKS クラスターにデプロイできます。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 アイデンティティセンター統合を使用すると、Argo CD でアプリケーションにアクセスして管理できるユーザーを制御できます。Argo CD では、Application 内のリソース (デプロイ、ポッド、ConfigMap、シークレット) へのアクセスをきめ細かく制御できます。

 **マルチ環境デプロイに ApplicationSet を使用する**: ApplicationSet を使用すると、設定が異なる複数のクラスターまたは名前空間にアプリケーションをデプロイできます。

## ライフサイクル管理
<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>

同期期間を設定して、どのような場合にアプリケーションを同期できるかを制御します。
+ メンテナンス期間中にのみ同期を許可します。
+ 営業時間中の同期をブロックします。
+ 特定の時間に自動同期をスケジュールします。
+ 変更を行い、同期を停止する必要がある状況で同期ウィンドウを使用する (ブレークグラスシナリオ)

## ウェブフックを設定して同期を高速化する
<a name="_webhook_configuration_for_faster_sync"></a>

デフォルトでは、Argo CD は 6 分ごとに Git リポジトリをポーリングして変更がないか検出します。デプロイの応答性を高めるには、変更がプッシュされたらすぐに同期をトリガーするように Git ウェブフックを設定します。

ウェブフックには、次のような利点があります。
+ コードがプッシュされたらすぐに同期応答が返されます (秒か分かの違い)
+ ポーリングのオーバーヘッドが軽減され、システムのパフォーマンスが向上します。
+ API レートリミットをより効率的に使用できます。
+ フィードバックがすぐに返されるので、ユーザーエクスペリエンスが向上します。

### ウェブフックエンドポイント
<a name="_webhook_endpoint"></a>

ウェブフック URL はパターン `${serverUrl}/api/webhook` に従います。ここでは、Argo CD サーバー URL は `serverUrl` です。

例えば、Argo CD サーバー URL が `https://abc123.eks-capabilities.us-west-2.amazonaws.com` の場合、ウェブフック URL は次のようになります。

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

### Git プロバイダーでウェブフックを設定する
<a name="_configure_webhooks_by_git_provider"></a>

 **GitHub**: リポジトリ設定に、Argo CD ウェブフック URL と共にウェブフックを追加します。コンテンツタイプを `application/json` に設定し、「Just the push event」を選択します。

 **GitLab**: Project 設定に、Argo CD ウェブフック URL と共にウェブフックを追加します。「Push events」とオプションで「Tag push events」を有効にします。

 **Bitbucket**: リポジトリ設定に、Argo CD ウェブフック URL と共にウェブフックを追加します。トリガーとして「Repository push」を選択します。

 **CodeCommit**: Amazon EventBridge に、CodeCommit リポジトリの状態が変化したらトリガーして、Argo CD ウェブフックエンドポイントに通知を送信するというルールを作成します。

ウェブフック設定の詳細な手順については、「[Argo CD ウェブフック設定](https://argo-cd.readthedocs.io/en/stable/operator-manual/webhook/)」を参照してください。

**注記**  
ウェブフックは、ポーリングを補完するものであり、ポーリングに置き換わるものではありません。Argo CD は、ウェブフック通知が見逃された場合に備えて、フォールバックメカニズムとしてリポジトリを継続的にポーリングします。

## 次のステップ
<a name="_next_steps"></a>
+  [Argo CD の使用](working-with-argocd.md) - Argo CD Application を作成および管理する方法を学ぶ
+  [Argo CD 機能に関する問題をトラブルシューティングする](argocd-troubleshooting.md) - Argo CD の問題をトラブルシューティングする
+  [機能リソースの使用](working-with-capabilities.md) - Argo CD 機能リソースを管理する

# Argo CD 機能に関する問題をトラブルシューティングする
<a name="argocd-troubleshooting"></a>

このトピックでは、機能のヘルスチェック、アプリケーション同期の問題、リポジトリ認証、マルチクラスターデプロイなど、EKS Capability for Argo CD をトラブルシューティングする際のガイダンスを示します。

**注記**  
EKS の機能は完全に管理され、クラスターの外部で実行されます。Argo CD サーバーログや `argocd` 名前空間にアクセスすることはできません。トラブルシューティングでは、機能のヘルス、アプリケーションのステータス、および設定に焦点を当てています。

## 機能はアクティブなのにアプリケーションが同期しない
<a name="_capability_is_active_but_applications_arent_syncing"></a>

Argo CD 機能のステータスが `ACTIVE` であるのにアプリケーションが同期しない場合は、機能のヘルスとアプリケーションのステータスを確認してください。

 **機能のヘルスを確認する**:

機能のヘルスとステータスの問題は、EKS コンソールまたは AWS CLI を使用して表示できます。

 **コンソール:**

1. https://console.aws.amazon.com/eks/home\$1/clusters で Amazon EKS コンソールを開きます。

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 が作成されていない**: クラスターに 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}'
```

## アプリケーションが「進行中」のまま変化しない
<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"
```

 **一般的な原因:**
+  **デプロイの準備が完了していない**: ポッドの起動に失敗したか、準備状況プローブが失敗しています。
+  **リソースの依存関係**: リソースが他のリソースの準備を待っています。
+  **イメージプルエラー**: コンテナイメージにアクセスできません。
+  **リソースが不十分**: クラスターでポッドの 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` フィールドに、Kubernetes API URL ではなく EKS クラスター ARN が含まれていることを確認します。

 **ターゲットクラスターのアクセスエントリを確認する**:

ターゲットクラスターで、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 機能ロールにアクセスエントリがあることを確認します。マネージド機能は、IAM ロールの引き受けではなく、クロスアカウントアクセスの EKS アクセスエントリを使用します。

マルチクラスター設定の詳細については、「[ターゲットクラスターを登録する](argocd-register-clusters.md)」を参照してください。

## 次のステップ
<a name="_next_steps"></a>
+  [Argo CD に関する考慮事項](argocd-considerations.md) - Argo CD の考慮事項とベストプラクティス
+  [Argo CD の使用](working-with-argocd.md) - Argo CD Application を作成して管理する
+  [ターゲットクラスターを登録する](argocd-register-clusters.md) - マルチクラスターデプロイを設定する
+  [EKS 機能をトラブルシューティングする](capabilities-troubleshooting.md) - 一般的な機能をトラブルシューティングする際のガイダンス

# EKS Capability for Argo CD とセルフマネージド Argo CD を比較する
<a name="argocd-comparison"></a>

EKS Capability for Argo CD により、完全マネージド型の Argo CD を EKS で動作させることができます。EKS 機能とセルフマネージドソリューションの全般的な比較については、「[EKS 機能と考慮事項](capabilities-considerations.md)」を参照してください。このトピックでは、認証、マルチクラスター管理、アップストリーム機能のサポートなど、Argo CD 固有の違いに焦点を当てます。

## アップストリーム Argo CD との違い
<a name="_differences_from_upstream_argo_cd"></a>

EKS Capability for Argo CD は、アップストリームの Argo CD に基づいていますが、アクセス方法、設定方法、AWS サービスとの統合方法が異なります。

 **RBAC と認証**: 機能が備える RBAC ロールには管理者、編集者、ビューワーの 3 つがあり、Argo CD に組み込みの認証ではなく AWS アイデンティティセンターを使用して認証を行います。Argo CD の `argocd-rbac-cm` ConfigMap ではなく、機能の `rbacRoleMapping` パラメータを使用して、アイデンティティセンターのグループを Argo CD ロールにマッピングするように、ロールマッピングを設定します。Argo CD UI は独自のダイレクト URL (クラスターの [機能] タブの EKS コンソールで確認) でホストされ、API アクセスは IAM を介した AWS 認証と認可を使用します。

 **クラスター設定**: ローカルクラスターやハブアンドスポークトポロジは自動的には設定されません。自分でデプロイターゲットクラスターと EKS アクセスエントリを設定します。Amazon EKS クラスターがデプロイターゲットとしてサポートされるのは、Kubernetes API サーバー URL ではなく EKS クラスター ARN を使用している場合のみです。ローカルクラスター (`kubernetes.default.svc`) がデプロイターゲットとして自動的に追加されることはありません。機能の作成先と同じクラスターにデプロイするには、ARN を使用してそのクラスターを明示的に登録します。

 **シンプルなリモートクラスターアクセス**: EKS アクセスエントリを使用して Argo CD にリモートクラスターへのアクセスを許可することで、マルチクラスターのデプロイをシンプルにします。そのため、サービスアカウントの IAM ロール (IRSA) を設定したり、クロスアカウント IAM ロールの前提条件をセットアップしたりする必要がありません。また、VPC ピアリングや特殊なネットワーク設定を施すことなく、完全にプライベートな EKS クラスターに透過的にアクセスできます。AWS が Argo CD 機能とプライベートリモートクラスターとの接続を自動的に管理します。

 **AWS サービスの直接統合**: 機能ロールの IAM アクセス許可により、AWS サービスを直接統合します。リポジトリ設定を作成しなくても、CodeCommit リポジトリ、ECR Helm チャート、および CodeConnections を Application リソースで直接参照できます。これにより、認証がシンプルになり、AWS サービスごとに認証情報を管理する必要がありません。詳細については、「[リポジトリアクセスを設定する](argocd-configure-repositories.md)」を参照してください。

 **名前空間のサポート**: この機能では、Argo CD Application、ApplicationSet、および AppProject カスタムリソースを作成する必要がある単一の名前空間を指定する必要があります。

**注記**  
この名前空間の制限は、Argo CD 独自のカスタムリソース (Application、ApplicationSet、AppProject) にのみ適用されます。アプリケーションワークロードは、任意のターゲットクラスター内の任意の名前空間にデプロイできます。例えば、名前空間 `argocd` でこの機能を作成する場合、すべての Application CR を `argocd` 名前空間に作成する必要がありますが、それらの Application はワークロードを `default`、`production`、`staging`、またはその他の名前空間にデプロイできます。

**注記**  
マネージド機能には、CLI の使用と AppProject 設定に関する特定の要件があります。  
Argo CD CLI を使用する場合は、名前空間プレフィックス `argocd app sync namespace/appname` を使用してアプリケーションを指定します。
AppProject リソースは `.spec.sourceNamespaces` を指定して、プロジェクトが Application を監視できる名前空間を定義する必要があります (通常は、機能の作成時に指定した名前空間を設定します)。
リソース追跡注釈は形式 `namespace_appname:group/kind:namespace/name` を使用します。

 **サポートされていない機能**: 次の機能は、マネージド機能では使用できません。
+ Config Management Plugin (CMP) によるカスタムマニフェストの生成
+ カスタム Lua スクリプトによるリソースヘルスの評価 (標準リソースに対する組み込みのヘルスチェックはサポートされています)
+ Notifications コントローラー
+ カスタム SSO プロバイダー (AWS アイデンティティセンターを利用したサードパーティーのフェデレーション ID を含め、AWS アイデンティティセンターのみがサポートされています)
+ UI の拡張機能とカスタムのバナー
+ `argocd-cm` や `argocd-params` などの設定 ConfigMaps への直接アクセス
+ 同期タイムアウトの変更 (120 秒に固定)

 **互換性**: Application と ApplicationSet は、アップストリーム Argo CD と同じように動作し、マニフェストの変更は不要です。この機能は同じ Kubernetes API と CRD を使用するため、`kubectl` のようなツールは同じように機能します。完全にサポートされるのは、Application と ApplicationSet、自動同期を備えた 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 UI (**[設定]** → **[アカウント]** → **[管理者]** → **[新しいトークンを生成]**) からアカウントトークンを生成して、環境変数として設定します。

   ```
   export ARGOCD_AUTH_TOKEN="your-token-here"
   ```

**重要**  
このように生成した管理者アカウントトークンは、初期セットアップと開発ワークフローに使用します。本番稼働のユースケースでは、プロジェクト範囲のロールとトークンを使用して、最小特権の原則に従います。Project のロールと 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` コマンドはサポートされていません (直接ポッドアクセスが必要です)。
+  `argocd login` はサポートされていません (代わりにアカウントトークンまたはプロジェクトトークンを使用します)。
+  `argocd cluster add` には、EKS クラスター ARN を指定した `--aws-cluster-name` フラグが必要です。

### 例: クラスターを登録する
<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. サポートされていない機能 (Notifications コントローラー、CMP、カスタムヘルスチェック、UI 拡張機能) の現在の Argo CD 設定を確認します。

1. セルフマネージド Argo CD コントローラーをゼロレプリカにスケールして、競合を防ぐ

1. クラスターに Argo CD 機能リソースを作成します。

1. 既存の Application、ApplicationSet、AppProject をエクスポートします。

1. リポジトリ認証情報、クラスターシークレット、リポジトリ認証情報テンプレート (repocreds) を移行します。

1. GPG キー、TLS 証明書、または SSH 既知のホストを使用する場合は、こうした設定も移行します。

1. クラスター名または EKS クラスター ARN を使用するように `destination.server` フィールドを更新します。

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 アイデンティティセンターの統合を設定する