Implementando GitOps usando Argo CD

Tutoriais
Git Kubernetes

Introdução

O Argo CD é uma implementação de código aberto popular para realizar a entrega contínua do GitOps em cima do Kubernetes. Suas aplicações, definições, configurações e ambientes devem ser declarativos e controlados por versão. Além disso, o deployment da aplicação e o gerenciamento do ciclo de vida devem ser automatizados, auditáveis e de fácil compreensão. 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 acontece via um repositório Git, onde seus manifests do Kubernetes estão armazenados. Os manifests do Kubernetes podem ser especificados de várias maneiras:

Assim como em qualquer 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 uma aplicação 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 as aplicações em execução e compara o estado atual (ou ao vivo) com o estado alvo desejado (conforme especificado no repositório Git). Uma aplicação implantada cujo estado ao vivo se desvia do estado alvo é considerada Fora de Sincronia. O Argo CD relata e visualiza as diferenças, fornecendo 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 de modelos, como: Kustomize, Helm, Ksonnet, Jsonnet, plain-YAML.
  • Capacidade de gerenciar e implantar em múltiplos clusters.
  • Integração SSO (OIDC, OAuth2, LDAP, SAML 2.0, GitHub, GitLab, Microsoft, LinkedIn).
  • Multilocação e políticas RBAC para autorização.
  • Análise do status de saúde dos recursos da aplicação.
  • Reverter/Rolar-em qualquer aplicação de configuração para qualquer configuração aplicada no repositório Git.
  • Deteção e visualização automatizadas de desvio de configuração.
  • Interface de usuário da web que fornece visualização em tempo real da atividade da aplicação.
  • Interface de linha de comando para automação e integração CI.
  • Integração de webhook (GitHub, BitBucket, GitLab).
  • Ganchos PreSync, Sync, PostSync para suportar implantações complexas de aplicativos (por exemplo, atualizações blue/green e canary).
  • Métricas do Prometheus.

Neste tutorial, você aprenderá a:

  • Usar o Helm para provisionar o 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 GitOps).
  • Implantar e gerenciar aplicativos via Argo CD.

Após concluir todos os passos deste tutorial, você deve 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á um diagrama que mostra como o Argo CD gerencia aplicações 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. Kubectl CLI, para interação com Kubernetes. Siga estas instruções para se conectar ao seu cluster com kubectl e doctl.
  5. Argo CLI, para interagir com o Argo CD usando a interface de linha de comando.
  6. Kubeseal, para criptografar segredos e interação com Sealed Secrets Controller.
  7. Helm, para gerenciar lançamentos e atualizações do Argo CD (opcional, mas recomendado em geral para sistemas de produção).

Compreensão dos Conceitos do Argo CD para Implantação de Aplicativos

O Argo CD está utilizando o conceito central de Aplicação para gerenciar implantações e ciclo de vida de aplicações. 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, bem 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 várias 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 possui restrições. O projeto padrão pode ser modificado, mas não excluído.

O Starter Kit está usando o projeto default para um rápido início usando o Argo CD. Em seguida, você aprenderá como criar uma Application para cada componente do Starter Kit, e usar charts Helm como a fonte da aplicação. O Argo CD não se limita 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 (interface web) do Argo CD para criar aplicativos, o Starter Kit depende do modo declarativo do GitOps, via manifestos YAML. Cada configuração YAML atua como uma receita para cada aplicativo, assim pode ser armazenada em um repositório Git. Isso significa que você sempre pode recriar sua configuração do Argo CD se recriar seu ambiente ou mudar para outro cluster. Mais importante, você pode realizar auditorias e rastrear cada alteração 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 que aquele 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 tema.

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 é OutOfSync. 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 aciona uma implantação automática no cluster de destino.

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

