Despliegue de Go en Kubernetes: guía básica para principiantes

Introducción: por qué Go y Kubernetes son la pareja ideal

Go (Golang) y Kubernetes (K8s) están hechos el uno para el otro. El propio Kubernetes está escrito en Go, por lo que el conjunto de herramientas nativas, el rendimiento y la simplicidad de despliegue hacen de esta combinación el estándar para los microservicios modernos. Si estás comenzando tu camino en DevOps o deseas automatizar el despliegue de tu aplicación Go, esta guía te ayudará a pasar por todas las etapas: desde escribir un servidor HTTP simple en Go hasta ejecutarlo en un clúster de Kubernetes.

En este artículo analizaremos:

\n
• Compilación de una aplicación Go en una imagen Docker
\n
• Creación de manifiestos mínimos de Kubernetes (Deployment, Service, Ingress)
\n
• Despliegue y verificación del funcionamiento
\n

Se asume que ya tienes instalados docker, kubectl y minikube (o acceso a cualquier clúster K8s).

Paso 1: Escribimos una aplicación Go simple

Crearemos un servidor HTTP básico que responderá a las solicitudes. Crea el archivo main.go:

package main\n\nimport (\n    "fmt"\n    "net/http"\n    "os"\n)\n\nfunc main() {\n    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {\n        fmt.Fprintf(w, "¡Hola desde Go! Versión: %s", os.Getenv("APP_VERSION"))\n    })\n\n    port := os.Getenv("PORT")\n    if port == "" {\n        port = "8080"\n    }\n\n    fmt.Printf("Servidor iniciado en el puerto %s\\n", port)\n    http.ListenAndServe(":"+port, nil)\n}\n

Esta aplicación lee la variable de entorno APP_VERSION (se puede establecer durante el despliegue) y escucha en el puerto especificado en PORT. Ahora probamos localmente:

go run main.go\n# Abre el navegador en http://localhost:8080\n

Creación del módulo Go

Inicializa el módulo para una compilación más fácil:

go mod init my-go-app\n

Paso 2: Contenerización con Docker

Para el despliegue en Kubernetes, necesitamos empaquetar la aplicación en una imagen Docker. Usaremos una compilación de múltiples etapas (multi-stage build) para que la imagen sea mínima.

Crea el archivo Dockerfile:

# Etapa de compilación\nFROM golang:1.22-alpine AS builder\nWORKDIR /app\nCOPY go.mod ./\nCOPY main.go ./\nRUN go build -o my-app .\n\n# Imagen final\nFROM alpine:3.19\nWORKDIR /app\nCOPY --from=builder /app/my-app .\nEXPOSE 8080\nCMD ["./my-app"]\n

Compila la imagen y verifica:

docker build -t my-go-app:v1 .\ndocker run -p 8080:8080 my-go-app:v1\n# http://localhost:8080\n

Paso 3: Manifiestos de Kubernetes

Ahora prepararemos los archivos YAML para el despliegue en el clúster. Crearemos tres recursos: Deployment (gestión de pods), Service (acceso de red) e Ingress (acceso externo).

3.1. Deployment

Crea el archivo deployment.yaml:

apiVersion: apps/v1\nkind: Deployment\nmetadata:\n  name: go-app-deployment\n  labels:\n    app: go-app\nspec:\n  replicas: 2\n  selector:\n    matchLabels:\n      app: go-app\n  template:\n    metadata:\n      labels:\n        app: go-app\n    spec:\n      containers:\n      - name: go-app\n        image: my-go-app:v1\n        ports:\n        - containerPort: 8080\n        env:\n        - name: APP_VERSION\n          value: "1.0.0"\n        - name: PORT\n          value: "8080"\n        livenessProbe:\n          httpGet:\n            path: /\n            port: 8080\n          initialDelaySeconds: 5\n          periodSeconds: 10\n

Aquí hemos configurado 2 réplicas, una sonda de actividad (liveness probe) y las variables de entorno.

3.2. Service

Crea el archivo service.yaml para el acceso interno:

apiVersion: v1\nkind: Service\nmetadata:\n  name: go-app-service\nspec:\n  selector:\n    app: go-app\n  ports:\n  - protocol: TCP\n    port: 80\n    targe