Echtzeit-App-Leistungsüberwachung mit Apache Pinot

Einführung

In der heutigen schnelllebigen Softwareentwicklungsumgebung ist die Gewährleistung einer optimalen Anwendungsleistung von entscheidender Bedeutung. Durch die Überwachung von Echtzeitmetriken wie Reaktionszeiten, Fehlerraten und Ressourcenauslastung können eine hohe Verfügbarkeit aufrechterhalten und ein nahtloses Benutzererlebnis geliefert werden. Apache Pinot, ein Open-Source-OLAP-Datentore, bietet die Möglichkeit, Echtzeitdatenaufnahme und Abfragen mit geringer Latenz zu bewältigen. In diesem Artikel werden wir untersuchen, wie ein Echtzeit-Überwachungssystem implementiert wird, das ein Echtzeit-Überwachungssystem mithilfe von Apache-Pinot-Fokus implementiert, um KAFKA für Datenströmen zu erstellen. Definieren von Pinot-Schemat- und Tätigkeiten. wie Grafana.

Lernziele

• Erfahren Sie, wie Apache Pinot verwendet werden kann, um ein Echtzeit-Überwachungssystem für die Verfolgung von Metriken für Anwendungsleistung in einer verteilten Umgebung zu erstellen.
• Erfahren Sie, wie Sie SQL-Abfragen in Python schreiben und ausführen, um Echtzeit-Leistungsmetriken von Apache Pinot abzurufen und zu analysieren.
• Sammeln Sie praktische Erfahrungen beim Einrichten von Apache Pinot, beim Definieren von Schemas und beim Konfigurieren von Tabellen zum Einnehmen und Speichern von Anwendungsmetrikendaten in Echtzeit von Kafka.
• Verstehen Sie, wie Sie Apache Pinot in Visualisierungstools wie Grafana oder Apache Superset integrieren.

Dieser Artikel wurde als Teil des Data Science -Blogathons veröffentlicht.

Inhaltsverzeichnis

• Anwendungsfall: Echtzeit-Anwendungsleistung Überwachung
• Einrichten von Kafka für Echtzeitdaten-Streaming
  • Java installieren
  • Kafka herunterladen
  • Extrahieren der Binärdateien
  • Setzen Sie die Konfigurationsdateien mit dem Befehl zurück
  • Kafka starten
• Erstellen von Kafka -Themen
  • Veröffentlichung von Daten an Kafka
• Definieren von Pinot -Schema und Tabellenkonfiguration
  • Schema -Definition
  • Tabellenkonfiguration
• Bereitstellen der Konfiguration Schema und Tabelle
• Abfragen von Daten zur Überwachung von KPIs
  • Verständnis der Abfrageergebnisse
• Visualisierung der Daten: Integration von Pinot in Grafana
• Erweiterte Überlegungen
• Häufig gestellte Fragen

Anwendungsfall: Echtzeit-Anwendungsleistung Überwachung

Lassen Sie uns ein Szenario untersuchen, in dem wir eine verteilte Anwendung verwalten, die Millionen von Benutzern in mehreren Regionen bedient. Um eine optimale Leistung aufrechtzuerhalten, müssen wir verschiedene Leistungsmetriken überwachen:

• Antwortzeiten - Wie schnell unsere Anwendung auf Benutzeranfragen reagiert.
• Fehlerraten : Die Häufigkeit von Fehlern in Ihrer Anwendung.
• CPU und Speicherverbrauch : Die Ressourcen, die Ihre Anwendung verbraucht.

Stellen Sie Apache Pinot bereit, um ein Echtzeit-Überwachungssystem zu erstellen, das Leistungsdaten aufnimmt, speichert und abfragt, um eine schnelle Erkennung und Reaktion auf Probleme zu ermöglichen.

Systemarchitektur

• Datenquellen:
  • Metriken und Protokolle werden aus verschiedenen Anwendungsdiensten gesammelt.
  • Diese Protokolle werden zur Einnahme von Echtzeit in Apache Kafka gestreamt.
• Datenaufnahme:
  • Apache Pinot nimmt diese Daten direkt von KAFKA-Themen auf und bietet Echtzeitverarbeitung mit minimaler Verzögerung.
  • Pinot speichert die Daten in einem Spaltenformat, das für eine schnelle Abfrage und einen effizienten Speicher optimiert ist.
• Abfrage:
  • Pinot fungiert als Abfrage-Engine und ermöglicht es Ihnen, komplexe Abfragen gegen Echtzeitdaten auszuführen, um Einblicke in die Anwendungsleistung zu erhalten.
  • Die verteilte Architektur von Pinot stellt sicher, dass Abfragen schnell ausgeführt werden, auch wenn das Datenvolumen wächst.
