Amazon ECS naar STACKIT Kubernetes: een uitgewerkt voorbeeld

De invoer: één task definition, één service

Een demo-omgeving die voor deze pagina is geschreven: een Fargate-service met drie tasks van 0,5 vCPU en 1 GiB achter een Application Load Balancer, één secret, één gewone omgevingswaarde en een awslogs-loggroep. Links: de task definition en de service. Rechts: de Deployment die StackToIT ervoor opstelde (de lange commentaarkop van het bestand is hier weggelaten; al het getoonde is ongewijzigd).

resource "aws_ecs_task_definition" "web" {
  family                   = "shop-web"
  requires_compatibilities = ["FARGATE"]
  network_mode             = "awsvpc"
  cpu                      = "512"
  memory                   = "1024"
  execution_role_arn       = aws_iam_role.task_execution.arn

  container_definitions = jsonencode([
    {
      name         = "web"
      image        = "registry.example.com/shop/web:1.8.2"
      essential    = true
      portMappings = [{ containerPort = 8080, protocol = "tcp" }]
      environment  = [{ name = "APP_ENV", value = "production" }]
      secrets      = [{ name = "DATABASE_URL", valueFrom = aws_secretsmanager_secret.db_url.arn }]
      logConfiguration = {
        logDriver = "awslogs"
        options = {
          "awslogs-group"         = "/ecs/shop-web"
          "awslogs-region"        = "eu-central-1"
          "awslogs-stream-prefix" = "web"
        }
      }
    }
  ])
}

resource "aws_ecs_service" "web" {
  name            = "web"
  cluster         = aws_ecs_cluster.shop.id
  task_definition = aws_ecs_task_definition.web.arn
  desired_count   = 3
  launch_type     = "FARGATE"

  network_configuration {
    subnets         = [aws_subnet.app_a.id, aws_subnet.app_b.id]
    security_groups = [aws_security_group.web.id]
  }

  load_balancer {
    target_group_arn = aws_lb_target_group.web.arn
    container_name   = "web"
    container_port   = 8080
  }
}

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web
  labels:
    app.kubernetes.io/name: web
spec:
  replicas: 0 # held back until the start step of the plan scales to the number the header names
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxUnavailable: 0
      maxSurge: 3
  selector:
    matchLabels:
      app.kubernetes.io/name: web
  template:
    metadata:
      labels:
        app.kubernetes.io/name: web
    spec:
      containers:
      - name: web
        image: "registry.example.com/shop/web:1.8.2"
        ports:
        - containerPort: 8080
          protocol: TCP
        env:
        - name: APP_ENV
          valueFrom:
            configMapKeyRef:
              name: web-env
              key: APP_ENV
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: web-secrets
              key: DATABASE_URL
        resources:
          requests:
            cpu: "500m"
            memory: "1024Mi"
          limits:
            cpu: "500m"
            memory: "1024Mi"
        readinessProbe:
          httpGet:
            path: "/healthz"
            port: 8080
          periodSeconds: 30
          timeoutSeconds: 6
          successThreshold: 3
          failureThreshold: 3

De handleiding stap voor stap

Vijf stappen van de Terraform-bestanden naar een draaiende workload. StackToIT voert de eerste twee uit; alles daarna is werk van uw team, met de bestanden die StackToIT schreef.

1. 01

   1 · Voer het assessment uit

   Voer StackToIT uit in de map met de Terraform. StackToIT leest de bestanden, maakt nooit verbinding met AWS en schrijft een uitvoermap met het concept, de beslissingen en het uitvoeringsplan.

2. 02

   2 · Lees de classificatie

   Het cluster en de service zijn ingedeeld als REPLATFORM, het omliggende netwerk, het secret, de rol, de loggroep en de load balancer als RECONFIGURE. De task definition en de target group hebben geen eigen eenheid: hun inhoud gaat op in de service.

3. 03

   3 · Beantwoord de beslissingen

   Beantwoord de openstaande beslissingen in review/decisions.yaml (hoe de load balancer de pods bereikt, of de pods netwerksegmentatie krijgen, welk netwerk het cluster en de bijbehorende consumers bevat, de opt-in voor de API-aanroepen). Stel de variabelen van de nodepool (machinetype, minimum, maximum) in het bestand met doelwaarden in.

4. 04

   4 · Pas eerst het cluster toe, dan de manifests

   Pas eerst de Terraform voor het SKE-cluster toe. De manifests zijn geschreven met replicas op 0, zodat er niets draait of met een datastore verbindt voordat de data op zijn plaats staat.

5. 05

   5 · Schaal op en schakel het verkeer over

   Schaal na de dataverplaatsing op naar het aantal tasks dat de bron vermeldt, voer de smoketest uit de checklist uit, verplaats de load balancer of het DNS-record en laat ECS draaien tot u het resultaat accepteert.

Wat de run rapporteert

De samenvatting die het commando voor de demo-omgeving toont (console.txt in de uitvoermap). Het commando is vanuit de invoermap uitgevoerd als stacktoit assess . <output folder> --offline --no-validate. --offline is de gedocumenteerde manier om zonder netwerkverzoeken te draaien. --no-validate sloeg de OpenTofu-controle van de bron over; daarom meldt de samenvatting dat die niet is uitgevoerd.

Source:                 input
Source files:           1
Resources scanned:      13
  support resources:    1  (+0 Terraform helpers, out of scope; 1 + 0 = the 1 support node of summary.support.nodes in assessment.json)
Migration units:        10  (10 instances)
Unit dependencies:      14
Source checks:          Built-in source checks passed — OpenTofu validation of the source was not run

STACKIT mapping
────────────────────────────────────────────
DIRECT              0  
RECONFIGURE         8  ████████████████████████ 80%
REPLATFORM          2  ██████ 20%
CONTAINERIZE        0  
REDESIGN            0  
MANUAL_REVIEW       0  
BLOCKED             0    (the mapping class BLOCKED, not the execution blockers, which Migration readiness counts)

Hoe de ECS-instellingen op Kubernetes terechtkomen

Het cluster en de load balancer

Fargate heeft geen nodes, dus de omvang van de nodepool is een variabele die u instelt aan de hand van de taskgroottes die het rapport optelt (1,5 vCPU en 3 GiB op de ondergrens en op de bovengrens voor deze service). De load balancer bereikt de pods via een NodePort Service op poort 30000, met de nodeadressen als pooldoelen.

resource "stackit_ske_cluster" "shop" {
  project_id = var.project_id
  name       = "shop"
  node_pools = [{
    name               = "workloads"
    machine_type       = var.shop_machine_type
    minimum            = var.shop_nodes_min
    maximum            = var.shop_nodes_max
    availability_zones = var.availability_zones
  }]
}

  target_pools = [{
    name        = "web"
    target_port = 30000
    targets     = [for ip in var.web_target_ips : { ip = ip }]
    active_health_check = {
      healthy_threshold   = var.web_health_healthy_threshold
      interval            = var.web_health_interval
      interval_jitter     = var.alb_interval_jitter
      timeout             = var.web_health_timeout
      unhealthy_threshold = var.web_health_unhealthy_threshold
      http_health_checks = {
        ok_status = var.web_health_ok_status
        path      = "/healthz"
      }
    }
  }]

apiVersion: v1
kind: Service
metadata:
  name: web-nodeport
  labels:
    app.kubernetes.io/name: web
spec:
  type: NodePort
  selector:
    app.kubernetes.io/name: web
  ports:
  - name: p8080-tcp
    port: 8080
    targetPort: 8080
    protocol: TCP
    nodePort: 30000

Beslis hoe het verkeer de pods bereikt

De checklist die de workload gesloten houdt

applications/web.json meldt de workload als niet gereed en noemt drie blokkerende punten (omgevingswaarde, secret, smoketest). De workload geldt pas als gereed wanneer uw team ze in het beslissingenbestand als afgerond markeert; StackToIT rolt niets uit en voert geen test uit.

  "readiness": "NOT_READY",
  "readiness_words": "Checklist items are open: StackToIT lists the work and counts an item done only when the customer marks it in the decisions file (application_checklists); StackToIT never deploys the application.",

Wat u wijzigt voordat u het toepast

Het concept is een startpunt. Dit zijn de aanpassingen en antwoorden waar de demo-run om vraagt.

• Geef het cluster een omvang

  Stel het machinetype en het minimum en maximum aantal nodes in. Het maximum moet minimaal gelijk zijn aan het aantal zones; standaard worden drie zones geselecteerd.

• Plaats de load balancer

  De load balancer in de bron beslaat twee subnets die op STACKIT afzonderlijke netwerken zijn. De doelen zijn de clusternodes, dus het concept plaatst de load balancer in het netwerk dat SKE voor het cluster aanmaakt. De provider exporteert dat netwerk en de nodeadressen niet. Pas dus eerst het cluster toe en stel daarna de netwerk-id en de node-IP's in.

• Upload het certificaat

  De HTTPS-listener noemt een certificaat-ARN. De ARN wordt niet omgezet: upload het certificaat naar STACKIT en geef de id ervan mee in de listenervariabele.

• Beperk wie verbinding mag maken

  De bron laat elk IPv4-adres toe op poort 443 en de opgestelde load balancer doet hetzelfde. Beslis of u een toegestaan bronbereik schrijft.

• Schrijf het netwerkbeleid

  De security group van de tasks wordt niet naar pods vertaald. Het plan noemt als opties het schrijven van een NetworkPolicy, een security group op de nodes of geen segmentatie accepteren.

• Vul de ConfigMap en de Secret

  Voeg APP_ENV toe aan de ConfigMap, maak web-secrets aan met DATABASE_URL en controleer of de nodes de image registry kunnen bereiken.

Vragen van teams

Bronnen

• Amazon ECS task definitions (AWS-documentatie)
• Amazon ECS service definition parameters (AWS-documentatie)
• STACKIT Kubernetes Engine (STACKIT-documentatie)
• Create an Application Load Balancer (STACKIT-documentatie)
• SKE ALB Ingress (STACKIT-documentatie)