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

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

Utilisez les projets pour :

Projet par défaut

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 dans la documentation d'Argo CD.

Créer un projet

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

Référentiels de sources

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 dans la documentation d'Argo CD.

Restrictions de destination

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

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 dans la documentation d'Argo CD.

Restrictions de ressources

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

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

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 dans la documentation Argo CD.

Schémas courants

Projets axés sur l'environnement

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

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

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

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