• Visualisierung:
  • Die Ergebnisse von Pinot-Abfragen können in Echtzeit unter Verwendung von Tools wie Grafana oder Apache Superset visualisiert werden, wodurch dynamische Dashboards zur Überwachung von KPIs angeboten werden.
  • Die Visualisierung ist der Schlüssel, um die Daten umsetzbar zu machen, sodass Sie KPIs überwachen, Warnungen festlegen und auf Probleme in Echtzeit reagieren können.

Einrichten von Kafka für Echtzeitdaten-Streaming

Der erste Schritt besteht darin, Apache Kafka für das Echtzeit-Streaming der Protokolle und Metriken unserer Anwendung zu verarbeiten. Kafka ist eine verteilte Streaming-Plattform, mit der wir Streams of Records in Echtzeit veröffentlichen und abonnieren können. Jeder Microservice in unserer Anwendung kann Protokollnachrichten oder Metriken zu Kafka -Themen erstellen, die Pinot später verbrauchen wird

Java installieren

Um Kafka auszuführen, werden wir Java auf unserem System installieren.

 sudo apt installieren openjdk-11-jre-headless -y

Überprüfen Sie die Java -Version

 Java -Version

Kafka herunterladen

 wGet https://downloads.apache.org/kafka/3.4.0/kafka_2.13-3.4.0.tgz

Extrahieren der Binärdateien

 sudo mkdir/usr/local/kafka-server
sudo tar xzf kafka_2.13-3.4.0.tgz

