Quer aprender a automatizar seu deploy no Google Cloud Run usando o GCP Artifact Registry?
Hoje vou te mostrar um passo a passo que normalmente ninguém explica. Essa prática vai levar suas habilidades de Cloud Computing e DevOps para outro nível, aumentando suas oportunidades profissionais.
Dominar o deploy automatizado une o conhecimento de desenvolvimento de software com a infraestrutura em nuvem, criando uma expertise escassa e altamente valorizada no mercado.
Esse é o primeiro passo para dominar o deploy automatizado.
Aqui você vai entender como dar as permissões certas para sua conta de serviço e, ao mesmo tempo, aprender a manejar a nuvem com inteligência financeira. Isso porque não adianta só subir projeto na GCP: é preciso saber reduzir custos e maximizar valor, uma habilidade rara e que diferencia o profissional comum do verdadeiro especialista.
Passos:
Finalize clicando em Concluído.
Agora que criamos a conta de serviço, precisamos gerar a chave JSON para que o GitHub Actions consiga autenticar no Google Cloud.
O download do arquivo JSON será feito automaticamente para o seu computador.
⚠️ Atenção máxima aqui:
👉 Guarde esse JSON em um local seguro.
Mais à frente, vamos armazená-lo nos Secrets do GitHub, para que o workflow de deploy use essas credenciais de forma protegida, sem nunca expor os dados no repositório público.
No console da GCP, pesquise por Artifact Registry.
Habilite o serviço, clique em Criar Repositório e escolha o tipo Docker.
Aqui está um detalhe fundamental que diferencia um desenvolvedor de alguém que domina Cloud Economics: a escolha da região.
💡 Conselho de especialista:
Sempre que possível, configure o Artifact Registry na mesma região do seu Cloud Run e dos seus principais serviços.
👉 Por quê?
Porque a GCP não cobra apenas pela instância em execução, mas também pelo egress.
Egress é o tráfego de dados que sai de um serviço da GCP para outro local (pode ser outra região, outro provedor de cloud, ou até para a internet).
Esse é o tipo de decisão que, quando multiplicada por milhões de requisições, pode economizar milhares de dólares para sua empresa.
É aqui que a expertise em arquitetura cloud e a visão de otimização de custos fazem toda a diferença.
southamerica-east1
, para evitar custos de egress).Agora você terá onde armazenar as imagens Docker do seu projeto.
No seu servidor ou workflow de CI, instale o Google Cloud SDK:
sudo apt-get update && sudo apt-get install -y apt-transport-https ca-certificates gnupg curl
curl -fsSL https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo gpg --dearmor -o /usr/share/keyrings/cloud.google.gpg
echo "deb [signed-by=/usr/share/keyrings/cloud.google.gpg] https://packages.cloud.google.com/apt cloud-sdk main" | sudo tee /etc/apt/sources.list.d/google-cloud-sdk.list
sudo apt update
sudo apt install google-cloud-cli
Verifique a instalação:
gcloud version
Autentique-se com a chave JSON:
gcloud auth activate-service-account --key-file=./gcp-auth-file.json
Selecione o projeto:
gcloud config set project PROJECT_ID
Faça o build e envie para o Artifact Registry:
gcloud builds submit --tag southamerica-east1-docker.pkg.dev/SEU_PROJECT_ID/MEU_REPO/NOME_IMAGEM:latest
Agora que já temos a imagem Docker no Artifact Registry, é hora de configurar o Cloud Run, que será responsável por rodar seu serviço.
O Google Cloud Run é uma plataforma serverless que roda containers. Isso traz várias vantagens:
Esse é o poder de uma plataforma serverless moderna: você ganha velocidade, reduz custos e ainda leva para o mercado a expertise de entregar soluções que escalam sozinhas.
Clique em Criar e o deploy será iniciado.
deploy.sh
Antes de configurar o workflow do GitHub Actions, precisamos criar o script que vai orquestrar o processo de deploy: o deploy.sh
.
Esse script é quem faz todo o trabalho pesado: autenticação, build da imagem, atualização do Cloud Run e até a limpeza de imagens antigas no Artifact Registry.
Ou seja, é a peça que garante que seu deploy não só acontece, mas acontece de forma organizada e sustentável.
Crie um arquivo chamado deploy.sh
na raiz do projeto e adicione o seguinte conteúdo:
#!/bin/bash
set -e
# Verifica se todas as variáveis necessárias estão definidas
: "${PROJECT_ID:?Missing PROJECT_ID}"
: "${REPO_NAME:?Missing REPO_NAME}"
: "${REGION:?Missing REGION}"
: "${IMAGE_NAME:?Missing IMAGE_NAME}"
: "${IMAGE_TAG:?Missing IMAGE_TAG}"
: "${GCP_AUTH_KEY:?Missing GCP_AUTH_KEY}"
: "${CLOUD_RUN_JOB:?Missing CLOUD_RUN_JOB}"
KEEP_IMAGES=1
FULL_IMAGE_NAME="$REGION-docker.pkg.dev/$PROJECT_ID/$REPO_NAME/$IMAGE_NAME:$IMAGE_TAG"
AUTH_FILE=$(mktemp)
cleanup() {
rm -f "$AUTH_FILE"
}
trap cleanup EXIT
echo "$GCP_AUTH_KEY" > "$AUTH_FILE"
echo "🔐 Authenticating with Google Cloud..."
gcloud auth activate-service-account --key-file="$AUTH_FILE"
gcloud config set project "$PROJECT_ID"
echo "📸 Getting current Cloud Run job image (for rollback reference)..."
CURRENT_IMAGE=$(gcloud run jobs describe "$CLOUD_RUN_JOB" --region="$REGION" --format="value(spec.template.spec.template.spec.containers[0].image)" 2>/dev/null || echo "none")
echo "Current image: $CURRENT_IMAGE"
echo "✅ Submitting build to GCP..."
gcloud builds submit --tag "$FULL_IMAGE_NAME"
echo "✅ Fetching latest image name..."
NEW_IMAGE=$(gcloud builds list --limit=1 --format="value(images)")
echo "✅ Build completed. Image: $NEW_IMAGE"
echo "🚀 Updating Cloud Run job: $CLOUD_RUN_JOB"
gcloud run jobs update "$CLOUD_RUN_JOB" \
--image="$NEW_IMAGE" \
--region="$REGION"
echo "✅ Cloud Run job updated successfully!"
echo "🧹 Cleaning up old images from Artifact Registry..."
echo "Fetching image list..."
OLD_IMAGES=$(gcloud artifacts docker images list "$REGION-docker.pkg.dev/$PROJECT_ID/$REPO_NAME/$IMAGE_NAME" \
--format="value(IMAGE)" \
--sort-by="~CREATE_TIME" \
--limit=100)
if [ -z "$OLD_IMAGES" ]; then
echo "No images found to clean up"
else
IMAGE_ARRAY=($OLD_IMAGES)
TOTAL_IMAGES=${#IMAGE_ARRAY[@]}
echo "Found $TOTAL_IMAGES total images"
echo "Keeping $KEEP_IMAGES most recent images"
if [ $TOTAL_IMAGES -gt $KEEP_IMAGES ]; then
IMAGES_TO_DELETE=${IMAGE_ARRAY[@]:$KEEP_IMAGES}
echo "Deleting $(($TOTAL_IMAGES - $KEEP_IMAGES)) old images..."
for img in $IMAGES_TO_DELETE; do
echo "Deleting: $img"
gcloud artifacts docker images delete "$img" --quiet --async || echo "⚠️ Failed to delete $img"
done
echo "✅ Cleanup initiated (running asynchronously)"
else
echo "No old images to delete (only $TOTAL_IMAGES images, keeping $KEEP_IMAGES)"
fi
fi
echo "🎉 Deployment completed successfully!"
echo "📋 Summary:"
echo " - Previous image: $CURRENT_IMAGE"
echo " - New image: $NEW_IMAGE"
echo " - Cloud Run job: $CLOUD_RUN_JOB (updated)"
echo " - Old images: cleanup initiated"
Salve o arquivo, dê permissão de execução:
chmod +x deploy.sh
E pronto: agora você tem um motor de deploy inteligente pronto para ser chamado pelo GitHub Actions.
Crie o script deploy.sh
para autenticar, buildar e atualizar o Cloud Run.
Em seguida, crie o arquivo .github/workflows/deploy.yml
:
name: Build and Deploy Image to Artifact Registry
on:
push:
branches:
- main
jobs:
deploy:
runs-on: ubuntu-latest
env:
PROJECT_ID: ${{ secrets.PROJECT_ID }}
REPO_NAME: ${{ secrets.REPO_NAME }}
REGION: ${{ secrets.REGION }}
IMAGE_NAME: ${{ secrets.IMAGE_NAME }}
IMAGE_TAG: ${{ secrets.IMAGE_TAG }}
GCP_AUTH_KEY: ${{ secrets.GCP_AUTH_KEY }}
CLOUD_RUN_JOB: ${{ secrets.CLOUD_RUN_JOB }}
steps:
- name: Checkout code
uses: actions/checkout@v4
- name: Set up Google Cloud CLI
uses: google-github-actions/setup-gcloud@v2
with:
project_id: ${{ secrets.PROJECT_ID }}
service_account_key: ${{ secrets.GCP_AUTH_KEY }}
export_default_credentials: true
- name: Run deploy script
run: |
chmod +x ./deploy.sh
./deploy.sh
Todos os valores usados no arquivo deploy.yml
são carregados a partir de secrets do GitHub.
Isso garante que informações sensíveis, como sua chave JSON do GCP, ID do projeto e outros dados, não fiquem expostos no repositório.
Passos para configurar:
deploy.yml
(ex.: PROJECT_ID
, REPO_NAME
, REGION
, IMAGE_NAME
, IMAGE_TAG
, GCP_AUTH_KEY
, CLOUD_RUN_JOB
).PROJECT_ID
: ID do seu projeto no GCPREPO_NAME
: Nome do repositório no Artifact RegistryREGION
: Região (ex.: southamerica-east1
)IMAGE_NAME
: Nome da imagem DockerIMAGE_TAG
: Normalmente latest
ou outra tag de sua escolhaGCP_AUTH_KEY
: conteúdo completo do arquivo JSON da conta de serviçoCLOUD_RUN_JOB
: Nome do seu serviço/job no Cloud RunDepois de configurados, os secrets poderão ser acessados no workflow através da sintaxe:
${{ secrets.NOME_DO_SECRET }}
Com esses passos, você configurou um deploy automático no GCP Cloud Run usando Artifact Registry e GitHub Actions.
Isso garante mais agilidade, menos erros e uma cultura DevOps mais sólida.
Se quiser que eu aprofunde em rollback, ambientes de staging ou uso de GPU no Cloud Run, comente abaixo.
Artigo por Anderson Arruda.
Seja o primeiro a comentar o nosso artigo!