13 Min. Lesezeit

Lernziele

Am Ende dieses Moduls werden Sie in der Lage sein:

  • Dedizierte Core- und vCPU-Server mit `ionoscloud_server` und `ionoscloud_vcpu_server` provisionieren, dimensioniert innerhalb der Plattformgrenzen
  • Server beim ersten Start mit cloud-init `user_data` bootstrappen, die von Terraform übergeben werden
  • Statische öffentliche IPv4-Adressen mit `ionoscloud_ipblock` reservieren und sie einem Server-NIC zuweisen
  • Reproduzierbare Umgebungen aus `ionoscloud_snapshot` erstellen und horizontales Scaling mit `ionoscloud_autoscaling_group` definieren
  • Zwischen Cubes- und Compute Engine-Servern auf Basis des Speichermodells wählen, das jeweils provisioniert wird

Einheit 2.1: Compute- und Server-Automatisierung

Einführung

In Modul 1 haben Sie die Basis-VDC von TaskBoard mit einem generischen Server erstellt. Jetzt benötigt TaskBoard eine echte Compute-Ebene: einen API-Server mit dedizierten Kernen, der den Anfrageverkehr verarbeitet, sowie einen günstigeren Worker, der Hintergrundjobs verarbeitet. Beide müssen konfiguriert hochkommen, ohne dass sich jemand anmelden muss, um Pakete zu installieren.

In dieser Einheit schreiben Sie diese Compute-Ebene als Code: Servertypen und CPU-Optionen, cloud-init über Terraform, eine reservierte öffentliche IP, Snapshots, VM Auto Scaling Groups und Cubes. Im Code Lab deployen Sie die Compute-Ebene und verifizieren den SSH-Zugriff sowie die cloud-init-Ausführung.

1. Server Typen in 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
  }
}

Das Argument type wählt die Servernutzung aus: ENTERPRISE (jetzt als Dedicated Core bezeichnet), CUBE oder VCPU. Es ist unveränderlich, ebenso wie availability_zone, das AUTO, ZONE_1 oder ZONE_2 akzeptiert (Compute kennt keine Zone 3; siehe Einheit 2.4). ram wird in MB angegeben, daher entspricht 8 GB 8192.

1.1 Dedicated Core vs. vCPU

Die beiden Servertypen von Compute Engine unterscheiden sich darin, wie die CPU-Kapazität zugewiesen wird und was Sie im Code steuern können:

Eigenschaft Dedicated Core Server vCPU Server
CPU-Nutzung Exklusiv Geteilt
Maximale Rechenleistung 62 Kerne 60 vCPUs
Maximales RAM 230 GB 230 GB
cpu_family wählbar Ja Nein
Terraform-Ressource ionoscloud_server mit type = "ENTERPRISE" ionoscloud_vcpu_server (oder type = "VCPU")

Wie die Tabelle zeigt, eignet sich Dedicated Core für vorhersehbare CPU-Kapazität und Kontrolle über die CPU-Architektur. Die Leistung eines vCPU Servers hängt von der zugrunde liegenden CPU, der VM-Konfiguration und der aktuellen Last auf dem geteilten Host ab. RAM wird in Schritten von 0,25 GB eingestellt. Für den Hintergrund-Worker von TaskBoard ist ein vCPU Server ausreichend:

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 ist auf ionoscloud_vcpu_server erforderlich, und es gibt kein cpu_family-Argument: Die CPU-Familie eines vCPU Servers kann weder bei der Erstellung ausgewählt noch später geändert werden.

1.2 Auswahl der CPU-Familie

Auf einem Dedicated Core Server setzt cpu_family die CPU-Architektur. Nicht alle CPU-Architekturen sind in allen Rechenzentrumsregionen verfügbar, daher liest der oben genannte API-Server die Familie aus dem berechneten cpu_architecture-Attribut von ionoscloud_datacenter, anstatt eine fest einzuprogrammieren. Im Gegensatz zum vCPU Server kann die CPU-Familie eines Dedicated Core Servers nach der Erstellung geändert werden.

2. Cloud-Init Bootstrap aus Terraform

Cloud-init automatisiert die Initialisierung von Servern beim Systemstart. Benutzerdaten müssen in Shell-Skripten oder cloud-config-Direktiven mit YAML-Syntax geschrieben werden. Es ist auf allen öffentlichen Linux-Images verfügbar, die von IONOS CLOUD bereitgestellt werden; Windows-Images und Linux LVM sind derzeit nicht im Geltungsbereich.

2.1 Erstellen der cloud-config

Speichern Sie die Konfiguration neben Ihrem Terraform-Code, beispielsweise cloud-init/api.yaml:

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

