15 min de lectura

Objetivos de aprendizaje

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

  • Aprovisionar servidores Dedicated Core y vCPU con `ionoscloud_server` y `ionoscloud_vcpu_server`, dimensionados dentro de los límites de la plataforma
  • Inicializar servidores en el primer arranque mediante cloud-init `user_data` pasado desde Terraform
  • Reservar direcciones IPv4 públicas estáticas con `ionoscloud_ipblock` y asignarlas a una NIC de un servidor
  • Crear entornos reproducibles a partir de `ionoscloud_snapshot` y definir escalado horizontal con `ionoscloud_autoscaling_group`
  • Elegir entre servidores Cubes y Compute Engine en función del modelo de almacenamiento que cada uno aprovisiona

Unidad 2.1: Computación y automatización de servidores

Introducción

En el Módulo 1 construyó el VDC base de TaskBoard con un servidor genérico. Ahora TaskBoard necesita un nivel de cómputo real: un servidor de API con núcleos dedicados que maneje el tráfico de solicitudes, y un worker más económico que procese tareas en segundo plano. Ambos deben iniciarse configurados, sin que nadie inicie sesión para instalar paquetes.

En esta unidad escribe ese nivel de cómputo como código: tipos de servidor y opciones de CPU, cloud-init a través de Terraform, una IP pública reservada, instantáneas, grupos de VM Auto Scaling y Cubes. En el Code Lab despliega el nivel de cómputo y verifica el acceso SSH y la ejecución de cloud-init.

1. Tipos de servidor en Terraform

resource "ionoscloud_server" "api" {
  name              = "taskboard-api-01"
  datacenter_id     = ionoscloud_datacenter.taskboard.id
  type              = "ENTERPRISE"
  cores             = 4
  ram               = 8192
  cpu_family        = ionoscloud_datacenter.taskboard.cpu_architecture[0].cpu_family
  availability_zone = "AUTO"
  image_name        = data.ionoscloud_image.ubuntu.id
  ssh_keys          = [var.ssh_public_key]

  volume {
    name      = "system"
    size      = 20
    disk_type = "BALANCED"
  }

  nic {
    lan  = ionoscloud_lan.public.id
    name = "public"
    dhcp = true
  }
}

El argumento type selecciona el uso del servidor: ENTERPRISE (ahora denominado Dedicated Core), CUBE o VCPU. Es inmutable, al igual que availability_zone, que acepta AUTO, ZONE_1 o ZONE_2 (Compute no tiene Zona 3; consulte la Unidad 2.4). ram se expresa en MB, por lo que 8 GB es 8192.

1.1 Dedicated Core frente a vCPU

Los dos tipos de servidor de Compute Engine difieren en la forma en que se asigna la capacidad de CPU y en lo que puede controlar mediante el código:

Propiedad Dedicated Core Server vCPU Server
Uso de CPU Exclusivo Compartido
Cómputo máximo 62 núcleos 60 vCPUs
RAM máxima 230 GB 230 GB
cpu_family seleccionable Sí No
Recurso de Terraform ionoscloud_server con type = "ENTERPRISE" ionoscloud_vcpu_server (o type = "VCPU")

Como muestra la tabla, elija Dedicated Core para obtener una capacidad de CPU predecible y control sobre la arquitectura de CPU. El rendimiento de un vCPU Server depende de la CPU subyacente, de la configuración de la VM y de la carga actual en el host compartido. La RAM se establece en incrementos de 0.25 GB. Para el trabajador en segundo plano de TaskBoard, un vCPU Server es suficiente:

resource "ionoscloud_vcpu_server" "worker" {
  name          = "taskboard-worker-01"
  datacenter_id = ionoscloud_datacenter.taskboard.id
  cores         = 2
  ram           = 4096
  image_name    = data.ionoscloud_image.ubuntu.id
  ssh_keys      = [var.ssh_public_key]

  volume {
    name      = "system"
    size      = 20
    disk_type = "BALANCED"
  }

  nic {
    lan  = ionoscloud_lan.public.id
    name = "public"
    dhcp = true
  }
}

volume es obligatorio en ionoscloud_vcpu_server, y no existe el argumento cpu_family: la familia de CPU de un vCPU Server no puede elegirse en la creación ni modificarse posteriormente.

1.2 Selección de la familia de CPU

