Exporter les données d'observabilité Java vers Cloud Database ClickHouse Enterprise Edition - ApsaraDB for ClickHouse

Exportez les données d'observabilité d'une application Java vers Cloud Database ClickHouse Enterprise Edition et analysez-les via le service d'observabilité tout-en-un pour surveiller les performances de l'application en temps réel et résoudre les problèmes plus rapidement.

Prérequis

Le service d'observabilité tout-en-un doit être activé sur votre instance Alibaba Cloud ClickHouse Enterprise Edition.

Procédure

Cet exemple déploie le service métier et OpenTelemetry Collector sur la même instance ECS. Pour les environnements de production, nous vous recommandons de déployer le service métier et OpenTelemetry Collector séparément.

Étape 1 : Déployer OpenTelemetry Collector

Configurez l'instance ECS.
1. Achetez une instance ECS. Nous vous recommandons d'attribuer une adresse IP publique lors de l'achat pour permettre l'accès au réseau public.
2. Ajoutez l'adresse IP de l'instance ECS à la liste d'autorisation de Alibaba Cloud ClickHouse.
  - Adresse IP privée : si l'instance ECS et l'instance Alibaba Cloud ClickHouse Enterprise Edition se trouvent dans le même Virtual Private Cloud (VPC), ajoutez l'adresse IP privée de l'instance ECS à la liste d'autorisation. Dans ce cas, utilisez l'endpoint VPC de l'instance Alibaba Cloud ClickHouse dans les étapes suivantes.
  - Adresse IP publique : si l'instance ECS ne peut pas se connecter à l'instance Alibaba Cloud ClickHouse Enterprise Edition via le réseau privé, ajoutez l'adresse IP publique de l'instance ECS à la liste d'autorisation. Dans ce cas, utilisez l'endpoint public de l'instance Alibaba Cloud ClickHouse dans les étapes suivantes.
  Connectez-vous à l'instance ECS et exécutez la commande suivante pour tester la connexion à l'instance Alibaba Cloud ClickHouse. Une réponse Ok. indique que la connexion a réussi.
```
curl http://cc-xxxxxxx-clickhouse.clickhouseserver.pre.rds.aliyuncs.com:8123
```

Connectez-vous à l'instance ECS et exécutez les commandes suivantes pour installer 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

Configurez OpenTelemetry Collector pour recevoir les données d'observabilité via gRPC et HTTP, et les envoyer à l'instance Alibaba Cloud ClickHouse via HTTP.

Copiez la commande suivante et modifiez la configuration comme décrit ci-dessous :

Dans la section receivers, nous vous recommandons de remplacer l'endpoint du récepteur OTLP par l'endpoint de votre service OpenTelemetry Collector.
Dans la section exporters :
- Configurez les détails de connexion de votre instance Alibaba Cloud ClickHouse, y compris l'endpoint, le username et le password.
- Configurez les noms de la base de données et des tables destinées à stocker les données d'observabilité dans votre instance Alibaba Cloud ClickHouse. Cela inclut database, traces_table_name, logs_table_name et 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

Démarrez OpenTelemetry Collector.
```
service otelcol-contrib restart
```

Étape 2 : Créer une application Java

Cette section utilise un simple service de lancer de dés Spring Boot comme exemple.

Configurez l'environnement Java.
1. Déployez un environnement Java. Nous vous recommandons d'installer Java 17 ou une version ultérieure.
2. Téléchargez et installez Gradle. Nous vous recommandons d'installer Gradle 8 ou une version ultérieure.

Initialisez un projet Gradle.

Dans cet exemple, le répertoire est nommé java-simple. Après l'initialisation, la structure des répertoires est la suivante :

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

Dans le répertoire java-simple, modifiez ou créez les fichiers suivants :

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);
  }
}

Étape 3 : Configurer l'agent Java OpenTelemetry

Téléchargez l'agent Java OpenTelemetry.

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

Configurez les variables d'environnement.

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 : définissez cette variable sur le chemin réel du fichier opentelemetry-javaagent.jar.
Configurations des endpoints : dans http://<IP_ADDRESS>:4318, remplacez <IP_ADDRESS> par l'adresse IP de l'endpoint du service Otel Collector accessible depuis votre application Java.
Pour plus d'informations sur les autres paramètres, consultez properties-exporters.

Étape 4 : Démarrer et accéder à l'application Java

Dans le répertoire de l'application du projet, exécutez les commandes suivantes pour démarrer l'application.

Dans cet exemple, le répertoire de l'application du projet est ../java-simple/app.
```
gradle assemble
java -jar ./build/libs/app.jar
```
Dans votre navigateur, accédez à http://<IP_ADDRESS>:8080/rolldice. Remplacez <IP_ADDRESS> par l'adresse IP du serveur exécutant l'application Java.

Après une requête réussie, la page renvoie un nombre aléatoire, comme illustré dans l'exemple suivant :
```
5
```

Étape 5 : Interroger et analyser les données d'observabilité

Dans le volet de navigation de gauche de la page des détails de l'instance Cloud Database ClickHouse, cliquez sur All-in-one Observe Suite et suivez les instructions à l'écran pour ouvrir le portail de service.
Sur la page principale, interrogez et analysez les données d'observabilité de votre application Java.

Sur la page Search dans HyperDX, définissez la source de données sur otel_traces. Saisissez la requête SQL SELECT Timestamp, ServiceName as service, StatusCode as level, round(Duration / 1e6) as duration, SpanName et définissez l'ordre de tri sur Timestamp DESC. Dans le panneau Filters à gauche, filtrez par SpanName (par exemple, GET /rolldice ou PUBLISH) et ServiceName (par exemple, app ou langgenius/dify). Le tableau de résultats, qui comprend des colonnes telles que Timestamp, service, level, duration et SpanName, affiche les détails de latence des spans entre les services.