Implantação Automática com GitHub Actions

Introdução

Este tutorial ensina como configurar deploy automático na Zenifra usando GitHub Actions. O fluxo permite que a imagem OCI seja construída e enviada para a Zenifra automaticamente sempre que houver uma nova alteração no repositório.

Importante: Este fluxo é para projetos com origem em Imagem OCI. Ele não substitui o fluxo de projetos criados com origem em Repositório GitHub.

Pré-requisitos

Repositório Git com o código-fonte da aplicação
Projeto HTTP já criado na Zenifra
Conta no GitHub

O que você vai aprender

Configurar GitHub Actions para build automático de imagem
Configurar deploy automático para a plataforma Zenifra
Disparar deploys via tags de versão

Passo 1: Configurar Segredos no GitHub

Antes de criar o fluxo de trabalho, configure os segredos necessários no seu repositório GitHub:

Acesse Settings > Secrets and variables > Actions do seu repositório
Adicione os seguintes segredos:

Segredo	Descrição
`OCI_USERNAME`	Username do registry Docker (ex: Docker Hub)
`OCI_PASSWORD`	Token de acesso ao registry
`ZENIFRA_PROJECT_ID`	ID do projeto na Zenifra
`ZENIFRA_API_KEY`	API Key do projeto na Zenifra

Importante: O Project ID e API Key são exibidos apenas na criação do projeto. Guarde-os em local seguro.

Passo 2: Criar o Workflow

Crie o arquivo .github/workflows/deploy.yml no seu repositório:

name: Deploy PRD

on:
  push: 
    tags:  
      - 'v[0-9]+.[0-9]+.[0-9]+'

jobs:
  build:
    name: Build e Publicar Imagem
    runs-on: ubuntu-latest
    steps:
      - name: Checkout do código
        uses: actions/checkout@v4

      - name: Configurar QEMU
        uses: docker/setup-qemu-action@v3

      - name: Configurar Docker Buildx
        uses: docker/setup-buildx-action@v3

      - name: Login no Registry
        uses: docker/login-action@v3
        with:
          username: ${{ secrets.OCI_USERNAME }}
          password: ${{ secrets.OCI_PASSWORD }}

      - name: Build e Publicar Imagem OCI
        run: |
          docker buildx build \
            --tag ${{ secrets.OCI_USERNAME }}/minha-app:${{ github.ref_name }} \
            --platform=linux/amd64 \
            --push .

  deploy:
    name: Deploy na Zenifra
    needs: build
    runs-on: ubuntu-latest
    steps:
      - name: Deploy Imagem na Zenifra
        uses: zenifra/action-zenifra-deploy@main
        with:
          PROJECT_ID: ${{ secrets.ZENIFRA_PROJECT_ID }}
          API_KEY: ${{ secrets.ZENIFRA_API_KEY }}
          IMAGE: ${{ secrets.OCI_USERNAME }}/minha-app:${{ github.ref_name }}

Configurações do Workflow

Campo	Descrição
`on.push.tags`	Dispara o fluxo de trabalho quando uma tag no formato v1.0.0 é criada
`OCI_USERNAME`	Username do seu registry Docker
`PROJECT_ID`	ID do projeto na Zenifra
`API_KEY`	Chave API do projeto
`IMAGE`	URI completa da imagem com tag

Passo 3: Disparar a Implantação

Para disparar a implantação:

Crie uma tag de versão no seu repositório:
```
git tag v1.0.0
git push origin v1.0.0
```
O GitHub Actions executará:
- Build da imagem Docker
- Publicação no registry
- Implantação automática na Zenifra

Implantação com AWS ECR

Além do Docker Hub, você pode usar o AWS ECR (Elastic Container Registry) como registro de contêineres. O exemplo abaixo demonstra um fluxo de trabalho completo usando AWS ECR.

Segredos Necessários

Adicione os seguintes segredos no seu repositório GitHub:

Segredo	Descrição
`AWS_ACCESS_KEY_ID`	AWS Access Key ID com permissões para ECR
`AWS_SECRET_ACCESS_KEY`	AWS Secret Access Key
`AWS_REGION`	Região AWS (ex: us-east-1)
`AWS_ECR_URL`	URL do seu registry ECR (ex: 123456789.dkr.ecr.us-east-1.amazonaws.com)
`ZENIFRA_PROJECT_ID`	ID do projeto na Zenifra
`ZENIFRA_API_KEY`	API Key do projeto na Zenifra

Workflow Completo (Implantação por Tag)

Este fluxo de trabalho é disparado quando uma tag no formato v1.0.0 é criada:

name: Deploy PRD

on:
  push: 
    tags:  
      - 'v[0-9]+.[0-9]+.[0-9]+'

jobs:
  build:
    name: Build e Publicar Imagem
    runs-on: ubuntu-latest
    steps:
      - name: Checkout do código
        uses: actions/checkout@v4

      - name: Configurar QEMU
        uses: docker/setup-qemu-action@v3
        with:
          platforms: linux/amd64

      - name: Configurar Docker Buildx
        uses: docker/setup-buildx-action@v3
        with:
          platforms: linux/amd64

      - name: Configurar credenciais AWS
        uses: aws-actions/configure-aws-credentials@v4
        with:
          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          aws-region: ${{ secrets.AWS_REGION }}

      - name: Login no Amazon ECR
        id: login-ecr
        uses: aws-actions/amazon-ecr-login@v2

      - name: Build e Publicar Imagem no ECR
        run: |
          docker buildx build \
            --tag ${{ secrets.AWS_ECR_URL }}/minha-app:${{ github.ref_name }} \
            --platform=linux/amd64 \
            --push .

  deploy:
    name: Deploy na Zenifra
    needs: build
    runs-on: ubuntu-latest
    steps:
      - name: Deploy Imagem na Zenifra
        uses: ramonpaolo/action-zenifra@main
        with:
          PROJECT_ID: ${{ secrets.ZENIFRA_PROJECT_ID }}
          API_KEY: ${{ secrets.ZENIFRA_API_KEY }}
          IMAGE: ${{ secrets.AWS_ECR_URL }}/minha-app:${{ github.ref_name }}

Workflow para Pull Requests (Implantação de Staging)

Este fluxo de trabalho é disparado a cada pull request aberto ou atualizado:

name: Deploy STG

on:
  pull_request:
    types:
      - opened
      - synchronize

jobs:
  build:
    name: Build e Publicar Imagem
    runs-on: ubuntu-latest
    permissions:
      contents: write
    steps:
      - name: Checkout do código
        uses: actions/checkout@v4

      - name: Configurar QEMU
        uses: docker/setup-qemu-action@v3
        with:
          platforms: linux/amd64

      - name: Configurar Docker Buildx
        uses: docker/setup-buildx-action@v3
        with:
          platforms: linux/amd64

      - name: Configurar credenciais AWS
        uses: aws-actions/configure-aws-credentials@v4
        with:
          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          aws-region: ${{ secrets.AWS_REGION }}

      - name: Login no Amazon ECR
        id: login-ecr
        uses: aws-actions/amazon-ecr-login@v2

      - name: Build e Publicar Imagem no ECR
        run: |
          docker buildx build \
            --tag ${{ secrets.AWS_ECR_URL }}/minha-app-stg:${{ github.sha }} \
            --platform=linux/amd64 \
            --push .

  deploy:
    name: Deploy na Zenifra
    needs: build
    runs-on: ubuntu-latest
    steps:
      - name: Deploy Imagem na Zenifra
        uses: ramonpaolo/action-zenifra@main
        with:
          PROJECT_ID: ${{ secrets.ZENIFRA_PROJECT_ID_STG }}
          API_KEY: ${{ secrets.ZENIFRA_API_KEY_STG }}
          IMAGE: ${{ secrets.AWS_ECR_URL }}/minha-app-stg:${{ github.sha }}

Vantagens do AWS ECR

Vantagem	Descrição
Integração AWS	Integrado nativamente com outros serviços AWS
Performance	Baixa latência quando usado com EC2/ECS/Fargate
Segurança	Criptografia em repouso com KMS
Custo	Pague apenas pelo armazenamento usado
IAM	Controle de acesso granular via políticas IAM

Criando um Repository no ECR

Antes de usar o fluxo de trabalho, crie um repositório no AWS ECR:

aws ecr create-repository \
  --repository-name minha-app \
  --region us-east-1

O comando retornará a URL do repository:

123456789.dkr.ecr.us-east-1.amazonaws.com/minha-app

Validação

Para verificar se o deploy foi realizado com sucesso:

Acesse o console da Zenifra
Selecione seu projeto
Verifique na aba Deployments se há um novo deploy com status "success"
Acesse a URL do projeto para confirmar que a nova versão está ativa

Próximos Passos

FAQ

Posso usar outro registry além do Docker Hub?

Sim. Você pode usar AWS ECR, Google Container Registry (GCR), GitHub Container Registry (GHCR), Azure Container Registry (ACR), entre outros. Cada um possui sua própria ação de login:

AWS ECR: aws-actions/amazon-ecr-login@v2
GCR/Artifact Registry: docker/login-action@v3
GHCR: docker/login-action@v3 (username: ${{ github.actor }}, password: ghp_xxx)

Como funciona o versionamento?

O fluxo de trabalho usa a tag do Git como versão da imagem. Por exemplo, ao criar a tag v1.2.3, a imagem será sua-app:v1.2.3.

Qual a diferença entre deploy por tag vs. por pull request?

Aspecto	Por Tag	Por Pull Request
Uso típico	Produção	Staging/QA
Versionamento	Semântico (v1.0.0)	Hash do commit
Trigger	`git push tag v1.0.0`	`git push` na branch
Ambiente	PRD	STG

O que acontece se o build falhar?

O deploy na Zenifra não será executado. Você receberá uma notificação de falha pelo GitHub Actions com os logs de erro.

Como configurar permissões IAM para AWS ECR?

Crie uma política IAM com as seguintes permissões:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "ecr:GetAuthorizationToken",
        "ecr:BatchCheckLayerAvailability",
        "ecr:GetDownloadUrlForLayer",
        "ecr:BatchGetImage",
        "ecr:PutImage"
      ],
      "Resource": "arn:aws:ecr:us-east-1:123456789:repository/minha-app"
    }
  ]
}

Posso fazer deploy multi-plataforma (AMD64 + ARM64)?

Sim! Adicione ambas as plataformas na configuração:

- name: Configurar QEMU
  uses: docker/setup-qemu-action@v3
  with:
    platforms: linux/amd64,linux/arm64

- name: Configurar Docker Buildx
  uses: docker/setup-buildx-action@v3
  with:
    platforms: linux/amd64,linux/arm64

Nessa Página