Menu fechado

Devs, Dê um Passo para o Zero-Touch

Redação YTI&W-News● ●● Singular: 0 comentário
GitOps

Introdução ao GitOps

O gerenciamento de clusters Kubernetes pode ser um desafio, especialmente quando se trata de manter a consistência e a segurança. O GitOps oferece uma abordagem para gerenciar a infraestrutura e aplicações como código, utilizando o Git como a única fonte de verdade. Com o GitOps, é possível automatizar o processo de deploy e garantir que o estado do cluster esteja sempre alinhado com o que está definido no repositório Git.

Princípios do GitOps

O GitOps se baseia em quatro princípios fundamentais:
Declarativo,
Versionado e Imutável,
Puxado Automaticamente e
Reconciliado Continuamente.
Esses princípios garantem que o estado do cluster seja sempre consistente com o que está definido no Git e que qualquer mudança seja feita de forma controlada e auditável.

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: gitops-argocd-demo
spec:
  project: default
  source:
    repoURL: https://github.com/your-repo/your-repo.git
    targetRevision: HEAD
  destination:
    server: https://kubernetes.default.svc
  syncPolicy:
    automated:
      selfHeal: true
      prune: true

Pré-requisitos

Para seguir este tutorial, você precisará ter os seguintes pré-requisitos atendidos:

  • Repositório GitHub para servir como o Single Source of Truth.
  • Conta no DockerHub para atuar como seu Container Registry.
  • Cluster Kubernetes em execução.
  • Ferramentas Kubernetes, como o kubectl, instaladas e configuradas.
  • Conhecimento fundamental de Kubernetes.

O que é GitOps

Princípios do GitOps

GitOps é um framework operacional que utiliza o Git como a única fonte de verdade para a infraestrutura e aplicações. Ele é baseado em quatro princípios fundamentais:

  • Declarativo: Você descreve o estado desejado, não os comandos para alcançá-lo.
  • Versionado e imutável: Seu estado inteiro está no Git. Se uma implantação falhar, você pode reverter para um estado conhecido anterior.
  • Puxado automaticamente: Um agente de software (como o Argo CD) puxa o estado do Git.
  • Reconciliado continuamente: O sistema constantemente corrige a “deriva”. Se um desenvolvedor alterar manualmente um serviço no cluster, o Argo CD sobrescreverá para corresponder ao que está no Git.
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: gitops-argocd-demo
  namespace: argocd
spec:
  project: default
  source:
    repoURL: 'https://github.com/your-repo/your-app.git'
    targetRevision: HEAD
    path: 'Kubernetes-manifest'
  destination:
    server: 'https://kubernetes.default.svc'
    namespace: argocd-demo-ns
  syncPolicy:
    automated:
      selfHeal: true
      prune: true

O que é Argo CD

Definição e Funcionamento

Argo CD é um motor de entrega contínua declarativa, construído especificamente para Kubernetes, que ajuda a gerenciar a configuração do cluster e a automatizar a implantação de aplicações. Ele utiliza um modelo de “puxar” em vez de “empurrar”, onde o agente de Argo CD dentro do cluster puxa as alterações do repositório Git.

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: gitops-argocd-demo
  namespace: argocd
spec:
  project: default
  source:
    repoURL: 'https://github.com/[seu-usuario]/[seu-repositorio].git'
    targetRevision: HEAD
    path: 'Kubernetes-manifest'
  destination:
    server: 'https://kubernetes.default.svc'
    namespace: argocd-demo-ns
  syncPolicy:
    automated:
      selfHeal: true
      prune: true
    syncOptions:
    - CreateNamespace=true

Preparando o Código da Aplicação

Estrutura do Repositório

Para começar, precisamos criar a estrutura do repositório que conterá o código da nossa aplicação. A estrutura deve ser a seguinte:

GITOPS-ARGOCD-DEMO/
├── .github/workflows/main.yml
├── auxiliary-service/
│   └── Dockerfile
├── main-api/
│   └── Dockerfile
├── Kubernetes-manifest/
│   ├── aux-api.yaml
│   ├── kustomization.yaml
│   └── main-api.yaml
├── application.yaml
└── image-updater.yaml

Automatizando a Construção de Imagens com GitHub Actions

Criando o Workflow de GitHub Actions

Para automatizar a construção e publicação de imagens Docker, criaremos um workflow de GitHub Actions.

name: Build and Push Image to DockerHub
on:
  push:
    branches:
      - main
# Skip builds for image updater commits
paths-ignore:
  - 'Kubernetes-manifest/'
jobs:
  docker_build:
    name: Build & Push ${{ matrix.service }}
    environment: argocd-demo
    runs-on: ubuntu-latest
    permissions:
      contents: write
    strategy:
      matrix:
        include:
          - service: aux-service
            dockerfile: auxiliary-service/Dockerfile
          - service: main-service
            dockerfile: main-api/Dockerfile
    env:
      DOCKER_USER: ${{ secrets.DOCKERHUB_USERNAME }}
      RUN_TAG: ${{ github.run_number }}
    steps:
      - name: Check out code
        uses: actions/checkout@v4
      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3
      - name: Login to Docker Hub
        uses: docker/login-action@v3
        with:
          username: ${{ env.DOCKER_USER }}
          password: ${{ secrets.DOCKERHUB_PASSWORD }}
      - name: Build and Push ${{ matrix.service }}
        uses: docker/build-push-action@v6
        with:
          context: .
          file: ${{ matrix.dockerfile }}
          push: true
          tags: ${{ env.DOCKER_USER }}/${{ matrix.service }}:${{ env.RUN_TAG }}
          cache-from: type=gha,scope=${{ matrix.service }}
          cache-to: type=gha,mode=max,scope=${{ matrix.service }}

Instalando e Acessando o Argo CD

Instalação do Argo CD

Para instalar o Argo CD, execute os seguintes comandos no terminal:

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

Aguarde alguns minutos para que os pods sejam inicializados.

Acessando a Interface do Usuário do Argo CD

Para acessar a interface do usuário do Argo CD, use o port forwarding para criar um túnel seguro entre o seu computador e o serviço do Argo CD no cluster.




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

Abra um navegador e acesse https://localhost:8080.

Entendendo o Aplicativo Argo CD

Definição e Funcionalidade

Um Aplicativo Argo CD é um recurso personalizado (CRD) que atua como um “contrato” entre o repositório Git e o cluster Kubernetes.

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: gitops-argocd-demo
  namespace: argocd
spec:
  project: default
  source:
    repoURL: 'https://github.com/SEU_USUARIO/SEU_REPOSITORIO.git'
    targetRevision: HEAD
    path: 'Kubernetes-manifest'
  destination:
    server: 'https://kubernetes.default.svc'
    namespace: argocd-demo-ns
  syncPolicy:
    automated:
      selfHeal: true
      prune: true
    syncOptions:
    - CreateNamespace=true

Implantando o Manifesto da Aplicação

Criando o Manifesto da Aplicação

Para implantar a aplicação Argo CD, precisamos criar um manifesto que defina o repositório Git e o cluster de destino.

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: gitops-argocd-demo
  namespace: argocd
spec:
  project: default
  source:
    repoURL: 'https://github.com/SEU_USUARIO/SEU_REPOSITORIO.git'
    targetRevision: HEAD
    path: 'Kubernetes-manifest'
  destination:
    server: 'https://kubernetes.default.svc'
    namespace: argocd-demo-ns
  syncPolicy:
    automated:
      selfHeal: true
      prune: true
    syncOptions:
    - CreateNamespace=true

Automatizando Atualizações com o Argo CD Image Updater

Instalando o Argo CD Image Updater

Para automatizar a atualização de tags de imagem em manifestos Kubernetes, instale o Argo CD Image Updater.

kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj-labs/argocd-image-updater/stable/config/install.yaml

Configurando o Image Updater

Para que o Image Updater funcione corretamente, crie um token de acesso pessoal no GitHub e armazene-o como um segredo no Kubernetes.

kubectl -n argocd create secret generic git-creds \
  --from-literal=username= \
  --from-literal=password=

Resumo do Fluxo de Trabalho GitOps

Com a implementação do fluxo de trabalho GitOps utilizando o Argo CD e o Image Updater, você pode automatizar a construção, implantação e atualização de suas aplicações em um cluster Kubernetes.

git add .
git commit -m "Initial Argo application deployment"
git push origin main

Benefícios do Uso do Argo CD e do Image Updater

O uso do Argo CD e do Image Updater proporciona vários benefícios, incluindo:

  • Automatização da implantação e atualização da aplicação
  • Garantia de consistência entre a configuração da aplicação no cluster e no repositório Git
  • Redução do risco de erros humanos e configuração inconsistente
  • Melhoria da segurança e auditoria

Fonte: freecodecamp.org.
Curadoria e Insights: Redação YTI&W (Developers).



Redação YTI&W-News

Redação Developers | Yassutaro TI & Web

Notícias do universo do Desenvolvimento Web, dicas e tutoriais para Webmasters.

Você também pode gostar

Git e GitHub para Iniciantes: O guia prático para salvar seu código e carreira
26 de fevereiro de 2026

Git e GitHub para Iniciantes: O guia prático para salvar seu código e carreira
Kubernetes
6 de março de 2026

Simule Incêndios de Kubernetes em Produtividade
prototype
20 de fevereiro de 2026

O Poderoso Efeito do Prototype Chain em JavaScript

Deixe um comentário

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

Publicado em:Boas Práticas em Desenvolvimento,Desenvolvimento de Software,Engenharia de Software,Servidores & Hospedagem
Tagged ,,,,,,,,,
Fale Conosco
×

Inscreva-se em nossa Newsletter!

Receba nossos lançamentos e artigos em primera mão!