Introdução ao GitOps no Kubernetes com FluxCD: Configuração Inicial

A prática de GitOps permite definir a infraestrutura como código de forma declarativa, servindo como uma fonte única e auditada para o estado da nuvem ou cluster. Isso traz benefícios como controle de versão, auditoria de mudanças, reconciliação automatizada, segurança aprimorada, rollback simplificado e colaboração otimizada através de fluxos de trabalho Git. O FluxCD com Kubernetes automatiza a implantação, monitoramento e reconciliação de recursos de cluster com base em repositórios Git.

Este artigo aborda a configuração inicial e as funcionalidades principais do FluxCD com Kubernetes em um cluster Kubernetes, mostrando como ele facilita a gestão de infraestrutura como código e a automação de processos.

Configuração de Dependências Git

O primeiro passo é criar um repositório Git no Github. Em seguida, é necessário gerar um token de acesso granular que o FluxCD usará para interagir com o repositório. Esses tokens oferecem um controle mais preciso sobre as permissões do repositório em comparação com os tokens de acesso pessoal clássicos.

Para configurar o token, mantenha as permissões de Read and write para acesso à Administration e Contents, e Read-only para acesso a Metadata, limitando-o ao repositório criado. Essas permissões são recomendadas pela documentação oficial do FluxCD para a configuração inicial.

A utilização de permissões granulares é crucial para garantir a segurança e o controle sobre o acesso ao repositório, alinhando-se com as práticas recomendadas de segurança da informação.

Criar um repositório Git e gerar um token de acesso adequado são os primeiros passos para integrar o FluxCD com Kubernetes, permitindo que o FluxCD gerencie os recursos do cluster de forma automatizada e segura.

Configuração do Flux CLI

Comece instalando o FluxCD cli. No shell, execute o seguinte comando:

sudo zypper in flux2-cli

O próximo passo é exportar as variáveis de detalhe do usuário e token Github. Use os comandos abaixo:

export GITHUB_TOKEN=******
export GITHUB_USER=*****

Para este artigo, será utilizado um cluster k3s hospedado localmente em uma máquina virtual. Verifique se o acesso está correto com o comando kubectl:

# 1. Point to specific cluster we are setting up
export KUBECONFIG=~/.kube/local.config
# 2. Check for access and version
kubectl version

Verifique também se o Flux cli tem acesso:

flux check --pre

Esses passos garantem que o Flux cli esteja corretamente configurado e com acesso ao cluster Kubernetes, preparando o terreno para a instalação dos componentes do FluxCD.

Bootstrap do FluxCD com Kubernetes

A instalação incluirá todos os componentes, inclusive os extras para automação de imagem. Execute o seguinte comando:

flux bootstrap github \
    --owner=$GITHUB_USER \
    --repository=k8s-gitops \
    --branch=main \
    --path=./cluster/default \
    --read-write-key \
    --components source-controller,kustomize-controller,helm-controller,notification-controller \
    --components-extra image-reflector-controller,image-automation-controller \
    --personal

Verifique a instalação do Flux passo a passo:

1. O Bootstrap criou uma chave de implantação no repositório Github e a armazenou como flux-system/flux-secret.

Verifique a chave de implantação no Github e o segredo com kubectl -n flux-system get secrets. O Flux inicializou o repositório com o commit inicial contendo a definição dos componentes em cluster/default, conforme especificado no comando bootstrap.

1. O FluxCD com Kubernetes reconciliou com o repositório Git e instalou os componentes no namespace flux-system.

Essas verificações garantem que o FluxCD foi instalado corretamente e está pronto para gerenciar os recursos do cluster Kubernetes com base nas definições presentes no repositório Git.

Verificação da Instalação

Para verificar a instalação, crie uma implantação de exemplo.

apps/nginx/deployment.yaml

apiVersion: apps/v1
metadata:
  name: nginx-deployment
  namespace: default
kind: Deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:latest
        ports:
        - containerPort: 80
        resources:
          requests:
            memory: "64Mi"
            cpu: "50m"
          limits:
            memory: "64Mi"
            cpu: "50m"

apps/nginx/kustomization.yaml

apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
resources:
  - deployment.yaml

cluster/default/nginx.yaml

apiVersion: kustomize.toolkit.fluxcd.io/v1
kind: Kustomization
metadata:
  name: nginx
  namespace: flux-system
spec:
  interval: 5m
  path: ./apps/nginx
  prune: true
  retryInterval: 2m
  sourceRef:
    kind: GitRepository
    name: flux-system
  targetNamespace: default
  timeout: 3m
  wait: true

O recurso Kustomization possui campos importantes:

• interval: frequência com que o Flux deve reconciliar este recurso (5m = 5 minutos).
• path: diretório contendo os manifestos Kubernetes.
• prune: indica se o Flux deve excluir recursos que não estão mais definidos no Git.
• retryInterval: tempo de espera entre as tentativas se a reconciliação falhar.
• wait: indica se o Flux deve esperar que os recursos estejam prontos antes de concluir a reconciliação.
• timeout: tempo máximo de espera para a reconciliação.

Após enviar essas alterações, aguarde a conclusão da reconciliação e verifique se o nginx foi implantado.

O que Acontece Se…?

Um dos principais objetivos do GitOps é garantir que o estado do cluster corresponda sempre aos recursos definidos no repositório Git. Esse processo contínuo de reconciliação é o que torna o GitOps poderoso para manter a consistência do sistema.

Para demonstrar essa funcionalidade, exclua a implantação do nginx usando kubectl e observe como o processo de reconciliação do Flux a restaura automaticamente ao estado desejado definido no Git. Isso demonstra a capacidade de “auto-recuperação” da abordagem GitOps.

1. Verifique a implantação com kubectl get deployments para confirmar se o nginx está em execução.
2. Exclua a implantação com kubectl delete deployment/nginx-deployment.
3. Confirme se a implantação do nginx foi excluída com kubectl get deployment.
4. Observe a reconciliação do FluxCD com Kubernetes em ação.
5. Verifique se o nginx foi reimplantado após a reconciliação do Flux.

Essa demonstração prática reforça a importância do FluxCD com Kubernetes na manutenção da infraestrutura como código e na garantia de que o estado do cluster esteja sempre sincronizado com as definições no Git.

Com o aumento da popularidade dos dispositivos móveis, os consumidores estão buscando por aparelhos mais rápidos e eficientes, com mais recursos e conectividade. Não dá para ignorar: os dispositivos móveis estão dominando o mercado, e os consumidores estão cada vez mais exigentes. Todo mundo quer um aparelho rápido, eficiente e com muitos recursos, como os que falamos aqui.

Próximos Passos

Os próximos artigos abordarão padrões GitOps avançados com o FluxCD com Kubernetes, incluindo:

• Automação de Helm chart.
• Automação de atualização de imagem.
• Configuração de notificação e alerta.
• Gerenciamento de segredos com SOPS.

Mantenha-se atento para mais informações sobre cada um desses tópicos.

Este conteúdo foi auxiliado por Inteligência Artificial, mas escrito e revisado por um humano.
Via dev.to