**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.

# Benutzen ApplicationSets
<a name="argocd-applicationsets"></a>

ApplicationSets Generieren Sie mehrere Anwendungen anhand von Vorlagen, sodass Sie dieselbe Anwendung mit einer einzigen Ressourcendefinition in mehreren Clustern, Umgebungen oder Namespaces bereitstellen können.

## Voraussetzungen
<a name="_prerequisites"></a>
+ Es wurde ein EKS-Cluster mit der Argo-CD-Funktion erstellt
+ Der Repository-Zugriff ist konfiguriert (siehe[Repository-Zugriff konfigurieren](argocd-configure-repositories.md))
+  `kubectl`für die Kommunikation mit Ihrem Cluster konfiguriert

**Anmerkung**  
Für sind nicht mehrere Zielcluster erforderlich ApplicationSets. Sie können andere Generatoren als den Cluster-Generator (wie Listen-, Git- oder Matrix-Generatoren) verwenden, um Anwendungen ohne Remote-Cluster bereitzustellen.

## Wie ApplicationSets funktionieren
<a name="_how_applicationsets_work"></a>

ApplicationSets Verwenden Sie Generatoren, um Parameter zu erzeugen, und wenden Sie diese Parameter dann auf eine Anwendungsvorlage an. Jeder Satz generierter Parameter erstellt eine Anwendung.

Allgemeine Generatoren für EKS-Bereitstellungen:
+  **Listengenerator** — Definieren Sie explizit Cluster und Parameter für jede Umgebung
+  **Cluster-Generator** — Automatische Bereitstellung auf allen registrierten Clustern
+  **Git Generator - Generieren** Sie Anwendungen aus der Repository-Struktur
+  **Matrixgenerator** — Kombinieren Sie Generatoren für mehrdimensionale Bereitstellungen
+  **Generator zusammenführen** — Fügt Parameter aus mehreren Generatoren zusammen

