Todos os produtos
Search

Este produto

    Managed Service for OpenTelemetry:Integração com OpenTelemetry

    Central de documentação

    Managed Service for OpenTelemetry:Integração com OpenTelemetry

    Última atualização: Oct 20, 2026

    O Managed Service for OpenTelemetry recebe dados de trace, métricas e logs das suas aplicações. O service oferece dois métodos de envio: direto ou por encaminhamento via OpenTelemetry Collector.

    Escolha um método de envio

    Envie dados de telemetria diretamente ao Managed Service for OpenTelemetry ou encaminhe-os por meio de um OpenTelemetry Collector. Selecione o método conforme o tipo de dado de telemetria desejado.

    Método de envio

    Tipos de dados suportados

    Envio direto

    Traces e métricas

    OpenTelemetry Collector (Core)

    Traces e métricas

    OpenTelemetry Collector (Contrib)

    Traces, métricas e logs

    Os dados de log são encaminhados por meio do OpenTelemetry Collector (Contrib) para o Simple Log Service (SLS). Para enviar dados de log, utilize o método de encaminhamento pelo Collector na edição Contrib.

    Ao encaminhar dados via OpenTelemetry Collector, escolha uma opção de implantação. O OpenTelemetry Collector está disponível em duas edições:

    • OpenTelemetry Collector (Core): suporta o envio de dados de traces e métricas.

    • OpenTelemetry Collector (Contrib): suporta o envio de dados de traces, métricas e logs. A tabela a seguir compara as opções de implantação descritas neste tópico.

    Opção de implantação

    Edição suportada

    Tipos de dados suportados

    Implantar em um cluster ACK pelo ACK Marketplace

    OpenTelemetry Collector (Core)

    Traces e métricas

    Implantar com docker

    OpenTelemetry Collector (Core) e OpenTelemetry Collector (Contrib)

    Traces e métricas (Core). Traces, métricas e logs (Contrib).

    Outros métodos de instalação e implantação

    Consulte Outros métodos de instalação e implantação.

    Varia conforme o método

    Antes de começar

    Caso de usoVariávelDescriçãoExemplo
    Enviar dados de trace e métrica via gRPC${GRPC_ENDPOINT}Endpoint gRPC do Managed Service for OpenTelemetry, usado para enviar traces e métricas. Se o service executar na Alibaba Cloud na mesma região do endpoint selecionado, use o endpoint interno da Alibaba Cloud. Caso contrário, utilize o endpoint público.

    • Endpoint interno: http://tracing-analysis-dc-hz-internal.aliyuncs.com:8090

    • Endpoint público: http://tracing-analysis-dc-hz.aliyuncs.com:8090

    Enviar dados de trace e métrica via gRPC${GRPC_AUTHENTICATION_TOKEN}Token de autenticação necessário para enviar dados via gRPC ao Managed Service for OpenTelemetry. Para saber como obter o token, consulte Get started with Managed Service for OpenTelemetry.abcdef1234@abcdef****56789_abcdef1234@abcdef****56789
    Enviar dados de trace e métrica via HTTP${HTTP_TRACES_ENDPOINT}Endpoint HTTP do Managed Service for OpenTelemetry, utilizado para envio de traces. Se o service executar na Alibaba Cloud na mesma região do endpoint escolhido, prefira o endpoint interno da Alibaba Cloud. Caso contrário, use o endpoint público.

    • Endpoint interno: http://tracing-analysis-dc-hz-internal.aliyuncs.com/adapt__/api/otlp/traces
      - Endpoint público: http://tracing-analysis-dc-hz.aliyuncs.com/adapt__/api/otlp/traces

    Enviar dados de trace e métrica via HTTP${HTTP_METRICS_ENDPOINT}Endpoint HTTP do Managed Service for OpenTelemetry, destinado ao envio de métricas. Se o service executar na Alibaba Cloud na mesma região do endpoint, opte pelo endpoint interno da Alibaba Cloud. Caso contrário, utilize o endpoint público.

    • Endpoint interno: http://tracing-analysis-dc-hz-internal.aliyuncs.com/adapt__/api/otlp/metrics
      - Endpoint público: http://tracing-analysis-dc-hz.aliyuncs.com/adapt__/api/otlp/metrics

    Enviar dados de log${SLS_ENDPOINT}Endpoint do SLS Project. Necessário apenas para envio de logs. Para obter o endpoint, siga as etapas em Endpoint.test-project.cn-hangzhou.log.aliyuncs.com
    Enviar dados de log${SLS_PROJECT}Nome do SLS Project. Obrigatório somente ao enviar dados de log.test-project
    Enviar dados de log${SLS_LOGSTORE}Nome do SLS Logstore. Obrigatório apenas para envio de logs.test-logstore
    Enviar dados de log${ALIYUN_ACCESS_KEY_ID}accesskey id da sua conta Alibaba Cloud. Necessário exclusivamente para envio de logs. Recomendamos usar o par de AccessKey (composto por AccessKey id e AccessKey secret) de um usuário do Resource Access Management (RAM) com permissões de escrita restritas ao SLS Project. Para conceder permissões de escrita em um Project específico a um usuário RAM, veja RAM custom policy examples. Para obter um par de AccessKey, consulte AccessKey pair.N/A
    Enviar dados de log${ALIYUN_ACCESS_KEY_SECRET}AccessKey secret da sua conta Alibaba Cloud. Necessário apenas para envio de logs. Recomendamos utilizar o par de AccessKey de um usuário RAM com permissão de escrita limitada ao SLS Project.N/A

    Envio direto

    Configure o endpoint de envio e as informações de autenticação no OpenTelemetry Agent ou SDK para transmitir os dados de traces e métricas coletados pelo OpenTelemetry diretamente ao servidor do Managed Service for OpenTelemetry.

    Opção 1: Configurar as definições de envio no código (exemplo em Java)

    Os exemplos de código Java a seguir demonstram como configurar os endpoints do Managed Service for OpenTelemetry, que aceita envio via HTTP ou gRPC. Para acessar o código completo de integração e demonstrações, visite a Central de Integração ou consulte Report trace data from Java applications by using OpenTelemetry.

    Envio via HTTP

    ...

// Report trace data
SdkTracerProvider sdkTracerProvider = SdkTracerProvider.builder()
        .addSpanProcessor(BatchSpanProcessor.builder(OtlpHttpSpanExporter.builder()
                .setEndpoint("${HTTP_TRACES_ENDPOINT}") // Set the HTTP traces endpoint to report trace data to Managed Service for OpenTelemetry.
                .build()).build())
        .build();

// Report metric data
SdkMeterProvider sdkMeterProvider = SdkMeterProvider.builder()
    .registerMetricReader(PeriodicMetricReader.builder(OtlpHttpMetricExporter.builder()
        .setEndpoint("${HTTP_METRICS_ENDPOINT}")  // Set the HTTP metrics endpoint to report metric data to Managed Service for OpenTelemetry.
        .build()).build())
    .build();

...

    Envio via gRPC

    ...

// Report trace data
SdkTracerProvider sdkTracerProvider = SdkTracerProvider.builder()
        .addSpanProcessor(BatchSpanProcessor.builder(OtlpGrpcSpanExporter.builder()
                .setEndpoint("${GRPC_ENDPOINT}") // Set the gRPC endpoint to report trace data to Managed Service for OpenTelemetry.
                .addHeader("Authentication","${GRPC_AUTHENTICATION_TOKEN}") // Set the authentication token of Managed Service for OpenTelemetry.
                .build()).build())
        .setResource(resource)
        .build();

// Report metric data
SdkMeterProvider sdkMeterProvider = SdkMeterProvider.builder()
    .registerMetricReader(PeriodicMetricReader.builder(OtlpGrpcMetricExporter.builder()
        .setEndpoint("${GRPC_ENDPOINT}")  // Set the gRPC endpoint to report metric data to Managed Service for OpenTelemetry.
        .addHeader("Authentication", "${GRPC_AUTHENTICATION_TOKEN}")  // Set the authentication token of Managed Service for OpenTelemetry.
        .build()).build())
    .setResource(resource)
    .build();

