**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:
+ Separate Anwendungen nach Team, Umgebung oder Geschäftseinheit
+ Beschränken Sie, 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 zu deren Einschränkung 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'


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

Das Projekt anwenden:

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

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

### Quell-Repositorys
<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.

### Quell-Namespaces
<a name="_source_namespaces"></a>

Wenn Sie die EKS Argo CD-Funktion verwenden, ist das `spec.sourceNamespaces` Feld in Ihrer benutzerdefinierten **Definition erforderlich**. AppProject Dieses Feld gibt an, welche Namespaces Anwendungen enthalten können oder die auf ApplicationSets dieses Projekt verweisen:

**Wichtig**  
Dies ist ein Pflichtfeld für die EKS Argo CD-Funktion, die sich von OSS Argo CD unterscheidet, wo dieses Feld optional ist.

#### Standardverhalten AppProject
<a name="_default_appproject_behavior"></a>

Das schließt den `argocd` Namespace `default` AppProject automatisch ein. `sourceNamespaces` Wenn Sie Anwendungen oder ApplicationSets in zusätzlichen Namespaces erstellen müssen, ändern Sie das `sourceNamespaces` Feld, um diese Namespaces hinzuzufügen:

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

#### Benutzerdefinierte Konfiguration AppProject
<a name="_custom_appproject_configuration"></a>

Wenn Sie eine benutzerdefinierte Datei erstellen AppProject, müssen Sie den `argocd` System-Namespace und alle anderen Namespaces, in denen Sie Anwendungen erstellen möchten, manuell einbeziehen oder: 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: https://kubernetes.default.svc
```

**Anmerkung**  
Wenn Sie einen Namespace auslassen, können Anwendungen`sourceNamespaces`, die in diesem Namespace ApplicationSets erstellt wurden, nicht auf dieses Projekt verweisen, was zu Bereitstellungsfehlern führt.

### Einschränkungen für das Ziel
<a name="_destination_restrictions"></a>

Beschränken Sie, 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 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>

Geben Sie beim Erstellen einer Anwendung 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 detaillierte 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 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>

Bereitstellung auf mehreren Clustern mit konsistenten Richtlinien:

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