Fundamentos de Estudios de Caso

11 ejemplos para empezar con Estudios de Caso: 8 básicos y 3 intermedios.

Prerrequisitos

• Instala Go 1.26.x o posterior desde go.dev/dl.
• Clona o navega por las páginas site/go/case-studies/ de este sitio junto con tu propio módulo.
• Opcional: go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest para comparar la postura del linter con las compilaciones de referencia.
• Lee rápidamente Aprender de Sistemas Go en Producción para entender cómo los estudios de caso difieren de los tutoriales.

Ejemplos Básicos

1. Identifica el Contrato Operativo

Antes de leer el código, lista los SLO, el objetivo de despliegue y las dependencias externas de la historia.

# Contrato de compilación de referencia REST (ejemplo)
- Objetivo: Despliegue en Kubernetes detrás de Ingress
- SLO: p99 < 100ms para endpoints de lectura a 500 RPS
- Dependencias: Postgres, colector OTel, scrape de Prometheus

• Cada compilación de referencia asume un contrato. Encuéntralo en las secciones de introducción y Resumen.
• Mapea el contrato a los paquetes que esperas: cmd/, internal/, migraciones, fragmentos de Helm o manifiestos.
• Si el contrato no está indicado, escribe el tuyo antes de copiar patrones.

Relacionado: Aprender de Sistemas Go en Producción - Por qué importan los estudios de caso

2. Rastrea el Flujo de Solicitudes en Papel

Dibuja el protocolo entrante hasta las dependencias salientes antes de abrir los archivos de implementación.

Cliente -> Ingress -> middleware chi -> manejador -> servicio -> tienda -> Postgres
                              |-> slog + span de traza
                              |-> /healthz /readyz

• Las compilaciones de referencia son cortes verticales. Los diagramas de flujo exponen timeouts o sondas faltantes de forma temprana.
• Anota dónde se propaga el contexto y dónde los errores se convierten en códigos de estado HTTP o gRPC.
• Compara el diagrama de tu servicio con los enlaces Relacionados del estudio de caso para un análisis de brechas.

Relacionado: Compilación de Referencia: Microservicio REST Cloud-Native - Corte HTTP completo

3. Mapea los Límites de los Paquetes

Lista qué paquetes pueden importar cuáles otros en la disposición de referencia.

// Dirección permitida en compilaciones de referencia típicas:
// cmd/api -> internal/http -> internal/service -> internal/store
// internal/service no debe importar cmd/api

• internal/ significa "no es una API de módulo público". Las compilaciones de referencia mantienen la integración en los bordes.
• Busca interfaces en las uniones de la tienda y del cliente para dobles de prueba.
• Los paquetes "Dios" antes de los estados violan este grafo; después de los estados restauran importaciones acíclicas.

Relacionado: Antes/Después: Refactorización de un Paquete Dios - Historia de reparación de límites

4. Extrae la Lista de Verificación de Observabilidad

Copia los requisitos de señales, no el JSON del panel.

// Nombres mínimos de métricas estilo RED a buscar en una compilación de referencia
var (
    httpRequests = prometheus.NewCounterVec(/* ... */)
    httpDuration = prometheus.NewHistogramVec(/* ... */)
)

• Los logs estructurados deben usar slog con IDs de solicitud en las compilaciones HTTP.
• Los endpoints de salud separan la vivacidad (proceso activo) de la preparación (dependencias OK).
• Las trazas deben abarcar llamadas entrantes y salientes en ejemplos cloud-native.

Relacionado: Go en Producción: Logs, Métricas, Trazas y Señales - Vocabulario de señales

5. Lee las Pruebas como Documentación de Diseño

Encuentra primero las pruebas de tabla y las etiquetas de compilación de integración.

func TestServiceCreateUser(t *testing.T) {
    tests := []struct {
        name    string
        input   CreateUserInput
        wantErr bool
    }{
        {name: "valid email", input: CreateUserInput{Email: "a@b.co"}},
        {name: "empty email", input: CreateUserInput{}, wantErr: true},
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            // ...
        })
    }
}

• Las compilaciones de referencia simulan a través de interfaces, no parcheando globales.
• httptest registra los contratos del manejador sin iniciar un puerto real.
• Las historias de Operador y WASM añaden pasos de prueba de humo con envtest o WASM; ten en cuenta la conexión de CI.

Relacionado: Pruebas de Tabla y Subpruebas - Estilo de prueba utilizado en todas las compilaciones

6. Compara la Postura de Lanzamiento de CLI

Estudia cómo los comandos cobra, la configuración y los artefactos se alinean.