...

    Opção 2: Configurar as definições de envio com variáveis de ambiente

    O OpenTelemetry também permite configurar o endpoint de envio de dados por meio de variáveis de ambiente. A tabela abaixo apresenta as variáveis necessárias para enviar dados ao Managed Service for OpenTelemetry. Para conhecer outras variáveis de ambiente OTLP do OpenTelemetry, acesse Configuração do Exportador OTLP.

    Variável de ambienteDescriçãoExemplo
    OTEL_SERVICE_NAMENome da aplicação.export OTEL_SERVICE_NAME=opentelemetry-demo-service
    OTEL_EXPORTER_OTLP_PROTOCOLProtocolo de envio. Traces aceitam grpc, http/protobuf e http/json. Métricas suportam grpc e http/protobuf. Ao escolher um endpoint gRPC, defina esta variável como grpc. Caso contrário, utilize http/protobuf ou http/json.export OTEL_EXPORTER_OTLP_PROTOCOL=grpc
    OTEL_EXPORTER_OTLP_TRACES_ENDPOINTEndpoint para envio de traces. Suporta HTTP e gRPC. Utilize o valor ${GRPC_ENDPOINT} ou ${HTTP_TRACES_ENDPOINT} obtido anteriormente.

    • Envio via HTTP: export OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://tracing-analysis-dc-hz-internal.aliyuncs.com/adapt__/api/otlp/traces

    • Envio via gRPC: export OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://tracing-analysis-dc-hz-internal.aliyuncs.com:8090

    OTEL_EXPORTER_OTLP_METRICS_ENDPOINTEndpoint para envio de métricas. Compatível com HTTP e gRPC. Use o valor ${GRPC_ENDPOINT} ou ${HTTP_METRICS_ENDPOINT} obtido anteriormente.

    • Envio via HTTP: export OTEL_EXPORTER_OTLP_METRICS_ENDPOINT=http://tracing-analysis-dc-hz-internal.aliyuncs.com/adapt__/api/otlp/metrics

    • Envio via gRPC: export OTEL_EXPORTER_OTLP_METRICS_ENDPOINT=http://tracing-analysis-dc-hz-internal.aliyuncs.com:8090

    OTEL_EXPORTER_OTLP_HEADERSCabeçalho de requisição para envio via gRPC, usado principalmente para autenticação. Adote o formato Authentication=${GRPC_AUTHENTICATION_TOKEN}, onde ${GRPC_AUTHENTICATION_TOKEN} corresponde ao token de autenticação obtido previamente.export OTEL_EXPORTER_OTLP_HEADERS=Authentication=abcdef1234@abcdef****56789_abcdef1234@abcdef****56789

    Encaminhamento de dados via OpenTelemetry Collector

    Um OpenTelemetry Collector recebe dados de traces, métricas e logs das suas aplicações e os encaminha ao Managed Service for OpenTelemetry conforme a configuração do exportador.

    Opção 1: Implantar em um cluster ACK pelo ACK Marketplace

    Nesta opção, implante o collector em um cluster do Container Service for Kubernetes (ACK) por meio do ACK Marketplace. Atualmente, o ACK Marketplace disponibiliza apenas a edição OpenTelemetry Collector (Core), sem a versão Contrib. Para coletar dados de log, adote um dos outros métodos de implantação.

    Etapa 1: Implantar o collector

    1. Faça login no ACK console. No painel de navegação à esquerda, clique em Marketplace > Marketplace.

    2. No Marketplace, pesquise e clique em opentelemetry-collector e, em seguida, clique em Deploy no canto superior direito da página.

    3. Na página Create , selecione o cluster e o namespace onde deseja implantar o opentelemetry-collector. O namespace padrão é otel-collector. Depois, clique em Next.

    4. Na página Parameter Configurations, defina o parâmetro mode como deployment ou daemonset e clique em OK.

    Etapa 2: Configurar os parâmetros do collector

    1. Na página Clusters, clique no cluster desejado.

    2. No painel de navegação à esquerda, escolha Configuration Management > Configuration Item.

    3. Selecione o namespace onde o opentelemetry-collector foi implantado. Por padrão, trata-se do namespace otel-collector.

    4. Na página Configuration Item, localize opentelemetry-collector e clique em YAML.

    5. Configure as seções exporters, processors, receivers e service com base no conteúdo YAML abaixo e clique em OK.

      Item de configuração do opentelemetry-collector (envio via gRPC)

      exporters:
  otlp:
    endpoint: "${GRPC_ENDPOINT}"
    headers:
      Authentication: "${GRPC_AUTHENTICATION_TOKEN}"
    tls:
      insecure: true

processors:
  batch: {}
  memory_limiter:
    check_interval: 5s # The interval at which memory usage is checked. Change the value as needed.
    limit_percentage: 80 # The maximum memory usage as a percentage. Change the value as needed.
    spike_limit_percentage: 25 # The additional memory as a percentage that is allowed for spikes. Change the value as needed.

receivers:
  otlp:
    protocols:
      grpc:
        endpoint: ${env:MY_POD_IP}:4317
      http:
        endpoint: ${env:MY_POD_IP}:4318