En un Dedicated Core Server, cpu_family establece la arquitectura de CPU. No todas las arquitecturas de CPU están disponibles en todas las regiones de los centros de datos, por lo que el servidor de API anterior lee la familia del atributo cpu_architecture calculado de ionoscloud_datacenter en lugar de codificarla de forma fija. A diferencia del vCPU Server, la familia de CPU de un Dedicated Core Server puede modificarse después de la creación.

2. Bootstrap de Cloud-Init desde Terraform

Cloud-init automatiza la inicialización de los servidores durante el arranque del sistema. Los datos de usuario deben escribirse en scripts de shell o en directivas de cloud-config utilizando la sintaxis YAML. Está disponible en todas las imágenes públicas de Linux proporcionadas por IONOS CLOUD; las imágenes de Windows y Linux LVM están actualmente fuera del alcance.

2.1 Escritura de la configuración cloud-config

Guarde la configuración junto a su código de Terraform, por ejemplo cloud-init/api.yaml:

#cloud-config
package_update: true
packages:
  - nginx
runcmd:
  - systemctl enable --now nginx

La primera línea #cloud-config marca el contenido como datos de cloud-config. Un archivo que comienza con #! se ejecuta como un script de user-data.

2.2 Paso de user_data

En la Cloud API v6, cloud-init se configura en el recurso de volumen. En Terraform, user_data es un argumento del bloque de volumen y espera la configuración de cloud-init como una cadena codificada en base64:

data "ionoscloud_image" "ubuntu" {
  image_alias = "ubuntu:latest"
  type        = "HDD"
  cloud_init  = "V1"
  location    = var.location
}

resource "ionoscloud_server" "api" {
  # ... arguments from Section 1 ...
  volume {
    name      = "system"
    size      = 20
    disk_type = "BALANCED"
    user_data = base64encode(file("${path.module}/cloud-init/api.yaml"))
  }
}

La propiedad user_data es inmutable, solo se permite al crear un nuevo volumen y solo funciona con imágenes compatibles con cloud-init, por lo que la fuente de datos de la imagen filtra por cloud_init = "V1".

2.3 Inyección de claves SSH

ssh_keys acepta texto de clave o rutas de archivo, y las claves SSH solo se admiten si se utiliza una imagen pública de Linux para la creación del volumen. El campo es inmutable, solo puede establecerse en las solicitudes de creación y siempre devuelve null al leerse.

variable "ssh_public_key" {
  type        = string
  description = "Public key text, for example the content of ~/.ssh/id_ed25519.pub"
}

El formato de ruta no admite la expansión de ~, por lo que debe pasar el texto de la clave desde una variable, como se muestra, o utilizar una ruta absoluta.

3. Direcciones IP públicas con ionoscloud_ipblock

Una NIC conectada a Internet obtiene una dirección IPv4 pública mediante DHCP, y esa dirección puede cambiar cuando se desasigne la VM mediante Power Stop o se elimine la interfaz de red. Para un endpoint de API detrás de un registro DNS, reserve una dirección estática.

3.1 Reserva del bloque

resource "ionoscloud_ipblock" "api" {
  name     = "taskboard-api-ip"
  location = ionoscloud_datacenter.taskboard.location
  size     = 1
}

Una dirección IP solo puede utilizarse en la región del centro de datos donde se reservó, por lo que el bloque toma su location del centro de datos. No es posible reservar una dirección IPv4 específica. Solo los propietarios de contratos, los administradores o los usuarios con el privilegio Reserve IP Blocks pueden reservar direcciones IP, por lo que un token de CI necesita dicho privilegio.

3.2 Asignación de la dirección a la NIC

resource "ionoscloud_server" "api" {
  # ...
  nic {
    lan  = ionoscloud_lan.public.id
    name = "public"
    dhcp = true
    ips  = [ionoscloud_ipblock.api.ips[0]]
  }
}

La referencia a la lista calculada ips hace que Terraform reserve el bloque antes de crear el servidor. El atributo calculado ip_consumers muestra qué NIC y servidor utilizan cada dirección. Las direcciones reservadas se facturan, por lo que debe destruir los bloques que no se utilicen.

4. Instantáneas y entornos reproducibles

4.1 Captura de un volumen configurado

resource "ionoscloud_snapshot" "api_golden" {
  datacenter_id = ionoscloud_datacenter.taskboard.id
  volume_id     = ionoscloud_server.api.boot_volume
  name          = "taskboard-api-golden"
  description   = "API server after cloud-init bootstrap"
}

