15 min de lectura

Objetivos de aprendizaje

Al final de este módulo, podrás:

  • Automatizar la rotación de tokens de API con la Auth API: emitir, verificar, almacenar y revocar tokens por servicio y entorno
  • Gestionar los usuarios, grupos, privilegios y recursos compartidos de TaskBoard con `ionoscloud_user`, `ionoscloud_group` y `ionoscloud_share`
  • Entregar las credenciales de la base de datos desde las salidas de Terraform a Secrets de Kubernetes sin hacer commit de ellas en ningún lugar
  • Ejecutar las reglas de NSG a través del pipeline de infraestructura con detección de desviaciones, y proteger las cargas de trabajo de MKS donde los NSG no se aplican
  • Distribuir y rotar claves SSH para servidores Linux con Terraform y cloud-init

Unidad 5.2: Automatización de seguridad

Introducción

TaskBoard ahora cuenta con un usuario de CI que dispone de un token de Cloud API, un token de extracción para el registro, claves de Object Storage, dos contraseñas de base de datos y acceso SSH a la VM de trabajo. Cada uno de estos elementos se creó una sola vez, de forma manual, y nadie recuerda cuándo. Es así como se filtran las credenciales: un token de un colega que ya no trabaja en la empresa, una contraseña en un archivo .tfvars, o una regla de firewall que alguien activó en el DCD durante un incidente.

En esta unidad, convertirá la seguridad en código que se ejecuta según un programa. Rotará los tokens de API mediante la API de autenticación, modelará el acceso con usuarios y grupos gestionados por Terraform, alimentará los Secrets de Kubernetes a partir de las salidas de Terraform, mantendrá las reglas de NSG en el pipeline y gestionará las claves SSH de la misma manera en que IONOS CLOUD las inyecta. En el laboratorio de código, rotará el token de CI de TaskBoard, añadirá una regla de NSG a través de Terraform y conectará las credenciales de PostgreSQL a un Secret de Kubernetes.

1. Automatización del ciclo de vida de los tokens de API

1.1 Inventario antes de la rotación

curl --silent "https://api.ionos.com/auth/v1/tokens" \
  --header "Authorization: Bearer $IONOS_TOKEN" \
  | jq -r '.tokens[] | "\(.id)  created \(.createdDate)  expires \(.expirationDate)"'

GET /tokens lista los tokens del usuario autenticado con id, createdDate y expirationDate. Los usuarios con varios contratos añaden la cabecera X-Contract-Number. El valor del token en sí mismo nunca vuelve a aparecer: Token Manager lo muestra solo una vez, en el momento de su generación. Un usuario puede tener hasta 100 tokens, por lo que una tarea de rotación que nunca elimina los tokens antiguos eventualmente fallará.

1.2 Una tarea de rotación

Cada servicio obtiene su propio usuario de IONOS CLOUD (sección 2), y la tarea de rotación se ejecuta con el token actual de ese usuario:

import base64
import json
import os
import subprocess

import requests

AUTH = "https://api.ionos.com/auth/v1"
TTL = 30 * 24 * 3600  # seconds; the API accepts 60 to 31536000


def key_id(jwt: str) -> str:
    header = jwt.split(".")[0]
    header += "=" * (-len(header) % 4)
    return json.loads(base64.urlsafe_b64decode(header))["kid"]


def main() -> None:
    old = os.environ["IONOS_TOKEN"]
    resp = requests.get(f"{AUTH}/tokens/generate", params={"ttl": TTL},
                        headers={"Authorization": f"Bearer {old}"}, timeout=30)
    resp.raise_for_status()
    new = resp.json()["token"]
    auth_new = {"Authorization": f"Bearer {new}"}

    # 1. prove the new token works before anything depends on it
    requests.get("https://api.ionos.com/cloudapi/v6/datacenters", params={"depth": 0},
                 headers=auth_new, timeout=30).raise_for_status()

    # 2. store it (stdin, so the value never appears in the process list)
    subprocess.run(["gh", "secret", "set", "IONOS_TOKEN"], input=new, text=True, check=True)

    # 3. revoke the old token by its key ID, then remove expired tokens
    requests.delete(f"{AUTH}/tokens/{key_id(old)}", headers=auth_new, timeout=30).raise_for_status()
    requests.delete(f"{AUTH}/tokens", params={"criteria": "EXPIRED"},
                    headers=auth_new, timeout=30).raise_for_status()
    print("rotated, new token expires in", TTL // 86400, "days")


if __name__ == "__main__":
    main()

El parámetro path de DELETE /tokens/{tokenId} es la Key ID de la sección de encabezado del token. Eliminar un token lo desactiva de inmediato, incluso antes de que venza, por lo que el orden importa: generar, verificar, almacenar y luego revocar. Los usuarios con autenticación de dos factores deben usar tokens protegidos con 2FA para eliminar tokens; ejecute la rotación con usuarios de servicio dedicados.

1.3 Programación y limpieza

Guarde la tarea como .github/workflows/rotate-token.yml:

on:
  schedule:
    - cron: "0 3 * * 1"
jobs:
  rotate:
    runs-on: ubuntu-latest
    environment: production
    steps:
      - uses: actions/checkout@v4
      - run: pip install requests && python ops/rotate_token.py
        env:
          IONOS_TOKEN: ${{ secrets.IONOS_TOKEN }}
          GH_TOKEN: ${{ secrets.SECRETS_ADMIN_PAT }}

Una tarea semanal con un ttl de 30 días deja suficiente margen para una ejecución fallida. La última llamada del script utiliza criteria=EXPIRED, que elimina los tokens vencidos para el contrato. Los otros valores son ALL y CURRENT, por lo que nunca debe construir ese parámetro a partir de la entrada. GH_TOKEN debe tener permiso para escribir secretos del repositorio; el token de flujo de trabajo predeterminado no lo tiene.

2. IAM como código

2.1 Usuarios y grupos por servicio

Los derechos en IONOS CLOUD se asignan a través de grupos. Un grupo posee privilegios, y un usuario los hereda de cada grupo al que pertenece:

resource "ionoscloud_group" "taskboard_ci" {
  name                           = "taskboard-ci"
  create_datacenter              = false
  create_k8s_cluster             = true
  create_network_security_groups = true
  access_and_manage_monitoring   = true
  access_and_manage_logging      = true
  manage_dbaas                   = true
}

resource "ionoscloud_user" "taskboard_ci" {
  first_name          = "taskboard"
  last_name           = "ci"
  email               = "taskboard-ci@example.com"
  password_wo         = random_password.ci.result
  password_wo_version = "1"
  administrator       = false
  force_sec_auth      = false
  active              = true
  group_ids           = [ionoscloud_group.taskboard_ci.id]
}

resource "random_password" "ci" {
  length  = 24
  special = true
}

password_wo es solo de escritura: no se guarda en el estado, requiere Terraform 1.11 o posterior, y se actualiza cuando eleva password_wo_version. Mantenga administrator = false para cada usuario del servicio. Los administradores no necesitan gestionarse en grupos, ya que tienen acceso automático a todos los recursos del contrato, por lo que un token de administrador anula todos los demás controles de esta unidad.

2.2 Compartir recursos

Los privilegios permiten a un grupo crear recursos. El acceso a los recursos existentes proviene de las comparticiones:

resource "ionoscloud_share" "ci_datacenter" {
  group_id        = ionoscloud_group.taskboard_ci.id
  resource_id     = ionoscloud_datacenter.taskboard.id
  edit_privilege  = true
  share_privilege = false
}

resource "ionoscloud_share" "ci_cluster" {
  group_id        = ionoscloud_group.taskboard_ci.id
  resource_id     = ionoscloud_k8s_cluster.taskboard.id
  edit_privilege  = true
  share_privilege = false
  depends_on      = [ionoscloud_share.ci_datacenter]
}

Shares controla el acceso a centros de datos, instantáneas, imágenes, bloques de IP, Cross Connects, unidades de copia de seguridad y clústeres de Kubernetes, con tres niveles de autorización: Read, Edit y Sharing. La lectura es implícita en cuanto un grupo se asigna a un recurso. Crear varias shares al mismo tiempo produce un error, por lo que la segunda share utiliza depends_on; terraform apply -parallelism=1 es la alternativa.

Para TaskBoard, utilice un grupo por servicio y entorno: taskboard-ci-dev con derechos de edición solo en el centro de datos de desarrollo, taskboard-ci-prod en producción, y un grupo de solo lectura taskboard-monitor para scripts como el obtentor de Activity Log de la Unidad 5.1, que también necesita access_activity_log = true.

3. Secrets de Kubernetes desde las salidas de Terraform

3.1 El patrón del pipeline

La Unidad 2.5 mantuvo la contraseña de PostgreSQL fuera del estado de Terraform mediante un argumento de solo escritura y exportó únicamente el host. El trabajo de despliegue combina ambos en un Secret:

PGHOST="$(terraform -chdir=infra output -raw pg_host)"

kubectl -n taskboard create secret generic taskboard-db \
  --from-literal=PGHOST="$PGHOST" \
  --from-literal=PGUSER=taskboard \
  --from-literal=PGPASSWORD="$TF_VAR_pg_password" \
  --from-literal=PGSSLMODE=verify-full \
  --dry-run=client -o yaml | kubectl apply -f -

--dry-run=client -o yaml | kubectl apply hace que el paso sea idempotente, de modo que el mismo trabajo crea o actualiza el Secret. Nada toca el disco ni Git. Evite el proveedor de Terraform para Kubernetes para las credenciales que haya mantenido deliberadamente fuera del estado: un recurso de Secret almacena sus datos en el archivo de estado.

3.2 Secretos externos y rotación

Cuando la contraseña se encuentra en un almacén de secretos, permita que el clúster la obtenga en lugar de enviarla desde CI:

apiVersion: external-secrets.io/v1
kind: ExternalSecret
metadata:
  name: taskboard-db
  namespace: taskboard
spec:
  refreshInterval: 1h
  secretStoreRef:
    kind: ClusterSecretStore
    name: vault
  target:
    name: taskboard-db
  data:
    - secretKey: PGPASSWORD
      remoteRef: { key: secret/taskboard/prod, property: pg_password }

Una rotación consta, por lo tanto, de tres pasos: escribir la nueva contraseña en el almacén, aplicar Terraform con password_version incrementado en uno, y reiniciar los pods con kubectl rollout restart deploy/taskboard-api después de que el operador haya actualizado el Secret. Las variables de entorno solo se leen al iniciar el contenedor. En MKS, se puede habilitar y configurar el cifrado de los datos del Secret en reposo.

4. Automatización de NSG en la pipeline

4.1 Reglas como datos

La Unidad 2.3 introdujo ionoscloud_nsg y ionoscloud_nsg_firewallrule. En producción, describa las reglas como datos para que una solicitud de extracción (pull request) muestre exactamente qué puerto se abre para qué origen:

variable "app_ingress" {
  type = map(object({ source_ip = string, port = number }))
  default = {
    http-from-alb = { source_ip = "10.10.1.6", port = 80 }
  }
}

resource "ionoscloud_nsg_firewallrule" "app" {
  for_each         = var.app_ingress
  datacenter_id    = ionoscloud_datacenter.taskboard.id
  nsg_id           = ionoscloud_nsg.app.id
  name             = each.key
  type             = "INGRESS"
  protocol         = "TCP"
  source_ip        = each.value.source_ip
  port_range_start = each.value.port
  port_range_end   = each.value.port
}

El grupo del usuario de CI necesita create_network_security_groups. protocol no puede modificarse después de la creación; cambiarlo obliga a crear una nueva regla.

4.2 Detección de desviación

Una regla que se activa en DCD durante un incidente permanece activa hasta que alguien la detecte. Un plan programado la detecta por usted:

terraform plan -input=false -detailed-exitcode -lock=false > drift.txt
case $? in
  0) echo "no drift" ;;
  2) echo "drift detected"; gh issue create --title "NSG drift" --body-file drift.txt ;;
  *) echo "plan failed"; exit 1 ;;
esac

El código de salida 2 indica que la configuración real difiere del código. Resuélvalo modificando el código y aplicando los cambios, nunca dejando la modificación manual en su lugar.

4.3 Dónde no llegan las NSG

Los miembros de las NSG son VM y NIC. El ALB y el NLB no son miembros, y los nodos de los grupos de nodos de Managed Kubernetes están excluidos de las NSG. Para el tráfico entre pods en MKS, use Kubernetes NetworkPolicies, que el plugin CNI de Calico en MKS admite:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: api-from-ingress-only
  namespace: taskboard
spec:
  podSelector: { matchLabels: { app: taskboard-api } }
  policyTypes: [Ingress]
  ingress:
    - from:
        - namespaceSelector: { matchLabels: { kubernetes.io/metadata.name: ingress } }
      ports:
        - { port: 8000, protocol: TCP }

5. Claves SSH

5.1 Inyección durante la aprovisionamiento

variable "team_ssh_keys" {
  type = list(string)   # public keys, one per team member
}

resource "ionoscloud_vcpu_server" "worker" {
  # ... arguments and volume from Unit 2.1 ...
  image_name = data.ionoscloud_image.ubuntu.id
  ssh_keys   = var.team_ssh_keys
}

La Cloud API inyecta claves públicas cuando se crea un volumen a partir de una imagen de IONOS CLOUD Linux; las imágenes de Windows, las instantáneas, las imágenes privadas y las imágenes de MS SQL no admiten la inyección. ssh_keys es inmutable y solo puede establecerse en el momento de la creación. Las claves guardadas en el SSH Key Manager del DCD (hasta 100 por usuario) son una comodidad del DCD; la Cloud API no gestiona ese almacén, por lo que debe mantener la lista de claves del equipo en el código.

5.2 Rotación

Dado que las claves inyectadas no pueden modificarse en un servidor en ejecución, gestione authorized_keys con cloud-init (Unidad 2.1) para los nuevos servidores y con su herramienta de gestión de configuración para los que ya están en funcionamiento:

#cloud-config
users:
  - name: deploy
    groups: [sudo]
    shell: /bin/bash
    ssh_authorized_keys:
      - ssh-ed25519 AAAA... alice@taskboard
      - ssh-ed25519 AAAA... bob@taskboard

Para eliminar la clave de un compañero que ha dejado la empresa, elimínela de la variable, inicie nuevas VM de workers o ejecute la tarea de configuración y confírmelo con ssh-keygen -lf en el servidor.

Tarjeta rápida de referencia de la API

Endpoints principales de la API para el tema de esta unidad:

Método Endpoint Descripción
GET https://api.ionos.com/auth/v1/tokens/generate?ttl=<seconds> Generar un nuevo token
GET https://api.ionos.com/auth/v1/tokens Listar los tokens del usuario
DELETE https://api.ionos.com/auth/v1/tokens/{tokenId} Revocar un token por ID de clave
DELETE https://api.ionos.com/auth/v1/tokens?criteria=EXPIRED Eliminar tokens vencidos
POST /datacenters/{datacenterId}/securitygroups/{securityGroupId}/rules Agregar una regla de NSG

URL base: https://api.ionos.com/cloudapi/v6 (API de autenticación, tal como se indica) Autenticación: Authorization: Bearer <token>

Laboratorio de código

Objetivo: Rotar el token de CI de TaskBoard, agregar una regla de NSG mediante Terraform e integrar las credenciales de PostgreSQL en un Secret de Kubernetes.

Requisitos previos:

  • Un usuario de CI dedicado y su token en IONOS_TOKEN
  • El proyecto de Terraform con el NSG de la Unidad 2.3 y PostgreSQL de la Unidad 2.5
  • Acceso a kubectl al espacio de nombres TaskBoard, jq, gh y Python 3 con requests

Paso 1: Listar los tokens actuales

curl --silent "https://api.ionos.com/auth/v1/tokens" -H "Authorization: Bearer $IONOS_TOKEN" | jq '.tokens | length'

Salida esperada:

3

Paso 2: Rotar el token

python ops/rotate_token.py

Salida esperada:

✓ Set Actions secret IONOS_TOKEN for <org>/taskboard
rotated, new token expires in 30 days

Paso 3: Confirme que el token anterior ha sido revocado

curl --silent -o /dev/null -w "%{http_code}\n" \
  "https://api.ionos.com/cloudapi/v6/datacenters" -H "Authorization: Bearer $IONOS_TOKEN"

Salida esperada:

401

Cargue el nuevo valor desde su almacén de secretos en IONOS_TOKEN antes de continuar.

Paso 4: Agregar una regla de NSG mediante una solicitud de extracción

Agregue ssh-from-vpn = { source_ip = "10.10.9.10", port = 22 } a var.app_ingress (Sección 4.1), publique una rama y abra una solicitud de extracción.

terraform plan

Salida esperada:

  # ionoscloud_nsg_firewallrule.app["ssh-from-vpn"] will be created
