AZURE → STACKIT · VOLLSTÄNDIGER LEITFADEN

Der vollständige Leitfaden für die Migration von Azure zu STACKIT

Sie starten mit dem Terraform, das Sie für Azure schon haben. StackToIT liest es, stuft jede Ressource ein, entwirft, wo es möglich ist, das STACKIT-Terraform und führt je verantwortlicher Rolle auf, was nur eine Person entscheiden kann. Danach legen Sie die Landing Zone an, wenden den Entwurf in Wellen an, übertragen die Daten und stellen um. Dieser Leitfaden folgt dieser Reihenfolge und zeigt einen echten Lauf über eine gemischte Umgebung mit 11 Ressourcen.

Die Migration in acht Schritten

Jeder Schritt nennt die Datei des Laufs, in der seine Antwort steht. Die Dateien liegen im Ausgabeordner, den der Befehl assess schreibt.

  1. 1. Das Terraform sammeln

    Sammeln Sie die Root-Module für AzureRM oder AzAPI samt Variablendateien. Fehlt einer Variablen der Wert, bleibt eine Einheit ohne Entwurf; geben Sie der Engine deshalb dieselben Dateien, die auch Ihre Pipeline verwendet. StackToIT liest nur den Code und verbindet sich nicht mit einem Azure-Konto.

  2. 2. Die Bewertung starten

    Führen Sie stacktoit assess auf dem Ordner aus. Die Konsole zeigt die Quellzahlen, wie viele Einheiten entworfen wurden und wie viele offene Anfragen es gibt. Öffnen Sie zuerst index.html.

  3. 3. Die ersten Anfragen beantworten

    review/inputs.yaml führt die typisierten Fragen auf. Eine blockiert den Entwurf: die Zielregion. Andere, etwa die erlaubten CIDRs jedes verwalteten Dienstes, sind Variablen des Entwurfs.

  4. 4. Entscheidungen nach verantwortlicher Rolle prüfen

    review/decisions.yaml enthält je verantwortlicher Rolle und Einheit einen Eintrag. Eine Prüfung hält fest, dass jemand hingesehen hat; sie gibt keinen Schritt frei, bis der Entwurf mit den Antworten neu erzeugt wird.

  5. 5. Das Ziel aufbauen

    Legen Sie Folder und Projekt an, dazu eine Network Area, wenn Netzwerke sich erreichen müssen. migration/landing-zone-requirements.md führt auf, was die Organisation vor dem ersten Anwenden bereitstellen muss.

  6. 6. In Wellen anwenden

    migration/technical-sequencing.md ordnet die Einheiten nach Abhängigkeit. Im Lauf unten kommen die verwalteten Dienste und das Netzwerk zuerst, dann das Subnetz, danach der Server und zuletzt der Datenträger, weil er an den Server angehängt wird.

  7. 7. Die Daten übertragen

    migration/data-movement.md führt jede zustandsbehaftete Einheit mit dem Mechanismus UNKNOWN auf, bis eine Person einen wählt. StackToIT überträgt nie Daten.

  8. 8. Umstellen und Einstellungen schließen

    Stellen Sie die Anwendungen um und schließen oder akzeptieren Sie dann jede offene kritische Einstellung in execution/manual/actions.md. Behalten Sie die Azure-Seite, bis die Prüfungen abgeschlossen sind.

Schritt 2: die Bewertung starten

Eine für diesen Leitfaden geschriebene gemischte Demo-Umgebung: ein virtuelles Netzwerk mit einem Subnetz, eine Linux-VM mit Datenträger, ein Redis-Cache, ein Service-Bus-Namespace mit Queue und ein Cosmos-DB-Konto mit MongoDB-API. Der Lauf stammt vom 4. November 2026. Die Zeilen der Zusammenfassung stammen aus der Konsole dieses Laufs.

Befehlterminal
stacktoit assess . ./out --offline --no-validate
Konsolen-Zusammenfassungconsole
Source        11 resources · 7 units · visibility: Complete
Migration     6 drafted · 1 need no resource (of 7 units the draft considered)
Target        STACKIT Terraform generated
Attention     7 units to review · 5 open requests (1 block the draft, marked in inputs-template.yaml)
  • 11 Ressourcen, 7 Einheiten

    Die Queue geht in ihrem Namespace auf, die Datenträger-Anbindung im Datenträger und die NIC in der VM; die Ressourcengruppe ist keine Einheit. Sechs Einheiten wurden entworfen, eine braucht keine Ressource: das virtuelle Netzwerk.

  • Was der Lauf erzeugte

    OpenTofu-Schritte für 10 Ressourcenblöcke und 16 manuelle Schritte in 11 Arbeitspaketen für die 25 kritischen Einstellungen, die der Entwurf nicht übernimmt.

Compute: eine VM und ihr Datenträger

Links die Linux-VM und der verwaltete Datenträger. Rechts die Server- und Volume-Blöcke, die die Engine geschrieben hat; die Prüfkommentare über jedem Block sind hier ausgelassen.

Beispieleingabemain.tf
resource "azurerm_linux_virtual_machine" "batch" {
  name                  = "vm-batch-01"
  location              = azurerm_resource_group.core.location
  resource_group_name   = azurerm_resource_group.core.name
  size                  = "Standard_D4s_v5"
  admin_username        = "azureuser"
  network_interface_ids = [azurerm_network_interface.batch.id]

  admin_ssh_key {
    username   = "azureuser"
    public_key = "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIExampleKeyOnlyForTheDemo demo"
  }

  os_disk {
    caching              = "ReadWrite"
    storage_account_type = "Premium_LRS"
    disk_size_gb         = 64
  }

  source_image_reference {
    publisher = "Canonical"
    offer     = "ubuntu-24_04-lts"
    sku       = "server"
    version   = "latest"
  }
}

resource "azurerm_managed_disk" "batch_data" {
  name                 = "disk-batch-data"
  location             = azurerm_resource_group.core.location
  resource_group_name  = azurerm_resource_group.core.name
  storage_account_type = "Premium_LRS"
  create_option        = "Empty"
  disk_size_gb         = 256
}
STACKIT-Terraform von StackToITterraform/compute.tf
resource "stackit_server" "batch" {
  project_id        = var.project_id
  name              = "vm-batch-01"
  machine_type      = var.batch_machine_type
  availability_zone = var.availability_zone
  boot_volume = {
    source_type           = "image"
    source_id             = var.batch_image_id
    size                  = 64
    delete_on_termination = true
  }
  keypair_name       = stackit_key_pair.batch.name
  network_interfaces = [stackit_network_interface.batch_1.network_interface_id]
}

resource "stackit_volume" "batch_data" {
  project_id        = var.project_id
  name              = "disk-batch-data"
  availability_zone = var.availability_zone
  size              = 256
  performance_class = var.batch_data_performance_class
}
  • Größe, Image und Login sind Variablen

    Maschinentyp und Image-ID haben keinen Standardwert. Die Azure-VM-Größe lässt sich keinem Namen zuordnen; Sie wählen einen STACKIT-Maschinentyp. Der Admin-Benutzer azureuser wird nicht übernommen: Der Login-Benutzer ist der des Images.

  • Die Datenträger-Performance ist eine Wahl

    Das Boot-Volume behält seine Größe und verliert Caching und den Typ Premium_LRS; das Daten-Volume übernimmt die Größe 256 und eine Variable für die Performance-Klasse. Binden Sie das Volume im Gastsystem über die Volume-ID ein, nicht über die LUN, denn die LUN wird nicht übernommen.

  • Die Reihenfolge zählt

    Der Datenträger ist die letzte Einheit, denn er hängt an einem Server, der zuerst existieren muss.

Verwaltete Dienste: Cache und Messaging

Aus demselben Lauf. Erster Ausschnitt: der Redis-Cache und der Service-Bus-Namespace. Danach die Valkey- und die RabbitMQ-Instanz, ein Ausschnitt je Entwurfsdatei. Die Queue und die Namespace-Einstellungen werden nicht erzeugt.

Beispieleingabemain.tf
resource "azurerm_redis_cache" "sessions" {
  name                = "redis-sessions-gwc"
  location            = azurerm_resource_group.core.location
  resource_group_name = azurerm_resource_group.core.name
  capacity            = 1
  family              = "C"
  sku_name            = "Standard"
  minimum_tls_version = "1.2"
}

resource "azurerm_servicebus_namespace" "events" {
  name                = "sb-events-gwc"
  location            = azurerm_resource_group.core.location
  resource_group_name = azurerm_resource_group.core.name
  sku                 = "Standard"
}
STACKIT: data.tfterraform/data.tf
resource "stackit_valkey_instance" "sessions" {
  project_id = var.project_id
  name       = "redis-sessions-gwc"
  plan_name  = var.sessions_plan_name
  version    = var.sessions_version
  parameters = {
    sgw_acl = join(",", var.sessions_allowed_cidrs)
  }
}
STACKIT: messaging.tfterraform/messaging.tf
resource "stackit_rabbitmq_instance" "messaging" {
  project_id = var.project_id
  name       = "messaging"
  plan_name  = var.rabbitmq_plan_name
  version    = var.rabbitmq_version
  parameters = {
    sgw_acl = join(",", var.rabbitmq_allowed_cidrs)
  }
}
  • Zugriffslisten ohne sicheren Standard

    Der Entwurf setzt die Zugriffsliste aus Variablen ohne Standardwert. Der Kommentar sagt, dass STACKIT ohne Liste seine Standard-ACL anwendet, die die Adressen aller STACKIT-Kunden umfasst. Tragen Sie die Client-CIDRs ein, bevor Sie planen.

  • Ein neues Client-Protokoll

    Service Bus spricht AMQP 1.0. Der Lauf nennt für RabbitMQ einen AMQP-0-9-1-Client; Producer und Consumer wechseln also ihre Bibliothek, und die Queue wird von Hand neu angelegt.

  • Die Cache-Größe ist ein Plan

    Familie und Kapazität werden nicht übernommen. Sie wählen den Valkey-Plan, und Clients erhalten neue Zugangsdaten; Cache-Inhalte werden meist neu aufgebaut, nicht migriert.

So wird die Umgebung zugeordnet

Azure-RessourceSTACKIT-ZielMigrationsklasse
Linux-VM (mit NIC)Compute-Engine-Server und NetzwerkschnittstelleRekonfigurieren
Verwalteter Datenträger (mit Anbindung)Block-Storage-Volume, an den Server angehängtRekonfigurieren
Virtuelles NetzwerkSTACKIT-Projektnetzwerk oder Network AreaRekonfigurieren
SubnetzSTACKIT-Netzwerk mit demselben IPv4-PräfixRekonfigurieren
Azure Cache for RedisKey-Value-Store-Instanz (Valkey) und ZugangsdatenRekonfigurieren
Service-Bus-Namespace (mit Queue)RabbitMQ-InstanzReplatforming
Cosmos-DB-Konto, MongoDB-APIMongoDB-Flex-InstanzReplatforming

Klassen so, wie der Lauf sie entschieden hat: 5 RECONFIGURE und 2 REPLATFORM, alle mit Konfidenz MEDIUM. Weitere Dienste folgen demselben Muster; die Leitfäden zu Azure SQL, AKS und Netzwerk zeigen ihre eigenen Läufe.

So ziehen die Daten um, je Dienst

  • MongoDB-API

    Das Wire-Protokoll ist dasselbe, Clients ziehen daher mit neuem Connection String, TLS-CA und Zugangsdaten um. Die Daten übertragen Sie mit mongodump und mongorestore. Globale Verteilung, einstellbare Konsistenz und Skalierung nach Request Units werden nicht übernommen.

  • Cache

    Cache-Inhalte werden meist neu aufgebaut, nicht migriert. Nur Zustand, den Sie nicht neu aufbauen können, etwa zu erhaltende Sessions, braucht einen Plan.

  • Queues

    Noch nicht zugestellte Nachrichten abarbeiten oder erneut einspielen und Queues, Exchanges und Bindings in RabbitMQ neu anlegen. Der Lauf führt den Namespace als Einheit auf, aber nicht als zustandsbehaftete Daten.

  • Datenträger

    Ein verwalteter Datenträger wird zu einem Volume gleicher Größe. Die Daten wandern mit dem Server-Image oder per Datei- oder Blockkopie; die Engine hält den Mechanismus als offen fest.

Entscheidungen, die bei Ihren Architekten liegen

  • Identität

    Wer sich an den neuen Diensten anmeldet. Der Lauf legt offene Einstellungen zum Administrator-Login der VM und zum Ressourcengruppen-Scope jeder Einheit an. STACKIT kennt keine Ressourcengruppen; bilden Sie deren Grenzen daher auf Projekte und Rollen ab.

  • Netzwerkerreichbarkeit

    Ob jeder verwaltete Dienst öffentlich oder auf eine Network Area beschränkt ist und welche CIDRs ihn erreichen dürfen.

  • Dimensionierung

    Maschinentyp, Valkey-Plan, MongoDB-Flavor und Storage-Klassen. Für keines davon hat der Entwurf einen Standardwert.

  • Datenumzug

    Mechanismus, Fenster und tolerierte Downtime je zustandsbehafteter Einheit. Die Quelle nennt keines davon.

  • Datenresidenz

    Der Standort jeder Ressource ist eine offene Einstellung; bestätigen Sie die Region und dass die Dienste darin existieren.

Fragen von Migrationsleitungen

Verbindet sich StackToIT mit meiner Azure-Subscription?

Nein. Es liest Terraform- und OpenTofu-Root-Module mit dem Provider azurerm oder azapi, auf Wunsch offline. Es liest kein Live-Konto, Ressourcen außerhalb von Terraform bleiben also unsichtbar.

Kann ich das erzeugte Terraform sofort anwenden?

Nein. Das Paket ist ein Vorschlag, den Ihre Architekten prüfen. In diesem Lauf kann kein OpenTofu-Schritt wie geschrieben laufen, weil Werte wie project_id und die Zugriffslisten fehlen und Einstellungen offen sind.

Welche Azure-Dienste haben ein verwaltetes STACKIT-Ziel?

Laut kuratierter Zuordnung: AKS zu SKE, PostgreSQL und SQL Server zu ihren Flex-Diensten, Storage Accounts zu Object Storage, Key Vault zu Secrets Manager und KMS, Redis zu Valkey, Service Bus zu RabbitMQ und Cosmos DB zu MongoDB Flex oder PostgreSQL Flex. App Service und Functions gehen zu Cloud Foundry oder SKE. Azure Firewall wird im Einzelfall entschieden.

Wo fange ich im Ausgabeordner an?

Öffnen Sie index.html, lesen Sie dann engineering/architect-report.md für die Befunde je Einheit, review/inputs.yaml und review/decisions.yaml für die Fragen und execution/README.md für die Reihenfolge der Schritte.

Quellen

Ihr nächster Schritt: STACKIT.

Erzählen Sie uns von Ihrer Umgebung. Wir zeigen Ihnen, was StackToIT dafür liefert: Zielarchitektur, Terraform-Artefakte und einen strukturierten Migrationsplan.