**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 Projects
<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éer un projet
<a name="_create_a_project"></a>

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

 **Exemple : projet spécifique à une équipe** 

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

Appliquez le projet :

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

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

### Référentiels de 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.

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

 Ressources étendues au **cluster** :

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

 **Ressources limitées à l'espace de noms :**

```
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 Argo CD.

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

### Projets axés sur l'environnement
<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
```

### Projets basés sur le travail d'équipe
<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: '*'
```

### Projets multi-clusters
<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'espaces 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