**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.

# Travailler avec des projets Argo CD
<a name="argocd-projects"></a>

Les projets Argo CD (AppProject) fournissent un regroupement logique et un contrôle d'accès pour les applications. Les projets définissent les référentiels Git, les clusters cibles et les espaces de noms que les applications peuvent utiliser, ce qui permet la mutualisation et les limites de sécurité dans les instances Argo CD partagées.

## Quand utiliser les projets
<a name="_when_to_use_projects"></a>

Utilisez les projets pour :
+ Séparez les applications par équipe, environnement ou unité commerciale
+ Limiter les référentiels à partir desquels les équipes peuvent effectuer des déploiements
+ Limiter les clusters et les espaces de noms vers lesquels les équipes peuvent effectuer des déploiements
+ Appliquer les quotas de ressources et les types de ressources autorisés
+ Proposez un déploiement d'applications en libre-service avec des garde-fous

## Projet par défaut
<a name="_default_project"></a>

Chaque fonctionnalité d'Argo CD inclut un `default` projet qui permet d'accéder à tous les référentiels, clusters et espaces de noms. Bien que cela soit utile pour les tests initiaux, créez des projets dédiés avec des restrictions explicites pour l'utilisation en production.

Pour plus de détails sur la configuration de projet par défaut et sur la manière de la restreindre, consultez [The Default Project](https://argo-cd.readthedocs.io/en/stable/user-guide/projects/#the-default-project) dans la documentation d'Argo CD.

## Création d’un projet
<a name="_create_a_project"></a>

Créez un projet en appliquant une `AppProject` ressource à votre cluster.

 **Exemple : Team-specific projet** 

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


  # Source namespaces (required for EKS capability)
  sourceNamespaces:
    - argocd
    - team-a-dev
    - team-a-prod

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

Appliquez le projet :

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

## Configuration du projet
<a name="_project_configuration"></a>

### Référentiels sources
<a name="_source_repositories"></a>

Contrôlez les référentiels Git que les applications de ce projet peuvent utiliser :

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

Vous pouvez utiliser des caractères génériques et des modèles de négation (`!`préfixe) pour autoriser ou refuser des référentiels spécifiques. Pour plus de détails, consultez [la section Gestion de projets](https://argo-cd.readthedocs.io/en/stable/user-guide/projects/#managing-projects) dans la documentation d'Argo CD.

### Espaces de noms sources
<a name="_source_namespaces"></a>

Lorsque vous utilisez la fonctionnalité EKS Argo CD, le `spec.sourceNamespaces` champ est **obligatoire** dans votre AppProject définition personnalisée. Ce champ indique quels espaces de noms peuvent contenir des applications ou ApplicationSets qui font référence à ce projet :

**Important**  
Ce champ est obligatoire pour la fonctionnalité EKS Argo CD, qui diffère du CD OSS Argo où ce champ est facultatif.

#### AppProject Comportement par défaut
<a name="_default_appproject_behavior"></a>

Inclut `default` AppProject automatiquement l'espace de `argocd` noms dans. `sourceNamespaces` Si vous devez créer des applications ou des espaces ApplicationSets de noms supplémentaires, modifiez le `sourceNamespaces` champ pour ajouter ces espaces de noms :

```
apiVersion: argoproj.io/v1alpha1
kind: AppProject
metadata:
  name: default
  namespace: argocd
spec:
  sourceNamespaces:
    - argocd           # Already included by default
    - team-a-apps      # Add additional namespaces as needed
    - team-b-apps
```

#### AppProject Configuration personnalisée
<a name="_custom_appproject_configuration"></a>

Lorsque vous créez un espace personnalisé AppProject, vous devez inclure manuellement l'espace de noms du `argocd` système et tous les autres espaces de noms dans lesquels vous prévoyez de créer des applications ou : ApplicationSets

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

  # Required: Manually specify all namespaces
  sourceNamespaces:
    - argocd           # ArgoCD system namespace (required)
    - team-a-dev       # Custom namespace for dev Applications
    - team-a-prod      # Custom namespace for prod Applications

  # 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  # Use cluster ARN from: aws eks describe-cluster
```

**Note**  
Si vous omettez un espace de noms`sourceNamespaces`, les applications ou celles ApplicationSets créées dans cet espace de noms ne pourront pas faire référence à ce projet, ce qui entraînera des échecs de déploiement.

### Restrictions de destination
<a name="_destination_restrictions"></a>

Limite dans laquelle les applications peuvent être déployées :

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

**Important**  
Utilisez des noms de cluster et des modèles d'espaces de noms spécifiques plutôt que des caractères génériques pour les projets de production. Cela permet d'éviter les déploiements accidentels vers des clusters ou des espaces de noms non autorisés.

Vous pouvez utiliser des caractères génériques et des modèles de négation pour contrôler les destinations. Pour plus de détails, consultez [la section Gestion de projets](https://argo-cd.readthedocs.io/en/stable/user-guide/projects/#managing-projects) dans la documentation d'Argo CD.

### Restrictions de ressources
<a name="_resource_restrictions"></a>

Contrôlez les types de ressources Kubernetes qui peuvent être déployés :

 **Cluster-scoped ressources** :

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

 **Namespace-scoped ressources** :

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

Utilisez des listes noires pour refuser des ressources spécifiques :

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

## Affecter des applications à des projets
<a name="_assign_applications_to_projects"></a>

Lors de la création d'une application, spécifiez le projet dans le `spec.project` champ :

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

Les applications sans projet spécifique utilisent le `default` projet.

## Rôles du projet et RBAC
<a name="_project_roles_and_rbac"></a>

Les projets peuvent définir des rôles personnalisés pour un contrôle d'accès précis. Associez les rôles du projet aux utilisateurs et aux groupes d' AWS Identity Center dans la configuration de vos fonctionnalités afin de contrôler qui peut synchroniser, mettre à jour ou supprimer des applications.

 **Exemple : projet avec rôles de développeur et d'administrateur** 

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

Pour plus de détails sur les rôles du projet, les jetons JWT pour les CI/CD pipelines et la configuration du RBAC, consultez la section [Rôles du projet](https://argo-cd.readthedocs.io/en/stable/user-guide/projects/#project-roles) dans la documentation d'Argo CD.

## Schémas courants
<a name="_common_patterns"></a>

### Environment-based Projets
<a name="_environment_based_projects"></a>

Créez des projets distincts pour chaque environnement :

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

### Team-based Projets
<a name="_team_based_projects"></a>

Isolez les équipes avec des projets dédiés :

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

### Multi-cluster Projets
<a name="_multi_cluster_projects"></a>

Déployez sur plusieurs clusters avec des politiques cohérentes :

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

## Bonnes pratiques
<a name="_best_practices"></a>

 **Commencez par des projets restrictifs** : commencez par des autorisations restreintes et étendez-les selon les besoins plutôt que de commencer par un accès étendu.

 **Utilisez des modèles d'espace de noms** : utilisez des caractères génériques dans les restrictions d'espace de noms (par exemple`team-a-*`) pour permettre de la flexibilité tout en maintenant les limites.

 **Projets de production distincts** : utilisez des projets dédiés pour la production avec des contrôles plus stricts et des politiques de synchronisation manuelle.

 **Documentez les objectifs du projet** : utilisez le `description` champ pour expliquer à quoi sert chaque projet et qui doit l'utiliser.

 **Vérifiez régulièrement les autorisations des projets : auditez régulièrement** les projets pour vous assurer que les restrictions correspondent toujours aux besoins de l'équipe et aux exigences de sécurité.

## Ressources supplémentaires
<a name="_additional_resources"></a>
+  [Configurer les autorisations d'Argo CD](argocd-permissions.md)- Configurer l'intégration du RBAC et de l'Identity Center
+  [Création d'applications](argocd-create-application.md)- Créez des applications dans des projets
+  [Utiliser ApplicationSets](argocd-applicationsets.md)- À utiliser ApplicationSets avec des projets pour des déploiements multi-clusters
+  [Documentation des projets Argo CD](https://argo-cd.readthedocs.io/en/stable/user-guide/projects/) - Référence complète en amont