@saulwade/swl-ses 1.0.0

package/habilidades/gcp-cloud/recursos/gke.md

@@ -0,0 +1,234 @@
+# GKE — Google Kubernetes Engine: Patrones de Producción
+
+Referencia de patrones para clusters GKE con Workload Identity, HPA y configuraciones de seguridad.
+
+---
+
+## 1. Crear cluster GKE con configuración segura
+
+```bash
+# Cluster con Workload Identity habilitado (OBLIGATORIO para acceder a servicios GCP)
+gcloud container clusters create mi-cluster \
+    --region=us-central1 \
+    --machine-type=e2-standard-4 \
+    --num-nodes=3 \
+    --min-nodes=1 \
+    --max-nodes=10 \
+    --enable-autoscaling \
+    --workload-pool=$PROJECT_ID.svc.id.goog \
+    --enable-ip-alias \
+    --enable-private-nodes \
+    --master-ipv4-cidr=172.16.0.0/28 \
+    --enable-network-policy \
+    --release-channel=regular
+```
+
+**Opciones clave:**
+- `--workload-pool`: habilita Workload Identity (reemplaza claves SA montadas como archivos)
+- `--enable-private-nodes`: nodos sin IP pública (acceso solo desde red privada)
+- `--enable-network-policy`: permite NetworkPolicy de Kubernetes para aislar pods
+- `--release-channel=regular`: parches de seguridad automáticos con estabilidad probada
+
+---
+
+## 2. Node Pools — separación de cargas de trabajo
+
+```bash
+# Node pool para cargas de producción (alta disponibilidad)
+gcloud container node-pools create produccion \
+    --cluster=mi-cluster \
+    --region=us-central1 \
+    --machine-type=e2-standard-8 \
+    --num-nodes=2 \
+    --min-nodes=2 \
+    --max-nodes=20 \
+    --enable-autoscaling \
+    --node-taints=env=produccion:NoSchedule \
+    --node-labels=env=produccion
+
+# Node pool para jobs/workers (puede escalar a cero)
+gcloud container node-pools create workers \
+    --cluster=mi-cluster \
+    --region=us-central1 \
+    --machine-type=e2-standard-4 \
+    --num-nodes=0 \
+    --min-nodes=0 \
+    --max-nodes=10 \
+    --enable-autoscaling \
+    --node-taints=workload=batch:NoSchedule \
+    --node-labels=workload=batch
+```
+
+---
+
+## 3. Workload Identity — acceso seguro a servicios GCP desde pods
+
+Workload Identity vincula una Kubernetes Service Account (KSA) con una Google Service Account (GSA).
+Los pods usan la KSA y GCP autentica usando la GSA vinculada. Sin claves de SA como archivos.
+
+```bash
+# 1. Crear Google Service Account para el servicio
+gcloud iam service-accounts create mi-api-gsa \
+    --display-name="GSA para mi-api en GKE"
+
+# 2. Otorgar permisos necesarios a la GSA
+gcloud projects add-iam-policy-binding $PROJECT_ID \
+    --member="serviceAccount:mi-api-gsa@$PROJECT_ID.iam.gserviceaccount.com" \
+    --role="roles/cloudsql.client"
+
+# 3. Permitir que la KSA actúe como la GSA
+gcloud iam service-accounts add-iam-policy-binding \
+    mi-api-gsa@$PROJECT_ID.iam.gserviceaccount.com \
+    --role="roles/iam.workloadIdentityUser" \
+    --member="serviceAccount:$PROJECT_ID.svc.id.goog[mi-namespace/mi-api-ksa]"
+```
+
+```yaml
+# Kubernetes Service Account con anotación de Workload Identity
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+  name: mi-api-ksa
+  namespace: mi-namespace
+  annotations:
+    iam.gke.io/gcp-service-account: mi-api-gsa@PROJECT_ID.iam.gserviceaccount.com
+```
+
+```yaml
+# Deployment que usa la KSA
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: mi-api
+  namespace: mi-namespace
+spec:
+  selector:
+    matchLabels:
+      app: mi-api
+  template:
+    metadata:
+      labels:
+        app: mi-api
+    spec:
+      serviceAccountName: mi-api-ksa  # Referencia a la KSA anotada
+      containers:
+        - name: api
+          image: gcr.io/PROJECT_ID/mi-api:latest
+          resources:
+            requests:
+              cpu: "250m"
+              memory: "256Mi"
+            limits:
+              cpu: "1"
+              memory: "512Mi"
+```
+
+---
+
+## 4. Horizontal Pod Autoscaler (HPA)
+
+```yaml
+# HPA basado en CPU y memoria
+apiVersion: autoscaling/v2
+kind: HorizontalPodAutoscaler
+metadata:
+  name: mi-api-hpa
+  namespace: mi-namespace
+spec:
+  scaleTargetRef:
+    apiVersion: apps/v1
+    kind: Deployment
+    name: mi-api
+  minReplicas: 2
+  maxReplicas: 20
+  metrics:
+    - type: Resource
+      resource:
+        name: cpu
+        target:
+          type: Utilization
+          averageUtilization: 70
+    - type: Resource
+      resource:
+        name: memory
+        target:
+          type: Utilization
+          averageUtilization: 80
+  behavior:
+    scaleDown:
+      stabilizationWindowSeconds: 300  # Evita flapping al escalar hacia abajo
+      policies:
+        - type: Percent
+          value: 25
+          periodSeconds: 60
+    scaleUp:
+      stabilizationWindowSeconds: 0    # Escala hacia arriba inmediatamente
+      policies:
+        - type: Percent
+          value: 100
+          periodSeconds: 30
+```
+
+---
+
+## 5. NetworkPolicy — aislar namespaces
+
+```yaml
+# Permitir tráfico solo desde el ingress y desde otros pods del mismo namespace
+apiVersion: networking.k8s.io/v1
+kind: NetworkPolicy
+metadata:
+  name: aislar-namespace
+  namespace: mi-namespace
+spec:
+  podSelector: {}  # Aplica a todos los pods del namespace
+  policyTypes:
+    - Ingress
+    - Egress
+  ingress:
+    - from:
+        - namespaceSelector:
+            matchLabels:
+              kubernetes.io/metadata.name: ingress-nginx
+        - podSelector: {}  # Tráfico dentro del mismo namespace
+  egress:
+    - to:
+        - namespaceSelector: {}  # Permitir todo egress (ajustar según necesidad)
+    - ports:
+        - protocol: UDP
+          port: 53   # DNS obligatorio
+```
+
+---
+
+## 6. Checklist de seguridad GKE
+
+- [ ] Workload Identity habilitado en el cluster (`--workload-pool`)
+- [ ] Nodos privados (`--enable-private-nodes`) en entornos de producción
+- [ ] NetworkPolicy habilitada (`--enable-network-policy`)
+- [ ] Node pools separados para producción y workers/batch
+- [ ] Todos los Deployments tienen `resources.requests` y `resources.limits`
+- [ ] HPA configurado con `minReplicas >= 2` para servicios críticos
+- [ ] Ningún pod usa la service account `default` sin anotación de Workload Identity
+- [ ] Imágenes de contenedor con versión explícita (nunca `:latest` en producción)
+
+---
+
+## 7. Comandos frecuentes
+
+```bash
+# Ver estado del cluster
+kubectl get nodes -o wide
+kubectl top nodes
+
+# Ver pods con su node y service account
+kubectl get pods -n mi-namespace -o wide
+
+# Ver logs en tiempo real
+kubectl logs -f deployment/mi-api -n mi-namespace
+
+# Verificar que Workload Identity está funcionando
+kubectl exec -it pod/mi-api-xxx -n mi-namespace -- \
+    curl -H "Metadata-Flavor: Google" \
+    http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/email
+```

