Azure Functions y Container Apps para Go

Microsoft Azure aloja Go a través de dos rutas principales: Azure Functions con un proceso de manejador personalizado y Azure Container Apps (ACA) para imágenes OCI con reglas de escala.

Ambos aceptan los mismos patrones de binarios estáticos de Go que utilizas en AWS y GCP; las diferencias radican en los contratos de alojamiento y la configuración de la identidad.

Resumen

Los manejadores personalizados de Functions permiten que Go posea un servidor HTTP en un puerto asignado por la plataforma, mientras que el host de Functions le reenvía los eventos del disparador.

Container Apps ejecuta tu imagen como Cloud Run con escalado a cero opcional y disparadores KEDA (HTTP, colas, cron).

Utiliza la identidad administrada y las referencias a Key Vault en lugar de cadenas de conexión en la configuración de la aplicación.

Receta

Tarjeta de receta de referencia rápida, lista para copiar y pegar.

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

# Esquema de implementación de Container Apps
az containerapp up --name go-api --source . --ingress external --target-port 8080

Cuándo recurrir a esto:

• Organizaciones centradas en Azure que necesitan disparadores de eventos (Storage, Service Bus) con lógica de negocio en Go.
• Microservicios HTTP en ACA con escalado a cero y opciones de entrada interna.
• Equipos híbridos que ejecutan Go en Azure junto con infraestructura .NET existente.

Ejemplo de Trabajo

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, "json malo", http.StatusBadRequest)
            return
        }
        slog.Info("evento", "claves", len(payload))
        w.Header().Set("Content-Type", "application/json")
        _ = json.NewEncoder(w).Encode(response{Message: "procesado"})
    })
    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("escuchando", "puerto", port)
    if err := http.ListenAndServe(":"+port, mux); err != nil {
        slog.Error("fallo al escuchar", "err", err)
        os.Exit(1)
    }
}

Lo que esto demuestra:

• Soporte dual de puertos de entorno: FUNCTIONS_CUSTOMHANDLER_PORT para Functions, PORT para Container Apps.
• Manejador JSON adecuado para Functions activadas por HTTP o entrada de ACA.
• Registro estructurado para la ingesta de Application Insights.

Análisis Profundo

Cómo Funciona

• Functions con manejador personalizado inician tu proceso Go; el host de Functions reenvía las solicitudes de disparador HTTP a las rutas que registras.
• Los disparadores no HTTP (Cola, Temporizador) aún llegan como llamadas HTTP a tus puntos de conexión del manejador según el contrato del manejador personalizado de Functions.
• Container Apps coloca tu contenedor en un entorno administrado con entrada, secretos y réplicas controlados por reglas de escala.

Functions vs Container Apps

Esenciales de host.json y function.json

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

Empareja cada disparador con una ruta que tu mux de Go implemente; las rutas no coincidentes devuelven un 404 desde tu proceso mientras que el host sigue facturando la invocación.

Entrada de Container Apps

• La entrada Externa expone un punto de conexión HTTPS público (similar a los servicios públicos de Cloud Run).
• La entrada Interna limita el tráfico a la VNet del entorno de ACA.
• Establece el puerto de destino al puerto en el que escucha tu binario Go dentro del contenedor.

Errores Comunes

• Falta FUNCTIONS_CUSTOMHANDLER_PORT: El host de Functions asigna el puerto; codificar 8080 de forma fija falla localmente con func start. Solución: Siempre enlaza os.Getenv("FUNCTIONS_CUSTOMHANDLER_PORT").
• Cadenas de conexión en la configuración de la aplicación: Las claves rotan y se filtran a través de exportaciones del portal. Solución: Identidad administrada + referencias a secretos de Key Vault.
• Arranque en frío en el plan de Consumo: El manejador personalizado aún incurre en el costo de inicio del proceso. Solución: Plan Premium o mover HTTP constante a Container Apps.
• Ignorar SIGTERM de ACA: Los mismos requisitos de apagado elegante que Cloud Run. Solución: signal.Notify + http.Server.Shutdown.
• Mezclar enlaces de Functions con middleware HTTP pesado: El host de Functions espera respuestas rápidas; el trabajo largo pertenece a flujos activados por cola. Solución: Descargar a Service Bus y una aplicación ACA trabajadora.
• Dockerfile no escucha en 0.0.0.0: Enlazar a 127.0.0.1 rompe las sondas de estado de entrada. Solución: Escuchar en 0.0.0.0 / : + puerto.

Alternativas

Preguntas Frecuentes

Relacionados

• Conceptos Básicos de Despliegue en la Nube - diseño de módulos compartidos y patrones Docker
• Go en la Nube: Lambda, Cloud Run y Más Allá - comparación entre nubes
• Patrones de GCP Cloud Run y AWS Fargate - salud y apagado de contenedores
• Secretos, IAM y Identidad de Carga de Trabajo - paralelos de identidad administrada
• Guía de Decisión de Arquitectura Serverless de Go - elige la forma adecuada de Azure
• Mejores Prácticas de Nube y Serverless - observabilidad en Azure

Versiones de Stack: Esta página se escribió para Go 1.26.x (predeterminado Green Tea GC, go fix modernizers - verifica el parche en la compilación), chi (última versión - verifica en la compilación), gin (última versión - verifica en la compilación), echo (última versión - verifica en la compilación), google.golang.org/grpc (última versión - verifica en la compilación), sigs.k8s.io/controller-runtime (última versión - verifica en la compilación), kubebuilder (última versión - verifica en la compilación), tinygo (última versión - verifica los objetivos de placa en la compilación), wazero (última versión - verifica en la compilación) y golangci-lint (última versión - verifica el conjunto de linters en la compilación).