Implementando GitOps usando Argo CD

Tutoriais
Git Kubernetes

Introdução

O Argo CD é uma implementação de código aberto popular para realizar entrega contínua GitOps no topo do Kubernetes. Suas aplicações, definições, configurações e ambientes devem ser declarativos e controlados por versão. Além disso, a implantação da aplicação e o gerenciamento do ciclo de vida devem ser automatizados, auditáveis e fáceis de entender. Tudo isso pode ser feito usando o Argo.

O Argo CD adere aos mesmos padrões e princípios do GitOps, mantendo assim o estado do seu cluster usando uma abordagem declarativa. A sincronização ocorre através de um repositório Git, onde seus manifestos Kubernetes estão armazenados. Os manifestos Kubernetes podem ser especificados de várias maneiras:

Como acontece com cada aplicativo que é executado em um cluster Kubernetes, o Argo CD é configurado por meio de definições de recursos personalizados (CRDs) armazenadas em manifestos YAML. O mais importante é o CRD Application. Em um aplicativo Argo CD, você define qual repositório Git deve ser usado para sincronizar com qual cluster Kubernetes. Pode ser o mesmo cluster Kubernetes onde o Argo CD está implantado, ou um externo.

O Argo CD é implementado como um Controlador Kubernetes que monitora continuamente aplicativos em execução e compara o estado atual (ou ao vivo) com o estado alvo desejado (como especificado no repositório Git). Um aplicativo implantado cujo estado ao vivo se desvia do estado alvo é considerado Fora de Sincronia. O Argo CD relata e visualiza as diferenças, ao mesmo tempo que fornece facilidades para sincronizar automaticamente ou manualmente o estado ao vivo de volta ao estado alvo desejado.

O Argo CD oferece muitos recursos, sendo os mais notáveis:

  • Suporte para várias ferramentas de gerenciamento/configuração, como: Kustomize, Helm, Ksonnet, Jsonnet, plain-YAML.
  • Capacidade de gerenciar e implantar em vários clusters.
  • Integração SSO (OIDC, OAuth2, LDAP, SAML 2.0, GitHub, GitLab, Microsoft, LinkedIn).
  • Multilocação e políticas de RBAC para autorização.
  • Análise do status de saúde dos recursos do aplicativo.
  • Reverter/Recolocar em qualquer lugar qualquer configuração de aplicativo cometida no repositório Git.
  • Deteção automatizada de deriva de configuração e visualização.
  • Interface de usuário da Web que fornece uma visualização em tempo real da atividade do aplicativo.
  • CLI para automação e integração de CI.
  • Integração de Webhook (GitHub, BitBucket, GitLab).
  • Gancho PreSync, Sync, PostSync para suportar implantações complexas de aplicativos (por exemplo, atualizações de azul/verde e canário).
  • Métricas do Prometheus.

Neste tutorial, você aprenderá a:

  • Usar Helm para provisionar Argo CD para o seu cluster DOKS.
  • Manter o estado das aplicações do seu cluster Kubernetes sincronizado com um repositório Git (usar princípios de GitOps).
  • Implantar e gerenciar aplicações via Argo CD.

Após concluir todos os passos deste tutorial, você deverá ter um cluster DOKS com Argo CD implantado, que irá:

DOKS e Argo CD para Visão Geral de Lançamentos do Helm

Abaixo está o diagrama que mostra como o Argo CD gerencia aplicações do Helm hospedadas usando um repositório Git:

Índice

Pré-requisitos

Para completar este tutorial, você precisará:

  1. A working DOKS cluster that you have access to. Please follow the Starter Kit DOKS Setup Guide to find out more.to find out more.
  2. A GitHub repository and branch, to store Argo CD and your applications manifests. Must be created beforehand.
  3. A Git client, for cloning the Starter Kit repository.
  4. A CLI do Kubectl, para interação com o Kubernetes. Siga estas instruções para se conectar ao seu cluster com kubectl e doctl.
  5. A CLI do Argo, para interagir com o Argo CD usando a interface de linha de comando.
  6. O Kubeseal, para criptografar segredos e interação com o Sealed Secrets Controller.
  7. O Helm, para gerenciar lançamentos e atualizações do Argo CD (opcional, mas recomendado em geral para sistemas de produção).

Compreendendo os Conceitos do Argo CD para Implantação de Aplicativos

O Argo CD está usando o conceito central de Aplicação para gerenciar implantações de aplicações e ciclo de vida. Dentro de um manifesto de aplicação do Argo CD, você define o repositório Git que hospeda as definições da sua aplicação, assim como o cluster Kubernetes correspondente para implantar as aplicações. Em outras palavras, uma aplicação do Argo CD define a relação entre um repositório de origem e um cluster Kubernetes. É um design muito conciso e escalável, onde você pode associar múltiplas fontes (repositórios Git) e clusters Kubernetes correspondentes.

A major benefit of using applications is that you don’t need to deploy Argo to each cluster individually. You can use a dedicated cluster for Argo, and deploy applications to all clusters at once from a single place. This way, you avoid Argo CD downtime or loss, in case other environments have issues or get decommissioned.

Além disso, você pode agrupar aplicações similares em um Projeto. Projetos permitem agrupamento lógico de aplicações e papéis/permisões associados, ao trabalhar com múltiplas equipes. Quando não especificado, cada nova aplicação pertence ao projeto default. O projeto default é criado automaticamente e não tem restrições. O projeto padrão pode ser modificado, mas não deletado.

