Einführung

Application Performance Management (APM) ist entscheidend für die Überwachung und Verwaltung der Leistung und Verfügbarkeit von Softwareanwendungen. Pinpoint ist ein Open-Source-APM-Tool, das umfassende Einblicke in die Leistung und Zuverlässigkeit von Anwendungen bietet. Es wurde entwickelt, um große verteilte Systeme zu überwachen und liefert Echtzeit-Leistungsmetriken, Tracing und detaillierte Visualisierungen.

Dieser Leitfaden bietet eine Schritt-für-Schritt-Anleitung zur Implementierung von Pinpoint APM für eine Node.js-Anwendung, einschließlich der Einrichtung des Servers, der Installation von Docker, der Bereitstellung von Pinpoint und dessen Integration in die Node.js-Anwendung.

Über Pinpoint

Pinpoint ist ein leistungsstarkes APM-Tool, das hilft, die Anwendungsleistung zu verstehen und Probleme aufzuspüren. Es unterstützt eine Vielzahl von Technologien und bietet Funktionen wie:

• Echtzeit-Anwendungsüberwachung
• Verteiltes Tracing
• Visualisierung der Anwendungstopologie
• Warnungen und Benachrichtigungen
• Detaillierte Transaktionsanalyse

Server einrichten:

Wir müssen einen neuen Server mit mindestens 2vCPU und 4GB RAM starten.

Docker Engine installieren

sudo apt-get update

sudo apt-get install docker-ce docker-ce-cli containerd.io

Docker Compose installieren

Laden Sie die Docker Compose Binärdatei in das Verzeichnis /usr/local/bin herunter:

sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

Ausführungsberechtigungen auf die Binärdatei anwenden

sudo chmod +x /usr/local/bin/docker-compose

Installation überprüfen:

docker --version

docker-compose --version

‍
Pinpoint mit Docker bereitstellen

Das Git-Repository klonen:

git clone https://github.com/pinpoint-apm/pinpoint-docker.git

cd pinpoint-docker

sudo docker-compose pull && docker-compose up -d
‍

HINWEIS:
Sollte die obige docker-compose.yml nicht funktionieren, verwenden Sie bitte die folgende YML-Datei, um Docker zu starten.

version: "3.6"

services:

  pinpoint-hbase:

    build:

      context: ./pinpoint-hbase/

      dockerfile: Dockerfile

      args:

        - PINPOINT_VERSION=${PINPOINT_VERSION}

    container_name: "${PINPOINT_HBASE_NAME}"

    image: "pinpointdocker/pinpoint-hbase:${PINPOINT_VERSION}"

    networks:

      - pinpoint

    environment:

      - AGENTINFO_TTL=${AGENTINFO_TTL}

      - AGENTSTATV2_TTL=${AGENTSTATV2_TTL}

      - APPSTATAGGRE_TTL=${APPSTATAGGRE_TTL}

      - APPINDEX_TTL=${APPINDEX_TTL}

      - AGENTLIFECYCLE_TTL=${AGENTLIFECYCLE_TTL}

      - AGENTEVENT_TTL=${AGENTEVENT_TTL}

      - STRINGMETADATA_TTL=${STRINGMETADATA_TTL}

      - APIMETADATA_TTL=${APIMETADATA_TTL}

      - SQLMETADATA_TTL=${SQLMETADATA_TTL}

      - TRACEV2_TTL=${TRACEV2_TTL}

      - APPTRACEINDEX_TTL=${APPTRACEINDEX_TTL}

      - APPMAPSTATCALLERV2_TTL=${APPMAPSTATCALLERV2_TTL}

      - APPMAPSTATCALLEV2_TTL=${APPMAPSTATCALLEV2_TTL}

      - APPMAPSTATSELFV2_TTL=${APPMAPSTATSELFV2_TTL}

      - HOSTAPPMAPV2_TTL=${HOSTAPPMAPV2_TTL}

    volumes:

      - hbase_data:/home/pinpoint/hbase

      - /home/pinpoint/zookeeper

    expose:

      # API-Port des HBase Masters

      - "60000"

      # Web-UI des HBase Masters

      - "16010"

      # API-Port des Regionservers

      - "60020"

      # Web-UI des HBase Regionservers

      - "16030"

    ports:

      - "60000:60000"

      - "16010:16010"

      - "60020:60020"

      - "16030:16030"

    restart: immer

    depends_on:

      - zoo1

‍

  pinpoint-mysql:

    container_name: pinpoint-mysql

    image: mysql:8.0

    restart: "no"

    hostname: pinpoint-mysql

    entrypoint: > 

      sh -c "

      curl -SL "https://raw.githubusercontent.com/ga-ram/pinpoint/latest/web/src/main/resources/sql/CreateTableStatement-mysql.sql" -o /docker-entrypoint-initdb.d/CreateTableStatement-mysql.sql &&

      curl -SL "https://raw.githubusercontent.com/ga-ram/pinpoint/latest/web/src/main/resources/sql/SpringBatchJobRepositorySchema-mysql.sql" -o /docker-entrypoint-initdb.d/SpringBatchJobRepositorySchema-mysql.sql &&

      sed -i '/^--/d' /docker-entrypoint-initdb.d/CreateTableStatement-mysql.sql &&

      sed -i '/^--/d' /docker-entrypoint-initdb.d/SpringBatchJobRepositorySchema-mysql.sql &&

      docker-entrypoint.sh mysqld

      "

    ports:

      - "3306:3306"

    environment:

      - MYSQL_ROOT_PASSWORD=${MYSQL_ROOT_PASSWORD}

      - MYSQL_USER=${MYSQL_USER}

      - MYSQL_PASSWORD=${MYSQL_PASSWORD}

      - MYSQL_DATABASE=${MYSQL_DATABASE}

    volumes:

      - mysql_data:/var/lib/mysql

    networks:

      - pinpoint

‍

  pinpoint-web:

    build:

      context: ./pinpoint-web/

      dockerfile: Dockerfile

      args:

        - PINPOINT_VERSION=${PINPOINT_VERSION}

    container_name: "${PINPOINT_WEB_NAME}"

    image: "pinpointdocker/pinpoint-web:${PINPOINT_VERSION}"

    depends_on:

      - pinpoint-hbase

      - pinpoint-mysql

      - zoo1

      - redis

    restart: always

    expose:

      - "9997"

    ports:

      - "9997:9997"

      - "${WEB_SERVER_PORT:-8080}:8080"

    environment:

      - WEB_SERVER_PORT=${WEB_SERVER_PORT}

      - SPRING_PROFILES_ACTIVE=${SPRING_PROFILES}

      - PINPOINT_ZOOKEEPER_ADDRESS=${PINPOINT_ZOOKEEPER_ADDRESS}

      - CLUSTER_ENABLE=${CLUSTER_ENABLE}

      - ADMIN_PASSWORD=${ADMIN_PASSWORD}

      - CONFIG_SENDUSAGE=${CONFIG_SENDUSAGE}

      - LOGGING_LEVEL_ROOT=${WEB_LOGGING_LEVEL_ROOT}

      - CONFIG_SHOW_APPLICATIONSTAT=${CONFIG_SHOW_APPLICATIONSTAT}

      - JDBC_DRIVERCLASSNAME=${JDBC_DRIVERCLASSNAME}

      - JDBC_URL=${SPRING_DATASOURCE_HIKARI_JDBCURL}

      - JDBC_USERNAME=${SPRING_DATASOURCE_HIKARI_USERNAME}

      - JDBC_PASSWORD=${SPRING_DATASOURCE_HIKARI_PASSWORD}

      - SPRING_DATASOURCE_HIKARI_JDBCURL=${SPRING_DATASOURCE_HIKARI_JDBCURL}

      - SPRING_DATASOURCE_HIKARI_USERNAME=${SPRING_DATASOURCE_HIKARI_USERNAME}

      - SPRING_DATASOURCE_HIKARI_PASSWORD=${SPRING_DATASOURCE_HIKARI_PASSWORD}

      - SPRING_METADATASOURCE_HIKARI_JDBCURL=${SPRING_METADATASOURCE_HIKARI_JDBCURL}

      - SPRING_METADATASOURCE_HIKARI_USERNAME=${SPRING_METADATASOURCE_HIKARI_USERNAME}

      - SPRING_METADATASOURCE_HIKARI_PASSWORD=${SPRING_METADATASOURCE_HIKARI_PASSWORD}

      - SPRING_DATA_REDIS_HOST=${SPRING_DATA_REDIS_HOST}

      - SPRING_DATA_REDIS_PORT=${SPRING_DATA_REDIS_PORT}

      - SPRING_DATA_REDIS_USERNAME=${SPRING_DATA_REDIS_USERNAME}

      - SPRING_DATA_REDIS_PASSWORD=${SPRING_DATA_REDIS_PASSWORD}

    links:

      - "pinpoint-mysql:pinpoint-mysql"

    networks:

      - pinpoint

  pinpoint-collector:

    build:

      context: ./pinpoint-collector/

      dockerfile: Dockerfile

      args:

        - PINPOINT_VERSION=${PINPOINT_VERSION}

    container_name: "${PINPOINT_COLLECTOR_NAME}"

    image: "pinpointdocker/pinpoint-collector:${PINPOINT_VERSION}"

    depends_on:

      - pinpoint-hbase

      - zoo1

      - redis

    restart: always

    expose:

      - "9991"

      - "9992"

      - "9993"

      - "9994"

      - "9995"

      - "9996"

    ports:

      - "${COLLECTOR_RECEIVER_GRPC_AGENT_PORT:-9991}:9991/tcp"

      - "${COLLECTOR_RECEIVER_GRPC_STAT_PORT:-9992}:9992/tcp"

      - "${COLLECTOR_RECEIVER_GRPC_SPAN_PORT:-9993}:9993/tcp"

      - "${COLLECTOR_RECEIVER_BASE_PORT:-9994}:9994"

      - "${COLLECTOR_RECEIVER_STAT_UDP_PORT:-9995}:9995/tcp"

      - "${COLLECTOR_RECEIVER_SPAN_UDP_PORT:-9996}:9996/tcp"

      - "${COLLECTOR_RECEIVER_STAT_UDP_PORT:-9995}:9995/udp"

      - "${COLLECTOR_RECEIVER_SPAN_UDP_PORT:-9996}:9996/udp"

    networks:

      pinpoint:

        ipv4_address: ${COLLECTOR_FIXED_IP}

    environment:

      - SPRING_PROFILES_ACTIVE=${SPRING_PROFILES}

      - PINPOINT_ZOOKEEPER_ADDRESS=${PINPOINT_ZOOKEEPER_ADDRESS}

      - CLUSTER_ENABLE=${CLUSTER_ENABLE}

      - LOGGING_LEVEL_ROOT=${COLLECTOR_LOGGING_LEVEL_ROOT}

      - FLINK_CLUSTER_ENABLE=${FLINK_CLUSTER_ENABLE}

      - FLINK_CLUSTER_ZOOKEEPER_ADDRESS=${FLINK_CLUSTER_ZOOKEEPER_ADDRESS}

      - SPRING_DATA_REDIS_HOST=${SPRING_DATA_REDIS_HOST}

      - SPRING_DATA_REDIS_PORT=${SPRING_DATA_REDIS_PORT}

      - SPRING_DATA_REDIS_USERNAME=${SPRING_DATA_REDIS_USERNAME}

      - SPRING_DATA_REDIS_PASSWORD=${SPRING_DATA_REDIS_PASSWORD}

  pinpoint-quickstart:

    build:

      context: ./pinpoint-quickstart/

      dockerfile: Dockerfile

    container_name: "pinpoint-quickstart"

    image: "pinpointdocker/pinpoint-quickstart"

    ports:

      - "${APP_PORT:-8085}:8080"

    volumes:

      - data-volume:/pinpoint-agent

    environment:

      JAVA_OPTS: "-javaagent:/pinpoint-agent/pinpoint-bootstrap.jar -Dpinpoint.agentId=${AGENT_ID} -Dpinpoint.applicationName=${APP_NAME} -Dpinpoint.profiler.profiles.active=${SPRING_PROFILES}"

    networks:

      - pinpoint

    depends_on:

      - pinpoint-agent

  pinpoint-batch:

    build:

      context: ./pinpoint-batch/

      dockerfile: Dockerfile

      args:

        - PINPOINT_VERSION=${PINPOINT_VERSION}

    container_name: "${PINPOINT_BATCH_NAME}"

    image: "pinpointdocker/pinpoint-batch:${PINPOINT_VERSION}"

    depends_on:

      - pinpoint-hbase

      - pinpoint-mysql

      - zoo1

    restart: always

    environment:

      - BATCH_SERVER_PORT=${BATCH_SERVER_PORT}

      - SPRING_PROFILES_ACTIVE=${SPRING_PROFILES}

      - PINPOINT_ZOOKEEPER_ADDRESS=${PINPOINT_ZOOKEEPER_ADDRESS}

      - CLUSTER_ENABLE=${CLUSTER_ENABLE}

      - ADMIN_PASSWORD=${ADMIN_PASSWORD}

      - CONFIG_SENDUSAGE=${CONFIG_SENDUSAGE}

      - LOGGING_LEVEL_ROOT=${BATCH_LOGGING_LEVEL_ROOT}

      - CONFIG_SHOW_APPLICATIONSTAT=${CONFIG_SHOW_APPLICATIONSTAT}

      - BATCH_FLINK_SERVER=${BATCH_FLINK_SERVER}

      - JDBC_DRIVERCLASSNAME=${JDBC_DRIVERCLASSNAME}

      - JDBC_URL=${SPRING_DATASOURCE_HIKARI_JDBCURL}

      - JDBC_USERNAME=${SPRING_DATASOURCE_HIKARI_USERNAME}

      - JDBC_PASSWORD=${SPRING_DATASOURCE_HIKARI_PASSWORD}

      - SPRING_DATASOURCE_HIKARI_JDBCURL=${SPRING_DATASOURCE_HIKARI_JDBCURL}

      - SPRING_DATASOURCE_HIKARI_USERNAME=${SPRING_DATASOURCE_HIKARI_USERNAME}

      - SPRING_DATASOURCE_HIKARI_PASSWORD=${SPRING_DATASOURCE_HIKARI_PASSWORD}

      - SPRING_METADATASOURCE_HIKARI_JDBCURL=${SPRING_METADATASOURCE_HIKARI_JDBCURL}

      - SPRING_METADATASOURCE_HIKARI_USERNAME=${SPRING_METADATASOURCE_HIKARI_USERNAME}

      - SPRING_METADATASOURCE_HIKARI_PASSWORD=${SPRING_METADATASOURCE_HIKARI_PASSWORD}

      - ALARM_MAIL_SERVER_URL=${ALARM_MAIL_SERVER_URL}

      - ALARM_MAIL_SERVER_PORT=${ALARM_MAIL_SERVER_PORT}

      - ALARM_MAIL_SERVER_USERNAME=${ALARM_MAIL_SERVER_USERNAME}

      - ALARM_MAIL_SERVER_PASSWORD=${ALARM_MAIL_SERVER_PASSWORD}

      - ALARM_MAIL_SENDER_ADDRESS=${ALARM_MAIL_SENDER_ADDRESS}

      - ALARM_MAIL_TRANSPORT_PROTOCOL=${ALARM_MAIL_TRANSPORT_PROTOCOL}

      - ALARM_MAIL_SMTP_PORT=${ALARM_MAIL_SMTP_PORT}

      - ALARM_MAIL_SMTP_AUTH=${ALARM_MAIL_SMTP_AUTH}

      - ALARM_MAIL_SMTP_STARTTLS_ENABLE=${ALARM_MAIL_SMTP_STARTTLS_ENABLE}

      - ALARM_MAIL_SMTP_STARTTLS_REQUIRED=${ALARM_MAIL_SMTP_STARTTLS_REQUIRED}

      - ALARM_MAIL_DEBUG=${ALARM_MAIL_DEBUG}

    links:

      - "pinpoint-mysql:pinpoint-mysql"

    networks:

      - pinpoint

  pinpoint-agent:

    build:

      context: ./pinpoint-agent/

      dockerfile: Dockerfile

      args:

        - PINPOINT_VERSION=${PINPOINT_VERSION}

    container_name: "${PINPOINT_AGENT_NAME}"

    image: "pinpointdocker/pinpoint-agent:${PINPOINT_VERSION}"

    restart: unless-stopped

    networks:

      - pinpoint

    volumes:

      - data-volume:/pinpoint-agent

    environment:

      - SPRING_PROFILES=${SPRING_PROFILES}

      - COLLECTOR_IP=${COLLECTOR_IP}

      - PROFILER_TRANSPORT_AGENT_COLLECTOR_PORT=${PROFILER_TRANSPORT_AGENT_COLLECTOR_PORT}

      - PROFILER_TRANSPORT_METADATA_COLLECTOR_PORT=${PROFILER_TRANSPORT_METADATA_COLLECTOR_PORT}

      - PROFILER_TRANSPORT_STAT_COLLECTOR_PORT=${PROFILER_TRANSPORT_STAT_COLLECTOR_PORT}

      - PROFILER_TRANSPORT_SPAN_COLLECTOR_PORT=${PROFILER_TRANSPORT_SPAN_COLLECTOR_PORT}

      - PROFILER_SAMPLING_TYPE=${PROFILER_SAMPLING_TYPE}

      - PROFILER_SAMPLING_COUNTING_SAMPLING_RATE=${PROFILER_SAMPLING_COUNTING_SAMPLING_RATE}

      - PROFILER_SAMPLING_PERCENT_SAMPLING_RATE=${PROFILER_SAMPLING_PERCENT_SAMPLING_RATE}

      - PROFILER_SAMPLING_NEW_THROUGHPUT=${PROFILER_SAMPLING_NEW_THROUGHPUT}

      - PROFILER_SAMPLING_CONTINUE_THROUGHPUT=${PROFILER_SAMPLING_CONTINUE_THROUGHPUT}

      - DEBUG_LEVEL=${AGENT_DEBUG_LEVEL}

      - PROFILER_TRANSPORT_MODULE=${PROFILER_TRANSPORT_MODULE}

    depends_on:

      - pinpoint-collector

  #zookeepers

  zoo1:

    image: zookeeper:3.4.13

    restart: always

    hostname: zoo1

    expose:

      - "2181"

      - "2888"

      - "3888"

    ports:

      - "2181"

    environment:

      ZOO_MY_ID: 1

      ZOO_SERVERS: server.1=0.0.0.0:2888:3888 server.2=zoo2:2888:3888 server.3=zoo3:2888:3888

    networks:

      - pinpoint

  zoo2:

    image: zookeeper:3.4.13

    restart: always

    hostname: zoo2

    expose:

      - "2181"

      - "2888"

      - "3888"

    ports:

      - "2181"

    environment:

      ZOO_MY_ID: 2

      ZOO_SERVERS: server.1=zoo1:2888:3888 server.2=0.0.0.0:2888:3888 server.3=zoo3:2888:3888

    networks:

      - pinpoint

  zoo3:

    image: zookeeper:3.4.13

    restart: always

    hostname: zoo3

    expose:

      - "2181"

      - "2888"

      - "3888"

    ports:

      - "2181"

    environment:

      ZOO_MY_ID: 3

      ZOO_SERVERS: server.1=zoo1:2888:3888 server.2=zoo2:2888:3888 server.3=0.0.0.0:2888:3888

    networks:

      - pinpoint

  ##flink

  jobmanager:

    build:

      context: pinpoint-flink

      dockerfile: Dockerfile

      args:

        - PINPOINT_VERSION=${PINPOINT_VERSION}

    container_name: "${PINPOINT_FLINK_NAME}-jobmanager"

    image: "pinpointdocker/pinpoint-flink:${PINPOINT_VERSION}"

    expose:

      - "6123"

    ports:

      - "${FLINK_WEB_PORT:-8081}:8081"

    command: standalone-job -p 1 pinpoint-flink-job.jar -spring.profiles.active release

    environment:

      - JOB_MANAGER_RPC_ADDRESS=jobmanager

      - PINPOINT_ZOOKEEPER_ADDRESS=${PINPOINT_ZOOKEEPER_ADDRESS}

    networks:

      - pinpoint

    depends_on:

      - zoo1

  taskmanager:

    build:

      context: pinpoint-flink

      dockerfile: Dockerfile

      args:

        - PINPOINT_VERSION=${PINPOINT_VERSION}

    container_name: "${PINPOINT_FLINK_NAME}-taskmanager"

    image: "pinpointdocker/pinpoint-flink:${PINPOINT_VERSION}"

    expose:

      - "6121"

      - "6122"

      - "19994"

    ports:

      - "6121:6121"

      - "6122:6122"

      - "19994:19994"

    depends_on:

      - zoo1

      - jobmanager

    command: taskmanager

    links:

      - "jobmanager:jobmanager"

    environment:

      - JOB_MANAGER_RPC_ADDRESS=jobmanager

    networks:

      - pinpoint

  redis:

    image: redis:7.0.14

    restart: always

    hostname: pinpoint-redis

    ports:

      - "6379:6379"

    networks:

      - pinpoint

