Problema

Muchos ingenieros de DevOps llegan a un punto donde el día a día se reduce a mantenimiento de pipelines, playbooks y contenedores. La falta de proyectos con impacto real dificulta el paso de “conozco Docker” a “despliego clústers de Kubernetes con IaC”. El patrón recurrente es: conocimientos fragmentados + escasez de entornos de práctica, lo que genera estancamiento profesional y poca exposición a herramientas como ArgoCD o GCP.

Causa

  1. Entorno aislado – Usar solo Docker en una máquina local no reproduce la complejidad de redes, IAM y almacenamiento que aparecen en la nube.
  2. Ausencia de roadmap estructurado – Saltar de tutorial a tutorial sin un objetivo medible lleva a aprender conceptos sueltos que no se integran.
  3. Recursos limitados – El coste percibido de GCP o de clústers gestionados frena la experimentación, aun cuando existen capas gratuitas y cuotas de prueba.
  4. Falta de feedback – Sin CI/CD que valide cada cambio, los ejercicios quedan en “funciona en mi máquina” y no se detectan errores de configuración.

Solución

Crear un lab modular que combine los tres pilares (Kubernetes, Terraform, GCP) y que pueda ejecutarse en ciclos de una a dos semanas. El lab sigue una arquitectura de tres capas:

  1. Infraestructura como código (Terraform) – Provisiona una VPC, un clúster GKE (o un clúster local con Kind) y los recursos de IAM necesarios.
  2. Aplicación de ejemplo – Un micro‑servicio sencillo (por ejemplo, una API en Python) empaquetado en Docker, desplegado mediante manifests de Kubernetes.
  3. Entrega continua (ArgoCD + GitHub Actions) – Cada commit dispara Terraform plan/apply y actualiza los manifests en el clúster.

Paso a paso

1. Configura la cuenta de GCP

  • Regístrate en el free tier y habilita la facturación mínima (no se facturan recursos dentro de la cuota gratuita).
  • Crea un proyecto llamado devops‑lab‑<tu‑alias> y genera una clave JSON para el service account con roles roles/container.admin y roles/compute.networkAdmin.

2. Repo base

Estructura el repositorio:

devops-lab/
├─ terraform/
│   └─ main.tf
├─ k8s/
│   ├─ deployment.yaml
│   └─ service.yaml
└─ .github/
    └─ workflows/
        └─ ci.yml

3. Terraform: provisionar GKE

terraform {
  required_version = ">= 1.0"
  required_providers {
    google = {
      source  = "hashicorp/google"
      version = "~> 5.0"
    }
  }
}

provider "google" {
  credentials = file(var.credentials_path)
  project     = var.project_id
  region      = var.region
}

resource "google_container_cluster" "primary" {
  name     = "devops-lab-cluster"
  location = var.region
  initial_node_count = 2

  node_config {
    machine_type = "e2-medium"
    oauth_scopes = ["https://www.googleapis.com/auth/cloud-platform"]
  }
}

Variables (terraform/variables.tf) incluyen project_id, region y credentials_path. Ejecuta terraform init && terraform apply y guarda el kubeconfig con:

gcloud container clusters get-credentials devops-lab-cluster --region $REGION --project $PROJECT_ID

4. Manifests de Kubernetes

k8s/deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-api
spec:
  replicas: 2
  selector:
    matchLabels:
      app: hello
  template:
    metadata:
      labels:
        app: hello
    spec:
      containers:
      - name: hello
        image: ghcr.io/<tu‑usuario>/hello-api:latest
        ports:
        - containerPort: 8080

k8s/service.yaml expone el deployment con un LoadBalancer.

5. CI/CD con GitHub Actions y ArgoCD

.github/workflows/ci.yml:

name: CI/CD Pipeline
on:
  push:
    branches: [ main ]