package/habilidades/gcp-cloud/recursos/terraform-gcp.md

@@ -0,0 +1,307 @@
+# Terraform para GCP — Proveedores, Módulos y State Remoto
+
+Referencia de patrones Terraform para infraestructura en Google Cloud Platform.
+
+---
+
+## 1. Configuración del provider y state remoto en GCS
+
+```hcl
+# versions.tf
+terraform {
+  required_version = ">= 1.5.0"
+
+  required_providers {
+    google = {
+      source  = "hashicorp/google"
+      version = "~> 5.0"
+    }
+    google-beta = {
+      source  = "hashicorp/google-beta"
+      version = "~> 5.0"
+    }
+  }
+
+  backend "gcs" {
+    bucket = "mi-proyecto-terraform-state"
+    prefix = "env/produccion"
+  }
+}
+
+# provider.tf
+provider "google" {
+  project = var.project_id
+  region  = var.region
+}
+
+provider "google-beta" {
+  project = var.project_id
+  region  = var.region
+}
+```
+
+```hcl
+# variables.tf
+variable "project_id" {
+  description = "ID del proyecto GCP"
+  type        = string
+}
+
+variable "region" {
+  description = "Región principal de despliegue"
+  type        = string
+  default     = "us-central1"
+}
+
+variable "env" {
+  description = "Entorno: dev, staging, produccion"
+  type        = string
+  validation {
+    condition     = contains(["dev", "staging", "produccion"], var.env)
+    error_message = "El entorno debe ser dev, staging o produccion."
+  }
+}
+```
+
+---
+
+## 2. Módulo para Cloud Run
+
+```hcl
+# modules/cloud-run/main.tf
+resource "google_cloud_run_v2_service" "servicio" {
+  name     = var.nombre
+  location = var.region
+  project  = var.project_id
+
+  ingress = "INGRESS_TRAFFIC_INTERNAL_LOAD_BALANCER"
+
+  template {
+    service_account = google_service_account.sa.email
+
+    scaling {
+      min_instance_count = var.min_instancias
+      max_instance_count = var.max_instancias
+    }
+
+    containers {
+      image = var.imagen
+
+      resources {
+        limits = {
+          cpu    = var.cpu
+          memory = var.memoria
+        }
+      }
+
+      dynamic "env" {
+        for_each = var.variables_entorno
+        content {
+          name  = env.key
+          value = env.value
+        }
+      }
+
+      dynamic "env" {
+        for_each = var.secretos
+        content {
+          name = env.key
+          value_source {
+            secret_key_ref {
+              secret  = env.value.nombre
+              version = env.value.version
+            }
+          }
+        }
+      }
+    }
+
+    annotations = {
+      "run.googleapis.com/cloudsql-instances" = var.cloud_sql_instance
+    }
+  }
+
+  labels = local.etiquetas_comunes
+}
+
+resource "google_service_account" "sa" {
+  account_id   = "${var.nombre}-sa"
+  display_name = "SA para ${var.nombre}"
+  project      = var.project_id
+}
+
+locals {
+  etiquetas_comunes = {
+    env      = var.env
+    servicio = var.nombre
+    equipo   = var.equipo
+    gestion  = "terraform"
+  }
+}
+```
+
+```hcl
+# modules/cloud-run/variables.tf
+variable "nombre" { type = string }
+variable "region" { type = string }
+variable "project_id" { type = string }
+variable "imagen" { type = string }
+variable "min_instancias" { type = number; default = 1 }
+variable "max_instancias" { type = number; default = 10 }
+variable "cpu" { type = string; default = "1" }
+variable "memoria" { type = string; default = "512Mi" }
+variable "env" { type = string }
+variable "equipo" { type = string }
+variable "cloud_sql_instance" { type = string; default = "" }
+variable "variables_entorno" { type = map(string); default = {} }
+variable "secretos" {
+  type = map(object({ nombre = string; version = string }))
+  default = {}
+}
+```
+
+---
+
+## 3. Cloud SQL con configuración de alta disponibilidad
+
+```hcl
+resource "google_sql_database_instance" "principal" {
+  name             = "${var.env}-db-principal"
+  database_version = "POSTGRES_15"
+  region           = var.region
+  project          = var.project_id
+
+  deletion_protection = var.env == "produccion" ? true : false
+
+  settings {
+    tier              = var.tier_db
+    availability_type = var.env == "produccion" ? "REGIONAL" : "ZONAL"
+    disk_autoresize   = true
+    disk_size         = 20
+
+    backup_configuration {
+      enabled                        = true
+      start_time                     = "03:00"
+      point_in_time_recovery_enabled = true
+      transaction_log_retention_days = 7
+    }
+
+    ip_configuration {
+      ipv4_enabled    = false                  # Sin IP pública
+      private_network = google_compute_network.vpc.id
+      require_ssl     = true
+    }
+
+    insights_config {
+      query_insights_enabled  = true
+      query_string_length     = 1024
+      record_application_tags = true
+    }
+
+    user_labels = {
+      env    = var.env
+      equipo = var.equipo
+    }
+  }
+}
+```
+
+---
+
+## 4. VPC y subredes privadas
+
+```hcl
+resource "google_compute_network" "vpc" {
+  name                    = "${var.env}-vpc"
+  auto_create_subnetworks = false
+  project                 = var.project_id
+}
+
+resource "google_compute_subnetwork" "privada" {
+  name          = "${var.env}-subred-privada"
+  ip_cidr_range = "10.0.0.0/20"
+  region        = var.region
+  network       = google_compute_network.vpc.id
+  project       = var.project_id
+
+  secondary_ip_range {
+    range_name    = "pods"
+    ip_cidr_range = "10.1.0.0/16"
+  }
+
+  secondary_ip_range {
+    range_name    = "servicios"
+    ip_cidr_range = "10.2.0.0/20"
+  }
+
+  private_ip_google_access = true  # Acceso a APIs GCP sin IP pública
+}
+
+# Cloud NAT para que los nodos privados puedan salir a internet
+resource "google_compute_router" "router" {
+  name    = "${var.env}-router"
+  region  = var.region
+  network = google_compute_network.vpc.id
+}
+
+resource "google_compute_router_nat" "nat" {
+  name                               = "${var.env}-nat"
+  router                             = google_compute_router.router.name
+  region                             = var.region
+  nat_ip_allocate_option             = "AUTO_ONLY"
+  source_subnetwork_ip_ranges_to_nat = "ALL_SUBNETWORKS_ALL_IP_RANGES"
+}
+```
+
+---
+
+## 5. Gestión del state y workspaces
+
+```bash
+# Crear bucket para state remoto (una sola vez por proyecto)
+gsutil mb -p $PROJECT_ID -l us-central1 gs://mi-proyecto-terraform-state
+gsutil versioning set on gs://mi-proyecto-terraform-state
+
+# Usar workspaces para múltiples entornos
+terraform workspace new staging
+terraform workspace new produccion
+terraform workspace select produccion
+
+# Inicializar con backend remoto
+terraform init -backend-config="bucket=mi-proyecto-terraform-state"
+
+# Plan y apply con variables por entorno
+terraform plan -var-file="entornos/produccion.tfvars"
+terraform apply -var-file="entornos/produccion.tfvars" -auto-approve
+```
+
+---
+
+## 6. Estructura de directorios recomendada
+
+```
+infra/
+├── modules/
+│   ├── cloud-run/         # Módulo reutilizable de Cloud Run
+│   ├── cloud-sql/         # Módulo reutilizable de Cloud SQL
+│   └── gke-cluster/       # Módulo reutilizable de GKE
+├── entornos/
+│   ├── dev.tfvars
+│   ├── staging.tfvars
+│   └── produccion.tfvars
+├── main.tf                # Composición de módulos
+├── variables.tf           # Variables del root module
+├── outputs.tf             # Outputs exportados
+└── versions.tf            # Versiones de providers y Terraform
+```
+
+---
+
+## 7. Reglas obligatorias para Terraform GCP
+
+- `deletion_protection = true` en Cloud SQL de producción
+- State en GCS con versionado habilitado — nunca state local en producción
+- Un módulo por tipo de recurso (cloud-run, cloud-sql, gke) — no monolitos
+- `labels` en TODOS los recursos: `env`, `equipo`, `gestion=terraform`
+- Variables con `validation` para entornos y valores críticos
+- NUNCA hacer `terraform apply` sin `terraform plan` previo revisado