Außerdem müssen wir die extrahierten Dateien in den unten angegebenen Ordner verschieben

 sudo mv kafka_2.13-3.4.0/*/usr/local/kafka-server

Setzen Sie die Konfigurationsdateien mit dem Befehl zurück

 sudo systemctl dämon-reload

Kafka starten

Vorausgesetzt, Kafka und Zookeeper sind bereits installiert, kann Kafka unter Verwendung der folgenden Befehle gestartet werden:

 # Zookeeper starten
zookeeper-server-start.sh config/zookeeper.properties

# Kafka Server starten
kafka-server-start.sh config/server.properties

Erstellen von Kafka -Themen

Als nächstes die Erstellung eines Kafka -Themas für unsere Anwendungsmetriken. Themen sind die Kanäle, über die die Daten in Kafka fließen. Wir haben ein Thema namens App-Metrics mit 3 Partitionen und einen Replikationsfaktor von 1 erstellt. Die Anzahl der Partitionen verteilt die Daten über Kafka-Makler hinweg, während der Replikationsfaktor die Entlastung steuert, indem er feststellt, wie viele Kopien der Daten existieren.

 kafka-topics

Veröffentlichung von Daten an Kafka

Unsere Anwendung kann Metriken zum Kafka-Thema in Echtzeit veröffentlichen. Dieses Skript simuliert das Senden von Anwendungsmetriken jede Sekunde an das Thema Kafka. Die Metriken enthalten Details wie Dienstname, Endpunkt, Statuscode, Antwortzeit, CPU -Verwendung, Speicherverbrauch und Zeitstempel.

 vom Importproduzenten crossuent_kafka importieren
JSON importieren
Importzeit

# Kafka Producer -Konfiguration
conf = {'bootstrap.servers': "localhost: 9092"}
Produzent = Produzent (** conf)

# Funktion zum Senden einer Nachricht an Kafka
Def send_metrics ():
    metriken = {
        "service_name": "auth-service",
        "Endpunkt": "/login",
        "status_code": 200,
        "response_time_ms": 123.45,
        "CPU_USAGE": 55.2,
        "Memory_usage": 1024.7,
        "Zeitstempel": int (time.time () * 1000)
    }
    produzent.produce ('App-metrics', value = json.dumps (Metriken)))
    Produzent.Flush ()

# Simulieren Sie alle 2 Sekunden das Senden von Metriken
während wahr:
    send_metrics ()
    time.sleep (2)

Definieren von Pinot -Schema und Tabellenkonfiguration

Mit der Einrichtung und Streaming -Daten von Kafka besteht der nächste Schritt darin, Apache Pinot für die Einnahme und Speicherung dieser Daten zu konfigurieren. Dies beinhaltet die Definition eines Schemas und das Erstellen einer Tabelle in Pinot.

Schema -Definition

Das Schema definiert die Struktur der Daten, die Pinot aufnimmt. Es gibt die Dimensionen (Attribute) und Metriken (messbare Mengen) an, die gespeichert werden, sowie die Datentypen für jedes Feld. Erstellen Sie eine JSON -Datei mit dem Namen „App_performance_ms_schema.json“ mit dem folgenden Inhalt:

 {
  "Schemaname": "app_performance_ms",
  "DimensionfieldSpecs": [
    {"Name": "Service", "DataType": "String"},
    {"Name": "Endpoint", "DataType": "String"},
    {"Name": "s_code", "DataType": "int"}
  ],
  "MetricfieldSpecs": [
    {"Name": "response_time", "dataType": "double"},
    {"Name": "cpu_usage", "Datentyp": "Double"},
    {"Name": "memory_usage", "Datentyp": "Double"}
  ],
  "DateTimeFieldSpecs": [
    {
      "Name": "Zeitstempel",
      "Datentyp": "Long",
      "Format": "1: Millisekunden: Epoche",
      "Granularität": "1: Millisekunden"
    }
  ]
}

Tabellenkonfiguration

In der Tabellenkonfigurationsdatei wird Pinot angegeben, wie die Daten verwaltet werden, einschließlich Details zur Datenaufnahme von KAFKA, Indizierungsstrategien und Retentionsrichtlinien.

Erstellen Sie eine andere JSON -Datei mit dem Namen "App_performance_Metrics_table.json" mit dem folgenden Inhalt:

 {
  "TableName": "Appperformancemetrics",
  "Tabletyp": "Echtzeit",
  "Segmenteconfig": {{
    "Timecolumnname": "TimeStamp",
    "Schemaname": "AppMetrics",
    "Replikation": "1"
  },
  "tableIndexconfig": {
    "LoadMode": "MMAP",
    "StreamConfigs": {
      "Streamtype": "Kafka",
      "Stream.kafka.topic.name": "App_performance_Metrics",
      "Stream.Kafka.Broker.List": "Localhost: 9092",
      "Stream.kafka.consumer.typ": "LowLevel"
    }
  }
}

Diese Konfiguration gibt an, dass die Tabelle Daten aus dem Thema app_performance_metrics kafka in Echtzeit aufnimmt. Die Spalte Zeitstempel verwendet als primäre Zeitspalte und konfiguriert die Indexierung, um effiziente Abfragen zu unterstützen.

Bereitstellen der Konfiguration Schema und Tabelle

Sobald die Schema- und Tabellenkonfiguration fertig ist, können wir sie mit den folgenden Befehlen für Pinot bereitstellen:

 bin/pinot -admin.sh addSchema -schemafile app_performance_ms_schema.json -exec
bin/pinot -admin.sh addtable -tableConFigFile app_performance_metrics_table.json -schemafile App_performance_ms_schema.json -exec

Nach der Bereitstellung startet Apache Pinot mit der Einnahme von Daten aus der KAFKA-Topic-App-Metrics und stellt sie für die Abfrage zur Verfügung.

Abfragen von Daten zur Überwachung von KPIs

Wenn Pinot Daten aufnimmt, können Sie jetzt damit beginnen, die wichtigsten Leistungsindikatoren (KPIs) zu überwachen. Pinot unterstützt SQL-ähnliche Abfragen, sodass wir Daten schnell abrufen und analysieren können. Hier ist ein Python -Skript, das in den letzten fünf Minuten die durchschnittliche Reaktionszeit und die Fehlerrate für jeden Dienst abfragt:

 Anfragen importieren
JSON importieren

# Pinot Broker URL
pinot_broker_url = "http: // localhost: 8099/query/sql"

# SQL -Abfrage, um die durchschnittliche Antwortzeit und Fehlerrate zu erhalten
query = "" ""
Wählen Sie service_name, 
       Avg (response_time_ms) als avg_response_time,
       Sum (fälle wenn status_code> = 400 dann 1 sonst 0 Ende) / count (*) als Fehler_Rate
Aus Appperformancemetrie 
Wo timestamp> = vor ('pt5m') 
Gruppe von service_name
"" "

# Führen Sie die Abfrage aus
response = requests.post (pinot_broker_url, data = query, headers = {"content-type": "application/json"})

if response.status_code == 200:
    result = response.json ()
    print (json.dumps (result, indent = 4))
anders:
    print ("Abfrage fehlgeschlagen mit Statuscode:", Antwort.Status_Code)

Dieses Skript sendet eine SQL -Abfrage an Pinot, um die durchschnittliche Antwortzeit und die Fehlerrate für jeden Dienst in den letzten fünf Minuten zu berechnen. Diese Metriken sind entscheidend für das Verständnis der Echtzeitleistung unserer Anwendung.

Verständnis der Abfrageergebnisse

• Durchschnittliche Antwortzeit : Bietet Einblick, wie schnell jeder Dienst auf Anfragen reagiert. Höhere Werte können auf Leistungs Engpässe hinweisen.
• Fehlerrate : Zeigt den Anteil der Anforderungen an, die zu Fehlern geführt haben (Statuscodes> = 400). Eine hohe Fehlerrate könnte Probleme mit dem Dienst signalisieren.

Visualisierung der Daten: Integration von Pinot in Grafana

Grafana ist ein beliebtes Open-Source-Visualisierungstool, das die Integration in Apache Pinot unterstützt. Durch die Verbindung von Grafana mit Pinot können wir Echtzeit-Dashboards erstellen, die Metriken wie Antwortzeiten, Fehlerraten und Ressourcenverbrauch anzeigen. Beispiel Das Dashboard kann die folgenden Informationen enthalten.

• Reaktionszeiten Frequenz: Ein Zeilendiagramm mit einem Bereich, der die durchschnittliche Reaktionszeit für jeden Dienst in den letzten 24 Stunden zeigt.
• Fehlerraten: Ein gestapeltes Balkendiagramm, das Dienste mit hohen Fehlerquoten hervorhebt und Ihnen dabei hilft, problematische Bereiche schnell zu identifizieren.
• Sessions -Nutzung: Ein Bereichstabelldiagramm mit CPU- und Speicherverbrauchstrends in verschiedenen Diensten.

Dieses Visualisierungs -Setup bietet einen umfassenden Überblick über die Gesundheit und Leistung unserer Anwendung, sodass wir KPIs kontinuierlich überwachen und proaktive Maßnahmen ergreifen können, wenn Probleme auftreten.

Erweiterte Überlegungen

Wenn unser Echtzeit-Überwachungssystem mit Apache Pinot erweitert wird, gibt es mehrere erweiterte Aspekte, um seine Effektivität aufrechtzuerhalten:

• Datenbindung und Archivierung:
  • Herausforderung : Wenn Ihre Anwendung zunehmende Datenmengen generiert, wird die effiziente Verwaltung von Speicher entscheidend, um aufgeblasene Kosten und Leistungsabfälle zu vermeiden.
  • Lösung : Implementierung von Datenspeicherrichtlinien hilft, das Datenvolumen durch Archivieren oder Löschen älterer Datensätze zu verwalten, die für die sofortige Analyse nicht mehr benötigt werden. Apache Pinot automatisiert diese Prozesse über seine Segmentverwaltungs- und Datenbetriebsmechanismen.
• Skalierung von Pinot:
  • Herausforderung : Das wachsende Datenvolumen und Abfrageanforderungen kann eine einzelne Pinot -Instanz oder ein Cluster -Setup belasten.
  • Lösung : Apache Pinot unterstützt die horizontale Skalierung, sodass Sie Ihren Cluster erweitern können, indem Sie weitere Knoten hinzufügen. Dies stellt sicher, dass das System eine erhöhte Datenaufnahme und Abfragelast effektiv bewältigen kann und die Leistung beim Wachstum Ihrer Anwendung aufrechterhalten kann.
• Alarmierung:
  • Herausforderung : Erkennung und Reaktion auf Leistungsprobleme ohne automatisierte Warnungen kann eine Herausforderung sein und möglicherweise die Problemlösung verzögert.
  • Lösung : Integrieren Sie Warnsysteme, um Benachrichtigungen zu erhalten, wenn Metriken vordefinierte Schwellenwerte überschreiten. Sie können Tools wie Grafana oder Prometheus verwenden, um Warnungen einzurichten, um sicherzustellen, dass Sie sofort über Anomalien oder Probleme in der Leistung Ihrer Anwendung informiert werden.
• Leistungsoptimierung:
  • Herausforderung : Mit einem wachsenden Datensatz und komplexen Abfragen kann die Aufrechterhaltung einer effizienten Abfrageleistung eine Herausforderung werden.
  • Lösung : Optimieren Sie kontinuierlich Ihr Schema -Design, Ihre Indexierungsstrategien und Ihr Abfragemuster. Verwenden Sie die Tools von Apache Pinot zur Überwachung und Adressierung von Leistungs Engpässen. Verwenden Sie Partitionierungs- und Sharding -Techniken, um Daten und Abfragen im Cluster besser zu verteilen.

Abschluss

Eine effektive Echtzeitüberwachung ist für die Gewährleistung der Leistung und Zuverlässigkeit moderner Anwendungen unerlässlich. Apache Pinot bietet eine leistungsstarke Lösung für die Echtzeit-Datenverarbeitung und -abfrage, wodurch sie für umfassende Überwachungssysteme geeignet ist. Durch die Implementierung der diskutierten Strategien und Berücksichtigung fortschrittlicher Themen wie Skalierung und Sicherheit können Sie ein robustes und skalierbares Überwachungssystem erstellen, mit dem Sie potenzielle Leistungsprobleme voraus bleiben und eine reibungslose Erfahrung für Ihre Benutzer sicherstellen können.

Key Takeaways

• Apache Pinot ist geschickt bei der Behandlung von Echtzeitdatenaufnahmen und bietet eine Abfrageleistung mit geringer Latenz. Es integriert sich gut in Streaming -Plattformen wie Kafka und ermöglicht eine sofortige Analyse von Metriken wie Reaktionszeiten, Fehlerraten und Ressourcenauslastung.
• Kafka streams Anwendungsprotokolle und Metriken, die Apache Pinot dann aufnimmt. Das Konfigurieren von KAFKA-Themen und das Verknüpfen mit Pinot ermöglicht eine kontinuierliche Verarbeitung und Abfragung von Leistungsdaten, um aktuelle Erkenntnisse zu gewährleisten.
• Das ordnungsgemäße Definieren von Schemas und das Konfigurieren von Tabellen in Apache Pinot ist für die effiziente Datenverwaltung von entscheidender Bedeutung. Das Schema skizziert die Datenstruktur und -typen, während die Tabellenkonfiguration die Datenaufnahme und -indexierung der Daten steuert und effektive Echtzeitanalysen unterstützt.
• Apache Pinot unterstützt SQL-ähnliche Abfragen für eine eingehende Datenanalyse. Bei Verwendung mit Visualisierungstools wie Grafana oder Apache Superset ermöglicht es die Erstellung dynamischer Dashboards, die eine Sichtbarkeit in Echtzeit in die Anwendungsleistung bieten, was die Erkennung und Auflösung von Problemen unterstützt.

Häufig gestellte Fragen

Q 1. Was macht Apache Pinot für die Überwachung der Anwendungsleistung in Echtzeit geeignet?

A. Apache Pinot ist für Abfragen mit geringer Latenz optimiert, was es ideal für Szenarien macht, in denen Echtzeit-Erkenntnisse von entscheidender Bedeutung sind. Seine Fähigkeit, Daten aus Streaming-Quellen wie Kafka aufzunehmen und mit hohen Durchsatzdatensätzen umfangreiche Datensätze zu verarbeiten, können aktuelle Analysen für Anwendungsleistungskennzahlen bereitstellen.

Q 2. Wie handelt Apache Pinot mit Echtzeitdaten auf die Einnahme von Kafka?

A. Apache Pinot wurde entwickelt, um Echtzeitdaten aufzunehmen, indem Nachrichten direkt von Kafka-Themen konsumiert werden. Es unterstützt sowohl Kafka-Verbraucher auf niedrigem und hohem Niveau und ermöglicht Pinot, Daten mit minimaler Verzögerung zu verarbeiten und zu speichern, wodurch es für sofortige Abfragen verfügbar ist.

F 3. Was sind die Schlüsselkomponenten erforderlich, um ein Echtzeitüberwachungssystem mithilfe von Apache Pinot einzurichten?

A. Um ein Echtzeit-Überwachungssystem mit Apache Pinot einzurichten, benötigen Sie:
Datenquellen: Anwendungsprotokolle und Metriken, die an Kafka gestreamt werden.
Apache Pinot: Für die Einnahme und Abfrage in Echtzeitdaten.
Schema- und Tabellenkonfiguration: Definitionen in Pinot zum Speichern und Indizieren der Metrikendaten.
Visualisierungstools: Tools wie Grafana oder Apache Superset zum Erstellen von Echtzeit-Dashboards

F 4.. Kann ich neben Kafka andere Datenstreaming -Plattformen mit Apache Pinot verwenden?

A. Ja, Apache Pinot unterstützt die Integration mit anderen Datenstreaming -Plattformen wie Apache Pulsar und AWS Kinesis. Während sich dieser Artikel auf KAFKA konzentriert, gelten dieselben Prinzipien bei der Verwendung verschiedener Streaming -Plattformen, obwohl die Konfigurationsdetails variieren.

Die in diesem Artikel gezeigten Medien sind nicht im Besitz von Analytics Vidhya und werden nach Ermessen des Autors verwendet.

Das obige ist der detaillierte Inhalt vonEchtzeit-App-Leistungsüberwachung mit Apache Pinot. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!