Kit Inicial está usando o projeto default para um rápido salto inicial usando o Argo CD. Em seguida, você aprenderá como criar uma Aplicação para cada componente do Kit Inicial e usar gráficos Helm como a fonte da aplicação. O Argo CD não está limitado apenas a fontes Helm, e você também pode aproveitar o poder do Kustomize, Ksonnet, Jsonnet, etc. Por favor, dê uma olhada na página de fontes de aplicação para mais detalhes.

Embora você possa usar a interface gráfica de usuário (interface web) do Argo CD para criar aplicativos, o Kit Inicial depende do modo declarativo GitOps, via manifestos YAML. Cada configuração YAML age como uma receita para cada aplicativo, portanto, pode ser armazenada em um repositório Git. Isso significa que você sempre pode recriar sua configuração Argo CD se recriar seu ambiente ou mover para outro cluster. Mais importante ainda, você pode realizar auditorias e rastrear cada mudança através do histórico do Git. É uma prática recomendada também ter os arquivos de configuração do Argo CD em um repositório Git separado do usado para o desenvolvimento de sua aplicação. Você pode ler a página de práticas recomendadas no site de documentação oficial do Argo CD para mais informações sobre o tópico.

Nota importante:
Um aspecto importante a ter em mente é que por padrão o Argo CD não sincroniza automaticamente suas novas aplicações. Quando uma Aplicação ArgoCD é criada pela primeira vez, seu estado é Fora de Sincronia. Isso significa que o estado do repositório Git apontado pela Aplicação ArgoCD não corresponde ao estado do cluster Kubernetes. Criar uma nova Aplicação ArgoCD não dispara uma implantação automática no cluster de destino.

Para habilitar a sincronização automática e exclusão de recursos órfãos (poda), você precisa criar uma política de sincronização. Você também pode configurar o Argo CD para reverter automaticamente alterações manuais feitas via kubectl. Você pode ler mais sobre as políticas de sincronização automática no site oficial da documentação.

Um CRD de Aplicação típico usando uma fonte de repositório Git se parece com o abaixo:

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: my-apps
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://github.com/myrepo/my-apps.git
    targetRevision: HEAD
    path: apps
  destination:
    server: https://kubernetes.default.svc
    namespace: my-apps
  syncPolicy:
    automated:
      prune: true
      selfHeal: true

Explicações para a configuração acima:

  • spec.project: Informa ao Argo CD qual projeto usar para a aplicação (default neste exemplo).
  • spec.source.repoURL: URL do repositório Git usado para sincronizar o estado do cluster.
  • spec.source.targetRevision: Revisão do repositório Git usada para sincronização (também pode ser um nome de branch ou tag).
  • spec.source.path: Caminho do repositório Git onde os arquivos de origem (manifestos YAML) estão armazenados.
  • spec.destination.server: Endereço do cluster Kubernetes de destino. Normalmente aponta para https://kubernetes.default.svc, se o Argo CD estiver usando o mesmo cluster onde está implantado.
  • spec.destination.namespace: Namespace Kubernetes a ser usada para sua aplicação.
  • spec.syncPolicy.automated: Ativa a sincronização automatizada de aplicações em seu cluster com um repositório Git.
  • spec.syncPolicy.automated.prune: Prune especifica se deve excluir recursos do cluster que não são mais encontrados nas fontes como parte da sincronização automatizada.
  • spec.syncPolicy.automated.selfHeal: Especifica se deve reverter recursos para seu estado desejado após modificação manual no cluster (por exemplo, via kubectl).

Você também pode usar repositórios Helm como uma fonte para instalar aplicações em seu cluster. Um CRD de Aplicação típico usando uma fonte de repositório Helm, se parece com o exemplo abaixo (semelhante ao exemplo de repositório Git, exceto que um repositório de gráficos Helm é usado em vez disso):

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: sealed-secrets
  namespace: argocd
spec:
  project: default
  source:
    chart: sealed-secrets
    repoURL: https://bitnami-labs.github.io/sealed-secrets
    targetRevision: 2.4.0
    helm:
      releaseName: sealed-secrets
      values: |
        replicaCount: 2
  destination:
    server: "https://kubernetes.default.svc"
    namespace: kubeseal

Explicações para a configuração acima:

  • spec.source.chart: Gráfico Helm a ser usado como fonte para a aplicação.
  • spec.source.repoURL: URL do repositório de gráficos Helm.
  • spec.source.targetRevision: Versão do gráfico Helm a ser usada para a aplicação.
  • spec.source.helm.releaseName: Nome do release Helm a ser criado em seu cluster Kubernetes.
  • spec.source.helm.values: Especifica os valores Helm a serem passados para o modelo do helm, geralmente definido como um bloco.
  • spec.destination.server: Endereço do cluster Kubernetes de destino. Normalmente aponta para https://kubernetes.default.svc, se o Argo CD estiver usando o mesmo cluster onde está implantado.
  • spec.destination.namespace: Namespace do Kubernetes a ser usado para a sua aplicação.

Por favor, continue lendo mais sobre os conceitos principais do Argo CD no site oficial da documentação. Em seguida, você irá descobrir as opções de instalação disponíveis para implantar o Argo CD no seu cluster Kubernetes.

Instalando o Argo CD

O Argo CD pode ser instalado usando kubectl ou Helm:

  1. Usando kubectl e um arquivo de manifesto de instalação. Este método não oferece controle direto para vários parâmetros de instalação. Se você não estiver muito familiarizado com instalações baseadas em Helm, esta é a opção mais direta para começar.
  2. Instalação baseada em Helm. Oferece controle mais granular para o deployment e ciclo de vida da aplicação Argo CD. Recomendado para configurações de Alta Disponibilidade (HA) e se o Argo CD for usado em produção.

