Huawei EVS and SFS Turbo to STACKIT storage

Two disks, an attachment and a file system

A small Huawei Cloud estate written for this page and assessed by StackToIT on 4 November 2026; a VPC, subnet, security group and server complete it. Left: two EVS disks and the resource that attaches one of them. Right: the SFS Turbo file system.

resource "huaweicloud_evs_volume" "data" {
  name              = "files-data"
  availability_zone = "eu-west-101a"
  volume_type       = "SSD"
  size              = 500
  device_type       = "SCSI"
  tags = {
    role = "data"
  }
}

resource "huaweicloud_evs_volume" "scratch" {
  name              = "files-scratch"
  availability_zone = "eu-west-101a"
  volume_type       = "SAS"
  size              = 100
}

resource "huaweicloud_compute_volume_attach" "data" {
  instance_id = huaweicloud_compute_instance.app.id
  volume_id   = huaweicloud_evs_volume.data.id
}

resource "huaweicloud_sfs_turbo" "shared" {
  name              = "files-shared"
  size              = 1000
  share_proto       = "NFS"
  vpc_id            = huaweicloud_vpc.main.id
  subnet_id         = huaweicloud_vpc_subnet.app.id
  security_group_id = huaweicloud_networking_secgroup.app.id
  availability_zone = "eu-west-101a"
}

The disk and the file system, assessed

Excerpts of assessment.json with the values exactly as the run wrote them.

{
  "id": "huaweicloud_evs_volume.data",
  "result": {
    "class": "RECONFIGURE",
    "confidence": "MEDIUM",
    "target": {
      "service": "STACKIT Block Storage",
      "resources": [
        "stackit_volume",
        "stackit_server_volume_attach"
      ]
    },
    "reason": "An EVS disk becomes a STACKIT volume. The disk type does not carry over; choose a STACKIT performance class, and move the data at the host level or with the server image."
  }
}

{
  "id": "huaweicloud_sfs_turbo.shared",
  "result": {
    "class": "REPLATFORM",
    "confidence": "MEDIUM",
    "target": {
      "service": "STACKIT File Storage (SFS)",
      "resources": [
        "stackit_sfs_resource_pool",
        "stackit_sfs_share",
        "stackit_sfs_export_policy"
      ]
    },
    "reason": "An SFS Turbo file system becomes a STACKIT File Storage share. Data moves with a file copy, and access rules are rewritten."
  }
}

• EVS: RECONFIGURE

  Settings listed for your architects: availability_zone, device_type, name, size, tags and volume_type for the data disk; availability_zone, name, size and volume_type for the scratch disk. Both share one reason.

• SFS Turbo: REPLATFORM

  Seven settings are listed: availability_zone, name, security_group_id, share_proto, size, subnet_id and vpc_id. Data moves with a file copy and the access rules are rewritten.

• Target resources named

  Block Storage lands as a volume and a server volume attachment. File Storage lands as a resource pool, a share and an export policy.

The attachment the run could not place

The run read huaweicloud_compute_volume_attach, an ordinary Terraform resource, as a type its catalogue does not contain. Left: its entry. Right: the waves; the attachment is last.

{
  "id": "huaweicloud_compute_volume_attach.data",
  "result": {
    "class": "MANUAL_REVIEW",
    "confidence": "LOW",
    "reason": "huaweicloud_compute_volume_attach 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)."
  }
}

## Wave 1 — 4 unit(s)

| Unit | Class | Target |
|---|---|---|
| `huaweicloud_evs_volume.data` | RECONFIGURE / MEDIUM | STACKIT Block Storage |
| `huaweicloud_evs_volume.scratch` | RECONFIGURE / MEDIUM | STACKIT Block Storage |
| `huaweicloud_networking_secgroup.app` | RECONFIGURE / MEDIUM | STACKIT security groups |
| `huaweicloud_vpc.main` | RECONFIGURE / MEDIUM | STACKIT network |

## Wave 2 — 1 unit(s)

| Unit | Class | Target |
|---|---|---|
| `huaweicloud_vpc_subnet.app` | RECONFIGURE / MEDIUM | STACKIT network |

## Wave 3 — 2 unit(s)

| Unit | Class | Target |
|---|---|---|
| `huaweicloud_compute_instance.app` | RECONFIGURE / MEDIUM | STACKIT Compute Engine |
| `huaweicloud_sfs_turbo.shared` | REPLATFORM / MEDIUM | STACKIT File Storage (SFS) |

## Wave 4 — 1 unit(s)

| Unit | Class | Target |
|---|---|---|
| `huaweicloud_compute_volume_attach.data` | MANUAL_REVIEW / LOW | — |

• Manual by design

  The unit is MANUAL_REVIEW with confidence LOW and no STACKIT target. The report lists the data disk and the server as linked to it, each with a confidence cap of MEDIUM. It is also the only step in this run without a role: nobody owns it until you assign someone.

• What it means for you

  A server volume attachment is among the target resources the run names for the disk, so the target side of this step exists. Do not wait for the run to place the Huawei resource; assign the step to the server owner.

• Disks are early, attach is late

  The disks depend on nothing, so they sit in wave 1 and can be created before the server. The server and the file system follow in wave 3.

How the storage estate maps

Classes as the run decided them for eight resources in eight units. Seven have confidence MEDIUM; the attachment is LOW.

The migration, in order

Steps 1 to 4 follow the waves of the run. Steps 5 to 7 are the data work; the run lists the units as stateful, records no mechanism, and leaves the choice to you.

1. 01

   Inventory what is attached and what is shared

   List every EVS disk with its type, size, IOPS and throughput, and every SFS Turbo with its type and clients. Shared disks (multiattach) and HPC file systems need a design decision before anything else.

2. 02

   Land the network, including the Network Area

   File Storage is always connected to a STACKIT Network Area, which needs routing tables, and the interconnection has subnet size requirements. Plan this in waves 1 and 2.

3. 03

   Choose performance classes from measurements

   Use the IOPS and throughput you measure on the source, not the disk type name. STACKIT classes are independent of volume size.

4. 04

   Create volumes, then the server, then attach

   A data volume attaches to one server at a time, and the server should be shut down to attach or detach it. Create them in wave 1, the server in wave 3, and attach as the last step.

5. 05

   Move block data at the host level or with the server image

   The run states both options in its reason. At host level, stop the writers and copy with a tool such as rsync from the old server to the new one. With the image, you rebuild or import it and carry the data in it. Both are general practice.

6. 06

   Create the resource pool, shares and export policies

   Size the pool (500 GB to 20 TB), create the shares (up to 200 per pool) and the export policies that grant your clients access. Then mount the shares from the new servers.

7. 07

   Copy files, repeat, cut over

   Run a first file copy while the source stays live, repeat to pick up changes, stop writers and run a last copy, then switch mounts. Keep the SFS Turbo read-only until acceptance.

EVS settings against STACKIT Block Storage

The run lists the settings; this table reads the ones that change the design against the STACKIT pages in the source list.

Source side: the Terraform provider documentation for huaweicloud_evs_volume. Target side: the Block Storage service plans and concepts pages.

SFS Turbo settings against STACKIT File Storage

Source side: the Terraform provider documentation for huaweicloud_sfs_turbo. Target side: the File Storage limits and concepts pages.

The data decision the run leaves open

From data-movement.md of the same run. Three stateful units; the mechanism of each is UNKNOWN and the state is DECISION REQUIRED, because size, change rate and tolerated downtime are not in the Terraform.

| Unit | Source service | Target service | Application | Mechanism | State | Data class | RPO | Downtime tolerance |
|---|---|---|---|---|---|---|---|---|
| huaweicloud_evs_volume.data | huaweicloud_evs_volume | STACKIT Block Storage |  | UNKNOWN | DECISION_REQUIRED | NOT_PROVIDED | NOT_PROVIDED | NOT_PROVIDED |
| huaweicloud_evs_volume.scratch | huaweicloud_evs_volume | STACKIT Block Storage |  | UNKNOWN | DECISION_REQUIRED | NOT_PROVIDED | NOT_PROVIDED | NOT_PROVIDED |
| huaweicloud_sfs_turbo.shared | huaweicloud_sfs_turbo | STACKIT File Storage (SFS) |  | UNKNOWN | DECISION_REQUIRED | NOT_PROVIDED | NOT_PROVIDED | NOT_PROVIDED |

Decisions the architects own

• Performance classes

  One class per volume, from measured IOPS and throughput.

• File systems above 20 TB

  How to split them, and whether the application tolerates several mounts.

• Shared disks

  Which clusters used multiattach and what replaces it.

• Copy method and window

  Host-level copy or image; first copy, repeats and the final stop, per volume and per share.

Questions storage teams ask

Sources

• Terraform Registry: huaweicloud_evs_volume (provider 1.100.0)
• Terraform Registry: huaweicloud_sfs_turbo (provider 1.100.0)
• STACKIT Docs: Block Storage service plans
• STACKIT Docs: Concepts of Block Storage
• STACKIT Docs: File Storage limits
• STACKIT Docs: File Storage concepts