El atributo boot_volume calculado del servidor le proporciona el ID del volumen. Si los datos que aún están en la RAM de la VM deben estar en el Snapshot, ejecute sync o apague primero el sistema operativo invitado.

4.2 Creación de servidores desde el Snapshot

image_name en un servidor acepta un nombre de imagen, un ID o un alias, y también puede ser un ID de Snapshot:

resource "ionoscloud_server" "api_clone" {
  # same arguments as ionoscloud_server.api, except:
  name       = "taskboard-api-02"
  image_name = ionoscloud_snapshot.api_golden.id
}

Los Snapshot están limitados a la ubicación del centro de datos donde se crearon originalmente, aunque varios VDC en esa ubicación pueden utilizarlos. Los Snapshot no son incrementales: cada uno es una copia independiente que ocupa espacio de almacenamiento en su cuenta, por lo que debe eliminar los antiguos en su pipeline. Utilice cloud-init para inicializaciones rápidas desde imágenes limpias, y un Snapshot cuando una inicialización lenta debe congelarse en un estado conocido.

5. VM Auto Scaling y Cubes

5.1 Un grupo de VM Auto Scaling como código

resource "ionoscloud_autoscaling_group" "workers" {
  datacenter_id     = ionoscloud_datacenter.taskboard.id
  name              = "taskboard-workers"
  min_replica_count = 1
  max_replica_count = 4

  policy {
    metric              = "INSTANCE_CPU_UTILIZATION_AVERAGE"
    scale_in_threshold  = 25
    scale_out_threshold = 70
    unit                = "PER_MINUTE"
    scale_in_action {
      amount                  = 1
      amount_type             = "ABSOLUTE"
      termination_policy_type = "OLDEST_SERVER_FIRST"
      cooldown_period         = "PT5M"
      delete_volumes          = true
    }
    scale_out_action {
      amount          = 1
      amount_type     = "ABSOLUTE"
      cooldown_period = "PT5M"
    }
  }

  replica_configuration {
    availability_zone = "AUTO"
    cores             = 2
    ram               = 4096
    nic {
      lan  = ionoscloud_lan.app.id # private app LAN, built in Unit 2.2
      name = "app"
      dhcp = true
    }
    volume {
      image_alias = "ubuntu:latest"
      name        = "system"
      size        = 20
      type        = "BALANCED"
      user_data   = base64encode(file("${path.module}/cloud-init/worker.yaml"))
      ssh_keys    = [var.ssh_public_key]
      boot_order  = "AUTO"
    }
  }
}

VM Auto Scaling solo admite escalado horizontal: agrega o elimina VMs del mismo tamaño, controlado por una política de escalado por grupo. La métrica es una de INSTANCE_CPU_UTILIZATION_AVERAGE, INSTANCE_NETWORK_IN_BYTES, INSTANCE_NETWORK_IN_PACKETS, INSTANCE_NETWORK_OUT_BYTES o INSTANCE_NETWORK_OUT_PACKETS. Los umbrales de escalado hacia dentro y hacia fuera deben diferir en al menos un 40%, por lo que el ejemplo utiliza 25 y 70. El período de espera va de 2 minutos a 24 horas, con un valor predeterminado de 5 minutos. Los volúmenes de réplica utilizan los tipos de almacenamiento Essential, Balanced o Performance.

5.2 Reglas que afectan su código

  • La configuración de réplica se aplica solo a las réplicas nuevas. Actualizar replica_configuration no afecta a las réplicas existentes.
  • Configure delete_volumes de forma deliberada. Con false, los volúmenes de las réplicas eliminadas permanecen en el centro de datos (véase Errores comunes).
  • Mantenga el tamaño del grupo moderado. La cantidad mínima de réplicas es 1. IONOS CLOUD recomienda un máximo de 100 VMs por grupo y un máximo de 5 VMs agregadas o eliminadas por acción de escalado.
  • Planifique para picos. Los temporizadores de espera escalan gradualmente, por lo que agregue VMs antes de un pico de tráfico conocido.

El grupo en sí reside en la API de VM Auto Scaling separada (véase la Tarjeta rápida).

5.3 Cubes en código

data "ionoscloud_template" "xs" {
  name = "Basic Cube XS"
}

resource "ionoscloud_cube_server" "helper" {
  name           = "taskboard-cube-01"
  datacenter_id  = ionoscloud_datacenter.taskboard.id
  template_uuid  = data.ionoscloud_template.xs.id
  image_name     = "ubuntu:latest"
  image_password = var.image_password
  volume {
    name         = "nvme"
    licence_type = "LINUX"
    disk_type    = "DAS"
  }
}

