Primeiras aulas do curso
Olá! Meu nome é Rafael Zago e serei seu instrutor nesse curso.
Audiodescrição: Rafael é uma pessoa branca de olhos castanhos. É careca, tem barba longa e usa uma camiseta clara. Ao fundo, uma prateleira com livros e itens de decoração. Na parede, há quadros decorativos.
Neste curso, exploraremos o ArgoCD, uma ferramenta essencial para automação da entrega contínua. O conteúdo é voltado para profissionais como DevOps, SRE, Platform Engineers, Sysadmins ou qualquer pessoa interessada em otimizar o processo de deploy. Com o ArgoCD, será possível gerenciar revisões, conversões e atualizações de forma mais eficiente e automatizada.
Primeiro, configuraremos um cluster Kubernetes com o ArgoCD instalado, além das ferramentas essenciais, como kubectl e Argo CD CLI. Ajustaremos nosso ambiente e adaptaremos os arquivos do repositório para que o ArgoCD identifique e implemente as alterações automaticamente.
Sempre que atualizarmos o manifesto e definirmos, por exemplo, a versão 1.0 da aplicação, o ArgoCD garantirá que essa versão seja entregue. Caso seja necessário um rollback devido a erros, a ferramenta permitirá essa reversão de forma rápida e eficiente.
Neste projeto, trabalharemos com a aplicação Fortune Cookie, um biscoito da sorte digital. Ao clicar em um botão, o usuário receberá uma mensagem aleatória. Com essa aplicação, navegaremos em diferentes versões dela, sendo uma totalmente em português, outra totalmente em inglês outra mesclada. Para isso usaremos a automatização de deploy continuo com ArgoCD.
Para aproveitar ao máximo este curso, é importante ter noções básicas de Linux, como a execução de comandos no terminal, além de conhecimentos fundamentais sobre CI/CD, especialmente deploy contínuo, que é o foco da ferramenta. Também é essencial compreender o funcionamento de uma aplicação, principalmente dentro do Kubernetes, incluindo conceitos como front-end e back-end, serviços e deploys no ambiente Kubernetes.
Aproveite todos os recursos disponíveis na plataforma da Alura. Participe dos fóruns para esclarecer dúvidas, compartilhe questões e interaja com outros alunos. As atividades complementares são uma ótima maneira de reforçar o aprendizado, então não deixe de realizá-las. Além disso, aproveite a comunidade no Discord para trocar experiências e aprofundar ainda mais seus conhecimentos.
Bora aproveitar este curso?
Vamos conversar um pouco sobre como manipular os deploys das nossas aplicações. Atualmente, temos aplicações que são contêineres, uma maneira mais moderna de entregar o software. Mas gerenciar isso manualmente é complicado quando temos uma escala muito grande de aplicações. Ou quando queremos automatizar essa entrega. Automatizar a entrega de aplicações em contêineres é essencial para manter o controle sobre as versões em execução, garantindo mais segurança, estabilidade e eficiência no processo.
Temos duas abordagens possíveis. A primeira é automatizar a entrega sempre utilizando a versão mais recente da aplicação. No entanto, também podemos criar um processo automatizado para gerenciar e controlar versões específicas.
Imagine que a última versão apresente um problema ou não atenda às necessidades do negócio. Nesse caso, podemos configurar uma automação que permite reverter para uma versão anterior—ou até para duas ou três versões anteriores. É exatamente nesse ponto que o ArgoCD entra em ação.
O ArgoCD é instalado em um cluster Kubernetes e atua como um controlador de versões de imagem, garantindo mais segurança e flexibilidade na entrega das aplicações.
Então, a primeira coisa que vamos fazer é criar nosso cluster do Kubernetes. Existem várias maneiras de fazer isso. Você pode ter seu cluster instalado do zero, com todos os nós, máquinas e configurações necessárias. Ou você pode usar outra solução, como o Minikube. O Minikube é uma distribuição do Kubernetes que você executa na máquina. Não é recomendado para ambientes de produção. Estamos usando para que você tenha um cluster que funcione mais rápido. Além disso, essa é uma ferramenta da própria distribuição do Kubernetes, ou seja, você pode usá-la diariamente para desenvolvimento.
Então, a primeira coisa que temos que fazer é ter uma máquina Linux em execução, ou estar conectado a uma máquina Linux. No nosso caso, estamos conectados ao Ubuntu, versão 24.04, que não tem muita coisa instalada. É uma máquina que tem pelo menos 4 GB de memória, apenas para podermos ter o cluster funcionando de maneira saudável.
Então, a primeira coisa que fazemos é baixar o executável do Minikube. Para isso, vamos usar o comando abaixo:
curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
Nesse comando, estamos executando o curl, um comando Linux que atua como um agente de navegador web, onde podemos consultar URLs. Estamos passando alguns parâmetros. O que importa para nós é o endereço e o endereço da versão. Estamos pegando a versão mais recente. Quando executamos o comando, o binário do Minikube é baixado.
A instalação do Minikube consiste em duas partes. Primeiramente, precisamos do binário do Minikube e precisamos movê-lo para um lugar onde eu possa executar.
Se limparmos o terminal e executar minikube, ele não será encontrado, apesar de ter baixado o binário. Então, precisamos mover esse arquivo para um lugar onde o caminho do sistema, ou seja, onde os executáveis comuns do meu sistema estão presentes. Então, executamos o comando abaixo:
sudo install minikube-linux-amd64 /usr/local/bin/minikube
Usamos o sudo, pois não somos usuários privilegiados, estamos pedindo permissão de privilégio. Em seguida, pedimos para a instalação ser feita do minikube-linux-amd64. Caso você esteja usando Mac você tera que usar outra url. Após, pedimos para enviar dentro de usr/local/bin/minikube.
Então, ao rodar o comando será solicitado a senha de usuário, então fazemos isso. Na sequência, se passarmos minikube, ele aparece. Isso significa que agora temos acesso ao binário. Se abrirmos outros terminais dentro dessa mesma máquina, o minikube estará disponível.
Assim, fizemos a primeira configuração que é a instalação. Primeiro estamos baixando as ferramentas para podermos trabalhar com elas. Outra ferramenta muito utilizada que precisaremos é o Kubectl. Essa é uma ferramenta de linha de comando que permite manipular o cluster e as aplicações.
Para isso, usamos o seguinte comando:
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
O curl baixa, dentro do próprio site do Kubernets, a versão do kubectl. Mas, dentro desse comando tem um subcomando, que é outro curl que pega a última release estável. Isso significa que, temos várias versões do Kubernets para download. Nesse caso, queremos pegar a última versão estável. Após, pedimos o bin/linux/amd64/kebectl. O sub shell só pega a versão. Após executar, limpamos a tela e passamos ls -l.
ls -l
Feito isso, notamos que há um kubectl. Esse já é um binário, é um executável. A primeira coisa que precisamos fazer é dar a permissão de execução. Então, passamos o comando chmod +x kubectl.
chmod +x kubectl
Nisso, notamos que o kubectl aparece na cor verde. Isso pode significar que está executável, porém nesse caso, ainda não está no lugar certo. Pois, se passarmos kubectl, teremos um retorno indicando que não foi encontrado. Da mesma forma que fizemos com o minikube, vamos passar sudo mc kubectl /usr/local/bin.
sudo mc kubectl /usr/local/bin
Feito isso, se passarmos kubectl e pressionarmos "TAB", já está executável. Assim, temos duas ferramentas instaladas, o binário minikub para criar o cluster e o kubectl para manipular o cluster.
Agora, falta a principal ferramenta do curso, que é o argocd.cli. Na verdade, o argocd.cli é dividido em duas partes. Primeiro, vamos instalar o cli, que é a Interface de Linha de Comando, que é como o kubectl. Depois, vamos instalar as ferramentas argocd.cli dentro do nosso cluster. Vamos por etapas.
Primeiro, vamos verificar a versão do ARGOCD que será baixada. O comando cria uma variável de ambiente chamada ARGOCD.VERSION, usando curl em modo silencioso para acessar a API do repositório argoproject, identificar a versão mais recente, extrair o nome da tag e realizar as substituições necessárias. Ao executar echo $ARGOCD.VERSION, obtemos a última versão estável.
echo $ARGOCD.VERSION
v2.13.3
Com a versão definida, o próximo passo é baixá-la para a máquina usando curl. Existem duas abordagens para isso: inserir o comando subshell diretamente no curl para que o kubectl obtenha a versão ou criar uma variável de ambiente para armazená-la. Ambas funcionam da mesma maneira.
curl -sSL -o /tmp/argocd-${ARGOCD_VERSION} https://github.com/argoproj/argo-cd/releases/download/${ARGOCD_VERSION}/argocd-linux-amd64
Ao executar, é feito o download, o binário do argocd será salvo no diretório /tmp. Para torná-lo executável, utilizamos o comando chmod +x /tmp/argocd-${ARGOCD_VERSION}.
chmod +x /tmp/argocd-${ARGOCD_VERSION}
Após, passamos o comando abaixo, para movê-lo para o usr/local/bin/argocd.
usr/local/bin/argocd
O comando já está disponível. A partir daqui, seguimos para a próxima etapa: criar o cluster, instalar o argo e configurar todas as ferramentas necessárias para o deploy automatizado. No próximo vídeo, começamos essa instalação. Até lá!
Agora, vamos criar o cluster. Para isso, o Minikube requer alguns arquivos essenciais, sendo o principal o kubeconfig. Esse arquivo armazena o endereço do cluster, mesmo que seja local, além dos certificados necessários para acessá-lo com ferramentas como o kubectl.
O primeiro comando que utilizaremos é export, que define a variável de ambiente KUBECONFIG. Essa variável é utilizada por qualquer ferramenta de gerenciamento de clusters, incluindo o Argo. O arquivo de configuração será armazenado no diretório home do usuário, dentro da pasta oculta .kube, no arquivo config.
export KUBECONFIG=$HOME/.kube/config
Com o comando acima, definimos a variável de ambiente KUBECONFIG para apontar para o arquivo de configuração que será criado. Após criar a variável, precisamos criar o diretório onde este arquivo existirá. Para isso, rodamos o comando mkdir, que cria um diretório dentro do $HOME, nosso diretório de usuário, seguido de .kube.
mkdir $HOME/.kube
Lembrando que apenas configuramos a variável, mas o diretório ainda não existia. Agora, criamos o arquivo com o comando touch, apontando para o $KUBECONFIG. Este comando criará um arquivo dentro do diretório .kube.
touch $KUBECONFIG
Podemos verificar o arquivo com ls -l no diretório raiz do nosso usuário, .kube/.
ls -l .kube/
Nisso, é indicado que existe um arquivo chamado config. Essa arquivo está vazio, pois ainda não criamos o cluster. Mas, antes de criar o cluster, precisamos escolher a tecnologia sobre a qual ele rodará. Lembrando que o Minikube é uma ferramenta para desenvolvimento e não é recomendada para produção. Vamos usar o Podman, que rodará um cluster em cima de containers Podman. Para isso, precisamos instalar o Podman com o comando abaixo:
sudo apt install podman -y
O Podman é daemonless e roda sem permissão de root. Então, orecisamos fazer algumas configurações para que o Minikube funcione, pois ele precisa acessar interfaces de rede que requerem root. Iniciaremos o socket do Podman para nosso usuário com o comando:
systemctl --user start podman.socket
Sem necessidade de
sudo, este comando inicia o socket do Podman para o usuário atual.
Como alguns recursos do cluster precisam acessar endereços protegidos pelo sistema operacional, editaremos o arquivo, passando sudo vi/etc/sudoers.
sudo vi /etc/sudoers
No final do arquivo, adicionaremos uma linha de código. Existem várias formas de fazer isso, nesse caso seguiremos com a mais simples, passando o comando abaixo:
[usuario] ALL=(ALL) NOPASSWD: /usr/bin/podman
Assim, silicitamos que, para o usuário, de qualquer recurso para qualquer endereço sem senha, porém, somente para o comando usr/bin/podman. Com essa configuração, salvamos. Assim, aparece uma mensagem indicando que esse é um arquivo apenas de leitura. Porém, estamos editando com o sudo, então pressionamos "Enter".
O que fizemos foi editar o arquivo sudoers e demos permissão para o usr/bin/podman, para quando precisar executar qualquer recurso que seja elevado, eu não precise dar senha. Isso só está sendo feito para o minicube funcionar.
Agora, podemos iniciar o cluster. Já temos o comando do minicube instalado, passamos start para iniciá-lo e avisar que o driver que ele usará é o podman.
Outros drivers que poderiamos usar é o
docker,virtualbox,kvm, e assim por diante. Escolhemos opodman, porque é mais simples e mais leve.
minikube start -- driver=podman
Ao pressionar "Enter", a instalação de todos os recursos necessários é feita, além da inicialização do cluster. Esse processo pode demorar alguns minutos.
Após a instalação, validamos com o seguinte comando:
minikube status
minikube type: Control Plane host: Running kubelet: Running apiserver: Running kubeconfig: Configured
Verificamos que o Minikube está rodando com um nó. Vamos habilitar um addon do Minikube, o ingress, que permite acessar de fora do Kubernetes algo que está dentro dele. Então, executamos o comando abaixo.
minikube addons enable ingress
Após habilitar o addon, verificamos o funcionamento do cluster com kubectl get nodes.
kubectl get nodes
NAME STATUS ROLES AGE VERSION
minikube Ready control-plane 2m27s v1.31.0
Nisso, notamos que existe um nó criado, com o nome minicube. Então, passaremos outro comando para realmente ver o kubectl funcionando dentro do cluster.
kubectl get pods -A
Passamos o -A, pois queremos ver de todos os namespaces. Nisso, roda o nginx, o etcd, ou seja, todo o nosso cluster está funcional agora.
kubectlA partir desse momento, estou apto a instalar o argo, fazer deploy das minhas aplicações. Tem duas coisas que vamos fazer antes de terminar esse vídeo. Primeira coisa será habilitar o autocomplete para o kubectl. Se passarmos kubectl e pressionarmos "TAB" duas vezes, não vai exibir as opções que o kubectl teria, caso quiséssemos manipular o arquivo. Para isso, vamos escrever vi .bashrc e executar.
vi .bashrc
No final do arquivo, vamos adicionar a linha abaixo:
echo 'source <(kubeclt completion bash)' >>~/.bashrc
Esse comando vai dar um echo, ou seja, vai gerar o conteúdo echo src, um subshell que o src vai ser carregado, estamos puxando essas configurações para o ambiente. O kubectl completion bash vai adicionar dentro do meu src, do ambiente, os subcomandos do kubectl. Estamos direcionando isso para o .bashrc, então, pressionamos "Enter".
Se eu estiver usando o
zsh, por exemplo, seriakubectl completion zsh.
Após, passaremos source .bashrc para recarregar o conteúdo do arquivo.
source .bashrc
Agora, se digitarmos kubectl e pressionarmos "TAB" duas vezes, temos todas as opções que o kubectl precisa para funcionar.
Por fim, algo que é opcional, mas muito viável para agilizar o dia a dia dos deploys, é a criação de um alias para o comando kubectl. Agora, vamos voltar ao arquivo .bashrc, onde já adicionamos conteúdo anteriormente. Vou até o final do arquivo e incluir duas novas linhas.
.bashrc
No fim, adicionaremos duas linhas. Estamos criando um alias para o kubectl chamado k. Além disso, usamos o complete -F. Essa linha habilita o autocomplete do kubectl também para o alias k.
alias k=kubectl
complete -F __start_kubectl k
Salvamos e executamos source . bashrc. Após, ao digitar k e pressionar duas vezes a tecla "Tab", o autocompletar funcionará da mesma forma. Isso vai nos ajudar a agilizar o deploy das nossas aplicações.
No próximo vídeo, vamos fazer a instalação do Argo CD (Argo Continuous Deployment) no cluster. Até breve!
O curso ArgoCD: automatizando deploy de aplicações possui 118 minutos de vídeos, em um total de 38 atividades. Gostou? Conheça nossos outros cursos de Entrega Contínua & CI/CD em DevOps, ou leia nossos artigos de DevOps.
Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:
Todos os cursos, trilhas e certificados para evoluir.
7 dias para cancelar com reembolso
Aprenda mais rápido com IA, idiomas e imersões.
7 dias para cancelar com reembolso
TUDO DO PLUS, MAIS:
Aceleração de carreira: mentoria, vagas e prática guiada.
7 dias para cancelar com reembolso
TUDO DO PRO, MAIS: