Este conteúdo foi traduzido por máquina para sua conveniência e a Huawei Cloud não pode garantir que o conteúdo foi traduzido com precisão. Para exibir o conteúdo original, use o link no canto superior direito para mudar para a página em inglês.

Central de ajuda/ Distributed Message Service for Kafka/ Referência de API/ APIs V2 (recomendado)/ Gerenciamento do ciclo da vida/ Consulta de uma instância

Atualizado em 2024-09-10 GMT+08:00

Ver PDF

Consulta de uma instância

Função

Essa API é usada para consultar os detalhes sobre uma instância especificada.

Método de chamada

Para obter detalhes, consulte Chamada de APIs.

URI

GET /v2/{project_id}/instances/{instance_id}

**Tabela 1** Parâmetros de caminho
Parâmetro	Obrigatório	Tipo	Descrição
project_id	Sim	String	ID do projeto. Para obter detalhes sobre como obtê-lo, consulte Obtenção de um ID de projeto.
instance_id	Sim	String	ID da instância.

Parâmetros de solicitação

Nenhum

Parâmetros de resposta

Código de status: 200

**Tabela 2** Parâmetros do corpo de resposta
Parâmetro	Tipo	Descrição
name	String	Nome da instância.
engine	String	Mecanismo de mensagens.
engine_version	String	Versão.
description	String	Descrição da instância
specification	String	Especificações de instância.
storage_space	Integer	Espaço de armazenamento de mensagens em GB.
partition_num	String	Número de partições em uma instância de Kafka.
used_storage_space	Integer	Espaço de armazenamento de mensagens usado em GB.
connect_address	String	Endereço IP de uma instância.
port	Integer	Porta de uma instância.
status	String	Status da instância. Para obter detalhes, consulte Status da instância.
instance_id	String	ID da instância.
resource_spec_code	String	Especificações de recursos. dms.instance.kafka.cluster.c3.mini: instância do Kafka com largura de banda de 100 MB/s dms.instance.kafka.cluster.c3.small.2: instância do Kafka com largura de banda de 300 MB/s dms.instance.kafka.cluster.c3.middle.2: instância do Kafka com largura de banda de 600 MB/s dms.instance.kafka.cluster.c3.high.2: instância do Kafka com largura de banda de 1200 MB/s
charging_mode	Integer	Modo de cobrança. Opções: 1: pagamento por uso; 0: anual/mensal.
vpc_id	String	ID de VPC
vpc_name	String	Nome da VPC.
created_at	String	Hora em que a instância foi criada. A hora está no formato de carimbo de data/hora, ou seja, o deslocamento em milissegundos de 01/01/1970 00:00:00 UTC até a hora especificada.
subnet_name	String	Nome da sub-rede.
subnet_cidr	String	Bloco CIDR da sub-rede.
user_id	String	ID do usuário.
user_name	String	Nome de usuário.
access_user	String	Nome de usuário para acessar a instância.
order_id	String	ID do pedido. Este parâmetro tem um valor apenas quando o modo de cobrança é anual/mensal.
maintain_begin	String	Hora em que a janela de tempo de manutenção começa. O formato é HH:mm:ss.
maintain_end	String	Hora em que a janela de tempo de manutenção termina. O formato é HH:mm:ss.
enable_publicip	Boolean	Se o acesso público está ativado para a instância. true: ativado false: desativado
management_connect_address	String	Endereço de conexão do Kafka Manager da instância do Kafka.
ssl_enable	Boolean	Se a autenticação de segurança está ativada. true: ativada false: desativada
broker_ssl_enable	Boolean	Indica se deve ser ativada a transmissão de réplicas criptografadas entre corretores. true: ativada false: desativada
kafka_security_protocol	String	Protocolo de segurança a ser usado após a ativação do SASL. SASL_SSL: os dados são criptografados com certificados SSL para transmissão de alta segurança. SASL_PLAINTEXT: os dados são transmitidos em texto não criptografado com autenticação de nome de usuário e senha. Este protocolo usa o mecanismo SCRAM-SHA-512 e oferece alto desempenho.
sasl_enabled_mechanisms	Array of strings	Mecanismo de autenticação usado após a ativação do SASL. PLAIN: verificação simples de nome de usuário e senha. SCRAM-SHA-512: verificação da credencial do usuário, que é mais segura do que PLAIN.
ssl_two_way_enable	Boolean	Indica se a autenticação bidirecional deve ser ativada.
cert_replaced	Boolean	Se o certificado pode ser substituído.
public_management_connect_address	String	Endereço para acessar o Kafka Manager em redes públicas.
enterprise_project_id	String	ID do projeto empresarial.
is_logical_volume	Boolean	Se a instância é uma nova instância. Esse parâmetro é usado para distinguir instâncias anteriores de instâncias novas durante a expansão da capacidade da instância. true: nova instância, que permite a expansão dinâmica da capacidade do disco sem reiniciar a instância. false: instância anterior.
extend_times	Integer	Número de tempos de expansão do disco. Se o valor exceder 20, a expansão do disco não será mais permitida.
enable_auto_topic	Boolean	Se a criação automática de tópicos está ativada. true: ativada false: desativada
type	String	Tipos de instâncias. O valor pode ser cluster.
product_id	String	ID do produto.
security_group_id	String	ID do grupo de segurança.
security_group_name	String	Nome do grupo de segurança.
subnet_id	String	ID da sub-rede.
available_zones	Array of strings	AZ ao qual os corretores de instância pertencem. O ID da AZ é retornado.
available_zone_names	Array of strings	Nome da AZ à qual o nó da instância pertence. O nome da AZ é retornado.
total_storage_space	Integer	Espaço de armazenamento de mensagens em GB.
public_connect_address	String	Endereço de acesso público da instância. Esse parâmetro está disponível somente quando o acesso público está ativado para a instância.
storage_resource_id	String	ID do recurso de armazenamento.
storage_spec_code	String	Especificações de I/O.
service_type	String	Tipo de serviço.
storage_type	String	Classe de armazenamento.
retention_policy	String	Política de retenção de mensagens.
kafka_public_status	String	Se o acesso público está ativado para o Kafka.
public_bandwidth	Integer	Largura de banda de acesso à rede pública.
kafka_manager_enable	Boolean	Se o Kafka Manager está ativado.
kafka_manager_user	String	Nome de usuário para efetuar logon no Kafka Manager.
enable_log_collection	Boolean	Se a coleta de logs está ativada.
new_auth_cert	Boolean	Indica se deve ativar um novo certificado.
cross_vpc_info	String	Informações de acesso entre VPCs.
ipv6_enable	Boolean	Se o IPv6 está ativado.
ipv6_connect_addresses	Array of strings	Endereço de conexão IPv6.
connector_enable	Boolean	Se o despejo está ativado. O despejo não é suportado para o novo tipo de especificação.
connector_node_num	Integer	Número de conectores.
connector_id	String	ID da tarefa de despejo.
rest_enable	Boolean	Se o Kafka REST está ativado.
rest_connect_address	String	Endereço de conexão do Kafka REST.
public_boundwidth	Integer	Largura de banda de acesso à rede pública. Versão a ser excluída.
message_query_inst_enable	Boolean	Se a consulta de mensagem está ativada.
vpc_client_plain	Boolean	Se o acesso de texto não criptografado dentro da VPC está ativado.
support_features	String	Lista de recursos suportados pela instância de Kafka.
trace_enable	Boolean	Se o rastreamento de mensagens está ativado.
agent_enable	Boolean	Indica se o proxy está ativado.
pod_connect_address	String	Endereço de conexão no lado do locatário.
disk_encrypted	Boolean	Se a criptografia de disco está ativada.
disk_encrypted_key	String	Key de criptografia de disco. Se a criptografia de disco não estiver ativada, esse parâmetro será deixado em branco.
kafka_private_connect_address	String	Endereço de conexão privada de uma instância do Kafka.
ces_version	String	Versão do Cloud Eye.
public_access_enabled	String	Hora em que o acesso público foi ativado para uma instância. O valor pode ser true, actived, closed ou false.
node_num	Integer	Quantidade de nó.
enable_acl	Boolean	Indica se o controle de acesso está ativado.
new_spec_billing_enable	Boolean	Se a cobrança com base em novas especificações está ativada.
broker_num	Integer	Quantidade do corretor.
tags	Array of TagEntity objects	Lista de tags.
dr_enable	Boolean	Indica se a DR está ativada.

**Tabela 3** TagEntity
Parâmetro	Tipo	Descrição
key	String	Chave de tag, que: Deve ser especificada. Deve ser exclusiva para a mesma instância. Pode conter de 1 a 128 caracteres. Pode conter letras, dígitos, espaços e caracteres especiais _.:=+-@ Não pode começar ou terminar com um espaço.
value	String	Valor da tag. Pode conter de 0 a 255 caracteres. Pode conter letras, dígitos, espaços e caracteres especiais _.:=+-@

Exemplo de solicitações

Consulta de uma instância

GET https://{endpoint}/v2/{project_id}/instances/{instance_id}

Exemplo de respostas

Código de status: 200

Instância especificada consultada.

A instância é consultada. Um exemplo de resultado retornado é o seguinte.

{
  "name" : "kafka-2085975099",
  "engine" : "kafka",
  "port" : 9092,
  "status" : "RUNNING",
  "type" : "cluster",
  "specification" : "100MB",
  "engine_version" : "1.1.0",
  "connect_address" : "192.168.0.100,192.168.0.61,192.168.0.72",
  "instance_id" : "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
  "resource_spec_code" : "dms.instance.kafka.cluster.c3.mini",
  "charging_mode" : 1,
  "vpc_id" : "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
  "vpc_name" : "dms-test",
  "created_at" : "1585618587087",
  "product_id" : "00300-30308-0--0",
  "security_group_id" : "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
  "security_group_name" : "Sys-default",
  "subnet_id" : "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
  "available_zones" : [ "38b0f7a602344246bcb0da47b5d548e7" ],
  "available_zone_names" : [ "AZ1" ],
  "user_id" : "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
  "user_name" : "paas_dms",
  "kafka_manager_enable" : false,
  "kafka_manager_user" : "root",
  "maintain_begin" : "02:00:00",
  "maintain_end" : "06:00:00",
  "enable_log_collection" : false,
  "new_auth_cert" : false,
  "storage_space" : 492,
  "total_storage_space" : 600,
  "used_storage_space" : 25,
  "partition_num" : "300",
  "enable_publicip" : false,
  "ssl_enable" : false,
  "broker_ssl_enable" : false,
  "cert_replaced" : false,
  "management_connect_address" : "https://192.168.0.100:9999",
  "cross_vpc_info" : "{\"192.168.0.61\":{\"advertised_ip\":\"192.168.0.61\",\"port\":9011,\"port_id\":\"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"},\"192.168.0.72\":{\"advertised_ip\":\"192.168.0.72\",\"port\":9011,\"port_id\":\"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"},\"192.168.0.100\":{\"advertised_ip\":\"192.168.0.100\",\"port\":9011,\"port_id\":\"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"}}",
  "storage_resource_id" : "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
  "storage_spec_code" : "dms.physical.storage.ultra",
  "service_type" : "advanced",
  "storage_type" : "hec",
  "enterprise_project_id" : "0",
  "is_logical_volume" : true,
  "extend_times" : 0,
  "retention_policy" : "produce_reject",
  "ipv6_enable" : false,
  "ipv6_connect_addresses" : [ ],
  "connector_enable" : false,
  "connector_node_num" : 0,
  "connector_id" : "",
  "rest_enable" : false,
  "rest_connect_address" : "",
  "kafka_public_status" : "closed",
  "public_bandwidth" : 0,
  "message_query_inst_enable" : true,
  "vpc_client_plain" : false,
  "support_features" : "kafka.new.pod.port,feature.physerver.kafka.topic.modify,feature.physerver.kafka.topic.accesspolicy,message_trace_enable,features.pod.token.access,feature.physerver.kafka.pulbic.dynamic,roma_app_enable,features.log.collection,auto_topic_switch,feature.physerver.kafka.user.manager",
  "trace_enable" : false,
  "agent_enable" : false,
  "pod_connect_address" : "100.86.75.15:9080,100.86.142.77:9080,100.86.250.167:9080",
  "disk_encrypted" : false,
  "kafka_private_connect_address" : "192.168.0.61:9092,192.168.0.100:9092,192.168.0.72:9092",
  "enable_auto_topic" : false,
  "new_spec_billing_enable" : false,
  "ces_version" : "linux"
}

