Padrões do GCP Cloud Run e AWS Fargate

Plataformas de contêineres permitem que equipes Go executem um main normal com net/http ou gRPC enquanto a nuvem gerencia escalonamento, patches e balanceamento de carga.

Cloud Run otimiza para HTTP orientado a requisições com escala para zero; AWS Fargate executa tarefas ECS sem gerenciar EC2 - frequentemente para serviços estáveis em vez de economias de ociosidade para zero.

Resumo

Envie uma imagem OCI mínima com um binário Go estático, escute em $PORT e configure verificações de saúde da plataforma.

Cloud Run define requisições simultâneas máximas por instância - ajuste-o em relação à latência do handler e ao tamanho do pool de banco de dados.

Tarefas Fargate precisam de CPU/memória na definição da tarefa, rede awsvpc e Service Connect opcional para descoberta estilo service mesh.

Ambas as plataformas se beneficiam do desligamento gracioso ciente de SIGTERM em Go.

Receita

Cartão de receita de referência rápida - pronto para copiar e colar.

srv := &http.Server{
    Addr:              ":" + port,
    Handler:           mux,
    ReadHeaderTimeout: 5 * time.Second,
    ReadTimeout:       30 * time.Second,
    WriteTimeout:      30 * time.Second,
    IdleTimeout:       120 * time.Second,
}
go func() {
    <-shutdown
    ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
    defer cancel()
    _ = srv.Shutdown(ctx)
}()
log.Fatal(srv.ListenAndServe())

# Esboço de deploy do Cloud Run
gcloud run deploy api --image IMAGE --region REGION --concurrency 80 --cpu 1 --memory 512Mi

Quando usar isso:

• APIs REST públicas com tráfego variável que devem ficar ociosas economicamente (Cloud Run).
• Workers de background ou APIs internas sempre ativas na AWS sem limites do Lambda (Fargate).
• Equipes que já estão conteinerizando Go em CI e desejam paridade com docker run local.

Exemplo de Trabalho

package main
 
import (
    "context"
    "log/slog"
    "net/http"
    "os"
    "os/signal"
    "syscall"
    "time"
)
 
func main() {
    port := os.Getenv("PORT")
    if port == "" {
        port = "8080"
    }
    mux := http.NewServeMux()
    mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusNoContent)
    })
    mux.HandleFunc("GET /readyz", func(w http.ResponseWriter, r *http.Request) {
        // opcional: pingar banco de dados com timeout curto
        w.WriteHeader(http.StatusNoContent)
    })
    mux.HandleFunc("GET /api/status", func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "application/json")
        _, _ = w.Write([]byte(`{"status":"ok"}`))
    })
 
    srv := &http.Server{
        Addr:              ":" + port,
        Handler:           mux,
        ReadHeaderTimeout: 5 * time.Second,
    }
 
    stop := make(chan os.Signal, 1)
    signal.Notify(stop, syscall.SIGTERM, syscall.SIGINT)
    go func() {
        <-stop
        slog.Info("iniciando desligamento")
        ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
        defer cancel()
        if err := srv.Shutdown(ctx); err != nil {
            slog.Error("erro no desligamento", "err", err)
        }
    }()
 
    slog.Info("escutando", "addr", srv.Addr)
    if err := srv.ListenAndServe(); err != http.ErrServerClosed {
        slog.Error("erro no servidor", "err", err)
        os.Exit(1)
    }
}

O que isso demonstra:

• Liveness (/healthz) e readiness (/readyz) separadas para orquestradores.
• ReadHeaderTimeout no servidor para proteção contra clientes lentos.
• Handler SIGTERM com Shutdown limitado - Cloud Run envia SIGTERM antes de matar o contêiner.

Análise Profunda

Como Funciona

• Cloud Run coloca um proxy gerenciado pelo Google na frente do seu contêiner, roteia HTTP para a porta do contêiner e escala instâncias com base na taxa de requisições e configurações de concorrência.
• Quando o tráfego cai para zero, o Cloud Run pode escalar para zero instâncias - você não paga nada pela computação até a próxima requisição (início a frio se aplica).
• Fargate agenda tarefas em capacidade gerenciada pela AWS; serviços ECS mantêm contagem desejada de tarefas em execução - sem escala para zero por padrão.

Botões de Ajuste do Cloud Run para Go

Padrão de Tarefa Fargate

{
  "family": "go-api",
  "cpu": "512",
  "memory": "1024",
  "networkMode": "awsvpc",
  "containerDefinitions": [{
    "name": "api",
    "image": "ACCOUNT.dkr.ecr.REGION.amazonaws.com/go-api:latest",
    "portMappings": [{"containerPort": 8080}],
    "healthCheck": {
      "command": ["CMD-SHELL", "wget -q -O- http://127.0.0.1:8080/healthz || exit 1"],
      "interval": 30,
      "timeout": 5,
      "retries": 3
    },
    "stopTimeout": 30
  }]
}

Combine o stopTimeout do contêiner com o orçamento de Shutdown do seu Go para que o ECS não mate com SIGKILL no meio do descarregamento.

Compensações da Escala para Zero

Armadilhas

• :8080 codificado ignorando PORT - Cloud Run injeta PORT; vincular a porta errada falha nas verificações de saúde do deploy. Correção: Ler os.Getenv("PORT") com fallback.
• Sem tratamento SIGTERM - A plataforma mata o processo após um curto período de graça. Correção: signal.Notify + srv.Shutdown.
• Concorrência muito alta para pools de banco de dados - 80 requisições simultâneas com MaxOpenConns=10 causa esperas ou timeouts. Correção: Alinhe a concorrência do Cloud Run com a matemática do pool.
• Imagens de contêiner grandes - Inícios a frio lentos no Cloud Run. Correção: Imagens Distroless ou scratch; builds multi-stage.
• Função de tarefa Fargate ausente - Chamadas do AWS SDK falham com acesso negado. Correção: Anexe a função de tarefa IAM paralelamente às funções de execução do Lambda.
• Readiness igual a liveness - Falhas no banco de dados reiniciam a tarefa inteira em vez de parar o tráfego. Correção: Falhe apenas em /readyz, mantenha /healthz barato.

Alternativas

FAQs

Relacionados

• Noções Básicas do Cloud Deploy - Dockerfile e gcloud run deploy
• Go na Nuvem: Lambda, Cloud Run e Além - modelos de contêiner vs função
• Segredos, IAM e Identidade de Carga de Trabalho - contas de serviço do Cloud Run e funções de tarefa Fargate
• HTTP/2, Timeouts e ReverseProxy - ajuste de http.Server em produção
• Guia de Decisão de Arquitetura Serverless Go - seleção de plataforma
• Melhores Práticas de Nuvem e Serverless - custo e observabilidade

Versões de Stack: Esta página foi escrita para Go 1.26.x (padrão GC Green Tea, go fix modernizers - verifique o patch na compilação), chi (última versão - verifique na compilação), gin (última versão - verifique na compilação), echo (última versão - verifique na compilação), google.golang.org/grpc (última versão - verifique na compilação), sigs.k8s.io/controller-runtime (última versão - verifique na compilação), kubebuilder (última versão - verifique na compilação), tinygo (última versão - verifique os alvos de placa na compilação), wazero (última versão - verifique na compilação) e golangci-lint (última versão - verifique o conjunto de linters na compilação).