volumes:

  data-volume:

  mysql_data:

  hbase_data:

networks:

  pinpoint:

    driver: bridge

    ipam:

      config:

        - Subnetz: ${PINPOINT_NETWORK_SUBNET}

Die Erklärung der Komponenten, die wir in den docker-compose YAML-Dateien verwendet haben
‍
1. Services

Services sind die einzelnen Container, aus denen die Anwendung besteht. Jeder Service läuft in seinem eigenen Container, kann aber mit anderen Services interagieren, die in derselben docker-compose.yml-Datei definiert sind.

a. pinpoint-hbase

• Zweck: Pinpoint verwendet HBase als primären Speicher zum Speichern von Tracing-Daten.
• Build: Der Service wird aus einem Dockerfile erstellt, das sich im Verzeichnis ./pinpoint-hbase/ befindet.
• Umgebungsvariablen: Diese Variablen definieren verschiedene TTL (Time-to-Live)-Einstellungen für verschiedene Arten von Daten, die in HBase gespeichert sind.
• Volumes: Persistenter Speicher für HBase-Daten wird auf dem Host gemountet, um die Datenpersistenz über Container-Neustarts hinweg zu gewährleisten.
• Ports: Der Service stellt mehrere Ports für die Kommunikation bereit (60000, 16010, 60020, 16030).
• Depends_on: Dies stellt sicher, dass der zoo1 (Zookeeper)-Service vor pinpoint-hbase startet.

b. pinpoint-mysql

• Zweck: MySQL wird zur Speicherung von Anwendungsmetadaten und anderen relationalen Daten verwendet, die von Pinpoint benötigt werden.
• Image: Es wird ein MySQL 8.0 Image von Docker Hub verwendet.
• Umgebungsvariablen: Dazu gehören MySQL-Anmeldeinformationen wie Root-Passwort, Benutzer, Passwort und Datenbankname.
• Volumes: Persistenter Speicher für MySQL-Daten wird auf dem Host gemountet.
• Ports: Der MySQL-Dienst wird auf Port 3306 freigegeben.

c. pinpoint-web

• Zweck: Dies ist die Web-Benutzeroberfläche für Pinpoint, die es Benutzern ermöglicht, die Tracing-Daten zu visualisieren und zu analysieren.
• Build: Der Dienst wird aus einem Dockerfile im Verzeichnis ./pinpoint-web/ erstellt.
• Abhängigkeiten: Dies stellt sicher, dass die Dienste pinpoint-hbase, pinpoint-mysql, zoo1 und redis laufen, bevor der Webdienst gestartet wird.
• Umgebungsvariablen: Diese konfigurieren den Webdienst, einschließlich Datenbankverbindungen, Logging-Levels und anderer Eigenschaften.
• Ports: Der Dienst gibt Port 9997 für die Weboberfläche frei.

d. pinpoint-collector

• Zweck: Der Collector-Dienst sammelt Trace-Daten von Anwendungen und speichert sie in HBase.
• Erstellung: Der Dienst wird aus einem Dockerfile erstellt, das sich im Verzeichnis ./pinpoint-collector/ befindet.
• Abhängigkeiten: Dies stellt sicher, dass die Dienste pinpoint-hbase, zoo1 und redis laufen, bevor der Collector gestartet wird.
• Umgebungsvariablen: Diese konfigurieren den Collector-Dienst, einschließlich seiner Verbindung zu HBase, Zookeeper und der Protokollierungsstufen.
• Ports: Der Collector stellt mehrere Ports (9991-9996) für verschiedene Kommunikationsarten (gRPC, UDP usw.) bereit.
• Netzwerke: Der Collector-Dienst ist Teil des Pinpoint-Netzwerks und verwendet eine feste IP-Adresse.

e. zoo1

• Zweck: Zookeeper wird zur Verwaltung und Koordination der verteilten Komponenten von Pinpoint eingesetzt.
• Image: Ein Zookeeper-Image (3.4.14) von Docker Hub wird verwendet.
• Umgebungsvariablen: Diese konfigurieren die Zookeeper-Instanz.
• Ports: Der Dienst ist für die Zookeeper-Kommunikation auf Port 2181 verfügbar.

f. redis

• Zweck: Redis wird als Caching-Schicht für Pinpoint verwendet, um die Leistung zu verbessern.
• Image: Es wird ein Redis-Image (5.0.6) von Docker Hub verwendet.
• Ports: Der Redis-Dienst ist auf Port 6379 verfügbar.

2. Netzwerke

Netzwerke ermöglichen die Kommunikation der Dienste untereinander. In dieser docker-compose.yml ist ein benutzerdefiniertes Bridge-Netzwerk namens pinpoint definiert.

• pinpoint: Dies ist ein benutzerdefiniertes Bridge-Netzwerk, das allen Diensten die Kommunikation untereinander in einem privaten Netzwerk ermöglicht. Jeder Dienst kann andere über deren Dienstnamen erreichen.

3. Volumes

Volumes bieten persistenten Speicher, der Container-Neustarts überdauert. Sie werden verwendet, um von Diensten (wie Datenbanken) generierte Daten zu speichern.

• hbase_data: Ein Volume zum Speichern von HBase-Daten.
• mysql_data: Ein Volume zum Speichern von MySQL-Daten.

4. Umgebungsvariablen

Umgebungsvariablen werden zur Laufzeit zur Konfiguration der Dienste verwendet. Dazu können Datenbankzugangsdaten, Logging-Stufen, Ports und andere Konfigurationsdetails gehören. Jeder Dienst definiert seinen eigenen Satz von Umgebungsvariablen, zugeschnitten auf seine spezifischen Anforderungen.

5. Ports

Ports werden freigegeben, um externen Zugriff auf die Dienste zu ermöglichen. Zum Beispiel:

• 3306:3306 für MySQL
• 9997:9997 für die Pinpoint Web-UI
• 6379:6379 für Redis

6. Neustartrichtlinien

Neustartrichtlinien (restart: always) stellen sicher, dass die Container automatisch neu gestartet werden, wenn sie anhalten oder abstürzen. Dies trägt dazu bei, die hohe Verfügbarkeit der Dienste aufrechtzuerhalten.

7. Links

Links ermöglichen Containern die Kommunikation untereinander mittels Hostnamen. In dieser docker-compose.yml sind die Dienste pinpoint-web und pinpoint-collector mit dem Dienst pinpoint-mysql verknüpft, um die Datenbankkommunikation zu erleichtern.

8. Expose vs. Ports

• Expose: Dies ermöglicht Containern die interne Kommunikation untereinander, ohne die Ports der Hostmaschine freizugeben.
• Ports: Diese bilden die Container-Ports auf die Hostmaschine ab, wodurch externer Zugriff auf die Dienste ermöglicht wird.

Anschließend müssen die folgenden Ports auf die Whitelist gesetzt werden 8080, 80 und 443  in den Sicherheitsgruppen.

Das Dashboard ist unten zu sehen.

Pinpoint in die Node.js-Anwendung integrieren:

Wir müssen den Pinpoint-Agenten in die Node.js-Anwendung importieren.
Befehle, die nach dem Import des Pinpoint-Agenten ausgeführt werden sollen:

Installation mit npm:

npm install --save pinpoint-node-agent

Installation mit yarn:

yarn add pinpoint-node-agent

Code hinzufügen:

Um den Pinpoint-Agenten für Anwendungen auszuführen, müssen wir zunächst sicherstellen, dass die Voraussetzungen erfüllt sind.

CommonJS

require('pinpoint-node-agent')

Wenn wir pm2 verwenden, nutzen Sie node-args (CLI) oder node_args (Ecosystem-Datei).

module.exports = {

  apps : [{

    name: "app",

    script: "./app.js",

    'node_args': ['-r', 'pinpoint-node-agent']

  }]

}

Nachfolgend das beigefügte Beispiel:

Mit Umgebungsvariablen konfigurieren und die Anwendung starten

‍
Basierend auf der Datei pinpoint-config-default.json auf dem Server werden nur die notwendigen Teile als Umgebungsvariablen festgelegt.

PINPOINT_AGENT_ID=${HOSTNAME} PINPOINT_APPLICATION_NAME=Test-Node-App PINPOINT_COLLECTOR_IP=<pinpoint server private-ip> PINPOINT_ENABLE=true pm2 start ~/application path/app.js

Sobald die Anwendung läuft, überprüfen Sie die Seite. Die Ausgabe ist nachfolgend dargestellt.

Fazit

Durch Befolgen dieser Schritte konnten wir Pinpoint APM erfolgreich einrichten, um unsere Node.js-Anwendung zu überwachen. Mit Pinpoint erhalten wir tiefe Einblicke in die Leistung unserer Anwendung, können Engpässe identifizieren und unseren Code optimieren, um eine reibungslose und effiziente Benutzererfahrung zu gewährleisten. Die Echtzeitüberwachung und die umfassenden Tracing-Funktionen von Pinpoint machen es zu einem unschätzbaren Werkzeug für die Verwaltung der Leistung unserer Anwendungen.
‍

Referenzen

‍
https://github.com/pinpoint-apm

https://github.com/pinpoint-apm/pinpoint

https://github.com/pinpoint-apm/pinpoint-node-agent

https://www.baeldung.com/ops/pinpoint-intro