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

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

Funcionamento dos ApplicationSets

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:

Para obter uma referência completa dos geradores, consulte a Documentação do ApplicationSet.

Gerador de listas

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

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

Gerador de cluster

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

Os geradores do Git criam Applications com base na estrutura do repositório:

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 na documentação do Argo CD.

Gerador de matriz

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 na documentação do Argo CD.

Implantação multirregião

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

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

Recursos adicionais