service:
  pipelines:
    traces:
      exporters: [otlp]
      processors: [memory_limiter, batch]
      receivers: [otlp]
    metrics:
      exporters: [otlp]
      processors: [memory_limiter, batch]
      receivers: [otlp]

      Item de configuração do opentelemetry-collector (envio via HTTP)

      exporters:
  otlphttp:
    traces_endpoint: "${HTTP_TRACES_ENDPOINT}"
    metrics_endpoint: "${HTTP_METRICS_ENDPOINT}"
    tls:
      insecure: true
    timeout: 5s # The timeout period. The default value is 5s. Change the value as needed.

processors:
  batch: {}
  memory_limiter:
    check_interval: 5s # The interval at which memory usage is checked. Change the value as needed.
    limit_percentage: 80 # The maximum memory usage as a percentage. Change the value as needed.
    spike_limit_percentage: 25 # The additional memory as a percentage that is allowed for spikes. Change the value as needed.

receivers:
  otlp:
    protocols:
      grpc:
        endpoint: ${env:MY_POD_IP}:4317
      http:
        endpoint: ${env:MY_POD_IP}:4318

service:
  pipelines:
    traces:
      exporters: [otlphttp]
      processors: [memory_limiter, batch]
      receivers: [otlp]
    metrics:
      exporters: [otlphttp]
      processors: [memory_limiter, batch]
      receivers: [otlp]

    6. Após concluir a configuração, reinicie manualmente o opentelemetry-collector.

    Opção 2: Implantar com docker

    Neste método, execute o collector como um contêiner docker. As edições Core e Contrib estão disponíveis.

    Etapa 1: Baixar a imagem

    opentelemetry-collector

    Para especificar uma versão da imagem, acesse Docker Hub - OpenTelemetry Collector.

    docker pull otel/opentelemetry-collector:latest

    opentelemetry-collector-contrib

    Para definir uma versão específica da imagem, visite Docker Hub - OpenTelemetry Collector Contrib.

    docker pull otel/opentelemetry-collector-contrib:latest

    Etapa 2: Preparar o arquivo de configuração

    Crie um arquivo config.yaml e configure os parâmetros relacionados. Nos exemplos a seguir, substitua os placeholders no formato ${VAR} pelos valores preparados na seção Antes de começar. Esses placeholders diferem da sintaxe nativa de expansão ${env:...} do Collector, como ${env:MY_POD_IP}, resolvida pelo Collector a partir de variáveis de ambiente em tempo de execução.

    Item de configuração do opentelemetry-collector (envio via gRPC)

    # config.yaml
exporters:
  otlp:
    endpoint: "${GRPC_ENDPOINT}"
    headers:
      Authentication: "${GRPC_AUTHENTICATION_TOKEN}"
    tls:
      insecure: true

processors:
  batch: {}
  memory_limiter:
    check_interval: 5s # The interval at which memory usage is checked. Change the value as needed.
    limit_percentage: 80 # The maximum memory usage as a percentage. Change the value as needed.
    spike_limit_percentage: 25 # The additional memory as a percentage that is allowed for spikes. Change the value as needed.

receivers:
  otlp:
    protocols:
      grpc:
        endpoint: 0.0.0.0:4317 # The default value is localhost:4317. Change the value as needed.
      http:
        endpoint: 0.0.0.0:4318 # The default value is localhost:4318. Change the value as needed.

service:
  pipelines:
    traces:
      exporters: [otlp]
      processors: [memory_limiter, batch]
      receivers: [otlp]
    metrics:
      exporters: [otlp]
      processors: [memory_limiter, batch]
      receivers: [otlp]

    Item de configuração do opentelemetry-collector (envio via HTTP)

    # config.yaml
exporters:
  otlphttp:
    traces_endpoint: "${HTTP_TRACES_ENDPOINT}"
    metrics_endpoint: "${HTTP_METRICS_ENDPOINT}"
    tls:
      insecure: true
    timeout: 5s # The timeout period. The default value is 5s. Change the value as needed.

processors:
  batch: {}
  memory_limiter:
    check_interval: 5s # The interval at which memory usage is checked. Change the value as needed.
    limit_percentage: 80 # The maximum memory usage as a percentage. Change the value as needed.
    spike_limit_percentage: 25 # The additional memory as a percentage that is allowed for spikes. Change the value as needed.

receivers:
  otlp:
    protocols:
      grpc:
        endpoint: 0.0.0.0:4317 # The default value is localhost:4317. Change the value as needed.
      http:
        endpoint: 0.0.0.0:4318 # The default value is localhost:4318. Change the value as needed.

service:
  pipelines:
    traces:
      exporters: [otlphttp]
      processors: [memory_limiter, batch]
      receivers: [otlp]
    metrics:
      exporters: [otlphttp]
      processors: [memory_limiter, batch]
      receivers: [otlp]

    Item de configuração do opentelemetry-collector-contrib (envio via gRPC)

    # config.yaml
exporters:
  otlp:
    endpoint: "${GRPC_ENDPOINT}"
    headers:
      Authentication: "${GRPC_AUTHENTICATION_TOKEN}"
    tls:
      insecure: true
  # Log exporter configuration (optional)
  alibabacloud_logservice/logs:
    endpoint: "${SLS_ENDPOINT}"
    project: "${SLS_PROJECT}"
    logstore: "${SLS_LOGSTORE}"
    access_key_id: "${ALIYUN_ACCESS_KEY_ID}"
    access_key_secret: "${ALIYUN_ACCESS_KEY_SECRET}"

processors:
  batch: {}
  memory_limiter:
    check_interval: 5s # The interval at which memory usage is checked. Change the value as needed.
    limit_percentage: 80 # The maximum memory usage as a percentage. Change the value as needed.
    spike_limit_percentage: 25 # The additional memory as a percentage that is allowed for spikes. Change the value as needed.

receivers:
  otlp:
    protocols:
      grpc:
        endpoint: 0.0.0.0:4317 # The default value is localhost:4317. Change the value as needed.
      http:
        endpoint: 0.0.0.0:4318 # The default value is localhost:4318. Change the value as needed.

service:
  pipelines:
    traces:
      exporters: [otlp]
      processors: [memory_limiter, batch]
      receivers: [otlp]
    metrics:
      exporters: [otlp]
      processors: [memory_limiter, batch]
      receivers: [otlp]
    # Log data processing pipeline (optional)
    logs:
      exporters: [alibabacloud_logservice/logs]
      processors: [memory_limiter, batch]
      receivers: [otlp]

    Item de configuração do opentelemetry-collector-contrib (envio via HTTP)

    # config.yaml
exporters:
  otlphttp:
    traces_endpoint: "${HTTP_TRACES_ENDPOINT}"
    metrics_endpoint: "${HTTP_METRICS_ENDPOINT}"
    tls:
      insecure: true
    timeout: 5s # The timeout period. The default value is 5s. Change the value as needed.

  # Log exporter configuration (optional)
  alibabacloud_logservice/logs:
    endpoint: "${SLS_ENDPOINT}"
    project: "${SLS_PROJECT}"
    logstore: "${SLS_LOGSTORE}"
    access_key_id: "${ALIYUN_ACCESS_KEY_ID}"
    access_key_secret: "${ALIYUN_ACCESS_KEY_SECRET}"

processors:
  batch: {}
  memory_limiter:
    check_interval: 5s # The interval at which memory usage is checked. Change the value as needed.
    limit_percentage: 80 # The maximum memory usage as a percentage. Change the value as needed.
    spike_limit_percentage: 25 # The additional memory as a percentage that is allowed for spikes. Change the value as needed.

receivers:
  otlp:
    protocols:
      grpc:
        endpoint: 0.0.0.0:4317 # The default value is localhost:4317. Change the value as needed.
      http:
        endpoint: 0.0.0.0:4318 # The default value is localhost:4318. Change the value as needed.

service:
  pipelines:
    traces:
      exporters: [otlphttp]
      processors: [memory_limiter, batch]
      receivers: [otlp]
    metrics:
      exporters: [otlphttp]
      processors: [memory_limiter, batch]
      receivers: [otlp]
    # Log data processing pipeline (optional)
    logs:
      exporters: [alibabacloud_logservice/logs]
      processors: [memory_limiter, batch]
      receivers: [otlp]

    Etapa 3: Montar o arquivo de configuração personalizado e executar o collector

    As flags -p expõem as portas dos receivers para que suas aplicações enviem dados ao collector. Ajuste o mapeamento de portas para corresponder aos endpoints de receiver definidos no arquivo de configuração.

    opentelemetry-collector

    docker run -p 4317:4317 -p 4318:4318 -v $(pwd)/config.yaml:/etc/otelcol/config.yaml otel/opentelemetry-collector:latest

    opentelemetry-collector-contrib

    docker run -p 4317:4317 -p 4318:4318 -v $(pwd)/config.yaml:/etc/otelcol-contrib/config.yaml otel/opentelemetry-collector-contrib:latest

    Para outros métodos de implantação, consulte Outros métodos de instalação e implantação.

    Referências