Em seguida, dependendo das funcionalidades que deseja disponíveis, você tem duas opções:

  • Modo Multi-Tenant. Este tipo de instalação é tipicamente usado para atender a várias equipes de desenvolvimento de aplicativos na organização e é mantido por uma equipe de plataforma. Os usuários finais podem acessar o Argo CD via servidor de API usando a interface Web ou CLI do argocd.
  • Modo apenas Núcleo. Esta é uma instalação simplificada, sem a interface gráfica do usuário, servidor de API, SSO, etc., e instala a versão leve (não-HA) de cada componente.

O Starter Kit está utilizando os modos Multi-Tenant e Alta Disponibilidade para instalar o Argo CD no seu cluster DOKS. Dessa forma, você terá uma configuração confiável e poderá explorar todos os recursos disponíveis, incluindo a interface do usuário. Por favor, visite a página de documentação de métodos de instalação para mais informações sobre o assunto.

Instalação Baseada em Kubectl

Este método requer kubectl, e é um processo de dois passos:

  1. Crie um namespace para implantar o próprio Argo CD.
  2. Execute o manifesto de instalação de HA, via kubectl.

Por favor, execute os comandos abaixo na ordem indicada:

kubectl create namespace argocd
kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/ha/install.yaml

Agora, por favor, verifique se a instalação foi bem-sucedida. Primeiro, verifique se todas as implantações do Argo CD estão saudáveis:

kubectl get deployments -n argocd

A saída se parece com (verifique a coluna READY – todos os Pods devem estar em execução):

Output
NAME                               READY   UP-TO-DATE   AVAILABLE   AGE
argocd-applicationset-controller   1/1     1            1           51s
argocd-dex-server                  1/1     1            1           50s
argocd-notifications-controller    1/1     1            1           50s
argocd-redis-ha-haproxy            3/3     3            3           50s
argocd-repo-server                 2/2     2            2           49s
argocd-server                      2/2     2            2           49s

O servidor Argo CD deve ter um valor mínimo de replicaset de 2 para o modo HA. Se, por algum motivo, algumas implantações não estiverem saudáveis, verifique os eventos do Kubernetes e os logs dos Pods do componente afetado.

Instalação Baseada em Helm

Este método requer que o Helm esteja instalado em sua máquina local. O Starter Kit fornece um arquivo de valores do Helm pronto para uso para começar e instala o Argo CD no modo HA (sem escalonamento automático).

Por favor, siga os passos abaixo para concluir a instalação baseada em Helm:

  1. Primeiro, clone o diretório do Starter Kit (se ainda não o fez) e mude o diretório para sua cópia local:
git clone https://github.com/digitalocean/Kubernetes-Starter-Kit-Developers.git
cd Kubernetes-Starter-Kit-Developers
  1. Em seguida, adicione o repositório Helm do Argo CD:
helm repo add argo https://argoproj.github.io/argo-helm
helm repo update argo
  1. Agora, pesquise o repositório Helm do argo para ver os gráficos disponíveis para instalação:
helm search repo argo

O resultado se parece com:

Output
NAME                            CHART VERSION   APP VERSION     DESCRIPTION 
argo/argo                       1.0.0           v2.12.5         A Helm chart for Argo Workflows  
argo/argo-cd                    4.9.4           v2.4.0          A Helm chart for Argo CD, a declarative, GitOps...
...
  1. Depois, abra e inspecione o arquivo de valores do Helm do Argo CD fornecido no repositório do Starter Kit usando um editor de sua escolha (preferencialmente com suporte para lint YAML). Por exemplo, você pode usar o VS Code:
code 14-continuous-delivery-using-gitops/assets/manifests/argocd/argocd-values-v4.9.4.yaml
  1. Por fim, implante o Argo CD em seu cluster DOKS:
HELM_CHART_VERSION="4.9.4"
helm install argocd argo/argo-cd --version "${HELM_CHART_VERSION}" \
  --namespace argocd \
  --create-namespace \
  -f "14-continuous-delivery-using-gitops/assets/manifests/argocd/argocd-values-v${HELM_CHART_VERSION}.yaml"

–create-namespace \

Nota:
Uma versão específica do gráfico Helm é usada. Neste caso, é selecionada a versão 4.9.4, que corresponde à versão 2.4.0 do aplicativo. É uma boa prática, em geral, travar em uma versão específica. Isso ajuda a ter resultados previsíveis e permite o controle de versionamento via Git.

helm ls -n argocd

Agora, verifique se o lançamento do Helm foi bem-sucedido:

NAME    NAMESPACE       REVISION        UPDATED                                 STATUS          CHART           APP VERSION
argocd  argocd          1               2022-03-23 11:22:48.486199 +0200 EET    deployed        argo-cd-4.9.4   v2.4.0

A saída parece semelhante a (o valor da coluna STATUS deve ser definido como deployed):

kubectl get deployments -n argocd

Finalmente, verifique o status de implantação da aplicação Argo CD:

Output
NAME                               READY   UP-TO-DATE   AVAILABLE   AGE
argocd-applicationset-controller   1/1     1            1           2m9s
argocd-dex-server                  1/1     1            1           2m9s
argocd-notifications-controller    1/1     1            1           2m9s
argocd-redis-ha-haproxy            3/3     3            3           2m9s
argocd-repo-server                 2/2     2            2           2m9s
argocd-server                      2/2     2            2           2m9s

A saída parece semelhante a (verifique a coluna READY – todos os Pods devem estar em execução):

O servidor Argo CD deve ter um valor mínimo de replicaset de 2 para o modo HA. Se, por algum motivo, algumas implantações não estiverem saudáveis, verifique os eventos do Kubernetes e os logs dos Pods do componente afetado.

Você também pode encontrar mais informações sobre o gráfico Helm do Argo CD acessando o repositório mantido pela comunidade.

Em seguida, você vai aprender como acessar e explorar os principais recursos da interface de usuário gráfica fornecida pelo Argo CD.

Acessando e Explorando a Interface Web do Argo CD

Uma das características interessantes que o Argo CD oferece é a interface web, utilizada para realizar várias tarefas administrativas e visualizar o estado de implantação da aplicação. Você pode criar aplicações usando a interface gráfica do usuário e interagir com o Argo CD de várias maneiras. Outra característica importante é a capacidade de inspecionar o estado de cada aplicação e acessar eventos do Kubernetes, bem como os logs da sua aplicação. Além disso, o Argo CD fornece uma representação visual de todos os objetos do Kubernetes (replicasets, pods, etc.) que cada implantação de aplicação está usando.

kubectl port-forward svc/argocd-server -n argocd 8080:443

A interface web pode ser acessada por meio do encaminhamento de porta do serviço Kubernetes argocd-server. Por favor, execute o comando abaixo em um terminal de shell:

kubectl -n argocd get secret argocd-initial-admin-secret -o jsonpath="{.data.password}" | base64 -d; echo

Agora, abra um navegador da web e navegue até localhost:8080 (por favor, ignore os certificados TLS inválidos por enquanto). Você será recebido com a página de login do Argo CD. O nome de usuário do administrador padrão é admin, e a senha é gerada aleatoriamente no momento da instalação. Você pode obtê-la executando o comando abaixo:

Em seguida, você será redirecionado para a página do painel de aplicações. A partir daqui, você pode visualizar, criar ou gerenciar aplicações via interface do usuário (um editor YAML também está disponível), bem como realizar operações de sincronização ou atualização:

Se você clicar em qualquer bloco de aplicação, uma representação visual de todos os objetos envolvidos também é mostrada:

Na próxima seção, você pode gerenciar seus projetos de aplicação, repositórios e clusters:

Por fim, a seção de informações do usuário mostra os usuários disponíveis e permite atualizações de senha do administrador:

Você pode brincar e explorar cada seção e subseção detalhadamente para ver todos os recursos disponíveis. Em seguida, você aprenderá como usar a contraparte de CLI, chamada argocd.

Conhecendo o CLI do Argo CD

argocd
Usage:
  argocd [flags]
  argocd [command]

Available Commands:
  account     Manage account settings
  admin       Contains a set of commands useful for Argo CD administrators and requires direct Kubernetes access
  app         Manage applications
  cert        Manage repository certificates and SSH known hosts entries
  cluster     Manage cluster credentials
  completion  output shell completion code for the specified shell (bash or zsh)
  context     Switch between contexts
  gpg         Manage GPG keys used for signature verification
  help        Help about any command
...

O Argo CD permite que o mesmo conjunto de recursos seja utilizado tanto via interface web quanto via CLI. Para usar o CLI argocd, você precisa abrir uma janela de terminal separada e simplesmente digitar argocd sem nenhum argumento. Por padrão, ele exibirá os comandos e opções disponíveis:

argocd app --help

Para qualquer comando ou subcomando, você pode invocar a página de ajuda correspondente usando o seguinte padrão: argocd <comando/subcomando> --help. Por exemplo, se você quiser verificar quais opções estão disponíveis para o comando app:

Manage Applications
Usage:
  argocd app [flags]
  argocd app [command]

Examples:
  A saída se parece com:
  argocd app list
  
  # Listar todas as aplicações.
  argocd app get my-app
...

# Obter os detalhes de uma aplicação

Por favor, prossiga e explore outros comandos/subcomandos também para ver todas as opções disponíveis. Em seguida, você aprenderá como inicializar sua primeira aplicação Argo CD, que implantará automaticamente todos os componentes do Starter Kit.

Inicializando Aplicativos Argo CD

Em uma instalação nova, o Argo CD não sabe de onde sincronizar seus aplicativos, nem quais repositórios Git estão disponíveis para obter manifestos de aplicativos. Portanto, o primeiro passo é realizar uma operação única chamada inicialização. Você pode executar todas as operações apresentadas nesta seção usando tanto a CLI do argocd quanto a interface gráfica do usuário.

Há várias maneiras de inicializar seu cluster (por exemplo, via scripts), mas geralmente, os usuários do Argo CD fazem uso do padrão aplicativo de aplicativos. Isso significa que você começará criando um aplicativo pai usando a CLI argocd (ou a interface web), que por sua vez fará referência e inicializará o restante dos aplicativos em seu cluster Kubernetes.

Preparando o Layout do Repositório Git

clusters
└── dev
    └── helm
        ├── cert-manager-v1.8.0.yaml
        ├── nginx-v4.1.3.yaml
        ├── prometheus-stack-v35.5.1.yaml
        ├── sealed-secrets-v2.4.0.yaml
        └── velero-v2.29.7.yaml

Primeiro, você precisa preparar seu repositório Git para usar um layout consistente. No exemplo a seguir, você criará uma estrutura de layout de repositório Git semelhante a:

  1. Por favor, abra um terminal e siga as etapas abaixo para criar o layout para seu repositório Git:
git clone <YOUR_ARGOCD_GIT_REPOSITORY_ADDRESS>
  1. Primeiro, clone o seu repositório git usado para testar o Argo CD (certifique-se de substituir os espaços reservados <> conforme necessário):
cd <YOUR_GIT_REPO_LOCAL_COPY_DIRECTORY>
mkdir -p clusters/dev/helm
  1. Em seguida, mude para o diretório da sua cópia local e crie a estrutura de diretórios (certifique-se de substituir os espaços reservados <> conforme necessário):
CERT_MANAGER_CHART_VERSION="1.8.0"
NGINX_CHART_VERSION="4.1.3"
PROMETHEUS_CHART_VERSION="35.5.1"
SEALED_SECRETS_CHART_VERSION="2.4.0"
VELERO_CHART_VERSION="2.29.7"

curl "https://raw.githubusercontent.com/digitalocean/Kubernetes-Starter-Kit-Developers/main/14-continuous-delivery-using-gitops/assets/manifests/argocd/applications/helm/cert-manager-v${CERT_MANAGER_CHART_VERSION}.yaml" > "clusters/dev/helm/cert-manager-v${CERT_MANAGER_CHART_VERSION}.yaml"

curl "https://raw.githubusercontent.com/digitalocean/Kubernetes-Starter-Kit-Developers/main/14-continuous-delivery-using-gitops/assets/manifests/argocd/applications/helm/nginx-v${NGINX_CHART_VERSION}.yaml" > "clusters/dev/helm/nginx-v${NGINX_CHART_VERSION}.yaml"

curl "https://raw.githubusercontent.com/digitalocean/Kubernetes-Starter-Kit-Developers/main/14-continuous-delivery-using-gitops/assets/manifests/argocd/applications/helm/prometheus-stack-v${PROMETHEUS_CHART_VERSION}.yaml" > "clusters/dev/helm/prometheus-stack-v${PROMETHEUS_CHART_VERSION}.yaml"

curl "https://raw.githubusercontent.com/digitalocean/Kubernetes-Starter-Kit-Developers/main/14-continuous-delivery-using-gitops/assets/manifests/argocd/applications/helm/sealed-secrets-v${SEALED_SECRETS_CHART_VERSION}.yaml" > "clusters/dev/helm/sealed-secrets-v${SEALED_SECRETS_CHART_VERSION}.yaml"

curl "https://raw.githubusercontent.com/digitalocean/Kubernetes-Starter-Kit-Developers/main/14-continuous-delivery-using-gitops/assets/manifests/argocd/applications/helm/velero-v${VELERO_CHART_VERSION}.yaml" > "clusters/dev/helm/velero-v${VELERO_CHART_VERSION}.yaml"
  1. Copie os manifestos de aplicativos fornecidos para cada componente no repositório do Starter Kit (você também pode dar uma olhada e ver como cada manifesto está estruturado):

Finalmente, faça commit das alterações e envie para a origem.

Em seguida, você irá criar o deployment da aplicação pai e permitir que o Argo CD sincronize automaticamente todos os aplicativos do Starter Kit para o seu cluster DOKS.

Usando o Padrão de App of Apps via CLI do Argo CD

Nesta seção, você aprenderá como usar a CLI do argocd para criar e utilizar o padrão app of apps para implantar todos os componentes do Starter Kit no seu cluster DOKS. A imagem abaixo ilustra o conceito principal:

kubectl port-forward svc/argocd-server -n argocd 8080:443

Primeiro, você precisa encaminhar a porta do servidor principal do Argo CD na sua máquina local em uma janela de terminal separada:

ADMIN_USER="admin"
ADMIN_PASSWD="$(kubectl -n argocd get secret argocd-initial-admin-secret -o jsonpath="{.data.password}" | base64 -d)"
argocd login localhost:8080 --username $ADMIN_USER --password $ADMIN_PASSWD --insecure

Em seguida, é necessário acessar o servidor da API do Argo CD para que o CLI argocd funcione. Usando outra janela do terminal, você precisa autenticar o cliente argocd com a instância do servidor Argo CD:

Output
'admin:login' logged in successfully
Context 'localhost:8080' updated

A saída se parece com:

argocd app create starter-kit-apps \
    --dest-namespace argocd \
    --dest-server https://kubernetes.default.svc \
    --repo https://github.com/<YOUR_GITHUB_USERNAME>/<YOUR_ARGOCD_GITHUB_REPO_NAME>.git \
    --path clusters/dev/helm

Em seguida, execute o comando abaixo para criar a aplicação pai starter-kit-apps (certifique-se de substituir os espaços reservados <> conforme necessário):

  • –dest-namespace argocd \
  • –dest-server https://kubernetes.default.svc \
  • O comando acima irá criar uma nova aplicação Argo CD chamada starter-kit-apps no namespace argocd, configurada para:

Alvejar o mesmo cluster Kubernetes onde o Argo CD está implantado, porque --dest-server está definido como https://kubernetes.default.svc.

argocd app sync starter-kit-apps

Usar o repositório do GitHub definido pelo argumento --repo para sincronizar o seu cluster.