Plan: 1 to add, 0 to change, 0 to destroy.

Paso 5: Verificar la deriva

Después de la fusión y la aplicación, ejecute el script de la sección 4.2. Salida esperada:

no drift

Paso 6: Crear el Secret de la base de datos

export TF_VAR_pg_password="$(vault kv get -field=pg_password secret/taskboard/dev)"
bash ops/db-secret.sh    # the commands from Section 3.1
kubectl -n taskboard get secret taskboard-db -o jsonpath='{.data.PGHOST}' | base64 -d

Salida esperada:

secret/taskboard-db configured
<cluster-dns-name>

Lista de verificación de validación:

  • [ ] El token antiguo devuelve 401, el nuevo funciona desde CI
  • [ ] La regla de NSG existe solo debido a una solicitud de extracción fusionada
  • [ ] La comprobación de desviación no informa de ninguna desviación
  • [ ] taskboard-db existe en el clúster y no en ningún archivo de Git

Limpieza:

unset TF_VAR_pg_password
history -c

Mantenga el flujo de trabajo de rotación; elimine la regla ssh-from-vpn mediante otra solicitud de extracción (pull request) si no utiliza la VPN.

Errores comunes

Errores de desarrollo a evitar con el tema de esta unidad:

  1. Revocar antes de almacenar

    • Problema: La tarea de rotación elimina el token antiguo, luego no logra escribir el nuevo, y todos los pipelines devuelven 401.
    • Por qué ocurre: La eliminación surte efecto de inmediato, y el valor del nuevo token solo se muestra una vez.
    • Solución: Primero genere, verifique y almacene; elimine al final (Sección 1.2); mantenga un procedimiento de emergencia para emitir un token con la contraseña del usuario.
  2. Tokens de servicio desde una cuenta de administrador

    • Problema: Un token de CI filtrado elimina recursos en un ámbito de contrato completo.
    • Por qué ocurre: Los administradores tienen acceso a todos los recursos del contrato, independientemente de los grupos y las comparticiones.
    • Solución: Cree un usuario no administrador por servicio y entorno, otorgue privilegios a través de un grupo y acceso a recursos a través de ionoscloud_share.
  3. Esperar que los NSG aíslen pods

    • Problema: Agrega una regla de NSG para el puerto de la base de datos, pero los pods en MKS aún se comunican entre sí en todos los puertos.
    • Por qué ocurre: Los nodos del grupo de nodos de Managed Kubernetes están excluidos de los NSG.
    • Solución: Use Kubernetes NetworkPolicies para el tráfico de pods (Sección 4.3) y NSG para las VM y sus NIC.

Resumen

Ahora puede ejecutar las credenciales y las reglas de acceso de TaskBoard como código. Los tokens se rotan según un calendario con un breve ttl, los usuarios de servicio obtienen solo los privilegios y las comparticiones que necesitan, las contraseñas de la base de datos fluyen desde el almacén de secretos hacia Kubernetes sin tocar Git ni el estado, las reglas de NSG solo cambian a través de solicitudes de extracción con detección de desviación, y el acceso SSH sigue la lista de claves del equipo en el código.

Puntos clave:

  • Rotar los tokens en el orden: generar, verificar, almacenar, revocar; la eliminación es inmediata
  • Un usuario no administrador por servicio y entorno, derechos a través de grupos, acceso a través de comparticiones
  • Alimentar los Secrets de Kubernetes desde las salidas de Terraform y el almacén de secretos, nunca desde archivos en Git
  • Las NSG cubren VMs y NICs; use NetworkPolicies para pods en MKS
  • Las claves SSH inyectadas son inmutables; gestione la rotación con cloud-init y la gestión de configuración

Terminología importante:

  • Key ID: El identificador del token en la cabecera JWT, utilizado por DELETE /tokens/{tokenId}
  • Privilege: Un derecho de grupo, como create_k8s_cluster, que permite crear un tipo de recurso
  • Share: El acceso de un grupo a un recurso existente mediante Read, Edit o Sharing
  • Argumento de solo escritura: Un argumento de Terraform, como password_wo, que nunca se almacena en el estado
  • Drift: Una diferencia entre la configuración real y el código, detectada con plan -detailed-exitcode

Próximos pasos

Siga aprendiendo: Unidad 5.3: GitOps y operaciones de despliegue

Temas relacionados: