De complete migratiegids van Oracle Cloud naar STACKIT

De migratie in negen stappen

Elke stap noemt het bestand van de run dat het antwoord bevat.

1. 01

   1. De Terraform-code verzamelen

   Verzamel elke rootmodule die Oracle Cloud-resources declareert. StackToIT leest Terraform en OpenTofu en maakt geen verbinding met uw tenancy.

2. 02

   2. Het assessment uitvoeren

   Eén commando levert het hele pakket op. De samenvatting op de console vertelt hoeveel eenheden er zijn en wat aan mensen is overgelaten.

3. 03

   3. Het architectenrapport lezen

   engineering/architect-report.md geeft elke eenheid een klasse, een zekerheidsniveau, een doel en de reden, met de instellingen die aan u zijn overgelaten.

4. 04

   4. De eigenaren en beslissingen vastleggen

   execution/manual/actions.md en migration/work-packages.csv noemen per pakket een eigenaarsrol. review/decisions.yaml en inputs.yaml nemen uw antwoorden op.

5. 05

   5. De landing zone bouwen

   De STACKIT-organisatie, de projecten en het netwerk komen eerst. Netwerkeenheden staan in de vroege golven.

6. 06

   6. In golven bouwen

   migration/technical-sequencing.md rangschikt de eenheden op afhankelijkheid. Eenheden van dezelfde golf kunnen parallel overgaan.

7. 07

   7. De data verplaatsen

   migration/data-movement.md noemt elke stateful eenheid en de beslissingen die nog openstaan. Kies per eenheid een mechanisme.

8. 08

   8. Overschakelen

   Schakel clients om naar de nieuwe endpoints en inloggegevens en houd de bron achter de hand als terugweg.

9. 09

   9. De bron uitfaseren

   Controleer het doel en schakel daarna de OCI-resources uit, in omgekeerde volgorde van afhankelijkheid.

Stap 2: het assessment uitvoeren

Een gemengde demo-omgeving, voor deze gids opgesteld: een VCN met twee privé-subnets, een network security group, een compute-instance met een blockvolume, een load balancer, een PostgreSQL-DB-systeem, een bucket, een cachecluster en een IAM-policy. De run dateert van 4 november 2026. Het eerste venster toont het commando zoals het is uitgevoerd, vanuit de invoermap van de demo; de andere vensters bevatten regels uit de consoleuitvoer van die run: de bronregel en de klassetellingen.

# run from inside the demo's input folder; the output folder sits next to it
stacktoit assess . ../out --offline --no-validate

Source        11 resources · 11 units · visibility: Complete

DIRECT              0  
RECONFIGURE         9  ████████████████████████ 81%
REPLATFORM          1  ██ 9%
CONTAINERIZE        0  
REDESIGN            0  
MANUAL_REVIEW       1  ██ 9%

• 11 resources, 11 eenheden

  Elke resource is hier een eigen eenheid. Negen zijn RECONFIGURE, één is REPLATFORM en één is MANUAL_REVIEW. Tien hebben zekerheidsniveau MEDIUM en één, de IAM-policy, LOW.

• De samenvatting en het concept

  StackToIT schrijft een STACKIT-Terraform-concept voor uw architecten om te beoordelen, naast het assessment, de volgorde en de werkpakketten.

• Offline en niet gevalideerd

  De run gebruikte --offline en --no-validate, dus de bron is alleen met ingebouwde controles gecontroleerd. Met een lockbestand en een providermirror kunt u OpenTofu-validatie van de bron toevoegen.

Stap 3: hoe de omgeving wordt gekoppeld

Klassen zoals de run ze heeft vastgesteld: negen eenheden RECONFIGURE (de twee subnets delen een rij), één REPLATFORM, één MANUAL_REVIEW.

Een eenheid lezen: de compute-instance

De compute-instance zoals geschreven (regels 54 tot 74 van main.tf) en het resultaat dat de run ervoor heeft vastgelegd, een fragment van assessment.json met de waarden precies zoals de run ze schreef. assessment.json staat op één regel, dus het venster toont geselecteerde velden van elke eenheid, ingesprongen en genest zoals in het bestand, met ongewijzigde waarden.

resource "oci_core_instance" "web" {
  compartment_id      = var.compartment_id
  availability_domain = var.availability_domain
  display_name        = "web-01"
  shape               = "VM.Standard.E5.Flex"

  shape_config {
    ocpus         = 2
    memory_in_gbs = 16
  }

  source_details {
    source_type = "image"
    source_id   = var.image_id
  }

  create_vnic_details {
    subnet_id = oci_core_subnet.app.id
    nsg_ids   = [oci_core_network_security_group.app.id]
  }
}

[
  {
    "id": "oci_core_instance.web",
    "result": {
      "class": "RECONFIGURE",
      "confidence": "MEDIUM",
      "target": {
        "service": "STACKIT Compute Engine"
      },
      "reason": "A compute instance becomes a STACKIT server. The shape becomes a STACKIT flavor, the image is rebuilt or imported, and the attached volumes and network interfaces move with it."
    }
  }
]

• De shape wordt een flavor

  De instance draait op de shape VM.Standard.E5.Flex met 2 OCPU's en 16 GB. Op STACKIT wordt de shape een flavor en wordt het image opnieuw gebouwd of geïmporteerd.

• Wat eraan hangt, gaat mee

  Volumes en netwerkinterfaces horen bij de migratie van de server. Daarom wacht de instance op het subnet en de groep.

Een eenheid lezen: database en bucket

Het PostgreSQL-DB-systeem zoals geschreven (regels 96 tot 120 van main.tf) en het resultaat daarvoor en voor de bucket, een fragment van assessment.json met de waarden precies zoals de run ze schreef. assessment.json staat op één regel, dus het venster toont geselecteerde velden van elke eenheid, ingesprongen en genest zoals in het bestand, met ongewijzigde waarden.

resource "oci_psql_db_system" "orders" {
  compartment_id = var.compartment_id
  display_name   = "orders"
  db_version     = "16"
  shape          = "PostgreSQL.VM.Standard.E5.Flex.2.32GB"
  instance_count = 2

  network_details {
    subnet_id = oci_core_subnet.data.id
  }

  storage_details {
    is_regionally_durable = true
    system_type           = "OCI_OPTIMIZED_STORAGE"
  }

  credentials {
    username = "orders_admin"

    password_details {
      password_type = "PLAIN_TEXT"
      password      = "change-me"
    }
  }
}

[
  {
    "id": "oci_psql_db_system.orders",
    "result": {
      "class": "REPLATFORM",
      "confidence": "MEDIUM",
      "target": {
        "service": "STACKIT PostgreSQL Flex"
      },
      "reason": "Managed PostgreSQL to managed PostgreSQL: data moves with pg_dump/pg_restore or logical replication, and the shape becomes a Flex flavor."
    }
  },
  {
    "id": "oci_objectstorage_bucket.media",
    "result": {
      "class": "RECONFIGURE",
      "confidence": "MEDIUM",
      "target": {
        "service": "STACKIT Object Storage"
      },
      "reason": "A bucket becomes a STACKIT Object Storage bucket with an S3 API. Clients change endpoint and credentials; lifecycle, replication and access rules are rewritten."
    }
  }
]

• Van managed naar managed

  De database is de enige REPLATFORM-eenheid. De run wijst op pg_dump en pg_restore of logische replicatie en vermeldt dat de shape een Flex-flavor wordt.

• Buckets krijgen een ander endpoint

  Een bucket krijgt op STACKIT een S3-API. Clients wijzigen endpoint en inloggegevens; lifecycle-, replicatie- en toegangsregels worden herschreven.

Stap 6: de golven

De run rangschikt de elf eenheden op basis van hun afhankelijkheden in drie golven.

1. 01

   Golf 1

   Het VCN, het blockvolume, de IAM-policy en de bucket: de eenheden die van niets afhankelijk zijn.

2. 02

   Golf 2

   De security group en de twee subnets.

3. 03

   Golf 3

   De instance, de load balancer, het PostgreSQL-DB-systeem en het cachecluster, die het netwerk nodig hebben.

Stappen 4 en 7: de beslissingen die bij u liggen

De run doet voorstellen. Deze punten blijven bij mensen, en de run zegt dat ook.

• Vier data-eenheden, geen mechanisme

  Het volume, de bucket, de database en de cache zijn stateful. Hun mechanisme is UNKNOWN, met de dataklasse, het herstelpunt en de downtimetolerantie als niet aangeleverd.

• Zeven werkpakketten, vijf rollen

  De 11 handmatige stappen vallen uiteen in 7 pakketten met eigenaren: Network Architect, Identity Architect, Data Architect, Storage Architect en Platform Architect. Aan elk pakket kan nu worden begonnen.

• Het publieke adres verandert

  De listeners, backends en certificaten van de load balancer worden herschreven en het publieke adres verandert. DNS en de allowlists van clients zijn aan u.

• Bereikbaarheid wordt ontworpen

  Op STACKIT bereikt een netwerk het internet uitgaand via source NAT en voor inkomende bereikbaarheid is een publiek IP-adres nodig. De publieke of privé-rol van elk subnet wordt beoordeeld.

• Identiteit wordt opnieuw opgebouwd

  De OCI-policy heeft geen tegenhanger op documentniveau. Mensen en workloads worden gekoppeld aan STACKIT-rollen en serviceaccounts.

Vragen van migratieleiders

Bronnen

• STACKIT: Network Area, concepts
• STACKIT: Security groups, concepts
• STACKIT: Virtual Network, concepts
• Oracle Cloud Infrastructure: Networking overview
• Oracle Cloud Infrastructure: Network security groups