Output
TIMESTAMP                  GROUP        KIND             NAMESPACE   NAME                       STATUS     HEALTH  ...
2022-03-23T17:39:38+02:00  argoproj.io  Application      argocd      sealed-secrets-controller  OutOfSync  Missing ...            
2022-03-23T17:39:38+02:00  argoproj.io  Application      argocd      velero                     OutOfSync  Missing ...             
2022-03-23T17:39:38+02:00  argoproj.io  Application      argocd      ingress-nginx              OutOfSync  Missing ...
...
GROUP        KIND         NAMESPACE  NAME                       STATUS  HEALTH  HOOK  MESSAGE
argoproj.io  Application  argocd     sealed-secrets-controller  Synced                application.argoproj.io/sealed-secrets-controller created
argoproj.io  Application  argocd     ingress-nginx              Synced                application.argoproj.io/ingress-nginx created
argoproj.io  Application  argocd     kube-prometheus-stack      Synced                application.argoproj.io/kube-prometheus-stack created
argoproj.io  Application  argocd     velero                     Synced                application.argoproj.io/velero created
argoproj.io  Application  argocd     cert-manager               Synced                application.argoproj.io/cert-manager created

Escaneie e aplique todos os manifestos de aplicação encontrados no diretório clusters/dev/helm (argumento --path).

Em seguida, é necessário sincronizar a aplicação starter-kit-apps (lembre-se de que o Argo CD não sincroniza nada por padrão, a menos que seja especificado):

argocd app list

A saída se parece com:

Output
NAME                       CLUSTER                         NAMESPACE       PROJECT  STATUS     HEALTH   SYNCPOLICY  ...
ingress-nginx              https://kubernetes.default.svc  ingress-nginx   default  OutOfSync  Missing  Auto-Prune  ...
cert-manager               https://kubernetes.default.svc  cert-manager    default  OutOfSync  Missing  Auto-Prune  ...
kube-prometheus-stack      https://kubernetes.default.svc  monitoring      default  OutOfSync  Missing  Auto-Prune  ...
sealed-secrets-controller  https://kubernetes.default.svc  sealed-secrets  default  OutOfSync  Missing  Auto-Prune  ...
starter-kit-apps           https://kubernetes.default.svc  argocd          default  Synced     Healthy  <none>      ...  
velero                     https://kubernetes.default.svc  velero          default  OutOfSync  Missing  Auto-Prune  ...

Após o comando acima ser concluído, você deverá ver um novo aplicativo presente no painel principal do seu servidor Argo CD. Por favor, abra um navegador da web e navegue até http://localhost:8080. Em seguida, selecione a aba Applications e clique no bloco starter-kit-apps (observe o padrão app of apps ao olhar para o gráfico de composição):

argocd app sync -l argocd.argoproj.io/instance=starter-kit-apps

Você também pode inspecionar os novos aplicativos via CLI:

A saída se parece com:

argocd app list

O aplicativo pai starter-kit-apps aparecerá como sincronizado, mas os aplicativos filhos estarão fora de sincronia. Em seguida, você pode sincronizar tudo usando a interface web ou via CLI:

Output
NAME                       CLUSTER                         NAMESPACE       PROJECT  STATUS    HEALTH   SYNCPOLICY  CONDITIONS ...
ingress-nginx              https://kubernetes.default.svc  ingress-nginx   default  Synced    Healthy  Auto-Prune  <none>     ...
cert-manager               https://kubernetes.default.svc  cert-manager    default  Synced    Healthy  Auto-Prune  <none>     ...
kube-prometheus-stack      https://kubernetes.default.svc  monitoring      default  Synced    Healthy  Auto-Prune  <none>     ...
sealed-secrets-controller  https://kubernetes.default.svc  sealed-secrets  default  Synced    Healthy  Auto-Prune  <none>     ...
starter-kit-apps           https://kubernetes.default.svc  argocd          default  Synced    Healthy  <none>      <none>     ...
velero                     https://kubernetes.default.svc  velero          default  OutOfSync Missing  Auto-Prune  SyncError  ...

A operação de sincronização pode demorar um pouco para ser concluída (até 5-10 minutos), dependendo da complexidade e do número de objetos Kubernetes de todos os aplicativos sendo implantados.

Após algum tempo, liste novamente todos os aplicativos:

argocd app create starter-kit-apps \
  --dest-namespace argocd \
  --dest-server https://kubernetes.default.svc \
  -repo https://github.com/<YOUR_GITHUB_USERNAME>/<YOUR_ARGOCD_GITHUB_REPO_NAME>.git \
  --path clusters/dev/helm \
   --sync-policy automated \
  --auto-prune \
  --self-heal
  • A saída será semelhante a (observe que todos os aplicativos estão sincronizados agora):
argocd app get velero

A implantação do aplicativo Velero falhará e será deixada de propósito no estado SyncError como um exercício para o leitor se familiarizar e aprender a diagnosticar problemas de aplicativos no Argo CD. Consulte a seção Dicas abaixo para ver como diagnosticar problemas de aplicativos no Argo CD.
O bootstrap do aplicativo pai é uma operação única. Em alterações subsequentes do Git para cada aplicativo, o Argo CD detectará a deriva e aplicará as alterações necessárias. O Argo CD está usando um mecanismo de polling por padrão para detectar alterações no seu repositório Git. O intervalo de atualização padrão está definido como 3 minutos. Em vez de depender de um mecanismo de polling, você também pode aproveitar o poder dos ganchos do Git. Visite o site de documentação oficial para aprender como criar e configurar o Argo CD para usar ganchos do Git.

Output
 Name:               velero
Project:            default
Server:             https://kubernetes.default.svc
Namespace:          velero
URL:                https://argocd.example.com/applications/velero
Repo:               https://vmware-tanzu.github.io/helm-charts
Target:             2.27.3
 Path:               