O Application CRD típico usando uma fonte de repositório Git se parece com o seguinte:

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: Indica ao Argo CD qual projeto usar para a aplicação (default neste exemplo).
  • spec.source.repoURL: URL do repositório Git usada 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) sã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 do Kubernetes a ser utilizado para sua aplicação.
  • spec.syncPolicy.automated: Habilita 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 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 do repositório Git, exceto que um repositório de gráficos Helm é usado):

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 lançamento Helm a ser criado em seu cluster Kubernetes.
  • spec.source.helm.values: Especifica os valores do Helm a serem passados para o modelo helm, geralmente definidos 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 sua aplicação.

Por favor, prossiga e leia mais sobre os conceitos principais do Argo CD no site oficial de documentação. Em seguida, você irá descobrir as opções de instalação disponíveis para implantar o Argo CD em 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 no 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 HA (Alta Disponibilidade) e se o Argo CD for usado em produção.

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

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

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

Instalação Baseada em Kubectl

Este método requer kubectl e é um processo de duas etapas:

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

Por favor, execute os comandos abaixo na ordem correta:

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 todos os implantes 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 alguns implantes não estiverem saudáveis, verifique os eventos do Kubernetes e os logs para os 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 (alta disponibilidade) (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 altere 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 do 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

A saída 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. Em seguida, 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 a 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 para o gráfico do Helm é utilizada. Neste caso, a versão 4.9.4 é selecionada, a qual 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ê aprenderá como acessar e explorar as principais características 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, usada para realizar várias tarefas administrativas e visualizar o status de implantação de aplicativos. Você pode criar aplicativos 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 aplicativo e acessar eventos do Kubernetes, bem como os logs do seu aplicativo. 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 aplicativo está usando. 

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

A interface web pode ser acessada encaminhando a 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 aplicativos. A partir daqui, você pode visualizar, criar ou gerenciar aplicativos via UI (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 aplicativo, uma representação visual de todos os objetos envolvidos também é mostrada:

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

Finalmente, 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 o equivalente CLI, chamado 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 argumentos. 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:
  O resultado 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, 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 Aplicações Argo CD

Em uma instalação inicial, o Argo CD não sabe de onde sincronizar suas aplicações, 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 realizar 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 utilizam o padrão aplicativo de aplicativos. Isso significa que você começará criando um aplicativo pai usando a CLI good (ou a interface da web), que por sua vez fará referência e inicializará o restante das aplicações 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 do seu repositório Git:
git clone <YOUR_ARGOCD_GIT_REPOSITORY_ADDRESS>
  1. Primeiro, clone 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 Starter Kit (você também pode dar uma olhada e ver como cada manifesto está estruturado):

Por fim, faça o commit das alterações e faça o push para a origem.

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

Usando o padrão App of Apps via CLI do Argo CD

Nesta seção, você aprenderá como usar o CLI do argocd para criar e fazer uso do 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 do argocd funcione. Usando outra janela de terminal, você precisa autenticar o cliente argocd com a instância do seu 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 criará uma nova aplicação Argo CD chamada starter-kit-apps no namespace argocd, configurada para:

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

argocd app sync starter-kit-apps

Usar o repositório GitHub definido pelo argumento --repo para sincronizar 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 aplicativos encontrados no diretório clusters/dev/helm (argumento --path).

Em seguida, você precisa sincronizar a aplicação starter-kit-apps (lembre-se de que o Argo CD não sincroniza nada por padrão, a menos que 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  ...

Depois que o comando acima for concluído, você deve 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 guia Aplicações e clique no bloco starter-kit-apps (observe o padrão aplicativo de aplicativos 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 da 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 levar um tempo para ser concluída (até mesmo de 5 a 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 esta (observe que todos os aplicativos estão sincronizados agora):
argocd app get velero

A implantação da aplicação 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 aplicação no Argo CD. Consulte a seção Dicas abaixo para ver como diagnosticar problemas de aplicação do Argo CD.
O bootstrap da aplicação pai é uma operação única. Em alterações subsequentes do Git para cada aplicação, o Argo CD detectará o desvio 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 webhooks do Git. Visite o site oficial da documentação para aprender como criar e configurar o Argo CD para usar webhooks.

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 a aplicação pai para ser sincronizada automaticamente (e também habilitar auto-recuperação e poda automática), você pode usar o seguinte comando (não esqueça de substituir os marcadores <> 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 de aplicativo de aplicativos e realizar as mesmas etapas através da interface gráfica do usuário do Argo CD.
  • Usando o Padrão de Aplicativo de Aplicativos via Interface Web do Argo CD
  • Nesta seção, você aprenderá como usar a interface web do Argo CD para criar e usar o padrão aplicativo de aplicativos para implantar todos os componentes do Starter Kit em seu cluster DOKS. A imagem abaixo ilustra o conceito principal:
  • Conforme o diagrama acima mostra, inicializar uma nova aplicação via interface web é muito semelhante à contraparte da CLI. A única diferença é que você 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 através de:
  • Uma vez conectado, você será redirecionado para a página inicial do painel de aplicações (em uma instalação nova, o painel está vazio). Em seguida, clique no botão Criar Aplicação. 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 a qual esta aplicação pertence (quando usando Argo CD pela primeira vez, você pode usar default).

Política de Sincronização e Opções de Sincronização: Configura a política de sincronização e 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_REPOSITÓRIO_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).

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

Namespace de Destino: O namespace do cluster Kubernetes alvo a ser usado para as aplicações do Argo CD (argocd, geralmente).

Após preencher todos os detalhes da aplicação, clique no botão Criar no topo. Um novo bloco de aplicação aparece na página do painel:

Se você clicar no bloco do aplicativo, poderá observar o padrão 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 bloco do aplicativo pai. Um novo painel aparecerá no lado direito (observe que todos os aplicativos filhos estão selecionados abaixo):

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

A implantação do aplicativo Velero falhará e será deixada de propósito no estado de Erro de Sincronização como um exercício para o leitor se familiarizar e aprender a diagnosticar problemas de aplicativo no Argo CD. Consulte a seção de Dicas abaixo para ver como diagnosticar problemas de aplicativo 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 divergência 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 webhooks do Git. Por favor, visite o site oficial da documentação para aprender como criar e configurar o Argo CD para usar webhooks.

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 auto-reparo e poda automática, marque as caixas de seleção RECURSOS DE PODA e AUTO REPARO:

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 até o bloco de aplicativo afetado:

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

Conjuntos de Aplicativos é outra funcionalidade poderosa oferecida pelo Argo CD. O Controlador de ApplicationSet é um subprojeto do Argo CD, que adiciona automação de aplicativos por meio de definições modeladas. Essa funcionalidade ajuda a evitar repetições em seus manifestos de aplicativos (faça 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 de ApplicationSet é instalado junto com o Argo CD (no mesmo namespace) e ele gera automaticamente Aplicativos Argo CD com base no conteúdo de um novo Recurso Personalizado (CR) de ApplicationSet.

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

Observação:
A partir da versão 2.3.x do Argo CD, você não precisa instalar o Controlador de ApplicationSet separadamente, pois ele 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 é populado 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ê tantos CRDs de Aplicativos ArgoCD, quantos você desejar, com base nos valores de entrada. Assim, em vez de criar e lidar com vários manifestos de Aplicativos, você gerencia tudo por meio 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:
...

O CRD ApplicationSet típico usando um Gerador de Lista, se parece com 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 template são muito poderosos por natureza e oferecem muitas possibilidades. Por favor, visite o site principal de documentação do ApplicationSet para saber mais sobre esse recurso.

Desinstalando Aplicações do Argo CD

Desinstalar (ou excluir) aplicações gerenciadas pelo Argo CD é feito excluindo o manifesto correspondente da fonte do repositório Git. No caso de aplicações criadas usando o padrão app of apps, 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 os 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 Aplicativo:

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