Un Cube se dimensiona según su plantilla, no por cores y ram. Su volumen en línea debe utilizar disk_type = "DAS", y no puede establecer volume.size, porque la plantilla define el almacenamiento NVMe conectado directamente. Las plantillas Basic van desde Basic Cube XS (1 vCPU, 2 GB de RAM, 60 GB de NVMe) hasta Basic Cube XL (16 vCPUs, 32 GB de RAM, 960 GB de NVMe). Las propiedades de la plantilla no se pueden cambiar después del aprovisionamiento, y eliminar el Cube también elimina su volumen NVMe, por lo que debe tomar una instantánea primero si necesita los datos. Cada Cube admite hasta 23 volúmenes de Block Storage además del volumen NVMe.

Tarjeta rápida de referencia de la API

Endpoints clave de la API detrás de los recursos de esta unidad:

Método Endpoint Descripción
POST /datacenters/{datacenterId}/servers Creado por ionoscloud_server y ionoscloud_vcpu_server
POST /ipblocks Creado por ionoscloud_ipblock
POST /datacenters/{datacenterId}/volumes/{volumeId}/create-snapshot Crea una instantánea de un volumen
GET /templates Lista las plantillas de Cube
GET /groups/{groupId}/servers Lista los servidores de un grupo de Auto Scaling (API de VM Auto Scaling)

URL base: https://api.ionos.com/cloudapi/v6 (VM Auto Scaling: https://api.ionos.com/autoscaling) Autenticación: Authorization: Bearer <token>

Laboratorio de código

Objetivo: Desplegar la capa de cómputo de TaskBoard con Terraform: un servidor Dedicated Core API (4 núcleos, 8 GB de RAM) con una IP pública reservada y un bootstrap mediante cloud-init, y un worker de vCPU (2 núcleos). Verifique el acceso SSH y la ejecución de cloud-init.

Requisitos previos:

  • Cuenta de IONOS CLOUD con un token de API en IONOS_TOKEN y el privilegio Reserve IP Blocks
  • Terraform instalado localmente, con el proveedor fijado como en la Unidad 1.2
  • Un par de claves SSH, por ejemplo ~/.ssh/id_ed25519

Paso 1: Crear el proyecto y el cloud-config

mkdir -p taskboard-compute/cloud-init && cd taskboard-compute
# save the cloud-config from Section 2.1 as cloud-init/api.yaml
head -n 1 cloud-init/api.yaml

Salida esperada:

#cloud-config

Paso 2: Escriba main.tf

Combine el proveedor fijado, el centro de datos y la LAN pública de la Unidad 1.2, la fuente de datos de la imagen (Sección 2.2), el bloque de IP (Sección 3.1), el servidor de API (Sección 1, además de user_data de la 2.2 y ips de la 3.2) y el worker (Sección 1.1). Añada:

output "datacenter_id" { value = ionoscloud_datacenter.taskboard.id }
output "api_public_ip" { value = ionoscloud_ipblock.api.ips[0] }
output "worker_ip"     { value = ionoscloud_vcpu_server.worker.primary_ip }

Salida esperada:

(file saved)

Paso 3: Planificar y aplicar

export TF_VAR_ssh_public_key="$(cat ~/.ssh/id_ed25519.pub)"
terraform init
terraform plan -out=tfplan
terraform apply tfplan

Salida esperada:

Plan: 5 to add, 0 to change, 0 to destroy.
...
Apply complete! Resources: 5 added, 0 changed, 0 destroyed.

Outputs:
api_public_ip = "<reserved IP>"
datacenter_id = "<datacenter UUID>"
worker_ip = "<DHCP-assigned IP>"

Paso 4: Verifique los servidores a través de la API

DC=$(terraform output -raw datacenter_id)
curl -s -H "Authorization: Bearer $IONOS_TOKEN" \
  "https://api.ionos.com/cloudapi/v6/datacenters/$DC/servers?depth=1" \
  | jq -r '.items[].properties | "\(.name) \(.type) \(.cores) \(.ram) \(.vmState)"'

Salida esperada:

taskboard-api-01 ENTERPRISE 4 8192 RUNNING
taskboard-worker-01 VCPU 2 4096 RUNNING

Paso 5: Conectarse mediante SSH y esperar a cloud-init