SyncWindow:         Sync Allowed
Sync Policy:        Automated (Prune)
Sync Status:        OutOfSync from 2.27.3
Health Status:      Missing
CONDITION  MESSAGE                                                                                          LAST TRANSITION
SyncError  Failed sync attempt to 2.27.3: one or more objects failed to apply (dry run) (retried 5 times).  2022-03-24 12:14:21 +0200 EET
 GROUP                      KIND                      NAMESPACE  NAME                               STATUS     HEALTH      HOOK      MESSAGE
velero.io                  VolumeSnapshotLocation    velero     default                            Failed     SyncFailed  PostSync  error validating data: ValidationError(VolumeSnapshotLocation.spec): missing required field "provider" in io.velero.v1.VolumeSnapshotLocation.spec
velero.io                  BackupStorageLocation     velero     default                            Failed     SyncFailed  PostSync  error validating data: [ValidationError(BackupStorageLocation.spec.objectStorage): missing required field "bucket" in io.velero.v1.BackupStorageLocation.spec.objectStorage, ValidationError(BackupStorageLocation.spec): missing required field "provider" in io.velero.v1.BackupStorageLocation.spec]
...

Dicas: Se desejar, você pode configurar o aplicativo pai para ser sincronizado automaticamente (e também habilitar auto-reparo e poda automática), você pode usar o seguinte comando (não se esqueça de substituir os espaços reservados <> conforme necessário):

–dest-namespace argocd \

–dest-server https://kubernetes.default.svc \

–sync-policy automated \

–auto-prune \

kubectl -n argocd get secret argocd-initial-admin-secret -o jsonpath="{.data.password}" | base64 -d; echo

Em caso de falhas de sincronização, você sempre pode inspecionar os eventos do Kubernetes para a aplicação em questão (via argocd app get <nome_da_aplicação>):

A saída se parece com:

  • Em seguida, você aprenderá como usar o padrão app of apps e executar as mesmas etapas via interface gráfica do usuário do Argo CD.
  • Usando o Padrão App of Apps via Interface Web do Argo CD
  • Nesta seção, você aprenderá como usar a interface web do Argo CD para criar e fazer uso do padrão app of apps para implantar todos os componentes do Starter Kit em seu cluster DOKS. A imagem abaixo ilustra o conceito principal:
  • Como o diagrama acima mostra, inicializar uma nova aplicação via interface web é muito semelhante à contraparte da CLI. A única diferença é que você irá navegar entre diferentes painéis/janelas e usar operações de apontar e clicar. Nos bastidores, o Argo CD criará os CRDs de aplicativo necessários e aplicará alterações ao seu cluster Kubernetes.
  • Primeiro, por favor, abra um navegador da web e faça login no console web do Argo CD. O nome de usuário padrão é admin, e a senha padrão é obtida via:
  • Depois de fazer login, você será redirecionado para a página do painel de aplicativos (em uma instalação nova, o painel está vazio). Em seguida, clique no botão Criar Aplicativo. Um novo painel será exibido solicitando os detalhes da aplicação:
  • Por favor, preencha cada campo adequadamente:

Nome da Aplicação: O novo nome da aplicação (por exemplo, starter-kit-apps).

Projeto: O nome do projeto ao qual esta aplicação pertence (ao usar Argo CD pela primeira vez, você pode usar padrão).

Política de Sincronização e Opções de Sincronização: Configura a política de sincronização e as opções (por exemplo, Manual, Automático, número de tentativas, intervalo entre tentativas, etc).

Fonte URL do Repositório: O endereço URL do seu repositório GitHub – por exemplo, https://github.com/<SEU_NOME_DE_USUÁRIO_NO_GITHUB>/<NOME_DO_REPO_DO_ARGOCD_NO_GITHUB>.git.

Fonte Caminho: Caminho do diretório do repositório GitHub onde os manifestos da aplicação são armazenados (por exemplo, clusters/dev/helm).

