**Aidez à améliorer cette page**
Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
Pour contribuer à ce guide de l'utilisateur, cliquez sur le GitHub lien **Modifier cette page sur** qui se trouve dans le volet droit de chaque page.
Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Déploiement continu avec Argo CD
Argo CD est un outil de diffusion GitOps continue déclaratif pour Kubernetes. Avec Argo CD, vous pouvez automatiser le déploiement et la gestion du cycle de vie de vos applications sur plusieurs clusters et environnements. Argo CD prend en charge plusieurs types de sources, notamment les référentiels Git, les registres Helm (HTTP et OCI) et les images OCI, offrant ainsi de la flexibilité aux entreprises ayant des exigences de sécurité et de conformité différentes.
Grâce aux fonctionnalités d'EKS, Argo CD est entièrement géré par AWS, ce qui élimine le besoin d'installer, de maintenir et de dimensionner les contrôleurs Argo CD et leurs dépendances vis-à-vis de vos clusters.
## Comment fonctionne Argo CD
Argo CD suit le GitOps modèle selon lequel la source de votre application (dépôt Git, registre Helm ou image OCI) est la source fiable pour définir l'état souhaité de l'application. Lorsque vous créez une `Application` ressource Argo CD, vous spécifiez la source contenant les manifestes de votre application ainsi que le cluster et l'espace de noms Kubernetes cibles. Argo CD surveille en permanence l'état source et l'état réel du cluster, synchronisant automatiquement les modifications pour s'assurer que l'état du cluster correspond à l'état souhaité.
**Note**
Grâce à la fonctionnalité EKS pour Argo CD, le logiciel Argo CD s'exécute dans le plan de AWS contrôle, et non sur vos nœuds de travail. Cela signifie que vos nœuds de travail n'ont pas besoin d'un accès direct aux référentiels Git ou aux registres Helm : la fonctionnalité gère l'accès aux sources depuis le compte. AWS
Argo CD fournit trois types de ressources principaux :
+ **Application** : définit un déploiement depuis un dépôt Git vers un cluster cible
+ **ApplicationSet**: Génère plusieurs applications à partir de modèles pour les déploiements multi-clusters
+ **AppProject**: fournit un regroupement logique et un contrôle d'accès pour les applications
**Exemple : création d'une application Argo CD**
L'exemple suivant montre comment créer une `Application` ressource Argo CD :
```
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
```
**Note**
`destination.name`À utiliser avec le nom du cluster que vous avez utilisé lors de l'enregistrement du cluster (comme `in-cluster` pour le cluster local). Le `destination.server` champ fonctionne également avec le cluster EKS ARNs, mais il est recommandé d'utiliser des noms de clusters pour une meilleure lisibilité.
## Avantages d'Argo CD
Argo CD implémente un GitOps flux de travail dans lequel vous définissez les configurations de vos applications dans les référentiels Git et Argo CD synchronise automatiquement vos applications pour qu'elles correspondent à l'état souhaité. Cette approche centrée sur le GIT fournit une piste d'audit complète de toutes les modifications, permet des annulations faciles et s'intègre naturellement à vos processus de révision et d'approbation de code existants. Argo CD détecte et réconcilie automatiquement la dérive entre l'état souhaité dans Git et l'état réel dans vos clusters, garantissant ainsi la cohérence de vos déploiements avec votre configuration déclarée.
Avec Argo CD, vous pouvez déployer et gérer des applications sur plusieurs clusters à partir d'une seule instance Argo CD, ce qui simplifie les opérations dans les environnements multiclusters et multirégions. L'interface utilisateur d'Argo CD fournit des fonctionnalités de visualisation et de surveillance, vous permettant de visualiser l'état de déploiement, l'état de santé et l'historique de vos applications. L'interface utilisateur s'intègre à AWS Identity Center (anciennement AWS SSO) pour une authentification et une autorisation fluides, vous permettant de contrôler l'accès à l'aide de votre infrastructure de gestion des identités existante.
Dans le cadre des fonctionnalités gérées par EKS, Argo CD est entièrement géré par AWS, ce qui élimine le besoin d'installer, de configurer et de maintenir l'infrastructure Argo CD. AWS gère le dimensionnement, l'application de correctifs et la gestion opérationnelle, permettant à vos équipes de se concentrer sur la livraison des applications plutôt que sur la maintenance des outils.
## Intégration à AWS Identity Center
EKS Managed Capabilities fournit une intégration directe entre Argo CD et AWS Identity Center, permettant ainsi une authentification et une autorisation fluides pour vos utilisateurs. Lorsque vous activez la fonctionnalité Argo CD, vous pouvez configurer l'intégration AWS d'Identity Center pour mapper les groupes et les utilisateurs d'Identity Center aux rôles RBAC d'Argo CD, ce qui vous permet de contrôler qui peut accéder aux applications dans Argo CD et les gérer.
## Intégration avec d'autres fonctionnalités gérées par EKS
Argo CD s'intègre aux autres fonctionnalités gérées par EKS.
+ ** AWS Contrôleurs pour Kubernetes (ACK)** : utilisez Argo CD pour gérer le déploiement des ressources ACK sur plusieurs clusters, en activant les GitOps flux de travail pour votre infrastructure. AWS
+ **kro (Kube Resource Orchestrator)** : utilisez Argo CD pour déployer des compositions kro sur plusieurs clusters, permettant ainsi une composition cohérente des ressources dans l'ensemble de votre parc Kubernetes.
## Commencer à utiliser Argo CD
Pour commencer à utiliser la fonctionnalité EKS pour Argo CD :
1. Créez et configurez un rôle de capacité IAM avec les autorisations nécessaires pour qu'Argo CD puisse accéder à vos sources et gérer les applications.
1. [Créez une ressource de capacité Argo CD](create-argocd-capability.md) sur votre cluster EKS via la AWS console, la AWS CLI ou votre infrastructure préférée en tant qu'outil de code.
1. Configurez l'accès au référentiel et enregistrez les clusters pour le déploiement des applications.
1. Créez des ressources d'application pour déployer vos applications à partir de vos sources déclaratives.
# Création d’une fonctionnalité Argo CD
Cette rubrique explique comment créer une fonctionnalité Argo CD sur votre cluster Amazon EKS.
## Conditions préalables
Avant de créer une fonctionnalité Argo CD, assurez-vous de disposer des éléments suivants :
+ Un cluster Amazon EKS existant exécutant une version de Kubernetes prise en charge (toutes les versions du support standard et étendu sont prises en charge)
+ ** AWS Identity Center configuré** - Nécessaire pour l'authentification sur Argo CD (les utilisateurs locaux ne sont pas pris en charge)
+ Un rôle de capacité IAM avec des autorisations pour Argo CD
+ Autorisations IAM suffisantes pour créer des ressources de capacités sur les clusters EKS
+ `kubectl`configuré pour communiquer avec votre cluster
+ (Facultatif) L'Argo CD CLI est installée pour faciliter la gestion des clusters et des référentiels
+ (Pour CLI/ekSCTL) L'outil CLI approprié est installé et configuré
Pour obtenir des instructions sur la création du rôle de capacité IAM, consultez[Fonctionnalité Amazon EKS : rôle IAM](capability-role.md). Pour la configuration d'Identity Center, consultez [Getting Started with AWS Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/getting-started.html).
**Important**
Le rôle de capacité IAM que vous fournissez détermine les AWS ressources auxquelles Argo CD peut accéder. Cela inclut l'accès au dépôt Git via CodeConnections et les secrets dans Secrets Manager. Pour obtenir des conseils sur la création d'un rôle approprié avec des autorisations de moindre privilège, consultez [Fonctionnalité Amazon EKS : rôle IAM](capability-role.md) et. [Considérations relatives à la sécurité relatives aux fonctionnalités EKS](capabilities-security.md)
## Choisissez votre outil
Vous pouvez créer une fonctionnalité Argo CD à l'aide de la AWS Management Console AWS CLI ou de eksctl :
+ [Création d'une fonctionnalité Argo CD à l'aide de la console](argocd-create-console.md)- Utilisez la console pour une expérience guidée
+ [Création d'une fonctionnalité Argo CD à l'aide de la CLI AWS](argocd-create-cli.md)- Utilisez la AWS CLI pour la création de scripts et l'automatisation
+ [Création d'une fonctionnalité Argo CD à l'aide de eksctl](argocd-create-eksctl.md)- Utilisez eksctl pour une expérience native de Kubernetes
## Que se passe-t-il lorsque vous créez une fonctionnalité Argo CD
Lorsque vous créez une fonctionnalité Argo CD :
1. EKS crée le service de capacité Argo CD dans le plan de AWS contrôle
1. Des définitions de ressources personnalisées (CRDs) sont installées dans votre cluster
1. Une entrée d'accès est automatiquement créée pour votre rôle de capacité IAM avec des politiques d'entrée d'accès spécifiques aux fonctionnalités qui accordent des autorisations Kubernetes de base (voir) [Considérations relatives à la sécurité relatives aux fonctionnalités EKS](capabilities-security.md)
1. Argo CD commence à rechercher ses ressources personnalisées (Applications, ApplicationSets, AppProjects)
1. L'état de capacité passe de `CREATING` à `ACTIVE`
1. L'interface utilisateur d'Argo CD devient accessible via son URL
Une fois actives, vous pouvez créer des applications Argo CD dans votre cluster pour les déployer à partir de vos sources déclaratives.
**Note**
L'entrée d'accès créée automatiquement n'accorde pas l'autorisation de déployer des applications sur des clusters. Pour déployer des applications, vous devez configurer des autorisations Kubernetes RBAC supplémentaires pour chaque cluster cible. Consultez [Enregistrer les clusters cibles](argocd-register-clusters.md) pour plus de détails sur l'enregistrement des clusters et la configuration de l'accès.
## Étapes suivantes
Après avoir créé la fonctionnalité Argo CD :
+ [Concepts d'Argo CD](argocd-concepts.md)- Découvrez GitOps les principes, les politiques de synchronisation et les modèles multi-clusters
+ [Travailler avec Argo CD](working-with-argocd.md)- Configurer l'accès au référentiel, enregistrer les clusters cibles et créer des applications
+ [Considérations relatives à Argo CD](argocd-considerations.md)- Explorez les modèles d'architecture multi-clusters et la configuration avancée
# Création d'une fonctionnalité Argo CD à l'aide de la console
Cette rubrique décrit comment créer une fonctionnalité Argo CD à l'aide du AWS Management Console.
## Conditions préalables
+ ** AWS Identity Center configuré** : Argo CD nécessite AWS Identity Center pour l'authentification. Les utilisateurs locaux ne sont pas pris en charge. Si AWS Identity Center n'est pas configuré, consultez [Commencer à utiliser AWS Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/getting-started.html) pour créer une instance d'Identity Center, et [Ajouter des utilisateurs et Ajouter](https://docs.aws.amazon.com/singlesignon/latest/userguide/addusers.html) [des groupes](https://docs.aws.amazon.com/singlesignon/latest/userguide/addgroups.html) pour créer des utilisateurs et des groupes pour accéder à Argo CD.
## Création de la fonctionnalité Argo CD
1. Ouvrez la console Amazon EKS à l'adresse https://console.aws.amazon.com/eks/ home\$1/clusters.
1. Sélectionnez le nom de votre cluster pour ouvrir la page détaillée du cluster.
1. Choisissez l'onglet **Fonctionnalités**.
1. Dans le menu de navigation de gauche, choisissez **Argo CD**.
1. Choisissez la **fonctionnalité Create Argo CD.**
1. Pour le **rôle de capacité IAM** :
+ Si vous possédez déjà un rôle de capacité IAM, sélectionnez-le dans le menu déroulant
+ Si vous devez créer un rôle, choisissez **Créer un rôle Argo CD**
Cela ouvre la console IAM dans un nouvel onglet avec une politique de confiance préremplie et un accès complet en lecture à Secrets Manager. Aucune autre autorisation n'est ajoutée par défaut, mais vous pouvez les ajouter si nécessaire. Si vous prévoyez d'utiliser CodeCommit des référentiels ou d'autres AWS services, ajoutez les autorisations appropriées avant de créer le rôle.
Après avoir créé le rôle, retournez à la console EKS et le rôle sera automatiquement sélectionné.
**Note**
Si vous envisagez d'utiliser les intégrations facultatives avec AWS Secrets Manager or AWS CodeConnections, vous devrez ajouter des autorisations au rôle. Pour des exemples de politique IAM et des conseils de configuration, reportez-vous aux sections [Gérez les secrets des applications avec AWS Secrets Manager](integration-secrets-manager.md) et[Connectez-vous aux référentiels Git avec AWS CodeConnections](integration-codeconnections.md).
1. Configurer AWS l'intégration d'Identity Center :
1. Sélectionnez **Activer AWS l'intégration d'Identity Center**.
1. Choisissez votre instance Identity Center dans le menu déroulant.
1. Configurez les mappages de rôles pour RBAC en affectant des utilisateurs ou des groupes à des rôles Argo CD (ADMIN, EDITOR ou VIEWER)
1. Choisissez **Créer**.
Le processus de création de capacités commence.
## Vérifiez que la fonctionnalité est active
1. Dans l'onglet **Fonctionnalités**, consultez l'état des capacités de l'Argo CD.
1. Attendez que le statut passe de `CREATING` à`ACTIVE`.
1. Une fois active, la fonctionnalité est prête à être utilisée.
Pour plus d'informations sur l'état des fonctionnalités et la résolution des problèmes, consultez[Utilisation des ressources en matière de capacités](working-with-capabilities.md).
## Accédez à l'interface utilisateur d'Argo CD
Une fois la fonctionnalité activée, vous pouvez accéder à l'interface utilisateur d'Argo CD :
1. Sur la page des fonctionnalités d'Argo CD, choisissez **Ouvrir l'interface utilisateur d'Argo CD**.
1. L'interface utilisateur d'Argo CD s'ouvre dans un nouvel onglet du navigateur.
1. Vous pouvez désormais créer des applications et gérer les déploiements via l'interface utilisateur.
## Étapes suivantes
+ [Travailler avec Argo CD](working-with-argocd.md)- Configurer des référentiels, enregistrer des clusters et créer des applications
+ [Considérations relatives à Argo CD](argocd-considerations.md)- Architecture multi-clusters et configuration avancée
+ [Utilisation des ressources en matière de capacités](working-with-capabilities.md)- Gérez vos ressources de capacités Argo CD
# Création d'une fonctionnalité Argo CD à l'aide de la CLI AWS
Cette rubrique décrit comment créer une fonctionnalité Argo CD à l'aide de la AWS CLI.
## Conditions préalables
+ ** AWS CLI** : version `2.12.3` ou ultérieure. Pour vérifier votre version, lancez`aws --version`. Pour plus d'informations, consultez la section [Installation](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) dans le guide de l'utilisateur de l'interface de ligne de AWS commande.
+ ** `kubectl` ** : outil de ligne de commande pour travailler avec des clusters Kubernetes. Pour de plus amples informations, veuillez consulter [Configuration de `kubectl` et `eksctl`](install-kubectl.md).
+ ** AWS Identity Center configuré** : Argo CD nécessite AWS Identity Center pour l'authentification. Les utilisateurs locaux ne sont pas pris en charge. Si AWS Identity Center n'est pas configuré, consultez [Commencer à utiliser AWS Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/getting-started.html) pour créer une instance d'Identity Center, et [Ajouter des utilisateurs et Ajouter](https://docs.aws.amazon.com/singlesignon/latest/userguide/addusers.html) [des groupes](https://docs.aws.amazon.com/singlesignon/latest/userguide/addgroups.html) pour créer des utilisateurs et des groupes pour accéder à Argo CD.
## Étape 1 : Création d'un rôle de capacité IAM
Créez un fichier de politique de confiance :
```
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
```
Créez le rôle IAM :
```
aws iam create-role \
--role-name ArgoCDCapabilityRole \
--assume-role-policy-document file://argocd-trust-policy.json
```
**Note**
Si vous envisagez d'utiliser les intégrations facultatives avec AWS Secrets Manager or AWS CodeConnections, vous devrez ajouter des autorisations au rôle. Pour des exemples de politique IAM et des conseils de configuration, reportez-vous aux sections [Gérez les secrets des applications avec AWS Secrets Manager](integration-secrets-manager.md) et[Connectez-vous aux référentiels Git avec AWS CodeConnections](integration-codeconnections.md).
## Étape 2 : Création de la fonctionnalité Argo CD
Créez la ressource de capacité Argo CD sur votre cluster.
Définissez d'abord les variables d'environnement pour la configuration de votre Identity Center :
```
# Get your Identity Center instance ARN (replace region if your IDC instance is in a different region)
export IDC_INSTANCE_ARN=$(aws sso-admin list-instances --region [.replaceable]`region` --query 'Instances[0].InstanceArn' --output text)
# Get a user ID for RBAC mapping (replace with your username and region if needed)
export IDC_USER_ID=$(aws identitystore list-users \
--region [.replaceable]`region` \
--identity-store-id $(aws sso-admin list-instances --region [.replaceable]`region` --query 'Instances[0].IdentityStoreId' --output text) \
--query 'Users[?UserName==`your-username`].UserId' --output text)
echo "IDC_INSTANCE_ARN=$IDC_INSTANCE_ARN"
echo "IDC_USER_ID=$IDC_USER_ID"
```
Créez la fonctionnalité grâce à l'intégration d'Identity Center. *region-code*Remplacez-le par la AWS région où se trouve votre cluster, *my-cluster* par le nom de votre cluster et *idc-region-code* par le code de région dans lequel votre centre d'identité IAM a été configuré :
```
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"
}]
}]
}
}'
```
La commande revient immédiatement, mais la fonctionnalité met un certain temps à devenir active car EKS crée l'infrastructure et les composants de capacité requis. EKS installera les définitions de ressources personnalisées Kubernetes associées à cette fonctionnalité dans votre cluster lors de sa création.
**Note**
Si vous recevez un message d'erreur indiquant que le cluster n'existe pas ou que vous n'êtes pas autorisé, vérifiez :
Le nom du cluster est correct
Votre AWS CLI est configurée pour la bonne région
Vous disposez des autorisations IAM requises
## Étape 3 : vérifier que la fonctionnalité est active
Attendez que la fonctionnalité soit activée. Remplacez *region-code* par la AWS région où se trouve votre cluster et *my-cluster* par le nom de votre cluster.
```
aws eks describe-capability \
--region region-code \
--cluster-name my-cluster \
--capability-name my-argocd \
--query 'capability.status' \
--output text
```
La fonctionnalité est prête lorsque l'état s'affiche`ACTIVE`. Ne passez pas à l'étape suivante tant que le statut n'est pas atteint`ACTIVE`.
Vous pouvez également consulter les détails complets des fonctionnalités :
```
aws eks describe-capability \
--region region-code \
--cluster-name my-cluster \
--capability-name my-argocd
```
## Étape 4 : vérifier que les ressources personnalisées sont disponibles
Une fois la fonctionnalité activée, vérifiez que les ressources personnalisées Argo CD sont disponibles dans votre cluster :
```
kubectl api-resources | grep argoproj.io
```
Vous devriez voir apparaître une liste `Application` `ApplicationSet` des types de ressources.
## Étapes suivantes
+ [Travailler avec Argo CD](working-with-argocd.md)- Configurer des référentiels, enregistrer des clusters et créer des applications
+ [Considérations relatives à Argo CD](argocd-considerations.md)- Architecture multi-clusters et configuration avancée
+ [Utilisation des ressources en matière de capacités](working-with-capabilities.md)- Gérez vos ressources de capacités Argo CD
# Création d'une fonctionnalité Argo CD à l'aide de eksctl
Cette rubrique décrit comment créer une fonctionnalité Argo CD à l'aide de eksctl.
**Note**
Les étapes suivantes nécessitent la version eksctl `0.220.0` ou une version ultérieure. Pour vérifier votre version, lancez`eksctl version`.
## Étape 1 : Création d'un rôle de capacité IAM
Créez un fichier de politique de confiance :
```
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
```
Créez le rôle IAM :
```
aws iam create-role \
--role-name ArgoCDCapabilityRole \
--assume-role-policy-document file://argocd-trust-policy.json
```
**Note**
Pour cette configuration de base, aucune politique IAM supplémentaire n'est nécessaire. Si vous prévoyez d'utiliser Secrets Manager pour les informations d'identification du référentiel CodeConnections, vous devez également ajouter des autorisations au rôle. Pour des exemples de politique IAM et des conseils de configuration, reportez-vous aux sections [Gérez les secrets des applications avec AWS Secrets Manager](integration-secrets-manager.md) et[Connectez-vous aux référentiels Git avec AWS CodeConnections](integration-codeconnections.md).
## Étape 2 : obtenir la configuration de votre AWS Identity Center
Obtenez l'ARN et l'ID utilisateur de votre instance Identity Center pour la configuration du RBAC :
```
# Get your Identity Center instance ARN
aws sso-admin list-instances --query 'Instances[0].InstanceArn' --output text
# Get a user ID for admin access (replace 'your-username' with your Identity Center username)
aws identitystore list-users \
--identity-store-id $(aws sso-admin list-instances --query 'Instances[0].IdentityStoreId' --output text) \
--query 'Users[?UserName==`your-username`].UserId' --output text
```
Notez ces valeurs, vous en aurez besoin à l'étape suivante.
## Étape 3 : Création d'un fichier de configuration eksctl
Créez un fichier nommé `argocd-capability.yaml` avec le contenu suivant. Remplacez les valeurs de l'espace réservé par le nom de votre cluster, la région du cluster, l'ARN du rôle IAM, l'ARN de l'instance Identity Center, la région du centre d'identité et l'ID utilisateur :
```
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
```
**Note**
Vous pouvez ajouter plusieurs utilisateurs ou groupes aux mappages RBAC. Pour les groupes, utilisez `type: SSO_GROUP` et fournissez l'ID du groupe. Les rôles disponibles sont `ADMIN``EDITOR`, et`VIEWER`.
## Étape 4 : Création de la fonctionnalité Argo CD
Appliquez le fichier de configuration :
```
eksctl create capability -f argocd-capability.yaml
```
La commande revient immédiatement, mais la fonctionnalité met un certain temps à devenir active.
## Étape 5 : vérifier que la fonctionnalité est active
Vérifiez l'état des capacités. Remplacez *region-code* par la AWS région dans laquelle se trouve votre cluster et remplacez *my-cluster* par le nom de votre cluster.
```
eksctl get capability \
--region region-code \
--cluster my-cluster \
--name my-argocd
```
La fonctionnalité est prête lorsque l'état s'affiche`ACTIVE`.
## Étape 6 : vérifier que les ressources personnalisées sont disponibles
Une fois la fonctionnalité activée, vérifiez que les ressources personnalisées Argo CD sont disponibles dans votre cluster :
```
kubectl api-resources | grep argoproj.io
```
Vous devriez voir apparaître une liste `Application` `ApplicationSet` des types de ressources.
## Étapes suivantes
+ [Travailler avec Argo CD](working-with-argocd.md)- Apprenez à créer et à gérer des applications Argo CD
+ [Considérations relatives à Argo CD](argocd-considerations.md)- Configurer l'accès SSO et multi-clusters
+ [Utilisation des ressources en matière de capacités](working-with-capabilities.md)- Gérez vos ressources de capacités Argo CD
# Concepts d'Argo CD
Argo CD implémente Git GitOps en considérant Git comme la seule source fiable pour vos déploiements d'applications. Cette rubrique présente un exemple pratique, puis explique les concepts de base que vous devez comprendre lorsque vous travaillez avec l'EKS Capability for Argo CD.
## Commencer à utiliser Argo CD
Après avoir créé la fonctionnalité Argo CD (voir[Création d’une fonctionnalité Argo CD](create-argocd-capability.md)), vous pouvez commencer à déployer des applications. Cet exemple décrit l'enregistrement d'un cluster et la création d'une application.
### Étape 1 : Configurer
**Enregistrez votre cluster** (obligatoire)
Enregistrez le cluster dans lequel vous souhaitez déployer des applications. Dans cet exemple, nous allons enregistrer le même cluster sur lequel Argo CD est exécuté (vous pouvez utiliser le nom `in-cluster` pour des raisons de compatibilité avec la plupart des exemples d'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
```
**Note**
Pour plus d'informations sur la configuration de l'Argo CD CLI pour qu'elle fonctionne avec la fonctionnalité Argo CD dans EKS, consultez. [Utilisation de l'Argo CD CLI avec la fonctionnalité gérée](argocd-comparison.md#argocd-cli-configuration)
Vous pouvez également enregistrer le cluster à l'aide d'un secret Kubernetes (voir [Enregistrer les clusters cibles](argocd-register-clusters.md) pour plus de détails).
**Configurer l'accès au référentiel** (facultatif)
Cet exemple utilise un GitHub référentiel public, aucune configuration de référentiel n'est donc requise. Pour les référentiels privés, configurez l'accès à l'aide de AWS Secrets Manager ou de Kubernetes Secrets (voir [Configuration de l'accès au référentiel](argocd-configure-repositories.md) pour plus de détails). CodeConnections
Pour les AWS services (ECR pour les graphiques Helm CodeConnections, et CodeCommit), vous pouvez les référencer directement dans les ressources de l'application sans créer de référentiel. Le rôle de capacité doit disposer des autorisations IAM requises. Consultez [Configuration de l'accès au référentiel](argocd-configure-repositories.md) pour plus de détails.
### Étape 2 : Créer une application
Créez ce manifeste d'application dans `my-app.yaml` :
```
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
name: guestbook
namespace: argocd
spec:
project: default
source:
repoURL: https://github.com/argoproj/argocd-example-apps.git
targetRevision: HEAD
path: guestbook
destination:
name: in-cluster
namespace: guestbook
syncPolicy:
automated:
prune: true
selfHeal: true
syncOptions:
- CreateNamespace=true
```
Appliquez l'application :
```
kubectl apply -f my-app.yaml
```
Après avoir appliqué cette application, Argo CD : 1. Synchronise l'application de Git avec votre cluster (déploiement initial) 2. Surveille les modifications apportées au dépôt Git 3. Synchronise automatiquement les modifications ultérieures sur votre cluster 4. Détecte et corrige toute dérive par rapport à l'état souhaité 5. Fournit l'état de santé et l'historique de synchronisation dans l'interface utilisateur
Consultez le statut de la demande :
```
kubectl get application guestbook -n argocd
```
Vous pouvez également afficher l'application à l'aide de l'interface de ligne de commande Argo CD ou de l'interface utilisateur du CD Argo (accessible depuis la console EKS sous l'onglet Capabilities de votre cluster).
**Note**
Lorsque vous utilisez l'Argo CD CLI avec la fonctionnalité gérée, spécifiez les applications avec le préfixe d'espace de noms :. `argocd app get argocd/guestbook`
**Note**
Utilisez le nom du cluster dans `destination.name` (le nom que vous avez utilisé lors de l'enregistrement du cluster). La fonctionnalité gérée ne prend pas en charge la valeur par défaut locale au sein du cluster (`kubernetes.default.svc`).
## Concepts de base
### GitOps principes et types de sources
Argo CD implémente GitOps, où la source de votre application est la seule source fiable pour les déploiements :
+ **Déclaratif** - L'état souhaité est déclaré à l'aide de manifestes YAML, de graphiques Helm ou de superpositions Kustomize
+ **Versionné** : chaque modification est suivie grâce à une piste d'audit complète
+ **Automatisé** : Argo CD surveille en permanence les sources et synchronise automatiquement les modifications
+ **Autoréparation** : détecte et corrige le décalage entre l'état souhaité et l'état réel du cluster
**Types de sources pris** en charge :
+ **Référentiels Git** - GitHub GitLab, Bitbucket, CodeCommit (HTTPS, SSH ou) CodeConnections
+ **Registres Helm : registres** HTTP (similaires`https://aws.github.io/eks-charts`) et registres OCI (similaires) `public.ecr.aws`
+ Images **OCI : images** de conteneurs contenant des manifestes ou des diagrammes Helm (similaires`oci://registry-1.docker.io/user/my-app`)
Cette flexibilité permet aux entreprises de choisir les sources qui répondent à leurs exigences de sécurité et de conformité. Par exemple, les organisations qui limitent l'accès à Git depuis les clusters peuvent utiliser l'ECR pour les diagrammes Helm ou les images OCI.
Pour plus d'informations, consultez la section [Sources d'applications](https://argo-cd.readthedocs.io/en/stable/user-guide/application-sources/) dans la documentation Argo CD.
### Synchronisation et réconciliation
Argo CD surveille en permanence vos sources et vos clusters afin de détecter et de corriger les différences :
1. Interroge les sources pour connaître les modifications (par défaut : toutes les 6 minutes)
1. Compare l'état souhaité avec l'état du cluster
1. Marque les applications comme `Synced` ou `OutOfSync`
1. Synchronise les modifications automatiquement (si elles sont configurées) ou attend une approbation manuelle
1. Surveille l'état des ressources après la synchronisation
**Les ondes de synchronisation** contrôlent l'ordre de création des ressources à l'aide d'annotations :
```
metadata:
annotations:
argocd.argoproj.io/sync-wave: "0" # Default if not specified
```
Les ressources sont appliquées par ordre de vague (les nombres les plus bas d'abord, y compris les nombres négatifs comme`-1`). Wave `0` est la valeur par défaut si elle n'est pas spécifiée. Cela vous permet de créer des dépendances telles que des espaces de noms (wave`-1`) avant les déploiements (wave`0`) avant les services (wave`1`).
**L'autoréparation** annule automatiquement les modifications manuelles :
```
spec:
syncPolicy:
automated:
selfHeal: true
```
**Note**
La fonctionnalité gérée utilise le suivi des ressources basé sur les annotations (et non sur les étiquettes) pour une meilleure compatibilité avec les conventions Kubernetes et les autres outils.
Pour des informations détaillées sur les phases de synchronisation, les hooks et les modèles avancés, consultez la [documentation de synchronisation Argo CD](https://argo-cd.readthedocs.io/en/stable/user-guide/sync-waves/).
### État de santé des applications
Argo CD surveille l'état de toutes les ressources de votre application :
**État de santé :\$1** **Sain** - Toutes les ressources fonctionnent comme prévu \$1 **Progression** - Ressources en cours de création ou de mise à jour \$1 **Dégradée** - Certaines ressources ne sont pas saines (pods tombent en panne, tâches échouent) \$1 **Suspendue** - Application interrompue intentionnellement \$1 **Manquante** - Les ressources définies dans Git ne sont pas présentes dans le cluster
Argo CD intègre des contrôles de santé pour les ressources Kubernetes courantes (déploiements, tâches StatefulSets, etc.) et prend en charge les contrôles de santé personnalisés pour. CRDs
L'état de santé de l'application est déterminé par toutes ses ressources. Si une ressource l'est`Degraded`, c'est bien l'application qui l'est`Degraded`.
Pour plus d'informations, consultez [Resource Health](https://argo-cd.readthedocs.io/en/stable/operator-manual/health/) dans la documentation d'Argo CD.
### Modèles multi-clusters
Argo CD prend en charge deux modèles de déploiement principaux :
**H ub-and-spoke** - Exécutez Argo CD sur un cluster de gestion dédié qui se déploie sur plusieurs clusters de charge de travail :\$1 Contrôle et visibilité centralisés \$1 Politiques cohérentes sur tous les clusters \$1 Une instance Argo CD à gérer \$1 Séparation claire entre le plan de contrôle et les charges de travail
**Par cluster** : exécutez Argo CD sur chaque cluster, en gérant uniquement les applications de ce cluster :\$1 Séparation des clusters (une défaillance n'affecte pas les autres) \$1 Simplification du réseau (aucune communication entre clusters) \$1 Configuration initiale plus facile (pas d'enregistrement du cluster)
Choisissez hub-and-spoke pour les équipes de plateforme qui gèrent de nombreux clusters, ou par cluster pour les équipes indépendantes ou lorsque les clusters doivent être complètement isolés.
Pour une configuration multicluster détaillée, voir[Considérations relatives à Argo CD](argocd-considerations.md).
### Projets
Les projets fournissent un regroupement logique et un contrôle d'accès pour les applications :
+ **Restrictions relatives aux sources** - Limitez les référentiels Git pouvant être utilisés
+ **Restrictions de destination** : limitez les clusters et les espaces de noms pouvant être ciblés
+ **Restrictions de ressources** : limitez les types de ressources Kubernetes pouvant être déployés
+ **Intégration RBAC : associez** les projets à l'utilisateur et au groupe AWS Identity Center IDs
Les candidatures appartiennent à un seul projet. S'il n'est pas spécifié, ils utilisent le `default` projet, qui n'est soumis à aucune restriction par défaut. Pour une utilisation en production, modifiez le `default` projet pour en restreindre l'accès et créez de nouveaux projets avec les restrictions appropriées.
Pour la configuration du projet et les modèles RBAC, voir[Configurer les autorisations d'Argo CD](argocd-permissions.md).
### Options de synchronisation
Ajustez le comportement de synchronisation à l'aide des options courantes :
+ `CreateNamespace=true`- Création automatique d'un espace de noms de destination
+ `ServerSideApply=true`- Utilisez l'application côté serveur pour une meilleure résolution des conflits
+ `SkipDryRunOnMissingResource=true`- Ignorez l'exécution à sec lorsque cela CRDs n'existe pas encore (utile pour les instances Kro)
```
spec:
syncPolicy:
syncOptions:
- CreateNamespace=true
- ServerSideApply=true
- SkipDryRunOnMissingResource=true
```
Pour une liste complète des options de synchronisation, consultez la [documentation des options de synchronisation Argo CD](https://argo-cd.readthedocs.io/en/stable/user-guide/sync-options/).
## Étapes suivantes
+ [Configuration de l'accès au référentiel](argocd-configure-repositories.md)- Configurer l'accès au dépôt Git
+ [Enregistrer les clusters cibles](argocd-register-clusters.md)- Enregistrez les clusters cibles pour le déploiement
+ [Création d'applications](argocd-create-application.md)- Créez votre première application
+ [Considérations relatives à Argo CD](argocd-considerations.md)- Modèles spécifiques à EKS, intégration d'Identity Center et configuration multi-clusters
+ Documentation [Argo CD - Documentation](https://argo-cd.readthedocs.io/en/stable/) complète sur Argo CD, y compris les crochets de synchronisation, les contrôles de santé et les modèles avancés
# Configurer les autorisations d'Argo CD
La fonctionnalité gérée par Argo CD s'intègre à AWS Identity Center pour l'authentification et utilise des rôles RBAC intégrés pour l'autorisation. Cette rubrique explique comment configurer les autorisations pour les utilisateurs et les équipes.
## Comment fonctionnent les autorisations avec Argo CD
La fonctionnalité Argo CD utilise AWS Identity Center pour l'authentification et fournit trois rôles RBAC intégrés pour l'autorisation.
Lorsqu'un utilisateur accède à Argo CD :
1. Ils s'authentifient à l'aide AWS d'Identity Center (qui peut être fédéré auprès de votre fournisseur d'identité d'entreprise)
1. AWS Identity Center fournit des informations sur les utilisateurs et les groupes à Argo CD
1. Argo CD associe les utilisateurs et les groupes aux rôles RBAC en fonction de votre configuration
1. Les utilisateurs ne voient que les applications et les ressources auxquelles ils sont autorisés à accéder
## Rôles RBAC intégrés
La fonctionnalité Argo CD fournit trois rôles intégrés que vous pouvez associer aux utilisateurs et aux groupes AWS d'Identity Center. Il s'agit de **rôles de portée mondiale** qui contrôlent l'accès aux ressources Argo CD telles que les projets, les clusters et les référentiels.
**Important**
Les rôles globaux contrôlent l'accès à Argo CD lui-même, et non aux ressources liées au projet, telles que les applications. Les utilisateurs de EDITOR et VIEWER ne peuvent pas voir ou gérer les applications par défaut. Ils ont besoin de rôles de projet pour accéder aux ressources spécifiques au projet. Consultez [Rôles du projet et accès délimité par le projet](#project-roles) pour plus de détails sur l'octroi de l'accès aux applications et à d'autres ressources liées au projet.
**ADMINISTRATEUR**
Accès complet à toutes les ressources et à tous les paramètres d'Argo CD :
+ Créez, mettez à jour et supprimez des applications et ApplicationSets dans n'importe quel projet
+ Gérer la configuration d'Argo CD
+ Enregistrez et gérez les clusters cibles de déploiement
+ Configuration de l'accès au référentiel
+ Création et gestion de projets
+ Afficher l'état et l'historique de toutes les demandes
+ Répertorier et accéder à tous les clusters et référentiels
**RÉDACTEUR**
Peut mettre à jour des projets et configurer les rôles des projets, mais ne peut pas modifier les paramètres globaux d'Argo CD :
+ Mettre à jour les projets existants (impossible de créer ou de supprimer des projets)
+ Configuration des rôles et des autorisations du projet
+ Afficher les clés et certificats GPG
+ Impossible de modifier la configuration globale d'Argo CD
+ Impossible de gérer directement les clusters ou les référentiels
+ Impossible de voir ou de gérer les applications sans rôles dans le projet
**SPECTATEUR**
Accès en lecture seule aux ressources Argo CD :
+ Afficher les configurations de projet
+ Répertorier tous les projets (y compris les projets auxquels l'utilisateur n'est pas affecté)
+ Afficher les clés et certificats GPG
+ Impossible de répertorier les clusters ou les référentiels
+ Impossible d'apporter des modifications
+ Impossible de voir ou de gérer les applications sans rôles dans le projet
**Note**
Pour accorder aux utilisateurs EDITOR ou VIEWER l'accès aux applications, un ADMINISTRATEUR ou un ÉDITEUR doit créer des rôles de projet qui associent les groupes Identity Center à des autorisations spécifiques au sein d'un projet.
## Rôles du projet et accès délimité par le projet
Les rôles globaux (ADMIN, EDITOR, VIEWER) contrôlent l'accès à Argo CD lui-même. Les rôles de projet contrôlent l'accès aux ressources et aux capacités au sein d'un projet spécifique, notamment :
+ **Ressources** : applications, informations d'identification du référentiel ApplicationSets, informations d'identification du cluster
+ **Fonctionnalités** : accès aux journaux, accès exec aux modules de l'application
**Comprendre le modèle d'autorisation à deux niveaux** :
+ **Portée globale** : les rôles intégrés déterminent ce que les utilisateurs peuvent faire avec les projets, les clusters, les référentiels et les paramètres d'Argo CD
+ **Portée du** projet : les rôles du projet déterminent ce que les utilisateurs peuvent faire avec les ressources et les capacités d'un projet spécifique
Autrement dit :
+ Les utilisateurs ADMIN peuvent accéder à toutes les ressources et fonctionnalités du projet sans configuration supplémentaire
+ Les utilisateurs EDITOR et VIEWER doivent se voir attribuer des rôles de projet pour accéder aux ressources et aux capacités du projet
+ Les utilisateurs de l'ÉDITEUR peuvent créer des rôles de projet pour s'accorder, ainsi qu'à d'autres, un accès au sein de projets qu'ils peuvent mettre à jour
**Exemple de flux de travail** :
1. Un ADMINISTRATEUR associe un groupe Identity Center au rôle EDITOR à l'échelle mondiale
1. Un ADMIN crée un projet pour une équipe
1. L'ÉDITEUR configure les rôles du projet au sein de ce projet pour permettre aux membres de l'équipe d'accéder aux ressources définies dans le cadre du projet.
1. Les membres de l'équipe (qui peuvent avoir un rôle global VIEWER) peuvent désormais voir et gérer les applications de ce projet en fonction de leurs autorisations de rôle dans le projet
Pour plus de détails sur la configuration des rôles du projet, consultez[Contrôle d'accès basé sur le projet](#_project_based_access_control).
## Configuration des mappages de rôles
Associez les utilisateurs et les groupes AWS d'Identity Center aux rôles Argo CD lors de la création ou de la mise à jour de la fonctionnalité.
**Exemple de mappage des rôles** :
```
{
"rbacRoleMapping": {
"ADMIN": ["AdminGroup", "alice@example.com"],
"EDITOR": ["DeveloperGroup", "DevOpsTeam"],
"VIEWER": ["ReadOnlyGroup", "bob@example.com"]
}
}
```
**Note**
Les noms de rôles distinguent les majuscules des minuscules et doivent être en majuscules (ADMIN, EDITOR, VIEWER).
**Important**
L'intégration d'EKS Capabilities à AWS Identity Center prend en charge jusqu'à 1 000 identités par fonctionnalité Argo CD. Une identité peut être un utilisateur ou un groupe.
**Mettre à jour les mappages de rôles** :
```
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" }
]
}
]
}
}
}'
```
## Utilisation du compte administrateur
Le compte administrateur est conçu pour la configuration initiale et les tâches administratives telles que l'enregistrement de clusters et la configuration de référentiels.
**Lorsque le compte administrateur est approprié** :
+ Configuration et configuration initiales des fonctionnalités
+ Développement en solo ou démonstrations rapides
+ Tâches administratives (enregistrement du cluster, configuration du référentiel, création de projets)
**Bonnes pratiques pour le compte administrateur** :
+ Ne confiez pas les jetons de compte au contrôle de version
+ Faites pivoter les jetons immédiatement s'ils sont exposés
+ Limitez l'utilisation des jetons de compte aux tâches de configuration et d'administration
+ Définissez des délais d'expiration courts (maximum 12 heures)
+ Seuls 5 jetons de compte peuvent être créés à un moment donné
**Quand utiliser plutôt l'accès basé sur le projet** :
+ Environnements de développement partagés avec plusieurs utilisateurs
+ Tout environnement similaire à celui de la production
+ Lorsque vous avez besoin de pistes d'audit pour savoir qui a effectué des actions
+ Lorsque vous devez appliquer des restrictions de ressources ou des limites d'accès
Pour les environnements de production et les scénarios multi-utilisateurs, utilisez le contrôle d'accès basé sur le projet avec des rôles RBAC dédiés mappés aux groupes Identity Center. AWS
## Contrôle d'accès basé sur le projet
Utilisez Argo CD Projects (AppProject) pour fournir un contrôle d'accès précis et une isolation des ressources aux équipes.
**Important**
Avant d'affecter des utilisateurs ou des groupes à des rôles spécifiques au projet, vous devez d'abord les associer à un rôle Argo CD global (ADMIN, EDITOR ou VIEWER) dans la configuration des fonctionnalités. Les utilisateurs ne peuvent pas accéder à Argo CD sans mappage global des rôles, même s'ils sont affectés à des rôles de projet.
Envisagez de mapper les utilisateurs au rôle VIEWER de manière globale, puis d'accorder des autorisations supplémentaires via des rôles spécifiques au projet. Cela fournit un accès de base tout en permettant un contrôle précis au niveau du projet.
Les projets fournissent :
+ **Restrictions relatives aux sources** : limite les référentiels Git pouvant être utilisés
+ **Restrictions de destination** : limitez les clusters et les espaces de noms pouvant être ciblés
+ **Restrictions de ressources** : limitez les types de ressources Kubernetes pouvant être déployés
+ **Intégration RBAC : associez** les projets à des groupes AWS Identity Center ou à des rôles Argo CD
**Exemple de projet pour isoler une équipe** :
```
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
```
### Espaces de noms sources
Lorsque vous utilisez la fonctionnalité EKS Argo CD, le `spec.sourceNamespaces` champ est obligatoire dans AppProject les définitions. Ce champ indique quel espace de noms peut contenir des applications ou ApplicationSets qui font référence à ce projet.
**Important**
La fonctionnalité EKS Argo CD ne prend en charge qu'un seul espace de noms pour les applications, à savoir l'espace de ApplicationSets noms que vous avez spécifié lors de la création de la fonctionnalité (généralement). `argocd` Cela diffère de l'Argo CD open source qui prend en charge plusieurs espaces de noms.
**AppProject configuration**
Tous AppProjects doivent inclure l'espace de noms configuré pour la fonctionnalité dans `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
```
**Note**
Si vous omettez l'espace de noms de la fonctionnalité dans`sourceNamespaces`, les applications ou ApplicationSets dans cet espace de noms ne peuvent pas faire référence à ce projet, ce qui entraîne des échecs de déploiement.
**Affecter des utilisateurs à des projets** :
Les rôles de projet permettent aux utilisateurs de EDITOR et VIEWER d'accéder aux ressources du projet (applications ApplicationSets, informations d'identification du référentiel et du cluster) et aux fonctionnalités (journaux, exec) du projet. Sans rôles de projet, ces utilisateurs ne peuvent pas accéder à ces ressources même s'ils disposent d'un accès global aux rôles.
Les utilisateurs ADMIN ont accès à toutes les applications sans avoir besoin de rôles de projet.
**Exemple : accorder l'accès à l'application aux membres de l'équipe**
```
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
```
**Note**
Incluez `clusters, get, *, allow` les rôles dans le projet pour permettre aux utilisateurs de voir les noms des clusters dans l'interface utilisateur. Sans cette autorisation, le cluster de destination s'affiche comme « inconnu ».
**Comprendre les politiques relatives aux rôles du projet** :
Le format de la politique est le suivant : `p, proj::, , ,