Todos los productos
Search

Este producto

    ApsaraDB for ClickHouse:Exportar datos de observability de Java a Cloud Database ClickHouse Enterprise Edition

    Centro de documentos

    ApsaraDB for ClickHouse:Exportar datos de observability de Java a Cloud Database ClickHouse Enterprise Edition

    Última actualización: Sep 05, 2026

    Exporte los datos de observability desde una aplicación Java hacia Cloud Database ClickHouse Enterprise Edition y analícelos mediante el servicio ClickStack para supervisar el rendimiento de la aplicación en tiempo real y resolver incidencias con mayor rapidez.

    Requisitos previos

    Su instancia de Alibaba Cloud ClickHouse Enterprise Edition debe tener habilitado ClickStack service.

    Procedimiento

    En este ejemplo se despliegan el servicio empresarial y OpenTelemetry Collector en la misma instancia de ECS. Para entornos de producción, se recomienda desplegar el servicio empresarial y OpenTelemetry Collector por separado.

    Paso 1: Desplegar OpenTelemetry Collector

    1. Configure la instancia de ECS.

      1. Purchase an ECS instance. Se recomienda asignar una dirección IP pública durante la compra para permitir el acceso desde la red pública.

      2. Agregue la dirección IP de la instancia de ECS a la allowlist de Alibaba Cloud ClickHouse.

        • Dirección IP privada: si la instancia de ECS y la instancia de Alibaba Cloud ClickHouse Enterprise Edition se encuentran en la misma Virtual Private Cloud (VPC), agregue la dirección IP privada de la instancia de ECS a la lista de permitidos. En este caso, utilice el endpoint de VPC para la instancia de Alibaba Cloud ClickHouse en los pasos siguientes.

        • Dirección IP pública: si la instancia de ECS no puede conectarse a la instancia de Alibaba Cloud ClickHouse Enterprise Edition a través de la red privada, agregue la dirección IP pública de la instancia de ECS a la lista de permitidos. En este caso, utilice el endpoint público para la instancia de Alibaba Cloud ClickHouse en los pasos siguientes.

        Puede connect to the ECS instance y ejecutar el siguiente comando para probar la conexión a la instancia de Alibaba Cloud ClickHouse. Una respuesta Ok. indica que la conexión fue exitosa.

        curl http://cc-xxxxxxx-clickhouse.clickhouseserver.pre.rds.aliyuncs.com:8123

    2. Connect to the ECS instance y ejecute los siguientes comandos para instalar otelcol-contrib.

      mkdir llm-demo
cd llm-demo
wget -O otelcol-contrib.rpm https://github.com/open-telemetry/opentelemetry-collector-releases/releases/download/v0.136.0/otelcol-contrib_0.136.0_linux_amd64.rpm
yum install otelcol-contrib.rpm

    3. Configure OpenTelemetry Collector para recibir datos de observability mediante gRPC y HTTP, y enviarlos a la instancia de Alibaba Cloud ClickHouse a través de HTTP.

      Copie el siguiente comando y modifique la configuración según se describe:

      • En la sección receivers, se recomienda reemplazar el endpoint del receptor OTLP por el endpoint de su servicio OpenTelemetry Collector.

      • En la sección exporters:

        • Configure los detalles de conexión de su instancia de Alibaba Cloud ClickHouse, incluidos endpoint, username y password.

        • Configure los nombres de la base de datos y las tablas donde se almacenarán los datos de observability en su instancia de Alibaba Cloud ClickHouse. Esto incluye database, traces_table_name, logs_table_name y metrics_tables.

      cat > /etc/otelcol-contrib/config.yaml << EOF
receivers:
  otlp:
    protocols:
      grpc:
        endpoint: 0.0.0.0:4317
      http:
        endpoint: 0.0.0.0:4318
processors:
  batch:
    timeout: 5s
    send_batch_size: 5000
exporters:
  clickhouse:
    endpoint: http://cc-xxxxxx-clickhouse.clickhouseserver.pre.rds.aliyuncs.com:8123?dial_timeout=10s&compress=lz4&async_insert=1
    username: test
    password: password
    # ttl: 72h
    traces_table_name: otel_traces
    logs_table_name: otel_logs
    metrics_tables:
      gauge: 
        name: otel_metrics_gauge
      sum: 
        name: otel_metrics_sum
      summary: 
        name: otel_metrics_summary
      histogram: 
        name: otel_metrics_histogram
      exponential_histogram: 
        name: otel_metrics_exp_histogram
    create_schema: false
    timeout: 5s
    database: clickobserve_service
    sending_queue:
      queue_size: 1000
    retry_on_failure:
      enabled: true
      initial_interval: 5s
      max_interval: 30s
      max_elapsed_time: 300s

service:
  pipelines:
    traces:
      receivers: [otlp]
      processors: [batch]
      exporters: [clickhouse]
    metrics:
      receivers: [otlp]
      processors: [batch]
      exporters: [clickhouse]
    logs:
      receivers: [otlp]
      processors: [batch]
      exporters: [clickhouse]
EOF

    4. Inicie OpenTelemetry Collector.

      service otelcol-contrib restart

    Paso 2: Crear una aplicación Java

    Esta sección utiliza como ejemplo un servicio sencillo de lanzamiento de dados basado en Spring Boot.

    1. Configure el entorno de Java.

      1. Deploy a Java environment. Se recomienda instalar Java 17 o una versión posterior.

      2. Descargue e instale Gradle. Se recomienda instalar Gradle 8 o una versión posterior.

    2. Inicialice un proyecto de Gradle.

      En este ejemplo, el directorio se denomina java-simple. Después de la inicialización, la estructura del directorio es la siguiente:

      java-simple
