Azure Functions & Container Apps para Go

O Microsoft Azure hospeda Go através de dois caminhos principais: Azure Functions com um processo de manipulador personalizado e Azure Container Apps (ACA) para imagens OCI com regras de escala.

Ambos aceitam os mesmos padrões de binário Go estático que você usa na AWS e GCP - as diferenças estão nos contratos de hospedagem e na conexão de identidade.

Resumo

Os manipuladores personalizados do Functions permitem que o Go controle um servidor HTTP em uma porta atribuída pela plataforma, enquanto o host do Functions roteia eventos de gatilho para ele.

Os Container Apps executam sua imagem como o Cloud Run com opções de escala para zero e gatilhos KEDA (HTTP, filas, cron).

Use identidade gerenciada e referências do Key Vault em vez de strings de conexão nas configurações do aplicativo.

Receita

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

// cmd/functions/main.go - esqueleto do manipulador personalizado
http.HandleFunc("/api/HttpExample", func(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    _, _ = w.Write([]byte(`{"message":"hello from go"}`))
})
port := os.Getenv("FUNCTIONS_CUSTOMHANDLER_PORT")
log.Fatal(http.ListenAndServe(":"+port, nil))

# Esboço de implantação do Container Apps
az containerapp up --name go-api --source . --ingress external --target-port 8080

Quando usar isso:

• Organizações com foco principal no Azure que precisam de gatilhos de eventos (Storage, Service Bus) com lógica de negócios Go.
• Microsserviços HTTP no ACA com escala para zero e opções de entrada interna.
• Equipes híbridas executando Go no Azure ao lado da infraestrutura .NET existente.

Exemplo de Trabalho

package main
 
import (
    "encoding/json"
    "log/slog"
    "net/http"
    "os"
)
 
type response struct {
    Message string `json:"message"`
}
 
func main() {
    slog.SetDefault(slog.New(slog.NewJSONHandler(os.Stdout, nil)))
    mux := http.NewServeMux()
    mux.HandleFunc("POST /api/process", func(w http.ResponseWriter, r *http.Request) {
        var payload map[string]any
        if err := json.NewDecoder(r.Body).Decode(&payload); err != nil {
            http.Error(w, "bad json", http.StatusBadRequest)
            return
        }
        slog.Info("event", "keys", len(payload))
        w.Header().Set("Content-Type", "application/json")
        _ = json.NewEncoder(w).Encode(response{Message: "processed"})
    })
    mux.HandleFunc("GET /health", func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusNoContent)
    })
 
    port := os.Getenv("FUNCTIONS_CUSTOMHANDLER_PORT")
    if port == "" {
        port = os.Getenv("PORT")
    }
    if port == "" {
        port = "8080"
    }
    slog.Info("listening", "port", port)
    if err := http.ListenAndServe(":"+port, mux); err != nil {
        slog.Error("listen failed", "err", err)
        os.Exit(1)
    }
}

O que isso demonstra:

• Suporte a porta dupla de ambiente: FUNCTIONS_CUSTOMHANDLER_PORT para Functions, PORT para Container Apps.
• Manipulador JSON adequado para Functions acionados por HTTP ou entrada ACA.
• Logging estruturado para ingestão do Application Insights.

Mergulho Profundo

Como Funciona

• Functions de manipulador personalizado iniciam seu processo Go; o host do Functions encaminha as solicitações de gatilho HTTP para rotas que você registra.
• Gatilhos não HTTP (Fila, Temporizador) ainda chegam como chamadas HTTP para seus endpoints de manipulador de acordo com o contrato de manipulador personalizado do Functions.
• Container Apps colocam seu contêiner em um ambiente gerenciado com entrada, segredos e réplicas controlados por regras de escala.

Functions vs Container Apps

Essenciais de host.json e function.json

{
  "bindings": [{
    "authLevel": "function",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": ["post"],
    "route": "process"
  }, {
    "type": "http",
    "direction": "out",
    "name": "res"
  }]
}

Emparelhe cada gatilho com uma rota que seu mux Go implementa; rotas incompatíveis retornam 404 do seu processo enquanto o host ainda fatura a invocação.

Entrada do Container Apps

• A entrada Externa expõe um endpoint HTTPS público (semelhante aos serviços públicos do Cloud Run).
• A entrada Interna limita o tráfego à VNet do ambiente ACA.
• Defina a porta de destino para a porta em que seu binário Go escuta dentro do contêiner.

Armadilhas

• FUNCTIONS_CUSTOMHANDLER_PORT Ausente - O host do Functions atribui a porta; codificar 8080 falha localmente sob func start. Correção: Sempre vincule os.Getenv("FUNCTIONS_CUSTOMHANDLER_PORT").
• Strings de conexão nas configurações do aplicativo - As chaves rotacionam e vazam por meio de exportações do portal. Correção: Identidade gerenciada + referências de segredo do Key Vault.
• Cold start no plano de Consumo - O manipulador personalizado ainda incorre no custo de inicialização do processo. Correção: Plano Premium ou mova HTTP estável para Container Apps.
• Ignorando ACA SIGTERM - Os mesmos requisitos de desligamento gracioso do Cloud Run. Correção: signal.Notify + http.Server.Shutdown.
• Misturando associações do Functions com middleware HTTP pesado - O host do Functions espera respostas rápidas; trabalho pesado pertence a fluxos acionados por fila. Correção: Descarregue para Service Bus e um aplicativo ACA worker.
• Dockerfile não escutando em 0.0.0.0 - Vincular 127.0.0.1 quebra as sondas de integridade de entrada. Correção: Escute em 0.0.0.0 / : + porta.

Alternativas

FAQs

Relacionados

• Noções Básicas de Implantação na Nuvem - layout de módulo compartilhado e padrões Docker
• Go na Nuvem: Lambda, Cloud Run e Além - comparação entre nuvens
• Padrões GCP Cloud Run & AWS Fargate - integridade e desligamento de contêiner
• Segredos, IAM e Identidade de Carga de Trabalho - paralelos de identidade gerenciada
• Guia de Decisão de Arquitetura Serverless Go - escolha a forma Azure correta
• Melhores Práticas de Nuvem e Serverless - observabilidade no Azure

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).