ALIBABA CLOUD DNS, CDN, SLS → STACKIT · RUNBOOK

Alibaba DNS, CDN and Log Service migration runbook

DNS records, a CDN domain and a log project are the edge of an estate, and they decide what users and operators see on the day of the move. StackToIT assesses them as RECONFIGURE to STACKIT DNS, STACKIT CDN and STACKIT Logs and puts them in the first wave; the logstore below the log project is unknown to this build and lands in wave 2. This runbook gives the order, an owner and a check for each step, and the rollback. Facts from the demo run are marked as such; general practice is labelled practice.

The edge of a small estate, assessed

A small Alibaba Cloud estate written for this page and assessed by StackToIT on 4 November 2026. Left: one DNS record, the CDN domain and the logstore block of the input. Right: the result the run recorded, an excerpt of assessment.json with the values as the run wrote them. assessment.json is written as a single line, so the pane shows selected fields of each unit, indented and nested as in the file, with the values unchanged. The input blocks are shown in separate panes because they are not next to each other in main.tf.

Example input, lines 11–18main.tf
resource "alicloud_alidns_record" "www" {
  domain_name = "shop.example"
  rr          = "www"
  type        = "CNAME"
  value       = "shop.example.cdn.example-edge.net"
  ttl         = 600
}
Example input, lines 27–39main.tf
resource "alicloud_cdn_domain_new" "static" {
  domain_name = "static.shop.example"
  cdn_type    = "web"
  scope       = "overseas"
  sources {
    content  = "origin.shop.example"
    type     = "domain"
    port     = 443
    priority = 20
    weight   = 15
  }
}
Example input, lines 45–52main.tf
resource "alicloud_log_store" "access" {
  project_name          = alicloud_log_project.app.project_name
  logstore_name         = "access"
  retention_period      = 30
  shard_count           = 2
  auto_split            = true
  max_split_shard_count = 8
}
StackToIT assessmentassessment.json
[
  {
    "id": "alicloud_alidns_record.www",
    "result": {
      "class": "RECONFIGURE",
      "confidence": "MEDIUM",
      "target": {
        "service": "STACKIT DNS"
      },
      "reason": "An Alibaba Cloud DNS record becomes a record in a STACKIT DNS zone. Weighted and line-based resolution of the source need review."
    }
  },
  {
    "id": "alicloud_cdn_domain_new.static",
    "result": {
      "class": "RECONFIGURE",
      "confidence": "MEDIUM",
      "target": {
        "service": "STACKIT CDN"
      },
      "reason": "A CDN domain becomes a STACKIT CDN distribution. Cache rules and certificates are rewritten, and the origin moves with the workload."
    }
  },
  {
    "id": "alicloud_log_project.app",
    "result": {
      "class": "RECONFIGURE",
      "confidence": "LOW",
      "target": {
        "service": "STACKIT Logs"
      }
    }
  },
  {
    "id": "alicloud_log_store.access",
    "result": {
      "class": "MANUAL_REVIEW",
      "confidence": "LOW",
      "reason": "alicloud_log_store is not in the knowledge base catalogue; an architect has to decide the target. Nothing of this resource is assessed or drafted (unknown source type)."
    }
  }
]
  • Three targets named

    DNS record to a record in a STACKIT DNS zone, CDN domain to a STACKIT CDN distribution, log project to a STACKIT Logs instance, all RECONFIGURE.

  • One unit is unknown to the run

    alicloud_log_store is not in the catalogue of this build, so it is MANUAL_REVIEW and nothing of it is assessed. Your logstore settings, shard count, retention and splitting, are yours to carry over.

  • Confidence differs

    The log project has confidence LOW in this run, while the same resource type, with the same description-only block, has MEDIUM in our complete-guide and Function Compute demo runs, where no logstore references it. The run does not say why, so read it as a signal to check the project by hand.

Order from the run

The waves as the run wrote them. The execution plan files the two DNS records under the cutover phase and the other three units under platform services.

Waves in technical-sequencing.mdtechnical-sequencing.md
## Wave 1 — 4 unit(s)

| Unit | Class | Target |
|---|---|---|
| `alicloud_alidns_record.api` | RECONFIGURE / MEDIUM | STACKIT DNS |
| `alicloud_alidns_record.www` | RECONFIGURE / MEDIUM | STACKIT DNS |
| `alicloud_cdn_domain_new.static` | RECONFIGURE / MEDIUM | STACKIT CDN |
| `alicloud_log_project.app` | RECONFIGURE / LOW | STACKIT Logs |

## Wave 2 — 1 unit(s)

| Unit | Class | Target |
|---|---|---|
| `alicloud_log_store.access` | MANUAL_REVIEW / LOW | — |
  • Owners come from the plan

    WP-01 CDN: Network Architect. WP-02 log project: Platform Architect. WP-03 logstore: no owner, because the unit has no category, so you assign one. WP-04 the two DNS records, in the cutover phase: Network Architect.

  • Rollback is left to you

    Every step says the plan does not know how it is undone and the person who carries it out records how. The package notes that from the cutover on, the DNS steps cannot be undone in full by a tool, so decide how before the cutover starts.

The runbook, step by step

StepOwner and whenCheck before you move on
1. Assign the owner of the logstore step (WP-03) and give every step a date. Record owner, state and time per step in your copy of progress-template.yaml (fields owner, note, at).Project lead, before anything elseEvery manual step has an owner role and a date, and the next run no longer shows "Owner assignment required" for WP-03.
2. Export the zone from Alibaba Cloud DNS as zone file or xlsx.Network Architect, a day or more before cutover (practice)The count of exported records equals the records in the console. Keep the file as the rollback copy.
3. Create the zone and the records in STACKIT DNS, from the file or by API. Review weighted and line-based resolution of the source, which the run flags.Network ArchitectQuery a STACKIT name server for each record and compare with the export. STACKIT lists no weighted or geo routing on its overview page, so redesign those records.
4. Create the STACKIT CDN distribution with the origin, the custom domain and the certificate.Network ArchitectFetch an object through the managed CDN domain and check the cache headers. Use skipDnsCheck to provision the certificate before DNS is switched.
5. Create the STACKIT Logs instance and point the collectors at it, for example Grafana Alloy or Fluent Bit, two of the agents STACKIT names.Platform ArchitectLines arrive and queries return them. Check against the limits: 15 labels per stream, 256 KB per line, 30 days per query.
6. Rebuild what the logstore held: in the demo retention_period 30, shard_count 2 and automatic splitting up to 8 shards, plus the indexes, queries and alerts on top. STACKIT Logs lets you adjust retention; shards have no counterpart in its documentation.Assigned owner of step 1The queries your teams run daily return the same counts as on Alibaba Cloud for an overlapping period.
7. Cut over: switch the delegation or the records, then the CDN CNAME. Lower TTLs beforehand (practice).Network Architect, off-peakResolve through public resolvers and from outside your network. The static domain answers with the CNAME of the new distribution.
8. Observe, then retire the Alibaba Cloud DNS records, CDN domain and log project (practice).Platform Architect, after the observation windowNothing still queries the old name servers or the old CDN domain. Remove last, and keep the export.

Steps 1, 3, 4 and 5 follow the manual steps of the run. Steps 2, 7 and 8 are general practice. Dates are yours: the run writes "timing to be scheduled by the owner".

Where the platforms differ

Facts about the platforms come from the pages listed under sources, read on the day this page was written.

  • DNS record behaviour

    The run flags weighted and line-based resolution of the source for review. The STACKIT DNS overview lists forward, reverse and secondary zones, many record types including ALIAS and CAA, and states that DNSSEC zone signing is currently not available.

  • Import path

    Alibaba Cloud DNS exports .xlsx and zone files and imports .xls, .xlsx or zone files, with a mode that skips duplicates and a high-risk mode that deletes existing records first. The STACKIT DNS overview states that zone data can be saved and restored manually through the DNS API or the Portal; keep the zone file as your common format and your rollback copy.

  • CDN origins and certificates

    STACKIT CDN takes an HTTP origin or an S3-compatible bucket origin, maps custom domains with a CNAME to the managed domain, and offers managed Let's Encrypt certificates or your own PEM files, which you rotate yourself. Terraform support for several CDN features is still in progress per the documentation.

  • CNAME constraints

    On Alibaba Cloud, a CNAME cannot share a host with an A, AAAA, MX or TXT record, and a CNAME on the root domain can break mail. The same DNS rule applies after the move, so put the CDN on a subdomain.

  • Logs model

    STACKIT Logs is built on Grafana Loki and allows at most 15 label names per stream, so decide which fields of a Simple Log Service logstore become labels. Queries written for Simple Log Service are rewritten, and so are the collectors, as the run states.

Rollback, per area

  • DNS

    Keep the Alibaba Cloud zone untouched until the observation window ends. To roll back, restore the previous delegation or the previous records from the export. Write the exact values down before step 7.

  • CDN

    Keep the old distribution and its CNAME value. Alibaba Cloud advises backing up the original record before changing it and switching off-peak, which is the same discipline in reverse.

  • Logs

    Send logs to both targets during the overlap (practice), so the Alibaba Cloud project remains complete if you return.

  • Who decides

    The run assigns no rollback owner. Name one per step, in your copy of progress-template.yaml or your change record, before the cutover begins.

Questions operations teams ask

Does StackToIT write the STACKIT DNS, CDN and Logs resources?

Not for an Alibaba Cloud source in this build. The run writes five manual steps and no STACKIT resource, so you create them in the portal, with the API or in your own Terraform.

Why are the DNS records in the cutover phase?

The execution plan files them under cutover, the phase in which traffic switches. migration/technical-sequencing.md adds that the draft re-binds no record value to an address it generates, so what the values become at cutover is yours to define.

Can a log store be assessed?

Not yet in this build: alicloud_log_store is unknown to the catalogue and is classed MANUAL_REVIEW. The log project around it is assessed.

Can the old and the new log targets run in parallel?

Yes in practice, with collectors that write to two outputs. This is a practice recommendation, not a step of the run.

Sources

Your next move: STACKIT.

Tell us about your estate. We show you what StackToIT delivers for it: target architecture, Terraform artifacts and a structured migration plan.