Die erste Zeile #cloud-config kennzeichnet den Inhalt als cloud-config-Daten. Eine Datei, die mit #! beginnt, wird stattdessen als user-data-Skript ausgeführt.

2.2 Übergeben von user_data

In der Cloud API v6 wird cloud-init auf dem Volume-Ressource konfiguriert. In Terraform ist user_data ein Argument des volume-Blocks und erwartet die cloud-init-Konfiguration als base64-kodierten String:

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"))
  }
}

Die Eigenschaft user_data ist unveränderlich, wird nur bei der Erstellung neuer Volumes zugelassen und funktioniert nur mit cloud-init-kompatiblen Images. Aus diesem Grund filtert die Image-Datenquelle anhand von cloud_init = "V1".

2.3 SSH-Schlüssel-Injektion

ssh_keys akzeptiert Schlüsseltexte oder Dateipfade. SSH-Schlüssel werden nur unterstützt, wenn für die Volume-Erstellung ein öffentliches Linux-Image verwendet wird. Das Feld ist unveränderlich, kann nur in Erstellungsaufforderungen festgelegt werden und gibt beim Lesen immer null zurück.

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

Das Pfadformat unterstützt keine ~-Erweiterung. Übergeben Sie daher den Schlüsseltext aus einer Variable, wie gezeigt, oder verwenden Sie einen absoluten Pfad.

3. Öffentliche IP-Adressen mit ionoscloud_ipblock

Eine NIC, die mit dem Internet verbunden ist, erhält eine öffentliche IPv4-Adresse über DHCP. Diese Adresse kann sich ändern, wenn Sie die VM mit Power Stop freigeben oder die Netzwerkschnittstelle entfernen. Für einen API-Endpunkt hinter einem DNS-Eintrag sollten Sie eine statische Adresse reservieren.

3.1 Reservierung des Blocks

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

Eine IP-Adresse kann nur in der Rechenzentrumsregion verwendet werden, in der sie reserviert wurde. Daher übernimmt der Block seinen location aus dem Rechenzentrum. Es ist nicht möglich, eine bestimmte IPv4-Adresse zu reservieren. Nur Vertragsinhaber, Administratoren oder Benutzer mit dem Berechtigungsnachweis „Reserve IP Blocks" können IP-Adressen reservieren. Ein CI-Token benötigt daher diese Berechtigung.

3.2 Zuweisung der Adresse zur NIC

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

Der Verweis auf die berechnete ips-Liste sorgt dafür, dass Terraform den Block reserviert, bevor er den Server erstellt. Das berechnete ip_consumers-Attribut zeigt an, welche NIC und welcher Server jede Adresse verwenden. Reservierte Adressen werden berechnet, daher nicht genutzte Blöcke löschen.

4. Snapshots und reproduzierbare Umgebungen

4.1 Erfassen eines konfigurierten Volumes

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"
}

Das vom Server berechnete Attribut boot_volume liefert die Volume-ID. Wenn Daten, die sich noch im RAM der VM befinden, im Snapshot enthalten sein müssen, führen Sie zuerst sync aus oder schalten das Gast-Betriebssystem herunter.

4.2 Erstellen von Servern aus dem Snapshot

image_name auf einem Server akzeptiert einen Image-Namen, eine ID oder ein Alias und kann auch eine Snapshot-ID sein:

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

Snapshots sind auf den Standort des Rechenzentrums beschränkt, in dem sie ursprünglich erstellt wurden, wobei mehrere VDCs an diesem Standort sie nutzen können. Snapshots sind nicht inkrementell: Jeder Snapshot ist eine eigenständige Kopie, die Speicherplatz in Ihrem Konto belegt. Löschen Sie daher alte Snapshots in Ihrer Pipeline. Verwenden Sie cloud-init für schnelles Bootstrapping aus sauberen Images und einen Snapshot, wenn ein langsames Bootstrapping in einem bekannten Zustand eingefroren werden muss.

5. VM Auto Scaling und Cubes

5.1 Eine Auto Scaling Group als Code

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 unterstützt nur horizontales Scaling: Es werden VMs gleicher Größe hinzugefügt oder entfernt, gesteuert durch eine Scaling-Richtlinie pro Gruppe. Die Metrik ist eine von INSTANCE_CPU_UTILIZATION_AVERAGE, INSTANCE_NETWORK_IN_BYTES, INSTANCE_NETWORK_IN_PACKETS, INSTANCE_NETWORK_OUT_BYTES oder INSTANCE_NETWORK_OUT_PACKETS. Die Schwellenwerte für Scale-in und Scale-out müssen sich um mindestens 40 % unterscheiden, weshalb das Beispiel 25 und 70 verwendet. Die Abklingzeit liegt zwischen 2 Minuten und 24 Stunden, mit einem Standardwert von 5 Minuten. Replikate-Volumes verwenden die Speichertypen Essential, Balanced oder Performance.

5.2 Regeln, die Ihren Code beeinflussen

  • Die Replikat-Konfiguration gilt nur für neue Replikate. Ein Update von replica_configuration beeinflusst die vorhandenen Replikate nicht.
  • Setzen Sie delete_volumes bewusst. Bei false verbleiben die Volumes der entfernten Replikate im Rechenzentrum (siehe Häufige Fehlerquellen).
  • Halten Sie die Gruppengröße moderat. Die minimale Replikatanzahl beträgt 1. IONOS CLOUD empfiehlt höchstens 100 VMs pro Gruppe und höchstens 5 hinzugefügte oder entfernte VMs pro Scaling-Aktion.
  • Planen Sie für Spitzen vor. Abkling-Timer skalieren schrittweise, daher sollten Sie VMs vor einem bekannten Traffic-Hochpunkt hinzufügen.

Die Gruppe selbst befindet sich in der separaten VM Auto Scaling API (siehe Schnellkarte).

5.3 Cubes im Code

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"
  }
}

Die Größe eines Cube wird durch dessen Template bestimmt, nicht durch cores und ram. Sein Inline-Volumen muss disk_type = "DAS" verwenden, und volume.size kann nicht festgelegt werden, da das Template den direkt angebundenen NVMe-Speicher definiert. Die Basic-Templates reichen vom Basic Cube XS (1 vCPU, 2 GB RAM, 60 GB NVMe) bis zum Basic Cube XL (16 vCPUs, 32 GB RAM, 960 GB NVMe). Die Template-Eigenschaften können nach der Bereitstellung nicht mehr geändert werden. Außerdem wird beim Löschen des Cube auch sein NVMe-Volumen gelöscht. Erstellen Sie daher zuerst ein Snapshot, falls Sie die Daten benötigen. Jeder Cube unterstützt bis zu 23 Block Storage-Volumen zusätzlich zum NVMe-Volumen.

Schnellübersicht zur API-Referenz

Wichtige API-Endpunkte hinter den Ressourcen dieser Einheit:

Methode Endpunkt Beschreibung
POST /datacenters/{datacenterId}/servers Erstellt von ionoscloud_server und ionoscloud_vcpu_server
POST /ipblocks Erstellt von ionoscloud_ipblock
POST /datacenters/{datacenterId}/volumes/{volumeId}/create-snapshot Erstellt einen Snapshot eines Volumes
GET /templates Listet die Cube-Vorlagen auf
GET /groups/{groupId}/servers Listet die Server einer Auto Scaling Group (VM Auto Scaling API) auf

Basis-URL: https://api.ionos.com/cloudapi/v6 (VM Auto Scaling: https://api.ionos.com/autoscaling) Authentifizierung: Authorization: Bearer <token>

Code Lab

Ziel: Deployment der Compute-Ebene von TaskBoard mit Terraform: ein Dedicated Core API Server (4 Kerne, 8 GB RAM) mit reservierter öffentlicher IP und cloud-init-Bootstrap sowie ein vCPU Worker (2 Kerne). Überprüfung des SSH-Zugriffs und des cloud-init-Runs.

Voraussetzungen:

  • IONOS CLOUD Konto mit einem API-Token in IONOS_TOKEN und dem Privileg Reserve IP Blocks
  • Lokal installiertes Terraform, wobei der Provider wie in Einheit 1.2 festgelegt ist
  • Ein SSH-Schlüsselpaar, beispielsweise ~/.ssh/id_ed25519

Schritt 1: Projekt und cloud-config erstellen

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

Erwartete Ausgabe:

#cloud-config

Schritt 2: main.tf schreiben

Kombinieren Sie den festgelegten Anbieter, das Rechenzentrum und das öffentliche LAN aus Einheit 1.2, die Bilddatquelle (Abschnitt 2.2), den IP-Block (Abschnitt 3.1), den API-Server (Abschnitt 1, plus user_data aus 2.2 und ips aus 3.2) und den Worker (Abschnitt 1.1). Fügen Sie hinzu:

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 }

Erwartete Ausgabe:

(file saved)

Schritt 3: Planen und anwenden

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

Erwartete Ausgabe:

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>"

Schritt 4: Server über die API überprüfen

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)"'

Erwartete Ausgabe:

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

Schritt 5: Verbindung über SSH herstellen und auf cloud-init warten

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'

Erwartete Ausgabe:

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

Schritt 6: Überprüfen Sie den initialisierten Dienst

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

Erwartete Ausgabe:

HTTP/1.1 200 OK

