Como fazer o upload de imagens Docker para a Huawei Cloud usando o GitHub Actions

O GitHub Actions é uma ferramenta nativa do GitHub que permite a orquestração de workflows diretamente na própria plataforma. Esses workflows são definidos por arquivos YAML, que descrevem de forma declarativa o passo a passo de uma automação. Eles podem ser acionados a partir de eventos no repositório, como a abertura de um pull request, um commit ou a criação de um release.

Em pipelines de CI/CD, o GitHub Actions ajuda a reduzir processos manuais e a garantir a execução consistente das mesmas etapas em todos os ambientes. No contexto de provisionamento de recursos em nuvem, é possível utilizá-lo para criar um container registry por meio do Terraform, estabelecer a conexão com esse registry e enviar as imagens de contêiner para ele - tudo de forma automatizada por meio de workflows.

Neste blog, iremos demonstrar como criar um workflow capaz de provisionar um container registry na Huawei Cloud - o SWR (SoftWare Repository for Contianer) - e enviar imagens de contêiner para esse registry de forma automatizada.

1. Criando um OBS Bucket para armazenar o arquivo tfstate

Primeiramente, precisamos configurar nosso Terraform para armazenar o arquivo tfstate para um bucket OBS. O tfstate é um arquivo do Terraform que mapeia os recursos de infraestrutura com as configurações declaradas, permitindo que o Terraform saiba o que criar, atualizar ou destruir, armazenando o "estado" atual do seu ambiente.

Por padrão, é um arquivo JSON local (terraform.tfstate), mas para trabalho em equipe e segurança, deve-se usar armazenamento remoto (backends), como o OBS.

Para acessar a página do OBS na Huawei Cloud:

1. Clique em Service List (botão vermelho) localizado no canto superior esquerdo da console da Huawei Cloud;

2. Procure por "OBS";

3. Clique em Object Storage Service.

Na página do serviço OBS, clique no botão Create Bucket localizado no canto superior direto.

Forneça um nome para o bucket, selecione a opção Standard e a política do bucket como private. Por fim, clique em Create Now no canto inferior direito da tela.

2. Preparando o repositório e as credenciais no GitHub

O segundo passo é preparar o repositório no GitHub. No seu repositório, clique em Settings > Secrets and variables > Actions para acessar a página para configuração de Secrets e Variables.

No GitHub, devemos configurar os seguintes Secrets, que serão utilizados pelo workflow para autenticação na Huawei Cloud:

• HWC_ACCESS_KEY
• HWC_SECRET_KEY

Além disso, utilizamos Repository Variables para armazenar valores reutilizáveis e não sensíveis, como:

• HWC_OBS_BUCKET_NAME (bucket usado como backend remoto do Terraform)

3. Configurando o terraform para cirar o SWR

Com o repositório configurado, o próximo passo é provisionar o Container Registry da Huawei Cloud (SWR). A configuração é dividida em dois níveis:

1. Configuração principal do Terraform e do provider;
2. Módulo responsável pela criação do registry.

Configuração principal do Terraform (main.tf)

terraform {
  required_providers {
    huaweicloud = {
      source  = "huaweicloud/huaweicloud"
      version = "1.82.2"
    }
  }

Aqui especificamos o provider da Huawei Cloud e fixamos a versão para garantir consistência entre ambientes e execuções do pipeline.

backend "s3" {
  key    = "terraform.tfstate"
  region = "sa-brazil-1"

  endpoints = {
    s3 = "https://obs.sa-brazil-1.myhuaweicloud.com"
  }

  skip_region_validation      = true
  skip_credentials_validation = true
  skip_metadata_api_check     = true
  skip_requesting_account_id  = true
  skip_s3_checksum            = true
}

Nesse projeto, o state do Terraform é armazenado em um bucket OBS da Huawei Cloud, utilizando o backend S3-compatible.

provider "huaweicloud" {
  region     = var.region
  access_key = var.access_key
  secret_key = var.secret_key
}

O provider utiliza variáveis para região e credenciais. Essas variáveis são injetadas automaticamente pelo GitHub Actions por meio de variáveis de ambiente (TF_VAR_*). Assim, nenhuma credencial sensível fica exposta no código.

module "registry" {
  source = "./modules/registry"
  organization_name = var.organization_name
  repo_name      = var.repo_name
}

Aqui chamamos o módulo responsável por criar o SWR. Esse módulo encapsula toda a lógica relacionada ao registry, tornando o código principal mais limpo e fácil de manter. Note que é necessário criar também arquivos variables.tf onde serão armazenadas as variáveis.

Módulo do Container Registry (modules/registry/main.tf)

O módulo define a criação do SWR na Huawei Cloud.

terraform {
  required_providers {
    huaweicloud = {
      source  = "huaweicloud/huaweicloud"
      version = "1.82.2"
    }
  }
}

resource "huaweicloud_swr_organization" "org" {
  name = var.organization_name
}

resource "huaweicloud_swr_repository" "repo" {
  organization = huaweicloud_swr_organization.org.id
  name         = var.awesome_repo
}

4. Criando o Dockerfile (docker/Dockerfile)

Precisamos agora criar o arquivo Dockerfile que irá definir nossa imagem do container. Nossa imagem utilizará o NGINX mas com uma página própria nossa.

Crie uma pasta docker e, dentro dela, adicione o arquivo Dockerfile:

FROM nginx:alpine

COPY ./docker/index.html /usr/share/nginx/html/index.html

Na mesma pasta, crie o arquivo index.html com alguma mensagem no corpo do arquivo.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Docker Test</title>
</head>
<body>
    Hello from Huawei Cloud Brasil Team!
</body>
</html>

5. GitHub Actions

Agora, vamos configurar nossos workflows para aplicar o terraform e fazer o push da imagem para o registry. Teremos um workflow para a criação do registry e um outro workflow para enviar a imagem para o SWR.

Provisionando o SWR com Terraform

O primeiro workflow é responsável por criar a organização e o repositório no Software Repository for Container (SWR). Crie o arquivo .github/workflows/terraform-registry.yaml com o seguinte conteúdo:

name: Terraform – Create SWR

on:
  push:
    branches: [ "main" ]
  workflow_dispatch:
    inputs:
      approve:
        description: "Approve Terraform Apply?"
        required: true
        default: "skip"
        type: choice
        options:
          - skip
          - apply

env:
  # Variáveis utilizadas pelo provider da Huawei Cloud
  TF_VAR_access_key: ${{ secrets.HWC_ACCESS_KEY }}
  TF_VAR_secret_key: ${{ secrets.HWC_SECRET_KEY }}

  # Variáveis necessárias para o backend remoto no OBS (S3-compatible)
  AWS_ACCESS_KEY_ID: ${{ secrets.HWC_ACCESS_KEY }}
  AWS_SECRET_ACCESS_KEY: ${{ secrets.HWC_SECRET_KEY }}
  AWS_RESPONSE_CHECKSUM_VALIDATION: when_required
  AWS_REQUEST_CHECKSUM_CALCULATION: when_required

jobs:
  registry:
    name: Terraform – Registry
    runs-on: ubuntu-latest

    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      - name: Setup Terraform
        uses: hashicorp/setup-terraform@v3
        with:
          terraform_version: 1.6.6

      - name: Terraform Init
        run: terraform init -backend-config="bucket=${{ vars.HWC_OBS_BUCKET_NAME }}"

      - name: Apply SWR module
        run: terraform apply -auto-approve -target=module.registry

Esse workflow irá:

1. Fazer o checkout do repositório;
2. Instalar a versão definida do Terraform;
3. Inicializar o backend remoto utilizando um bucket OBS;
4. Aplicar somente o módulo responsável pelo registry, utilizando o parâmetro -target.

O uso do -target=module.registry garante que apenas os recursos relacionados ao SWR sejam criados, evitando a aplicação de outros recursos que possam existir futuramente no projeto.

Adquirindo a senha de login do Docker no SWR

Após a execução bem-sucedida do primeiro workflow, o Container Registry já estará disponível na Huawei Cloud. O próximo passo é gerar a senha de autenticação do Docker, que será utilizada para enviar imagens ao registry.

Primeiro, acesse a página do SWR na console da Huawei.

Em seguida, na página de Dashboard, clique no botão Generate Login Command, depois, para um login temporário, em Temporary Login Command. Copie a senha após o parâmetro -p do comando gerado.

No Secrets do GitHub, adicione mais uma secret com o nome DOCKER_LOGIN_PASS e atribua a ela o valor da senha.

Também crie duas variáveis em Variables para o nome da organização e do repositório onde será armazenada a imagem: ORGANIZATION_NAME e REPO_NAME.

Build e Push da imagem Docker

Com o registry criado e a senha de login configurada no GitHub, podemos automatizar o build e o push da imagem Docker. Crie o arquivo .github/workflows/docker-build-push.yaml com o seguinte conteúdo:

name: Build & Push Image to SWR

on:
  workflow_dispatch:

jobs:
  build:
    name: Build & Push Image
    runs-on: ubuntu-latest

    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      - name: Login to SWR
        run: |
          docker login \
            -u sa-brazil-1@${{ secrets.HWC_ACCESS_KEY }} \
            -p ${{ secrets.DOCKER_LOGIN_PASS }} \
            swr.sa-brazil-1.myhuaweicloud.com

      - name: Build Docker image
        run: |
          docker build \
            -f docker/Dockerfile \
            -t ${{ vars.SWR_URL }}/${{ vars.ORGANIZATION_NAME }}/${{ vars.REPO_NAME }}:latest .

      - name: Push Docker image
        run: |
          docker push \
            ${{ vars.SWR_URL }}/${{ vars.ORGANIZATION_NAME }}/${{ vars.REPO_NAME }}:latest

Para executar:

1. Vá até Actions no GitHub;
2. Selecione o workflow Build & Push Image to SWR;
3. Clique em Run workflow.

Uma vez executado com sucesso, a imagem será enviada para o SWR, podendo ser utilizada por workloads no CCE e no CCI da Huawei Cloud.

6. Conclusão

Com essa abordagem, conseguimos separar claramente as responsabilidades:

• Terraform é utilizado para provisionar a infraestrutura de forma declarativa;

• GitHub Actions automatiza tanto o provisionamento quanto o ciclo de build e entrega da imagem;

• O SWR passa a ser um registry centralizado e reutilizável para múltiplas pipelines.

Essa separação em dois workflows reflete um cenário real de produção, facilita a manutenção do pipeline e reduz acoplamentos desnecessários entre infraestrutura e entrega de aplicações.

Os repositórios do GitHub contendo pipelines semelhantes e mais exemplos de terraform podem ser encontrados em:

• Two Step Terraform HWC: https://github.com/MatheusFarias03/TwoStepTerraformHWC
• Huawei Cloud Terraform with GitHub Actions: https://github.com/gutierrezps/huaweicloud-terraform-github-actions