Querying Product Specifications List

Function

This API is used to query the product specifications list.

Calling Method

For details, see Calling APIs.

URI

GET /v2/{engine}/products

**Table 1** Path Parameters
Parameter	Mandatory	Type	Description
engine	Yes	String	Message engine. Default: kafka

**Table 2** Query Parameters
Parameter	Mandatory	Type	Description
product_id	No	String	Product ID.

Request Parameters

None

Response Parameters

Status code: 200

**Table 3** Response body parameters
Parameter	Type	Description
engine	String	Message engine of DMS.
versions	Array of strings	Supported versions.
products	Array of ListEngineProductsEntity objects	Product specification details.

**Table 4** ListEngineProductsEntity
Parameter	Type	Description
type	String	Product type. Currently, single-node and cluster types are supported.
product_id	String	Product ID.
ecs_flavor_id	String	ECS flavor.
billing_code	String	Billing mode.
arch_types	Array of strings	CPU architecture.
charging_mode	Array of strings	Billing mode. monthly: yearly/monthly; hourly: pay-per-use
ios	Array of ListEngineIosEntity objects	List of supported disk I/O types.
support_features	Array of ListEngineSupportFeaturesEntity objects	List of features supported by instances of the current specifications.
properties	ListEnginePropertiesEntity object	Attribute of instances of the current specifications.

**Table 5** ListEngineIosEntity
Parameter	Type	Description
io_spec	String	Disk I/O code.
type	String	Disk type.
available_zones	Array of strings	Available AZs.
unavailable_zones	Array of strings	Unavailable AZs.

**Table 6** ListEngineSupportFeaturesEntity
Parameter	Type	Description
name	String	Feature name.
properties	ListEngineSupportFeaturesPropertiesEntity object	Description of the features supported by the instance.

**Table 7** ListEngineSupportFeaturesPropertiesEntity
Parameter	Type	Description
max_task	String	Maximum number of dumping tasks.
min_task	String	Minimum number of dumping tasks.
max_node	String	Maximum number of dumping nodes.
min_node	String	Minimum number of dumping nodes.

**Table 8** ListEnginePropertiesEntity
Parameter	Type	Description
max_partition_per_broker	String	Maximum number of partitions of each broker.
max_broker	String	Maximum number of brokers.
max_storage_per_node	String	Maximum storage space of each broker. The unit is GB.
max_consumer_per_broker	String	Maximum number of consumers of each broker.
min_broker	String	Minimum number of brokers.
max_bandwidth_per_broker	String	Maximum bandwidth of each broker.
min_storage_per_node	String	Minimum storage space of each broker. The unit is GB.
max_tps_per_broker	String	Maximum TPS of each broker.
product_alias	String	Alias of product_id.

Example Requests

GET https://{endpoint}/v2/kafka/products

Example Responses

Status code: 200

The product specifications are listed successfully.

Successful.

{
  "engine" : "kafka",
  "versions" : [ "1.1.0", "2.3.0" ],
  "products" : [ {
    "type" : "cluster",
    "product_id" : "c6.2u4g.cluster",
    "ecs_flavor_id" : "c6.large.2",
    "billing_code" : "dms.platinum.c6",
    "arch_types" : [ "X86" ],
    "charging_mode" : [ "monthly", "hourly" ],
    "ios" : [ {
      "io_spec" : "dms.physical.storage.high.v2",
      "type" : "evs",
      "available_zones" : [ "xxx", "xxx" ],
      "unavailable_zones" : [ "xxx", "xxx" ]
    }, {
      "io_spec" : "dms.physical.storage.ultra.v2",
      "type" : "evs",
      "available_zones" : [ "xxx", "xxx" ],
      "unavailable_zones" : [ "xxx", "xxx" ]
    } ],
    "support_features" : [ {
      "name" : "connector_obs",
      "properties" : {
        "max_task" : "10",
        "max_node" : "10",
        "min_task" : "1",
        "min_node" : "2"
      }
    } ],
    "properties" : {
      "max_partition_per_broker" : "250",
      "max_broker" : "30",
      "max_storage_per_node" : "10000",
      "max_consumer_per_broker" : "4000",
      "min_broker" : "3",
      "max_bandwidth_per_broker" : "100",
      "min_storage_per_node" : "200",
      "max_tps_per_broker" : "30000",
      "product_alias" : "kafka.2u4g.cluster"
    }
  }, {
    "type" : "cluster",
    "product_id" : "c6.4u8g.cluster",
    "ecs_flavor_id" : "c6.xlarge.2",
    "billing_code" : "dms.platinum.c6",
    "arch_types" : [ "X86" ],
    "charging_mode" : [ "monthly", "hourly" ],
    "ios" : [ {
      "io_spec" : "dms.physical.storage.high.v2",
      "type" : "evs",
      "available_zones" : [ "xxx", "xxx" ],
      "unavailable_zones" : [ "xxx", "xxx" ]
    }, {
      "io_spec" : "dms.physical.storage.ultra.v2",
      "type" : "evs",
      "available_zones" : [ "xxx", "xxx" ],
      "unavailable_zones" : [ "xxx", "xxx" ]
    } ],
    "support_features" : [ {
      "name" : "connector_obs",
      "properties" : {
        "max_task" : "10",
        "max_node" : "10",
        "min_task" : "1",
        "min_node" : "2"
      }
    } ],
    "properties" : {
      "max_partition_per_broker" : "500",
      "max_broker" : "30",
      "max_storage_per_node" : "20000",
      "max_consumer_per_broker" : "4000",
      "min_broker" : "3",
      "max_bandwidth_per_broker" : "100",
      "min_storage_per_node" : "400",
      "max_tps_per_broker" : "100000",
      "product_alias" : "kafka.4u8g.cluster"
    }
  }, {
    "type" : "cluster",
    "product_id" : "c6.8u16g.cluster",
    "ecs_flavor_id" : "c6.2xlarge.2",
    "billing_code" : "dms.platinum.c6",
    "arch_types" : [ "X86" ],
    "charging_mode" : [ "monthly", "hourly" ],
    "ios" : [ {
      "io_spec" : "dms.physical.storage.high.v2",
      "type" : "evs",
      "available_zones" : [ "xxx", "xxx" ],
      "unavailable_zones" : [ "xxx", "xxx" ]
    }, {
      "io_spec" : "dms.physical.storage.ultra.v2",
      "type" : "evs",
      "available_zones" : [ "xxx", "xxx" ],
      "unavailable_zones" : [ "xxx", "xxx" ]
    } ],
    "support_features" : [ {
      "name" : "connector_obs",
      "properties" : {
        "max_task" : "10",
        "max_node" : "10",
        "min_task" : "1",
        "min_node" : "2"
      }
    } ],
    "properties" : {
      "max_partition_per_broker" : "1000",
      "max_broker" : "30",
      "max_storage_per_node" : "30000",
      "max_consumer_per_broker" : "4000",
      "min_broker" : "3",
      "max_bandwidth_per_broker" : "100",
      "min_storage_per_node" : "800",
      "max_tps_per_broker" : "150000",
      "product_alias" : "kafka.8u16g.cluster"
    }
  }, {
    "type" : "cluster",
    "product_id" : "c6.12u24g.cluster",
    "ecs_flavor_id" : "c6.3xlarge.2",
    "billing_code" : "dms.platinum.c6",
    "arch_types" : [ "X86" ],
    "charging_mode" : [ "monthly", "hourly" ],
    "ios" : [ {
      "io_spec" : "dms.physical.storage.high.v2",
      "type" : "evs",
      "available_zones" : [ "xxx", "xxx" ],
      "unavailable_zones" : [ "xxx", "xxx" ]
    }, {
      "io_spec" : "dms.physical.storage.ultra.v2",
      "type" : "evs",
      "available_zones" : [ "xxx", "xxx" ],
      "unavailable_zones" : [ "xxx", "xxx" ]
    } ],
    "support_features" : [ {
      "name" : "connector_obs",
      "properties" : {
        "max_task" : "10",
        "max_node" : "10",
        "min_task" : "1",
        "min_node" : "2"
      }
    } ],
    "properties" : {
      "max_partition_per_broker" : "1500",
      "max_broker" : "30",
      "max_storage_per_node" : "30000",
      "max_consumer_per_broker" : "4000",
      "min_broker" : "3",
      "max_bandwidth_per_broker" : "100",
      "min_storage_per_node" : "1200",
      "max_tps_per_broker" : "200000",
      "product_alias" : "kafka.12u24g.cluster"
    }
  }, {
    "type" : "cluster",
    "product_id" : "c6.16u32g.cluster",
    "ecs_flavor_id" : "c6.4xlarge.2",
    "billing_code" : "dms.platinum.c6",
    "arch_types" : [ "X86" ],
    "charging_mode" : [ "monthly", "hourly" ],
    "ios" : [ {
      "io_spec" : "dms.physical.storage.high.v2",
      "type" : "evs",
      "available_zones" : [ "xxx", "xxx" ],
      "unavailable_zones" : [ "xxx", "xxx" ]
    }, {
      "io_spec" : "dms.physical.storage.ultra.v2",
      "type" : "evs",
      "available_zones" : [ "xxx", "xxx" ],
      "unavailable_zones" : [ "xxx", "xxx" ]
    } ],
    "support_features" : [ {
      "name" : "connector_obs",
      "properties" : {
        "max_task" : "10",
        "max_node" : "10",
        "min_task" : "1",
        "min_node" : "2"
      }
    } ],
    "properties" : {
      "max_partition_per_broker" : "2000",
      "max_broker" : "30",
      "max_storage_per_node" : "30000",
      "max_consumer_per_broker" : "4000",
      "min_broker" : "3",
      "max_bandwidth_per_broker" : "100",
      "min_storage_per_node" : "1600",
      "max_tps_per_broker" : "250000",
      "product_alias" : "kafka.16u32g.cluster"
    }
  } ]
}

SDK Sample Code

The SDK sample code is as follows.

      
       
         
         
           package com.huaweicloud.sdk.test;

import com.huaweicloud.sdk.core.auth.ICredential;
import com.huaweicloud.sdk.core.auth.BasicCredentials;
import com.huaweicloud.sdk.core.exception.ConnectionException;
import com.huaweicloud.sdk.core.exception.RequestTimeoutException;
import com.huaweicloud.sdk.core.exception.ServiceResponseException;
import com.huaweicloud.sdk.kafka.v2.region.KafkaRegion;
import com.huaweicloud.sdk.kafka.v2.*;
import com.huaweicloud.sdk.kafka.v2.model.*;


public class ListEngineProductsSolution {

    public static void main(String[] args) {
        // The AK and SK used for authentication are hard-coded or stored in plaintext, which has great security risks. It is recommended that the AK and SK be stored in ciphertext in configuration files or environment variables and decrypted during use to ensure security.
        // In this example, AK and SK are stored in environment variables for authentication. Before running this example, set environment variables CLOUD_SDK_AK and CLOUD_SDK_SK in the local environment
        String ak = System.getenv("CLOUD_SDK_AK");
        String sk = System.getenv("CLOUD_SDK_SK");

        ICredential auth = new BasicCredentials()
                .withAk(ak)
                .withSk(sk);

        KafkaClient client = KafkaClient.newBuilder()
                .withCredential(auth)
                .withRegion(KafkaRegion.valueOf("<YOUR REGION>"))
                .build();
        ListEngineProductsRequest request = new ListEngineProductsRequest();
        request.withEngine(ListEngineProductsRequest.EngineEnum.fromValue("{engine}"));
        try {
            ListEngineProductsResponse response = client.listEngineProducts(request);
            System.out.println(response.toString());
        } catch (ConnectionException e) {
            e.printStackTrace();
        } catch (RequestTimeoutException e) {
            e.printStackTrace();
        } catch (ServiceResponseException e) {
            e.printStackTrace();
            System.out.println(e.getHttpStatusCode());
            System.out.println(e.getRequestId());
            System.out.println(e.getErrorCode());
            System.out.println(e.getErrorMsg());
        }
    }
}

          

        

      
     

      
       
         
         
           # coding: utf-8

from huaweicloudsdkcore.auth.credentials import BasicCredentials
from huaweicloudsdkkafka.v2.region.kafka_region import KafkaRegion
from huaweicloudsdkcore.exceptions import exceptions
from huaweicloudsdkkafka.v2 import *

if __name__ == "__main__":
    # The AK and SK used for authentication are hard-coded or stored in plaintext, which has great security risks. It is recommended that the AK and SK be stored in ciphertext in configuration files or environment variables and decrypted during use to ensure security.
    # In this example, AK and SK are stored in environment variables for authentication. Before running this example, set environment variables CLOUD_SDK_AK and CLOUD_SDK_SK in the local environment
    ak = __import__('os').getenv("CLOUD_SDK_AK")
    sk = __import__('os').getenv("CLOUD_SDK_SK")

    credentials = BasicCredentials(ak, sk) \

    client = KafkaClient.new_builder() \
        .with_credentials(credentials) \
        .with_region(KafkaRegion.value_of("<YOUR REGION>")) \
        .build()

    try:
        request = ListEngineProductsRequest()
        request.engine = "{engine}"
        response = client.list_engine_products(request)
        print(response)
    except exceptions.ClientRequestException as e:
        print(e.status_code)
        print(e.request_id)
        print(e.error_code)
        print(e.error_msg)

          

        

      
     

      
       
         
         
           package main

import (
	"fmt"
	"github.com/huaweicloud/huaweicloud-sdk-go-v3/core/auth/basic"
    kafka "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/kafka/v2"
	"github.com/huaweicloud/huaweicloud-sdk-go-v3/services/kafka/v2/model"
    region "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/kafka/v2/region"
)

func main() {
    // The AK and SK used for authentication are hard-coded or stored in plaintext, which has great security risks. It is recommended that the AK and SK be stored in ciphertext in configuration files or environment variables and decrypted during use to ensure security.
    // In this example, AK and SK are stored in environment variables for authentication. Before running this example, set environment variables CLOUD_SDK_AK and CLOUD_SDK_SK in the local environment
    ak := os.Getenv("CLOUD_SDK_AK")
    sk := os.Getenv("CLOUD_SDK_SK")

    auth := basic.NewCredentialsBuilder().
        WithAk(ak).
        WithSk(sk).
        Build()

    client := kafka.NewKafkaClient(
        kafka.KafkaClientBuilder().
            WithRegion(region.ValueOf("<YOUR REGION>")).
            WithCredential(auth).
            Build())

    request := &model.ListEngineProductsRequest{}
	request.Engine = model.GetListEngineProductsRequestEngineEnum().ENGINE
	response, err := client.ListEngineProducts(request)
	if err == nil {
        fmt.Printf("%+v\n", response)
    } else {
        fmt.Println(err)
    }
}

          

        

      
     