# Señales de higiene de CLI de producción en compilaciones de referencia
goreleaser release --clean
cosign sign-blob --key kms://... dist/myctl_linux_amd64.tar.gz
myctl version --output json

• Los árboles de comandos múltiples separan las preocupaciones de version, serve y migrate.
• Viper fusiona flags, env y archivo de configuración con precedencia explícita.
• Las canalizaciones de lanzamiento adjuntan SBOM o checksums donde la historia se dirige a usuarios empresariales.

Relacionado: Compilación de Referencia: CLI de Producción con cobra - Corte de CLI de extremo a extremo

7. Estudia los Hooks de Backpressure de gRPC

Localiza los patrones de control de flujo y streaming en las historias del plano de datos.

func (s *server) StreamEvents(req *pb.SubscribeRequest, stream pb.Events_StreamEventsServer) error {
    for evt := range s.bus.Subscribe(req.GetTopic()) {
        if err := stream.Send(evt); err != nil {
            return err // desconexión del cliente o control de flujo
        }
    }
    return nil
}

• Las compilaciones de alto rendimiento documentan los límites del lado del cliente y la configuración de keepalive.
• Las secciones pprof y benchmark pertenecen a la misma narrativa que el diseño RPC.
• Observa dónde las pasarelas JSON están intencionalmente ausentes para proteger el rendimiento.

Relacionado: Compilación de Referencia: Plano de Datos gRPC de Alto Rendimiento - Corte de streaming

8. Anota los Artefactos de Despliegue y Sonda

Recopila Dockerfile, rutas de sonda y manejadores de apagado elegante.

readinessProbe:
  httpGet:
    path: /readyz
    port: 8080
  periodSeconds: 5

• Las compilaciones de referencia REST conectan /healthz y /readyz por separado.
• Las imágenes de múltiples etapas compilan con CGO_ENABLED=0 para binarios estáticos.
• El apagado elegante escucha SIGTERM y vacía las solicitudes en curso.

Relacionado: Sondas de Salud, Preparación y Vivacidad - Semántica de las sondas

Ejemplos Intermedios

9. Recorre una Narrativa de Perfilado

Reproduce los pasos del estudio de caso de benchmark contra tus métricas de staging.

go test -bench=. -benchmem ./internal/api/...
curl -s localhost:6060/debug/pprof/profile?seconds=30 > cpu.prof
go tool pprof -top cpu.prof

• Empieza por una violación del SLO de latencia, no por micro-optimizaciones aleatorias.
• Compara los perfiles de alloc_space y wall antes de cambiar las capas JSON o SQL.
• Registra p50/p99 antes y después de cada cambio; una sola solución rara vez resuelve todas las colas.

Relacionado: Estudio de Caso de Benchmark: Latencia de API JSON - Historia de p99 de 200ms a 20ms

10. Audita la Idempotencia de Reconciliación del Operador

Para material de referencia del operador de Kubernetes, rastrea los bucles spec → status.

func (r *WidgetReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
    var widget examplev1.Widget
    if err := r.Get(ctx, req.NamespacedName, &widget); err != nil {
        return ctrl.Result{}, client.IgnoreNotFound(err)
    }
    // compara la generación, parchea el estado, vuelve a encolar en error transitorio
    return ctrl.Result{}, nil
}

• Los webhooks validan los valores predeterminados; los reconciliadores parchean el estado, no la especificación, en caso de errores.
• envtest ejecuta la lógica del controlador sin un clúster real para una retroalimentación rápida.
• El envío de bundles OLM es parte del contrato operativo, no un apéndice.

Relacionado: Compilación de Referencia: Operador de Kubernetes de Extremo a Extremo - De CRD a bundle

11. Evalúa los Contratos Host/Guest de WASM

Lee las exportaciones del módulo TinyGo junto con la incrustación host de wazero.

// Host carga el guest; el guest exporta _start o WASI main
mod, err := runtime.InstantiateModule(ctx, compiled, wazero.NewModuleConfig().
    WithStdout(os.Stdout))

• Los presupuestos de tamaño y las listas de permitidos de syscall son parte de la historia de seguridad.
• CI ejecuta pruebas de humo de WASM en cada PR para detectar exportaciones rotas.
• Incluso los equipos que no usan WASM aprenden a pensar en ABI estrictos a partir de esta compilación.

Relacionado: Compilación de Referencia: Módulo Edge WASI con Host wazero - Corte de módulo edge

Versiones de Stack: Esta página fue escrita para Go 1.26.x (predeterminado GC de Green Tea, go fix modernizadores - 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).