ssh -i ~/.ssh/id_ed25519 root@"$(terraform output -raw api_public_ip)" \
  'cloud-init status --wait && tail -n 3 /var/log/cloud-init-output.log'

Salida esperada:

status: done
Cloud-init v. ... finished at ...

Paso 6: Verificar el servicio inicializado

curl -sI "http://$(terraform output -raw api_public_ip)" | head -n 1

Salida esperada:

HTTP/1.1 200 OK

Lista de verificación:

  • [ ] terraform apply creó el centro de datos, la LAN, el bloque de IP y ambos servidores
  • [ ] La API lista taskboard-api-01 como ENTERPRISE y taskboard-worker-01 como VCPU
  • [ ] SSH funciona con su clave, y cloud-init status informa done
  • [ ] El servidor de API responde en su IP pública reservada

Limpieza:

terraform destroy -auto-approve

Errores comunes

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

  1. Probar antes de que cloud-init haya terminado

    • Problema: terraform apply se completa, pero la primera comprobación de estado falla o faltan paquetes.
    • Por qué ocurre: Que la aprovisionamiento esté completo significa que la infraestructura está lista; el aprovisionamiento inicial, incluida la ejecución de los datos de cloud-init, puede requerir tiempo adicional.
    • Solución: Espere con cloud-init status --wait en su pipeline, y lea /var/log/cloud-init-output.log y /var/log/cloud-init.log cuando algo falte.
  2. Esperar que un cambio en user_data reconfigure un servidor

    • Problema: Edita la configuración de cloud-config y ejecuta apply, pero el servidor en ejecución nunca aplica el cambio.
    • Por qué ocurre: user_data es inmutable y solo se permite en la creación de un nuevo volumen. Cloud-init solo puede configurarse durante el aprovisionamiento inicial y no puede aplicarse a servidores que ya han sido aprovisionados.
    • Solución: Diseñe los servidores como reemplazables y reconstrúyalos con terraform apply -replace=ionoscloud_server.api, o aplique cambios en tiempo de ejecución con una herramienta de gestión de configuración.
  3. Fugas de volúmenes de un Auto Scaling Group

    • Problema: Después de días de escalado, el escalado hacia fuera falla y el centro de datos está lleno de volúmenes sin adjuntar.
    • Por qué ocurre: Con delete_volumes = false, las réplicas eliminadas dejan sus volúmenes atrás, y cada escalado hacia fuera crea nuevos hasta alcanzar los límites de recursos del contrato.
    • Solución: Establezca delete_volumes = true para réplicas sin estado y mantenga el estado en servicios administrados o en almacenamiento compartido (Unidades 2.4 y 2.5).

Resumen

Ahora puede construir la capa de cómputo de TaskBoard como código: un servidor Dedicated Core API y un trabajador vCPU que se inicializan a partir de una cloud-config codificada en base64, una IP pública reservada para la API, instantáneas para reutilización en la misma ubicación, Auto Scaling Groups para réplicas idénticas y Cubes dimensionados por plantilla.

Puntos clave:

  • type y availability_zone en un servidor son inmutables; los servidores usan AUTO, ZONE_1 o ZONE_2
  • Solo los Dedicated Core Servers permiten elegir cpu_family; lea este valor desde cpu_architecture del centro de datos
  • user_data es cloud-init codificado en base64, que se configura solo al crear un nuevo volumen con una imagen compatible con cloud-init
  • Las IPs reservadas provienen de ionoscloud_ipblock en la región del centro de datos; las direcciones DHCP pueden cambiar al apagar el equipo
  • El Auto Scaling es solo horizontal, y los cambios en la configuración de la réplica solo afectan a las réplicas nuevas

Terminología importante:

  • Dedicated Core Server: Un servidor con núcleos de CPU exclusivos, type = "ENTERPRISE", con una familia de CPU seleccionable
  • vCPU Server: Un servidor con CPUs virtuales compartidas, gestionado con ionoscloud_vcpu_server
  • user_data: La configuración cloud-init codificada en base64 de un volumen, aplicada una sola vez en el primer arranque
  • IP block: Un conjunto de direcciones IPv4 públicas reservadas y estáticas que está vinculado a una región
  • Replica configuration: La plantilla que un Auto Scaling Group utiliza para crear cada nueva VM

Próximos pasos

Siga aprendiendo: Unidad 2.2: Red y conectividad como código

Temas relacionados: