Huawei DCS Redis to STACKIT Valkey

Two DCS instances, assessed

A small Huawei Cloud estate written for this page and assessed by StackToIT on 4 November 2026: a highly available session cache and a single-node job cache. Left: the two DCS blocks of the input. Right: the result recorded for the session cache, an excerpt of assessment.json with the values as the run wrote them.

resource "huaweicloud_dcs_instance" "sessions" {
  name               = "web-sessions"
  engine             = "Redis"
  engine_version     = "6.0"
  capacity           = 4
  flavor             = "redis.ha.xu1.large.r2.4"
  availability_zones = ["eu-west-101a", "eu-west-101b"]
  password           = var.redis_password
  vpc_id             = huaweicloud_vpc.main.id
  subnet_id          = huaweicloud_vpc_subnet.data.id

  backup_policy {
    backup_type = "auto"
    save_days   = 3
    backup_at   = [1, 3, 5, 7]
    begin_at    = "02:00-04:00"
  }

  whitelists {
    group_name = "app-servers"
    ip_address = ["10.40.1.0/24"]
  }
}

resource "huaweicloud_dcs_instance" "queue_cache" {
  name               = "job-cache"
  engine             = "Redis"
  engine_version     = "5.0"
  capacity           = 2
  flavor             = "redis.single.xu1.large.2"
  availability_zones = ["eu-west-101a"]
  password           = var.redis_password
  vpc_id             = huaweicloud_vpc.main.id
  subnet_id          = huaweicloud_vpc_subnet.data.id
}

{
  "id": "huaweicloud_dcs_instance.sessions",
  "result": {
    "class": "RECONFIGURE",
    "confidence": "MEDIUM",
    "target": {
      "service": "STACKIT Key Value Store (Valkey)",
      "resources": [
        "stackit_valkey_instance",
        "stackit_valkey_credential"
      ]
    },
    "reason": "A DCS instance becomes a Valkey instance. The application changes its endpoint and credentials; check the engine and version in use, since a Memcached instance needs a client change."
  }
}

• Both become Valkey

  Both instances are classified RECONFIGURE with MEDIUM confidence and land on STACKIT Key Value Store (Valkey). The application changes its endpoint and credentials; the engine and version in use decide whether a client changes too.

• Settings named, not carried

  The session cache lists 15 settings for your platform team: engine, engine_version, capacity, flavor, the two availability zones, the password, the network references, four backup_policy values and the two whitelist values. The job cache lists nine.

• Network first

  The run orders the estate in three waves: the VPC, then the subnet, then both caches. Create the STACKIT network before the Valkey instances.

• No Terraform for this source

  For a Huawei Cloud source this build writes no STACKIT resource blocks. The four units are manual steps with an owner, and the Network Architect and the Data Architect carry them.

The migration in seven steps

Steps 1 to 4 prepare the target and cost nothing in downtime. Steps 5 to 7 are the ones to rehearse.

1. 01

   1. Assess the Terraform

   Run the assessment against the folder that holds the huaweicloud provider code. It reads files only and never connects to your Huawei Cloud account. Pass the variable file too: a sensitive variable without a value leaves the instance marked as missing an input.

2. 02

   2. Confirm engine and version

   engine and engine_version are among the named settings. Redis 5.0 and 6.0 are the ones in the demo. The run notes that a Memcached instance would need a client change, because Valkey is not Memcached.

3. 03

   3. Create the target

   Create a Key Value Store instance in the STACKIT region you answered in the inputs file (eu01 or eu02), with the same capacity as the source or larger. STACKIT advises not writing to it before the consistency checks are complete.

4. 04

   4. Create credentials

   Key Value Store requires a username and password, and its connection strings use the rediss:// scheme, which means TLS. Every client of the old instance gets a new connection string and, if it only knew a password, a user name.

5. 05

   5. Choose the copy method

   The data-movement file records mechanism UNKNOWN and state DECISION_REQUIRED for both caches. Size, change rate, tolerated downtime and recovery point are not in the Terraform, so you provide them. The next section shows why the documented default does not fit a DCS source.

6. 06

   6. Copy and compare

   Disconnect or pause writers, copy, then compare INFO KEYSPACE on both sides: the keys and expires values must match. Compare the sorted key names as well, and compare memory use with an allowance for engine overhead.

7. 07

   7. Switch and keep the source

   Point the clients at the new endpoint. Keep the DCS instance and its last backup until the application has run on Valkey through its normal peak.

How each DCS setting travels

The run names these settings and leaves the decision to you. The right column is what the STACKIT documentation says about the target side.

The values come from the demo input. Plan names and prices on STACKIT are not part of the assessment.

Run it and read the open data question

One command assesses the folder. The data-movement file then lists both caches as stateful units with no mechanism chosen.

stacktoit assess . ../out --offline

| Unit | Source service | Target service | Application | Mechanism | State | Data class | RPO | Downtime tolerance |
|---|---|---|---|---|---|---|---|---|
| huaweicloud_dcs_instance.queue_cache | huaweicloud_dcs_instance | STACKIT Key Value Store (Valkey) |  | UNKNOWN | DECISION_REQUIRED | NOT_PROVIDED | NOT_PROVIDED | NOT_PROVIDED |
| huaweicloud_dcs_instance.sessions | huaweicloud_dcs_instance | STACKIT Key Value Store (Valkey) |  | UNKNOWN | DECISION_REQUIRED | NOT_PROVIDED | NOT_PROVIDED | NOT_PROVIDED |

• Not known, by design

  The file states that the size of the data, its change rate, the tolerated downtime, the recovery point and the data classification are not in the source. StackToIT never moves data and does not guess these values.

• Region first

  The one request that blocks the draft is the target region. The inputs template offers eu01 and eu02; answer it before you plan capacity.

Where a DCS source differs from the documented path

STACKIT documents a migration from its own Redis offering. It reads keys on the source and sends them with MIGRATE. Four facts about DCS change that plan.

• MIGRATE is disabled

  Huawei lists MIGRATE among the disabled commands of DCS Redis 6.0, for single-node, master/standby and Redis Cluster instances and again for Proxy Cluster, read/write splitting and the enterprise edition. Its Redis 5.0 list disables MIGRATE for single-node, master/standby, Proxy Cluster, Redis Cluster and read/write splitting instances too, so the same holds for the 5.0 job cache. The STACKIT pipe sends MIGRATE through the source connection, so it does not work from DCS as written.

• SYNC and PSYNC are disabled too

  The same Huawei lists disable SYNC and PSYNC for the Redis 6.0 and 5.0 instance types. A tool that attaches as a replica cannot read from such a source, so plan a key-by-key copy or a backup file.

• Single-node instances have no console backup

  Huawei states that data of single-node instances cannot be backed up on the console. In the demo the job cache is the one to plan around: read its keys with a client, not from a backup file.

• Several databases

  Huawei’s backup-import guide states that Proxy Cluster and Redis Cluster instances have only DB0 by default. If the source application uses numbered databases, map them before you copy, because the STACKIT command takes a database number.

Compare after the copy

These checks are taken from STACKIT’s migration tutorial. Replace the placeholders with the connection strings and certificate files of both sides.

valkey-cli -u "[source-db-connection-string]" --tls --sni [source-frontend-hosts-fqdn] --cacert [/path/to/ca_cert.pem] INFO KEYSPACE

valkey-cli -u "[target-db-connection-string]" --tls --sni [target-frontend-hosts-fqdn] --cacert [/path/to/ca_cert.pem] INFO KEYSPACE

• What must match

  The keys and expires values of both outputs. STACKIT also compares the sorted key lists with diff and expects an empty result.

• What to test beyond it

  Time-to-live values, the data types your code reads, and one real client session against TLS. A matching key count does not show that the application behaves the same.

What to change before you apply anything

• Answer the inputs file

  Copy target.region from inputs-template.yaml into your inputs file, answer it and run the assessment again with --inputs on the same output folder, as the template says. Then read the regenerated draft and plan.

• Fill the data facts

  Give each application its recovery point and tolerated downtime in the applications file, so the data-movement rows stop reading NOT_PROVIDED. Size and change rate never come from Terraform: measure them on the source and keep them with the copy plan.

• Pin the provider

  The run warns that no lock file pins the huaweicloud provider. Commit .terraform.lock.hcl so the assessed version is the proven one.

• Decide the owner of the copy

  Both cache units are assigned to the Data Architect role. Name the person who runs the copy and the person who signs the comparison.

Questions teams ask about DCS and Valkey

Sources

• STACKIT Key Value Store
• STACKIT: Migrate data from Redis to a Key Value Store instance
• STACKIT Key Value Store release notes
• Huawei Cloud: Commands Supported and Disabled by DCS for Redis 6.0
• Huawei Cloud: Exporting DCS backup data
• Huawei Cloud: Self-hosted Redis migration with backup files
• Huawei Cloud: Commands Supported and Disabled by DCS for Redis 5.0