Código de exemplo do SDK

O código de exemplo do SDK é o seguinte.

Java

    
     
       
       
         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 ShowInstanceSolution {

    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");
        String projectId = "{project_id}";

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

        KafkaClient client = KafkaClient.newBuilder()
                .withCredential(auth)
                .withRegion(KafkaRegion.valueOf("<YOUR REGION>"))
                .build();
        ShowInstanceRequest request = new ShowInstanceRequest();
        request.withInstanceId("{instance_id}");
        try {
            ShowInstanceResponse response = client.showInstance(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());
        }
    }
}

        

      

    
   

Python

    
     
       
       
         # 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")
    projectId = "{project_id}"

    credentials = BasicCredentials(ak, sk, projectId) \

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

    try:
        request = ShowInstanceRequest()
        request.instance_id = "{instance_id}"
        response = client.show_instance(request)
        print(response)
    except exceptions.ClientRequestException as e:
        print(e.status_code)
        print(e.request_id)
        print(e.error_code)
        print(e.error_msg)

        

      

    
   

Go

    
     
       
       
         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")
    projectId := "{project_id}"

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

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

    request := &model.ShowInstanceRequest{}
	request.InstanceId = "{instance_id}"
	response, err := client.ShowInstance(request)
	if err == nil {
        fmt.Printf("%+v\n", response)
    } else {
        fmt.Println(err)
    }
}

        

      

    
   

Mais

Para obter o código de exemplo do SDK de mais linguagens de programação, consulte a guia Código de exemplo no API Explorer. O código de exemplo do SDK pode ser gerado automaticamente.