Destino URL do Cluster: Cluster Kubernetes de destino para sincronizar com seu repositório GitHub (por exemplo, https://kubernetes.default.svc para o cluster local onde o Argo CD está implantado).

Destino Namespace: Namespace do cluster Kubernetes de destino para usar com as aplicações Argo CD (argocd, geralmente).

Depois de preencher todos os detalhes da aplicação, clique no botão Criar no topo. Um novo bloco de aplicativo aparecerá na página do painel:

Se você clicar no ícone do aplicativo, poderá observar o padrão de aplicativos de aplicativos, olhando para o gráfico de composição:

Se você olhar para a imagem acima, notará que todos os aplicativos estão marcados como Fora de Sincronia. O próximo passo é acionar uma operação de sincronização no aplicativo pai. Em seguida, todos os aplicativos filhos também serão sincronizados. Por favor, pressione o botão Sincronizar no ícone do aplicativo pai. Um novo painel surgirá no lado direito (observe que todos os aplicativos filhos estão selecionados abaixo):

Deixe os valores padrão e pressione o botão Sincronizar no topo e observe como o Argo CD cascata a operação de sincronização para todos os aplicativos:

A implantação do aplicativo Velero falhará e será deixada de propósito no estado Erro de Sincronização como um exercício para o leitor se familiarizar e aprender a diagnosticar problemas de aplicativos no Argo CD. Consulte a seção de Dicas abaixo para saber como diagnosticar problemas de aplicativos do Argo CD.

Se tudo correr bem, todas as aplicações devem ter uma borda verde e o status deve ser Saudável e Sincronizado. O processo de inicialização é uma operação única. Em alterações subsequentes do Git para cada aplicação, o Argo CD detectará a deriva e aplicará as alterações necessárias. O Argo CD usa um mecanismo de sondagem por padrão para detectar alterações no seu repositório Git. O intervalo de atualização padrão é definido como 3 minutos. Em vez de depender de um mecanismo de sondagem, você também pode aproveitar o poder dos gatilhos do Git. Por favor, visite o site de documentação oficial para aprender como criar e configurar o Argo CD para usar gatilhos do Git.

Dicas:
Se desejar, você pode configurar a aplicação pai para ser sincronizada automaticamente definindo o valor do campo POLÍTICA DE SINCRONIZAÇÃO para Automático. Para habilitar a auto-cura e a poda automática, marque as caixas de seleção RECURSOS DE PODA e AUTO CURA:

Em caso de falhas de sincronização, você sempre pode inspecionar os eventos do Kubernetes para a aplicação em questão. Usando a interface web, você pode navegar para o bloco de aplicativo afetado:

Em seguida, clique no link Falha de Sincronização sinalizado em vermelho, da seção ÚLTIMO RESULTADO DE SINCRONIZAÇÃO no cabeçalho da página de aplicação. Um novo painel aparece, mostrando informações úteis sobre por que a operação de sincronização falhou:

Conjuntos de Aplicativos é outro recurso poderoso oferecido pelo Argo CD. O Controlador de ApplicationSet é um subprojeto do Argo CD, que adiciona automação de aplicativos por meio de definições modeladas. Este recurso ajuda você a evitar repetições em seus manifestos de aplicativos (fazendo uso do princípio DRY).

apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
  name: my-app
spec:
  generators:
    - list:
        elements:
          - cluster: dev
            url: https://kubernetes.dev.svc
          - cluster: qa
            url: https://kubernetes.qa.svc
          - cluster: prod
            url: https://kubernetes.prod.svc
  template:
    metadata:
      name: '{{cluster}}-app'
    spec:
      project: default
      source:
        repoURL: https://github.com/myrepo/my-applicationset.git
        targetRevision: HEAD
        path: clusters/{{cluster}}/my-apps
      destination:
        server: '{{url}}'
        namespace: argocd

O controlador ApplicationSet é instalado junto com o Argo CD (no mesmo namespace) e ele gera automaticamente Aplicativos do Argo CD com base no conteúdo de um novo Recurso Personalizado de ApplicationSet (CR).

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: dev-app
spec:
  project: default
  source:
    repoURL: https://github.com/myrepo/my-applicationset.git
    targetRevision: HEAD
    path: clusters/dev/my-apps
  destination:
    server: https://kubernetes.dev.svc
    namespace: argocd

Nota:
A partir da versão 2.3.x do Argo CD, você não precisa instalar o Controlador de ApplicationSet separadamente, pois faz parte da instalação principal do Argo CD. O Starter Kit está usando versão >= 2.3.1, então você não precisa mexer em nada.

A ideia principal de um ApplicationSet baseia-se em ter uma lista de valores atuando como um gerador, e um modelo que é preenchido pelos valores da lista de entrada. Para cada item da lista, um novo modelo de aplicativo é gerado em sequência. Basicamente, você define um CRD de ApplicationSet e então o deixa gerar para você quantos CRDs de Application do ArgoCD você quiser, com base nos valores de entrada. Assim, em vez de criar e lidar com múltiplos manifestos de Application, você gerencia tudo através de um único manifesto – o ApplicationSet.

Este conceito também simplifica o gerenciamento de configurações multi-cluster e multi-ambiente usando modelos de aplicativos parametrizados. Os conjuntos de aplicativos incluem outros geradores também, além dos Geradores de Lista:

Gerador de Cluster: Usa clusters definidos pelo Argo CD para modelar aplicativos.

argocd app delete starter-kit-apps

Gerador Git: Usa os arquivos/diretórios de um repositório Git para modelar aplicativos.

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: cert-manager
  namespace: argocd
  finalizers:
    - resources-finalizer.argocd.argoproj.io
spec:
...

Um CRD de ApplicationSet típico usando um Gerador de Lista parece o seguinte:

Aplicar o ApplicationSet acima ao seu cluster Kubernetes renderizará três aplicativos Argo CD. Por exemplo, o aplicativo do ambiente dev é renderizado como mostrado abaixo:

Os motores de modelo são muito poderosos por natureza e oferecem muitas possibilidades. Visite o site principal da documentação do ApplicationSet para saber mais sobre este recurso.

Desinstalando Aplicações do Argo CD

Desinstalar (ou excluir) aplicações gerenciadas pelo Argo CD é realizado excluindo o manifesto correspondente da fonte do repositório Git. No caso de aplicações criadas usando o padrão de aplicativos de aplicativos, você precisa excluir apenas o aplicativo pai (seja via CLI ou interface web). Então, todas as aplicações filhas serão excluídas também como parte do processo.

  • Como excluir o aplicativo pai starter-kit-apps (incluindo aplicativos filhos) usando o CLI do argocd:
  • Se você deseja garantir que os aplicativos filhos e todos os seus recursos sejam excluídos quando o aplicativo pai for excluído, certifique-se de adicionar o finalizador apropriado à sua definição de Aplicação:

Source:
https://www.digitalocean.com/community/developer-center/implementing-gitops-using-argo-cd