Eine vollständige Generator-Referenz finden Sie in der [ApplicationSet Dokumentation](https://argo-cd.readthedocs.io/en/stable/user-guide/application-set/).

## Listengenerator
<a name="_list_generator"></a>

Bereitstellung auf mehreren Clustern mit expliziter Konfiguration:

```
apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
  name: guestbook-all-clusters
  namespace: argocd
spec:
  generators:
  - list:
      elements:
      - environment: dev
        replicas: "2"
      - environment: staging
        replicas: "3"
      - environment: prod
        replicas: "5"
  template:
    metadata:
      name: 'guestbook-{{environment}}'
    spec:
      project: default
      source:
        repoURL: https://github.com/example/guestbook
        targetRevision: HEAD
        path: 'overlays/{{environment}}'
      destination:
        name: '{{environment}}-cluster'
        namespace: guestbook
      syncPolicy:
        automated:
          prune: true
          selfHeal: true
```

**Anmerkung**  
Zur besseren Lesbarkeit `destination.name` zusammen mit Clusternamen verwenden. Das `destination.server` Feld funktioniert bei ARNs Bedarf auch mit EKS-Clustern.

Dadurch werden drei Anwendungen erstellt: `guestbook-dev``guestbook-staging`, und`guestbook-prod`.

## Clustergenerator
<a name="_cluster_generator"></a>

Automatisch auf allen registrierten Clustern bereitstellen:

```
apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
  name: cluster-addons
  namespace: argocd
spec:
  generators:
  - clusters: {}
  template:
    metadata:
      name: '{{name}}-addons'
    spec:
      project: default
      source:
        repoURL: https://github.com/example/cluster-addons
        targetRevision: HEAD
        path: addons
      destination:
        server: '{{server}}'
        namespace: kube-system
      syncPolicy:
        automated:
          prune: true
          selfHeal: true
```

Dadurch wird automatisch eine Anwendung für jeden registrierten Cluster erstellt.

 **Cluster filtern**:

Wird verwendet`matchLabels`, um bestimmte Cluster einzubeziehen oder `matchExpressions` um Cluster auszuschließen:

```
spec:
  generators:
  - clusters:
      selector:
        matchLabels:
          environment: production
        matchExpressions:
        - key: skip-appset
          operator: DoesNotExist
```

## Git-Generatoren
<a name="_git_generators"></a>

Git-Generatoren erstellen Anwendungen, die auf der Repository-Struktur basieren:
+  **Verzeichnisgenerator** — Stellen Sie jedes Verzeichnis als separate Anwendung bereit (nützlich für Microservices)
+  **Dateigenerator — Generieren** Sie Anwendungen aus Parameterdateien (nützlich für Bereitstellungen mit mehreren Mandanten)

 **Beispiel: Bereitstellung von Microservices** 

```
apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
  name: microservices
  namespace: argocd
spec:
  generators:
  - git:
      repoURL: https://github.com/example/microservices
      revision: HEAD
      directories:
      - path: services/*
  template:
    metadata:
      name: '{{path.basename}}'
    spec:
      project: default
      source:
        repoURL: https://github.com/example/microservices
        targetRevision: HEAD
        path: '{{path}}'
      destination:
        name: my-cluster
        namespace: '{{path.basename}}'
      syncPolicy:
        automated:
          prune: true
          selfHeal: true
        syncOptions:
        - CreateNamespace=true
```

Einzelheiten zu Git-Generatoren und dateibasierter Konfiguration finden Sie unter [Git Generator](https://argo-cd.readthedocs.io/en/stable/operator-manual/applicationset/Generators-Git/) in der Argo-CD-Dokumentation.

## Matrixgenerator
<a name="_matrix_generator"></a>

Kombinieren Sie mehrere Generatoren, um sie in mehreren Dimensionen (Umgebungen × Cluster) einzusetzen:

```
apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
  name: multi-env-multi-cluster
  namespace: argocd
spec:
  generators:
  - matrix:
      generators:
      - list:
          elements:
          - environment: dev
          - environment: staging
          - environment: prod
      - clusters:
          selector:
            matchLabels:
              region: us-west-2
  template:
    metadata:
      name: 'app-{{environment}}-{{name}}'
    spec:
      project: default
      source:
        repoURL: https://github.com/example/app
        targetRevision: HEAD
        path: 'overlays/{{environment}}'
      destination:
        name: '{{name}}'
        namespace: 'app-{{environment}}'
```

Einzelheiten zur Kombination von Generatoren finden Sie unter [Matrix Generator](https://argo-cd.readthedocs.io/en/stable/operator-manual/applicationset/Generators-Matrix/) in der Argo-CD-Dokumentation.

## Einsatz in mehreren Regionen
<a name="_multi_region_deployment"></a>

Bereitstellung auf Clustern in mehreren Regionen:

```
apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
  name: global-app
  namespace: argocd
spec:
  generators:
  - list:
      elements:
      - clusterName: prod-us-west
        region: us-west-2
      - clusterName: prod-us-east
        region: us-east-1
      - clusterName: prod-eu-west
        region: eu-west-1
  template:
    metadata:
      name: 'app-{{region}}'
    spec:
      project: default
      source:
        repoURL: https://github.com/example/app
        targetRevision: HEAD
        path: kubernetes
        helm:
          parameters:
          - name: region
            value: '{{region}}'
      destination:
        name: '{{clusterName}}'
        namespace: app
      syncPolicy:
        automated:
          prune: true
          selfHeal: true
```

## Verwalten ApplicationSets
<a name="_manage_applicationsets"></a>

 **Anwendungen anzeigen ApplicationSets und generieren**:

```
kubectl get applicationsets -n argocd
kubectl get applications -n argocd -l argocd.argoproj.io/application-set-name=<applicationset-name>
```

 **Aktualisieren und ApplicationSet**:

Ändern Sie die ApplicationSet Spezifikation und wenden Sie sie erneut an. Argo CD aktualisiert automatisch alle generierten Anwendungen:

```
kubectl apply -f applicationset.yaml
```

 **Löschen Sie und ApplicationSet**:

```
kubectl delete applicationset <name> -n argocd
```

**Warnung**  
Beim Löschen und ApplicationSet Löschen aller generierten Anwendungen werden alle generierten Anwendungen gelöscht. Wenn dies bei diesen Anwendungen der Fall ist`prune: true`, werden ihre Ressourcen ebenfalls aus den Zielclustern gelöscht.  
Um bereitgestellte Ressourcen beim Löschen eines `.syncPolicy.preserveResourcesOnDeletion` zu erhalten ApplicationSet, ist `true` in der ApplicationSet Spezifikation auf festgelegt. Weitere Informationen finden Sie unter [Anwendungsbereinigung und Löschen von Ressourcen](https://argo-cd.readthedocs.io/en/stable/operator-manual/applicationset/Application-Deletion/) in der Argo-CD-Dokumentation.

**Wichtig**  
Die ApplicationSets Funktion von Argo CD beinhaltet Sicherheitsaspekte, die Sie vor der Verwendung beachten sollten. ApplicationSets Weitere Informationen finden Sie in der Argo-CD-Dokumentation unter [ApplicationSet Sicherheit](https://argo-cd.readthedocs.io/en/stable/operator-manual/applicationset/Security/).

## Weitere Ressourcen
<a name="_additional_resources"></a>
+  [Zusammenarbeit mit Argo CD Projects](argocd-projects.md)- Organisieren Sie ApplicationSets mit Projekten
+  [Anwendungen erstellen](argocd-create-application.md)- Verstehen Sie die Anwendungskonfiguration
+  [ApplicationSet Dokumentation](https://argo-cd.readthedocs.io/en/stable/user-guide/application-set/) — Vollständige Generatorreferenz und Muster
+  [Generator-Referenz](https://argo-cd.readthedocs.io/en/stable/operator-manual/applicationset/Generators/) — Detaillierte Generatorspezifikationen