jobs:
  terraform:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - name: Set up Terraform
      uses: hashicorp/setup-terraform@v2
    - name: Terraform Init & Apply
      working-directory: ./terraform
      env:
        GOOGLE_APPLICATION_CREDENTIALS: ${{ secrets.GCP_KEY }}
      run: |
        terraform init
        terraform apply -auto-approve

  build:
    needs: terraform
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - name: Build Docker image
      run: |
        docker build -t ghcr.io/${{ github.repository_owner }}/hello-api:latest .
        echo ${{ secrets.GITHUB_TOKEN }} | docker login ghcr.io -u ${{ github.actor }} --password-stdin
        docker push ghcr.io/${{ github.repository_owner }}/hello-api:latest

  deploy:
    needs: build
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - name: Sync with ArgoCD
      run: |
        argocd login $ARGOCD_SERVER --username $ARGOCD_USER --password $ARGOCD_PASS --insecure
        argocd app sync hello-app

ArgoCD debe estar instalado en el clúster (helm repo add argo https://argoproj.github.io/argo-helm && helm install argo-cd argo/argo-cd). Configura una aplicación que apunte al directorio k8s/ del repo.

6. Ciclo de aprendizaje

  • Semana 1: Terraform + GKE. Enfócate en entender state, workspaces y políticas de IAM.
  • Semana 2: Docker + Kubernetes. Implementa liveness/readiness probes y recursos.
  • Semana 3: CI/CD. Añade pruebas unitarias, escaneo de imágenes y despliegues canary con ArgoCD.
  • Semana 4: Extiende con Cloud SQL, Pub/Sub o Cloud Run y crea un pipeline que incluya Terraform para esos recursos.

Cuándo aplicar esta solución

  • Síntomas: Sentir que el conocimiento está fragmentado, no poder explicar cómo conectar IaC con clústers reales, o no tener ejemplos que muestren todo el flujo de entrega.
  • Escenarios válidos: Ingenieros con 1‑3 años de experiencia en CI/CD que quieren pasar a orquestación y cloud.
  • Exclusiones: Equipos que ya operan clústers gestionados a gran escala y necesitan sólo optimizaciones de costos; en ese caso la solución se reduce a refactorizar Terraform, no a crear un lab completo.

Código

# 1. Inicializar Terraform
cd terraform
terraform init

# 2. Aplicar infraestructura
terraform apply -auto-approve

# 3. Obtener credenciales del clúster
gcloud container clusters get-credentials devops-lab-cluster --region us-central1 --project my-devops-lab

# 4. Desplegar aplicación (opcional, ArgoCD lo hará automáticamente)
kubectl apply -f ../k8s/deployment.yaml
kubectl apply -f ../k8s/service.yaml

Verificación

  1. Infraestructura – En la consola de GCP verifica que el clúster GKE está activo y que la VPC tiene las subredes esperadas.
  2. Aplicación – Ejecuta kubectl get pods -l app=hello y confirma que los pods están en estado Running.
  3. Exposición – kubectl get svc hello-api debe mostrar una IP externa; abre http://<IP>:8080 y verifica la respuesta JSON.
  4. CI/CD – Cada push al branch main debe generar una ejecución en GitHub Actions sin errores y ArgoCD debe marcar la aplicación como Synced.

Notas adicionales

  • Cuotas gratuitas: GKE free tier permite un clúster con 1 nodo e2‑micro sin coste. Ajusta initial_node_count a 1 para pruebas rápidas.
  • State remoto: Usa un bucket de Cloud Storage como backend para Terraform state; evita pérdidas al cambiar de máquina.
  • Seguridad: Nunca almacenes la clave JSON en el repo; usa GitHub Secrets (GCP_KEY).
  • Debugging: Si ArgoCD no sincroniza, revisa los logs del pod argocd-server y verifica que el repo URL sea accesible desde el clúster.
  • Escalado: Cuando el lab sea estable, agrega módulos Terraform para Cloud DNS, IAM bindings y Cloud Monitoring; así tendrás un entorno que simula producción sin sobrecargar la cuota.