**Unterstützung für die Verbesserung dieser Seite beitragen** 

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Um zu diesem Benutzerhandbuch beizutragen, wählen Sie den GitHub Link **Diese Seite bearbeiten auf**, der sich im rechten Bereich jeder Seite befindet.

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Zusammenarbeit mit Argo CD Projects
<a name="argocd-projects"></a>

Argo CD Projects (AppProject) bieten logische Gruppierung und Zugriffskontrolle für Anwendungen. Projekte definieren, welche Git-Repositorys, Zielcluster und Namespaces Anwendungen verwenden können, wodurch Mehrmandantenfähigkeit und Sicherheitsgrenzen in gemeinsam genutzten Argo-CD-Instanzen aktiviert werden.

## Wann sollten Projekte verwendet werden
<a name="_when_to_use_projects"></a>

Verwenden Sie Projekte, um:
+ Trennen Sie Anwendungen nach Team, Umgebung oder Geschäftseinheit
+ Schränken Sie ein, aus welchen Repositorys Teams Anwendungen bereitstellen können
+ Beschränken Sie, in welchen Clustern und Namespaces Teams Deployment durchführen können
+ Setzen Sie Ressourcenkontingente und zulässige Ressourcentypen durch
+ Sorgen Sie für die Self-Service-Anwendungsbereitstellung mit Leitplanken

## Standardprojekt
<a name="_default_project"></a>

Jede Argo-CD-Funktion beinhaltet ein `default` Projekt, das den Zugriff auf alle Repositorys, Cluster und Namespaces ermöglicht. Das ist zwar für erste Tests nützlich, aber Sie können spezielle Projekte mit ausdrücklichen Einschränkungen für den produktiven Einsatz erstellen.

Einzelheiten zur Standard-Projektkonfiguration und wie man sie einschränkt, finden Sie unter [Das Standardprojekt](https://argo-cd.readthedocs.io/en/stable/user-guide/projects/#the-default-project) in der Argo-CD-Dokumentation.

## Erstellen eines Projekts
<a name="_create_a_project"></a>

Erstellen Sie ein Projekt, indem Sie eine `AppProject` Ressource auf Ihren Cluster anwenden.

 **Beispiel: Teamspezifisches Projekt** 

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

Wenden Sie das Projekt an:

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

## Konfiguration des Projekts
<a name="_project_configuration"></a>

### Quell-Repositorien
<a name="_source_repositories"></a>

Steuern Sie, welche Git-Repositorys Anwendungen in diesem Projekt verwenden können:

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

Du kannst Platzhalter und Negationsmuster (`!`Präfix) verwenden, um bestimmte Repositorys zuzulassen oder abzulehnen. Einzelheiten finden Sie unter [Projekte verwalten](https://argo-cd.readthedocs.io/en/stable/user-guide/projects/#managing-projects) in der Argo-CD-Dokumentation.

### Einschränkungen im Hinblick auf Ziele
<a name="_destination_restrictions"></a>

Schränken Sie ein, wo Anwendungen bereitgestellt werden können:

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

**Wichtig**  
Verwenden Sie für Produktionsprojekte spezifische Clusternamen und Namespace-Muster anstelle von Platzhaltern. Dies verhindert versehentliche Bereitstellungen in nicht autorisierten Clustern oder Namespaces.

Sie können Platzhalter und Negationsmuster verwenden, um Ziele zu steuern. Einzelheiten finden Sie unter [Projekte verwalten](https://argo-cd.readthedocs.io/en/stable/user-guide/projects/#managing-projects) in der Argo-CD-Dokumentation.

### Einschränkungen bei den Ressourcen
<a name="_resource_restrictions"></a>

Steuern Sie, welche Kubernetes-Ressourcentypen bereitgestellt werden können:

 Ressourcen im **Clusterbereich**:

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

 **Ressourcen im Namespace-Bereich**:

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

Verwenden Sie schwarze Listen, um bestimmte Ressourcen abzulehnen:

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

## Ordnen Sie Anwendungen Projekten zu
<a name="_assign_applications_to_projects"></a>

Wenn Sie eine Anwendung erstellen, geben Sie das Projekt im `spec.project` Feld an:

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

Anwendungen ohne ein bestimmtes Projekt verwenden das `default` Projekt.

## Projektrollen und RBAC
<a name="_project_roles_and_rbac"></a>

Projekte können benutzerdefinierte Rollen für eine differenzierte Zugriffskontrolle definieren. Ordnen Sie in Ihrer Funktionskonfiguration Projektrollen AWS Identity Center-Benutzern und -Gruppen zu, um zu kontrollieren, wer Anwendungen synchronisieren, aktualisieren oder löschen kann.

 **Beispiel: Projekt mit Entwickler- und Administratorrollen** 

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

Einzelheiten zu Projektrollen, JWT-Token für CI/CD Pipelines und der RBAC-Konfiguration finden Sie unter [Projektrollen](https://argo-cd.readthedocs.io/en/stable/user-guide/projects/#project-roles) in der Argo-CD-Dokumentation.

## Allgemeine Muster
<a name="_common_patterns"></a>

### Umweltbezogene Projekte
<a name="_environment_based_projects"></a>

Erstellen Sie separate Projekte für jede Umgebung:

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

### Teambasierte Projekte
<a name="_team_based_projects"></a>

Isolieren Sie Teams mit speziellen Projekten:

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

### Projekte mit mehreren Clustern
<a name="_multi_cluster_projects"></a>

Stellen Sie die Lösung auf mehreren Clustern mit konsistenten Richtlinien bereit:

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

## Best Practices
<a name="_best_practices"></a>

 **Beginnen Sie mit restriktiven Projekten**: Beginnen Sie mit engen Berechtigungen und erweitern Sie diese nach Bedarf, anstatt mit einem breiten Zugriff zu beginnen.

 **Verwenden Sie Namespace-Muster**: Nutzen Sie Platzhalter in Namespace-Einschränkungen (wie`team-a-*`), um Flexibilität zu gewährleisten und gleichzeitig die Grenzen beizubehalten.

 **Separate Produktionsprojekte**: Verwenden Sie spezielle Projekte für die Produktion mit strengeren Kontrollen und manuellen Synchronisierungsrichtlinien.

 **Projektzwecke dokumentieren**: Verwenden Sie das `description` Feld, um zu erklären, wofür jedes Projekt gedacht ist und wer es verwenden sollte.

 **Überprüfen Sie die Projektberechtigungen regelmäßig**: Prüfen Sie Projekte regelmäßig, um sicherzustellen, dass die Einschränkungen weiterhin den Teamanforderungen und Sicherheitsanforderungen entsprechen.

## Weitere Ressourcen
<a name="_additional_resources"></a>
+  [Argo-CD-Berechtigungen konfigurieren](argocd-permissions.md)- Konfigurieren Sie die Integration von RBAC und Identity Center
+  [Anwendungen erstellen](argocd-create-application.md)- Erstellen Sie Anwendungen innerhalb von Projekten
+  [Benutzen ApplicationSets](argocd-applicationsets.md)- Verwendung ApplicationSets mit Projekten für Bereitstellungen mit mehreren Clustern
+  [Dokumentation zu Argo CD Projects](https://argo-cd.readthedocs.io/en/stable/user-guide/projects/) — Vollständige Upstream-Referenz