Prüfliste:

  • [ ] terraform apply hat das Rechenzentrum, das LAN, den IP-Block und beide Server erstellt
  • [ ] Die API listet taskboard-api-01 als ENTERPRISE und taskboard-worker-01 als VCPU
  • [ ] SSH funktioniert mit Ihrem Schlüssel, und cloud-init status meldet done
  • [ ] Der API-Server antwortet auf seiner reservierten öffentlichen IP

Bereinigung:

terraform destroy -auto-approve

Häufige Fehler

Fehler von Entwicklerinnen und Entwicklern, die bei diesem Thema der Einheit zu vermeiden sind:

  1. Testen, bevor cloud-init abgeschlossen ist

    • Problem: terraform apply ist abgeschlossen, aber der erste Health Check schlägt fehl oder Pakete fehlen.
    • Ursache: „Provisioning abgeschlossen“ bedeutet, dass die Infrastruktur bereit ist; das Bootstrapping, einschließlich der Ausführung der cloud-init-Daten, kann zusätzliche Zeit in Anspruch nehmen.
    • Lösung: Warten Sie in Ihrer Pipeline mit cloud-init status --wait, und lesen Sie /var/log/cloud-init-output.log und /var/log/cloud-init.log, wenn etwas fehlt.
  2. Erwartung, dass eine Änderung von user_data einen Server neu konfiguriert

    • Problem: Sie bearbeiten die cloud-config und führen apply aus, aber der laufende Server übernimmt die Änderung nie.
    • Ursache: user_data ist unveränderlich und wird nur bei der Erstellung neuer Volumes erlaubt. Cloud-init kann nur bei der initialen Bereitstellung gesetzt werden und kann nicht auf bereits bereitgestellte Server angewendet werden.
    • Lösung: Gestalten Sie Server als ersetzbar und bauen Sie sie mit terraform apply -replace=ionoscloud_server.api neu auf, oder wenden Sie Laufzeitänderungen mit einem Konfigurationsverwaltungstool an.
  3. Volume-Lecks aus einer Auto Scaling Group

    • Problem: Nach Tagen des Skalierens schlägt das Scale-out fehl und das Rechenzentrum ist voller nicht zugewiesener Volumes.
    • Ursache: Bei delete_volumes = false hinterlassen entfernte Replikate ihre Volumes, und jedes Scale-out erstellt neue, bis die Ressourcenlimits des Vertrags erreicht sind.
    • Lösung: Setzen Sie delete_volumes = true für zustandslose Replikate und halten Sie den Zustand in verwalteten Diensten oder gemeinsam genutztem Speicher (Einheiten 2.4 und 2.5).

Zusammenfassung

Sie können die Compute-Ebene von TaskBoard jetzt als Code erstellen: einen Dedicated Core API-Server und einen vCPU-Worker, die sich selbst aus einer base64-kodierten cloud-config initialisieren, eine reservierte öffentliche IP für die API, Snapshots zur Wiederverwendung am selben Ort, Auto Scaling Groups für identische Repliken und Cubes, die nach Vorlage dimensioniert werden.

Wichtige Punkte:

  • type und availability_zone auf einem Server sind unveränderlich; Server verwenden AUTO, ZONE_1 oder ZONE_2
  • Nur Dedicated Core Servers ermöglichen die Auswahl von cpu_family; lesen Sie diesen Wert aus cpu_architecture des Rechenzentrums
  • user_data ist base64-kodierte cloud-init-Konfiguration, die nur bei der erstmaligen Erstellung eines Volumes mit einem cloud-init-kompatiblen Image gesetzt wird
  • Reservierte IPs stammen aus ionoscloud_ipblock in der Region des Rechenzentrums; DHCP-Adressen können sich nach einem Power Stop ändern
  • Auto Scaling erfolgt nur horizontal, und Änderungen an der Replikat-Konfiguration wirken sich nur auf neue Replikate aus

Wichtige Begriffe:

  • Dedicated Core Server: Ein Server mit exklusiven CPU-Kernen, type = "ENTERPRISE", mit einer wählbaren CPU-Familie
  • vCPU Server: Ein Server mit gemeinsam genutzten virtuellen CPUs, verwaltet über ionoscloud_vcpu_server
  • user_data: Die base64-kodierte cloud-init-Konfiguration eines Volumes, die einmalig beim ersten Start angewendet wird
  • IP block: Ein Satz reservierter, statischer öffentlicher IPv4-Adressen, der an eine Region gebunden ist
  • Replica configuration: Die Vorlage, die eine Auto Scaling Group verwendet, um jedes neue VM zu erstellen

Nächste Schritte

Weiter lernen: Einheit 2.2: Netzwerk und Konnektivität als Code

Verwandte Themen: