Despliegue de una aplicación Go en Kubernetes: guía paso a paso

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

Go (Golang) y Kubernetes son el estándar moderno para construir y desplegar arquitecturas de microservicios. Go se compila en un binario estático, no requiere dependencias en la máquina de destino, se inicia rápidamente y utiliza la memoria de manera eficiente. Kubernetes, por su parte, proporciona automatización para el despliegue, escalado y gestión de contenedores.

En esta guía, analizaremos en la práctica el ciclo completo de despliegue de una aplicación Go simple en Kubernetes. Aprenderá a escribir un Dockerfile, crear manifiestos para Kubernetes (Deployment, Service, ConfigMap) y ejecutar la aplicación en un clúster. Todos los ejemplos de código se pueden usar directamente en sus proyectos.

1. Preparación de la aplicación Go para la contenerización

Para empezar, crearemos un servidor HTTP simple en Go que responderá a las solicitudes y mostrará un saludo. Es importante que la aplicación escuche en el puerto que especificaremos a través de una variable de entorno. Esta es una práctica estándar para Kubernetes.

Cree el archivo main.go:

package main

import (    "fmt"    "log"    "net/http"    "os")

func main() {    port := os.Getenv("PORT")    if port == "" {        port = "8080"    }

    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {        name := os.Getenv("APP_NAME")        if name == "" {            name = "Go App"        }        fmt.Fprintf(w, "¡Saludos desde %s! Trabajando en el puerto %s", name, port)    })

    log.Printf("Servidor iniciado en el puerto %s", port)    log.Fatal(http.ListenAndServe(":"+port, nil))}

Este código lee las variables de entorno PORT y APP_NAME, lo que nos permitirá configurar la aplicación de forma flexible a través de ConfigMap en Kubernetes.

2. Creación del Dockerfile para la aplicación Go

Para el despliegue en Kubernetes necesitamos una imagen Docker. Usaremos una compilación de múltiples etapas (multi-stage build): esto reducirá el tamaño de la imagen y mejorará la seguridad.

Cree el archivo Dockerfile:

# Etapa de compilaciónFROM golang:1.22-alpine AS builder

WORKDIR /appCOPY go.mod go.sum ./RUN go mod downloadCOPY . .RUN CGO_ENABLED=0 GOOS=linux go build -o /app/server .

# Imagen finalFROM alpine:latestRUN apk --no-cache add ca-certificatesWORKDIR /root/COPY --from=builder /app/server .EXPOSE 8080CMD ["./server"]

Construya la imagen y envíela a un registro (por ejemplo, Docker Hub):

docker build -t yourusername/go-k8s-app:latest .docker push yourusername/go-k8s-app:latest

3. Manifiestos de Kubernetes: Deployment, Service, ConfigMap

Ahora crearemos los manifiestos para desplegar la aplicación en el clúster. Se recomienda almacenarlos en la carpeta k8s/.

3.1. ConfigMap para la configuración

Extraeremos la configuración de la aplicación en un ConfigMap; esto permitirá cambiarla sin reconstruir la imagen.

Archivo k8s/configmap.yaml:

apiVersion: v1kind: ConfigMapmetadata:  name: go-app-configdata:  APP_NAME: "Mi aplicación Go"  PORT: "8080"

3.2. Deployment — descripción del pod

El Deployment gestiona las réplicas del pod y garantiza actualizaciones sin tiempo de inactividad.

Archivo k8s/deployment.yaml:

apiVersion: apps/v1kind: Deploymentmetadata:  name: go-app-deployment  labels:    app: go-appspec:  replicas: 2  selector:    matchLabels:      app: go-app  template:    metadata:      labels:        app: go-app    spec:      containers:      - name: go-app        image: yourusername/go-k8s-app:latest        ports:        - containerPort: 8080        envFrom:        - configMapRef:            name: go-app-config        livenessProbe:          httpGet:            path: /            port: 8080          initialDelaySeconds: 5          periodSeconds: 10\