Alibaba Cloud Tablestore and HBase on STACKIT

A Tablestore instance, its table and an HBase cluster, assessed

A telemetry estate written for this page, assessed by StackToIT on 4 November 2026. Left: the three data resources of the input. Right: an excerpt of assessment.json with the values the run wrote. 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.

resource "alicloud_ots_instance" "devices" {
  name        = "device-state"
  description = "Device state and recent readings"
  accessed_by = "Vpc"
  instance_type = "HighPerformance"
}

resource "alicloud_ots_table" "readings" {
  instance_name = alicloud_ots_instance.devices.name
  table_name    = "readings"
  time_to_live  = -1
  max_version   = 1
  primary_key {
    name = "device_id"
    type = "String"
  }
  primary_key {
    name = "ts"
    type = "Integer"
  }
}

resource "alicloud_hbase_instance" "history" {
  name                   = "telemetry-history"
  engine_version         = "2.0"
  master_instance_type   = "hbase.sn2.2xlarge"
  core_instance_type     = "hbase.sn2.2xlarge"
  core_instance_quantity = 3
  core_disk_type         = "cloud_ssd"
  core_disk_size         = 400
  vswitch_id             = alicloud_vswitch.data.id
  vpc_id                 = alicloud_vpc.main.id
  zone_id                = "eu-central-1a"
  pay_type               = "PostPaid"
}

[
  {
    "id": "alicloud_ots_instance.devices",
    "result": {
      "class": "REDESIGN",
      "confidence": "MEDIUM",
      "target": {
        "service": "a self-managed wide-column store on SKE, or MongoDB Flex after a data-model redesign"
      },
      "reason": "STACKIT has no managed wide-column store. Run one yourself on SKE, or redesign the data model for MongoDB Flex."
    }
  },
  {
    "id": "alicloud_ots_table.readings",
    "result": {
      "class": "MANUAL_REVIEW",
      "confidence": "LOW",
      "reason": "alicloud_ots_table 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)."
    }
  },
  {
    "id": "alicloud_hbase_instance.history",
    "result": {
      "class": "REDESIGN",
      "confidence": "LOW",
      "target": {
        "service": "a self-managed wide-column store on SKE, or MongoDB Flex after a data-model redesign"
      },
      "reason": "STACKIT has no managed wide-column store. Run one yourself on SKE, or redesign the data model for MongoDB Flex."
    }
  }
]

• Two instances, one verdict

  The Tablestore instance is REDESIGN with MEDIUM confidence, the HBase instance REDESIGN with LOW. Both name the same two targets.

• The table is not in the catalogue

  alicloud_ots_table is classified MANUAL_REVIEW with LOW confidence because StackToIT does not catalogue this resource type yet. Its primary key, version and expiry settings are yours to read from the input.

• Owners

  The run puts both instances in one work package for the Data Architect. The table sits in a separate package whose owner is NOT_STATED, so assign it.

The options and what each costs

The run does not choose between the first two. Its classification is REDESIGN because neither target is a drop-in replacement.

What the source settings mean for the choice

• Primary key and partition key

  A Tablestore primary key has one to four columns, rows are sorted by it, and the first column is the partition key. The example table uses device_id and ts, so a key that starts with the device is the natural start of a MongoDB index or a row key design.

• Versions and expiry

  The table sets max_version to 1 and time_to_live to -1. One version and no expiry are the simplest case to redesign; a table with several versions per cell needs a deliberate answer in a document model.

• A size limit to carry

  Tablestore advises keeping all rows of one partition key value under 10 GB in total. If you are close to that, the key design is part of the redesign.

• HBase API in your code

  Tablestore offers an HBase client that wraps the HBase client and supports only one column family per table, default f. Applications that already use HBase calls keep that API surface, which favours the wide-column route.

• ApsaraDB for HBase

  The service has its own SDK on the same major version line as open-source HBase, with the open-source dependency replaced in the build file. Moving back to an open-source HBase client is the inverse swap; this is an architect's suggestion, not run output, so test it.

• Document model

  MongoDB Flex offers replica sets for availability and sharded clusters that split data across several entities for performance. Expiry and the access pattern are then expressed in MongoDB itself, which is general practice to verify per workload.

How to decide

1. 01

   1. Find how the data is accessed

   Read the application code: Tablestore SDK, Tablestore HBase client or ApsaraDB for HBase client. That decides how much code changes under each option.

2. 02

   2. Measure size and growth

   The Terraform states an HBase cluster of three core nodes with 400 GB of disk each and a Tablestore instance without sizes. Real volume comes from your account, not from the run.

3. 03

   3. Choose the operating model

   A store on SKE is yours to run. MongoDB Flex is managed. Name the owner before you pick.

4. 04

   4. Plan the copy

   The run chooses no data-movement mechanism. Alibaba Cloud documents Data Integration for HBase to Tablestore; for the move to STACKIT the method is yours to pick from size and tolerated downtime.

5. 05

   5. Rehearse with a copy

   Load a sample into the target, run the read paths of the application and compare results before any cut-over.

Questions data teams ask

Sources

• Alibaba Cloud: Tablestore wide column model
• Alibaba Cloud: migrate from the HBase client to the Tablestore HBase client
• Alibaba Cloud: replace open-source HBase with the ApsaraDB for HBase SDK
• STACKIT MongoDB Flex: introduction