├── app
│   ├── build.gradle.kts
│   └── src
│       ├── main
│       │   ├── java
│       │   │   └── org
│       │   │       └── example
│       │   │           └── App.java
│       │   └── resources
│       └── test
│           ├── java
│           │   └── org
│           │       └── example
│           │           └── AppTest.java
│           └── resources
├── gradle
│   ├── libs.versions.toml
│   └── wrapper
│       ├── gradle-wrapper.jar
│       └── gradle-wrapper.properties
├── gradle.properties
├── gradlew
├── gradlew.bat
└── settings.gradle.kts

    3. En el directorio java-simple, modifique o cree los siguientes archivos:

      build.gradle.kts

      plugins {
  id("java")
  id("org.springframework.boot") version "3.0.6"
  id("io.spring.dependency-management") version "1.1.0"
}
sourceSets {
  main {
    java.setSrcDirs(setOf("."))
  }
}
repositories {
  mavenCentral()
}
dependencies {
  implementation("org.springframework.boot:spring-boot-starter-web")
}

      App.java

      package org.example;
import org.springframework.boot.Banner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class App {
  public static void main(String[] args) {
    SpringApplication app = new SpringApplication(App.class);
    app.setBannerMode(Banner.Mode.OFF);
    app.run(args);
  }
}

      RollController.java

      package org.example;
import java.util.Optional;
import java.util.concurrent.ThreadLocalRandom;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class RollController {
  private static final Logger logger = LoggerFactory.getLogger(RollController.class);
  @GetMapping("/rolldice")
  public String index(@RequestParam("player") Optional<String> player) {
    int result = this.getRandomNumber(1, 6);
    if (player.isPresent()) {
      logger.info("{} is rolling the dice: {}", player.get(), result);
    } else {
      logger.info("Anonymous player is rolling the dice: {}", result);
    }
    return Integer.toString(result);
  }
  public int getRandomNumber(int min, int max) {
    return ThreadLocalRandom.current().nextInt(min, max + 1);
  }
}

    Paso 3: Configurar OpenTelemetry Java Agent

    1. Descargue OpenTelemetry Java Agent.

      curl -L -O https://github.com/open-telemetry/opentelemetry-java-instrumentation/releases/latest/download/opentelemetry-javaagent.jar

    2. Configure las variables de entorno.

      export JAVA_TOOL_OPTIONS="-javaagent:/../opentelemetry-javaagent.jar" \
  OTEL_TRACES_EXPORTER=otlp \
  OTEL_METRICS_EXPORTER=otlp \
  OTEL_LOGS_EXPORTER=otlp \
  OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf \
  OTEL_EXPORTER_OTLP_ENDPOINT=http://<IP_ADDRESS>:4318 \
  OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://<IP_ADDRESS>:4318/v1/traces \
  OTEL_EXPORTER_OTLP_METRICS_ENDPOINT=http://<IP_ADDRESS>:4318/v1/metrics \
  OTEL_EXPORTER_OTLP_LOGS_ENDPOINT=http://<IP_ADDRESS>:4318/v1/logs \
  OTEL_METRIC_EXPORT_INTERVAL=15000

      • JAVA_TOOL_OPTIONS: establezca esta variable con la ruta real del archivo opentelemetry-javaagent.jar.

      • Configuraciones de endpoint: en http://<IP_ADDRESS>:4318, reemplace <IP_ADDRESS> por la dirección IP del endpoint del servicio Otel Collector al que su aplicación Java pueda acceder.

      • Para obtener información sobre otros parámetros, consulte properties-exporters.

    Paso 4: Iniciar y acceder a la aplicación Java

    1. En el directorio de la aplicación del proyecto, ejecute los siguientes comandos para iniciar la aplicación.

      En este ejemplo, el directorio de la aplicación del proyecto es ../java-simple/app.

      gradle assemble
java -jar ./build/libs/app.jar

    2. En su navegador, acceda a http://<IP_ADDRESS>:8080/rolldice. Reemplace <IP_ADDRESS> por la dirección IP del servidor donde se ejecuta la aplicación Java.

      Tras una solicitud exitosa, la página devuelve un número aleatorio, como se muestra en el siguiente ejemplo:

      5

    Paso 5: Consultar y analizar los datos de observability

    1. En el panel de navegación izquierdo de la página de detalles de la instancia de Cloud Database ClickHouse, haga clic en ClickStack y siga las instrucciones en pantalla para abrir el portal del servicio.

    2. En la página principal, consulte y analice los datos de observability de su aplicación Java.

      En la página Search de HyperDX, configure el origen de datos como otel_traces. Introduzca la consulta SQL SELECT Timestamp, ServiceName as service, StatusCode as level, round(Duration / 1e6) as duration, SpanName y establezca el orden de clasificación como Timestamp DESC. En el panel izquierdo Filters, filtre por SpanName (por ejemplo, GET /rolldice o PUBLISH) y por ServiceName (por ejemplo, app o langgenius/dify). La tabla de resultados, que incluye columnas como Timestamp, service, level, duration y SpanName, muestra los detalles de latencia de los spans entre servicios.