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 les projets

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éation d’un projet

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

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

Espaces de noms sources

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 :

AppProject Comportement par défaut

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

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

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 :

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

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

Schémas courants

Environment-based Projets

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

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

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