Amazon EC2 naar STACKIT Compute Engine in de praktijk

De handleiding in vijf stappen

Alles hieronder is op 4 november 2026 gemaakt uit een omgeving die voor deze pagina is geschreven.

1. 01

   1. Zet de Terraform in een map

   De demo-omgeving heeft een VPC, één subnet, een security group, een key pair, een m6i.large-instance met een 40 GiB gp3-rootschijf, een versleuteld datavolume van 200 GiB met bijbehorende attachment en een Elastic IP.

2. 02

   2. Voer het assessment uit

   Het commando is stacktoit assess ./ec2-demo. Het leest de Terraform offline, beoordeelt zeven eenheden en schrijft de rapportmap. Het roept AWS niet aan en raakt STACKIT niet aan.

3. 03

   3. Lees de klassen

   Twee eenheden zijn DIRECT (het key pair en het Elastic IP) en vijf zijn RECONFIGURE (VPC, subnet, security group, instance, volume). Geen enkele eenheid vereist een redesign.

4. 04

   4. Lees het concept en het document voor het kopiëren van data

   De map terraform bevat het concept. De map handover bevat een connectiviteitschecklist voor de server en een document voor het kopiëren van de data van de schijf.

5. 05

   5. Beantwoord de openstaande invoer

   Kies een image, een machinetype en een prestatieklasse, beoordeel het startscript, bepaal de egress-standaard en voer het assessment opnieuw uit tot het rapport geen in te vullen waarde meer toont.

De instance en het bijbehorende datavolume

Links: de EC2-instance, het EBS-volume en de attachment. Rechts: de resourceblokken van het concept met twee van hun commentaarregels, de NOT CARRIED-notities voor het gp3-type en de apparaatnaam; de overige reviewcommentaren van het bestand zijn weggelaten. Let op de drie variabelen: het image, het machinetype en de prestatieklasse kiest u zelf.

resource "aws_instance" "web" {
  ami                    = "ami-0abcdef1234567890"
  instance_type          = "m6i.large"
  subnet_id              = aws_subnet.app.id
  vpc_security_group_ids = [aws_security_group.web.id]
  key_name               = aws_key_pair.ops.key_name

  root_block_device {
    volume_size = 40
    volume_type = "gp3"
  }

  user_data = <<-EOT
    #!/bin/bash
    systemctl enable --now nginx
  EOT

  tags = {
    Name = "web-01"
  }
}

resource "aws_ebs_volume" "data" {
  availability_zone = "eu-central-1a"
  size              = 200
  type              = "gp3"
  encrypted         = true
  tags = {
    Name = "web-01-data"
  }
}

resource "aws_volume_attachment" "data" {
  device_name = "/dev/sdf"
  volume_id   = aws_ebs_volume.data.id
  instance_id = aws_instance.web.id
}

# NOT CARRIED (aws_instance.web): root_block_device.volume_type = gp3 — the boot volume's performance is a STACKIT performance class (boot_volume.performance_class, pinned provider): AWS volume types, IOPS and throughput do not map — not generated, choose the class.
resource "stackit_server" "web" {
  project_id        = var.project_id
  name              = "web-01"
  machine_type      = var.web_machine_type
  availability_zone = var.availability_zone
  boot_volume = {
    source_type           = "image"
    source_id             = var.web_image_id
    size                  = 40
    delete_on_termination = true
  }
  keypair_name       = stackit_key_pair.ops.name
  user_data          = var.web_user_data
  network_interfaces = [stackit_network_interface.web.network_interface_id]
  labels = {
    Name = "web-01"
  }
}

# NOT CARRIED (aws_volume_attachment.data): device_name = /dev/sdf — stackit_server_volume_attach has no device name (pinned provider); find the volume in the guest by its ID, not by the device path.
resource "stackit_volume" "data" {
  project_id        = var.project_id
  name              = "web-01-data"
  availability_zone = var.availability_zone
  size              = 200
  performance_class = var.data_performance_class
  labels = {
    Name = "web-01-data"
  }
}

resource "stackit_server_volume_attach" "data" {
  project_id = var.project_id
  server_id  = stackit_server.web.server_id
  volume_id  = stackit_volume.data.volume_id
}

• Bootvolume

  De rootgrootte van 40 GiB wordt overgenomen. Het gp3-type niet: STACKIT stelt de prestaties in via een klasse, dus de run vraagt u er een te kiezen.

• Image in plaats van AMI

  Een AMI-id heeft op STACKIT geen betekenis. Het concept neemt een STACKIT-image-id als variabele, omdat u zelf bepaalt welk image bij uw AMI hoort.

• Startscript achtergehouden

  De user_data wordt niet in het concept overgenomen. De run declareert er een gevoelige variabele voor en vraagt u het script eerst te beoordelen, omdat scripts vaak AWS-API's aanroepen of de EC2-metadatapaden lezen.

• Attachment zonder apparaatnaam

  stackit_server_volume_attach kent geen apparaatnaam, dus u vindt de schijf in de gast aan de hand van grootte en serienummer.

De security group, regel voor regel

De twee ingress-regels komen één voor één over. De egress-regel uit de bron, al het verkeer naar overal, wordt niet gekopieerd: het subnet had geen internetroute, dus de run beperkt uitgaand verkeer tot het VPC-bereik met een aparte egress-groep en schrijft twee API-aanroepen die de allow-all-egressregels van STACKIT zelf verwijderen.

resource "aws_security_group" "web" {
  name        = "web-sg"
  description = "HTTPS from the internet, SSH from the office"
  vpc_id      = aws_vpc.main.id

  ingress {
    from_port   = 443
    to_port     = 443
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  ingress {
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = ["203.0.113.0/24"]
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

resource "stackit_security_group" "web" {
  project_id  = var.project_id
  description = "HTTPS from the internet, SSH from the office"
  name        = "web-sg"
}

resource "stackit_security_group_rule" "web_ingress_1" {
  project_id        = var.project_id
  security_group_id = stackit_security_group.web.security_group_id
  direction         = "ingress"
  ether_type        = "IPv4"
  ip_range          = "0.0.0.0/0"
  port_range = {
    max = 443
    min = 443
  }
  protocol = {
    name = "tcp"
  }
}

resource "stackit_security_group_rule" "web_ingress_2" {
  project_id        = var.project_id
  security_group_id = stackit_security_group.web.security_group_id
  direction         = "ingress"
  ether_type        = "IPv4"
  ip_range          = "203.0.113.0/24"
  port_range = {
    max = 22
    min = 22
  }
  protocol = {
    name = "tcp"
  }
}

• Gesloten egress is een standaard die u bevestigt

  Het concept staat uitgaand verkeer alleen toe naar het VPC-bereik, het enige wat het bronsubnet kon bereiken. De beslissing blijft open tot u die beantwoordt in decisions.yaml; drie geautomatiseerde stappen berusten op deze standaard. Zolang de allow-all-regels niet zijn verwijderd, gelden ze naast de beperkte groep en wordt er niets beperkt.

• Regels verwijzen naar bereiken, niet naar AWS-objecten

  Een regel van een security group die naar een AWS prefix list of VPC-bereik verwees, moet worden herschreven met STACKIT-netwerkprefixen.

Wat de run schrijft en waar u het leest

Paden zijn relatief ten opzichte van de uitvoermap van de run.

De schijf kopiëren: methode en controles

Het document voor het kopiëren van data beschrijft een kopie op bestandsniveau met rsync over SSH tussen de twee servers. Dat is de methode uit de block-storage-handleiding van STACKIT, met een eigen sleutel en gestopte services tijdens de laatste ronde. Hieronder staan twee van de controles na de overdracht, ongewijzigd: tel bestanden en bytes aan beide kanten en vergelijk daarna de inhoud met een checksum. StackToIT voert geen enkele controle uit; uw team doet dat, na een proefrun.

find <target-mount> -type f | wc -l
du -sb <target-mount>
find <source-mount> -type f | wc -l
du -sb <source-mount>

rsync -aHAX --numeric-ids -nc --itemize-changes -e ssh <user>@<source-host>:<source-mount>/ <target-mount>/
sha256sum <large-file> <one-file-per-top-level-directory>

• Eerste ronde terwijl de bron draait

  De kopie zelf is rsync -aHAX --numeric-ids -e ssh van het mountpunt van de bron naar dat van het doel, uitgevoerd op het doel. De eerste ronde is niet consistent omdat de bron blijft schrijven. De laatste ronde, met hetzelfde commando, loopt binnen een schrijfstop die u zelf bepaalt. De run merkt op dat de rsync-regel in de handleiding van STACKIT niet klopt en neemt de syntaxis over uit de rsync-handleiding.

• Controleer de grootte-eenheid

  De run kopieert 200 als getal. STACKIT documenteert de volumegrootte als GB zonder te zeggen of GiB bedoeld is; als het 10^9 bytes betekent, is het volume ongeveer 7 % kleiner. Het document vraagt u vóór de eerste ronde de bruikbare grootte op het doel met lsblk -b te vergelijken met de gebruikte ruimte van de bron.

• Rollback

  Bewaar de bron-instance, het bijbehorende volume en het Elastic IP tot het doel is geverifieerd. Data die na de cutover op het doel is geschreven, kopieert u met hetzelfde commando in de andere richting terug, of u accepteert dat die verloren gaat; dat is een beslissing.

Wijzig dit voordat u het toepast

Het concept is een voorstel. Dit zijn de waarden en beslissingen die tussen het concept en een plan staan.

• project_id, image, machine type

  Drie variabelen zonder standaardwaarde. m6i.large is ongeveer 2 vCPU en 8 GiB, een verhouding van 1:4. In de lijst met machinetypen van STACKIT heeft de algemene familie (g) dezelfde verhouding van 1:4. Het getal na de familie en de versie is het aantal vCPU's. Begin dus met een g-type van 2 vCPU en bevestig dat in de lijst.

• data_performance_class

  Kies de klasse voor het datavolume; de variabele noemt de klassen uit de catalogus die de run las.

• web_user_data

  Beoordeel het startscript, verwijder AWS-specifieke aanroepen en geef het mee als cloud-init.

• Elastic IP naar publiek IP

  Het publieke IP is een nieuw adres. DNS-namen en allowlists die naar het oude adres verwezen, gaan mee bij de cutover; verlaag de TTL vooraf.

• Privé-DNS en routes

  De run legt vast dat de privénaamresolutie van de AWS-resolver niet wordt nagebootst en dat de routering van het subnet een beslissing van uw netwerkteam is.

Vragen van platformteams

Bronnen

• STACKIT Block Storage: data migreren vanaf een block storage
• STACKIT Compute Engine: machine types
• VM Import/Export, Amazon EC2