Eai, DevOps! Beleza?

Neste post, vamos deixar tudo pronto pra você montar uma pipeline de build e deploy da sua aplicação usando GitHub Actions e ArgoCD. Se você já manja de GitHub e ArgoCD, melhor ainda, porque aqui a ideia é ir direto ao ponto.

Bora lá?

Passo 1: Organize a casa com uma pasta para os objetos do Kubernetes

Vamos criar uma pasta chamada deploy com dois arquivos:

$ cd /path/to/your/repository
$ mkdir deploy

A estrutura final vai ficar da seguinte forma:

deploy/
├── deployment.yaml
└── service.yaml

Crie o arquivo deployment.yaml dentro da pasta deploy e adicione o conteúdo abaixo:

$ cd deploy
$ touch deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: minha-api
  labels:
    app: minha-api
spec:
  replicas: 1
  selector:
    matchLabels:
      app: minha-api
  template:
    metadata:
      labels:
        app: minha-api
    spec:
      containers:
        - name: minha-api-container
          image: usuario/minha-api:latest #aqui vai o endereço da imagem no seu registry
          ports:
            - containerPort: 8080
          env:
            - name: NODE_ENV
              value: "production"
            - name: PORT
              value: "8080"
          resources:
            requests:
              memory: "64Mi"
              cpu: "250m"
            limits:
              memory: "128Mi"
              cpu: "500m"

deploy/deployment.yaml

Arquivo deploy/service.yaml

$ cd deploy
$ touch service.yaml
apiVersion: v1
kind: Service
metadata:
  name: minha-api-service
  labels:
    app: minha-api
spec:
  selector:
    app: minha-api
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080
  type: ClusterIP

deploy/service.yaml

Passo 2: Prepare o Dockerfile pra rodar tudo em contêiner

Crie mais um arquivo no seu repositório com o nome "Dockerfile". Cada aplicação pode necessitar de um Dockerfile específico, mas aqui vai um exemplo de Dockerfile que funciona bem para uma aplicação Golang:

$ cd /path/to/your/repository
$ touch Dockerfile
FROM golang:1.23.1-alpine AS builder
WORKDIR /api
COPY . .
RUN go mod tidy
RUN go build -o main cmd/main.go


FROM alpine:3.19.1 AS release
RUN apk --no-cache add ca-certificates
WORKDIR /api
COPY --from=builder /api/main .
RUN chmod +x main
EXPOSE 8080
CMD ["./main"]

Dockerfile

Passo 3: Configure a Action para build e deploy

Agora vem o toque final: configurar a GitHub Action. Com ela, toda vez que você fizer um push, a pipeline vai cuidar de construir e fazer o deploy da aplicação. Neste exemplo vamos utilizar Kaniko para fazer build e push da imagem para o seu repositório de imagens. Crie um arquivo .github/workflows/deploy.yml com o conteúdo a seguir:

$ cd /path/to/your/repository
$ mkdir .github/workflows
$ cd .github/workflows/
$ touch deploy.yml
name: build and deploy

on:
  push:
    branches:
      - main

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v2

      - name: Build and push Docker image with Kaniko
        uses: gcr.io/kaniko-project/executor:latest
        env:
          DOCKER_CONFIG: /kaniko/.docker/
          DOCKER_USERNAME: ${{ secrets.DOCKER_USERNAME }}
          DOCKER_PASSWORD: ${{ secrets.DOCKER_PASSWORD }}
        with:
          args: |
            --context .
            --dockerfile ./Dockerfile
            --destination usuario/minha-api:v1.0.0

  deploy:
    runs-on: ubuntu-latest
    needs: build

    steps:
      - name: Checkout code
        uses: actions/checkout@v2

      - name: Set up ArgoCD CLI
        run: |
          curl -sSL -o argocd https://github.com/argoproj/argo-cd/releases/latest/download/argocd-linux-amd64
          chmod +x argocd
          sudo mv argocd /usr/local/bin/

      - name: Deploy to Kubernetes using ArgoCD
        run: |
          argocd app create my-app \
              --server my-argocd.my-domain.com.br \
              --auth-token ${{ secrets.ARGOCD_TOKEN }} \
              --repo https://github.com/usuario/repo \
              --path deploy/ \
              --dest-server https://kubernetes.default.svc \
              --grpc-web \
              --http-retry-max 3 \
              --revision main \
              --upsert \
              --dest-namespace default
              
          argocd app sync my-app \
              --grpc-web \
              --server my-argocd.my-domain.com.br \
              --force \
              --retry-limit 3 \
              --timeout "300" \
              --auth-token ${{ secrets.ARGOCD_TOKEN }}

.github/workflows/deploy.yml

Conclusão

E pronto! Basta commitar este código no seu Github que a pipeline deve iniciar. Esse workflow faz o checkout do código, instala as dependências, roda os testes, constrói a aplicação e a imagem Docker, e finaliza com o deploy usando o ArgoCD. Agora é só relaxar e deixar a pipeline fazer o trabalho pesado.

Precisa implementar fluxos de pipelines mais complexos? Nós da Cloudscript estamos aqui pra te auxiliar. Fique a vontade entrar em contato com a gente.

Att,

Jonathan Schmitt.

Share this post