**Ajudar a melhorar esta página** 

Para contribuir com este guia de usuário, escolha o link **Editar esta página no GitHub**, disponível no painel direito de cada página.

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

Os ApplicationSets geram diversas Applications a partir de modelos, possibilitando a implantação da mesma aplicação em diversos clusters, ambientes ou namespaces com uma única definição de recurso.

## Pré-requisitos
<a name="_prerequisites"></a>
+ Um cluster de EKS com a funcionalidade para o Argo CD criada
+ Acesso ao repositório configurado (consulte [Configuração do acesso ao repositório](argocd-configure-repositories.md))
+  `kubectl` configurado para o estabelecimento de comunicação com o cluster

**nota**  
Não são necessários vários clusters de destino para ApplicationSets. É possível usar geradores diferentes do gerador de cluster (como geradores de lista, git ou matriz) para implantar aplicações sem clusters remotos.

## Funcionamento dos ApplicationSets
<a name="_how_applicationsets_work"></a>

Os ApplicationSets usam geradores para criar parâmetros e, em seguida, aplicá-los a um modelo de Application. Cada conjunto de parâmetros gerados cria uma Application.

Geradores mais usados em implantações do EKS:
+  **Gerador de listas**: define explicitamente clusters e parâmetros para cada ambiente
+  **Gerador de cluster**: realiza a implantação automática em todos os clusters registrados
+  **Gerador do Git**: gera Applications com base na estrutura do repositório
+  **Gerador de matriz**: combina geradores para implantações multidimensionais
+  **Mesclar gerador**: mescla parâmetros de vários geradores

Para obter uma referência completa dos geradores, consulte a [Documentação do ApplicationSet](https://argo-cd.readthedocs.io/en/stable/user-guide/application-set/).

## Gerador de listas
<a name="_list_generator"></a>

Realize uma implantação em vários clusters usando configuração explícita:

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

**nota**  
Use `destination.name` com nomes de cluster para melhor legibilidade. O campo `destination.server` também funciona com ARNs de cluster de EKS, se necessário.

Essa ação realiza a criação de três Applications: `guestbook-dev`, `guestbook-staging` e `guestbook-prod`.

## Gerador de cluster
<a name="_cluster_generator"></a>

Realize a implantação automática de todos os clusters registrados:

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

Essa ação cria automaticamente uma Application para cada cluster registrado.

 **Clusters de filtros**:

Use `matchLabels` para incluir clusters específicos ou `matchExpressions` para excluir clusters:

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

## Geradores do Git
<a name="_git_generators"></a>

Os geradores do Git criam Applications com base na estrutura do repositório:
+  **Gerador de diretório**: implanta cada diretório como uma Application separada (útil para microsserviços)
+  **Gerador de arquivo** gera Applications com base em arquivos de parâmetros (útil para implantações multilocatárias)

 **Exemplo: implantação de microsserviços** 

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

Para obter mais detalhes sobre os geradores do Git e a configuração baseada em arquivos, consulte [Git Generator](https://argo-cd.readthedocs.io/en/stable/operator-manual/applicationset/Generators-Git/) na documentação do Argo CD.

## Gerador de matriz
<a name="_matrix_generator"></a>

Use a combinação de vários geradores para realizar implantações em diversas dimensões (ambientes × clusters):

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

Para obter mais detalhes sobre como combinar geradores, consulte [Matrix Generator](https://argo-cd.readthedocs.io/en/stable/operator-manual/applicationset/Generators-Matrix/) na documentação do Argo CD.

## Implantação multirregião
<a name="_multi_region_deployment"></a>

Realize a implantação em clusters distribuídos por várias regiões:

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

## Gerenciamento de ApplicationSets
<a name="_manage_applicationsets"></a>

 **Visualize os ApplicationSets e as Applications geradas**:

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

 **Atualize um ApplicationSet**:

Modifique a especificação do ApplicationSet e a aplique novamente. O Argo CD atualiza automaticamente todas as Applications geradas:

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

 **Exclua um ApplicationSet**:

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

**Atenção**  
Ao excluir um ApplicationSet, todas as Applications geradas são apagadas. Se essas Applications tiverem `prune: true`, os recursos correspondentes também serão removidos dos clusters de destino.  
Para preservar os recursos implantados ao excluir um ApplicationSet, defina `.syncPolicy.preserveResourcesOnDeletion` como `true` na especificação do ApplicationSet. Para obter mais informações, consulte [Corte de aplicações e exclusão de recursos](https://argo-cd.readthedocs.io/en/stable/operator-manual/applicationset/Application-Deletion/) na documentação do Argo CD.

**Importante**  
O recurso ApplicationSets do Argo CD tem considerações de segurança que devem ser conhecidas antes de usar o ApplicationSets. Para obter mais informações, consulte [Segurança do ApplicationSet](https://argo-cd.readthedocs.io/en/stable/operator-manual/applicationset/Security/) na documentação do Argo CD.

## Recursos adicionais
<a name="_additional_resources"></a>
+  [Trabalho com o Argo CD Projects](argocd-projects.md): organize os ApplicationSets com Projects
+  [Criação de Applications](argocd-create-application.md): compreenda a configuração das Applications
+  [Documentação do ApplicationSet](https://argo-cd.readthedocs.io/en/stable/user-guide/application-set/): referência completa de geradores e seus padrões
+  [Referência de geradores](https://argo-cd.readthedocs.io/en/stable/operator-manual/applicationset/Generators/): especificações detalhadas dos geradores