Realtime app-prestatiebewaking met Apache Pinot

Introductie

In de snelle softwareontwikkelingsomgeving van vandaag de dag is het cruciaal om optimale applicatieprestaties te garanderen. Het monitoren van realtime-statistieken zoals responstijden, foutpercentages en resourcegebruik kan helpen om een ​​hoge beschikbaarheid te behouden en een naadloze gebruikerservaring te leveren. Apache Pinot, een open-source OLAP-datastore, biedt de mogelijkheid om realtime-data-opname en query's met lage latentie te verwerken, waardoor het een geschikte oplossing is voor het monitoren van applicatieprestaties op schaal. In dit artikel onderzoeken we hoe u een realtime-monitoringsysteem implementeert met Apache Pinot, met een focus op het opzetten Kafka voor datastreaming, het definiëren van Pinot-schema's en -tabellen, het opvragen van prestatiegegevens met Pythonen het visualiseren van statistieken met hulpmiddelen zoals Grafana.

Leerdoelen

• Ontdek hoe u Apache Pinot kunt gebruiken om een ​​realtime monitoringsysteem te bouwen voor het bijhouden van prestatiegegevens van applicaties in een gedistribueerde omgeving.
• Leer hoe je moet schrijven en uitvoeren SQL query's in Python om realtime prestatiegegevens van Apache Pinot op te halen en te analyseren.
• Doe praktische ervaring op met het instellen van Apache Pinot, het definiëren van schema's en het configureren van tabellen om applicatiemetrische gegevens in realtime op te nemen en op te slaan vanuit Kafka.
• Begrijp hoe u Apache Pinot kunt integreren met visualisatiehulpmiddelen zoals Grafana of Apache Superset.

Dit artikel is gepubliceerd als onderdeel van het Data Science-blogathon.

Gebruiksscenario: Realtime-toepassingsprestatiebewaking

Laten we een scenario bekijken waarin we een gedistribueerde applicatie beheren die miljoenen gebruikers bedient in meerdere regio's. Om optimale prestaties te behouden, moeten we verschillende prestatie-indicatoren bewaken:

• Reactietijden– Hoe snel onze applicatie reageert op gebruikersverzoeken.
• Foutpercentages: De frequentie van fouten in uw applicatie.
• CPU- en geheugengebruik: De bronnen die uw applicatie verbruikt.

Implementeer Apache Pinot om een ​​realtime monitoringsysteem te creëren dat prestatiegegevens opneemt, opslaat en opvraagt, waardoor problemen snel kunnen worden gedetecteerd en aangepakt.

Systeem Architectuur

• Data bronnen:
  • Metrieken en logboeken worden verzameld van verschillende applicatieservices.
  • Deze logs worden gestreamd naar Apache Kafka voor realtime-verwerking.
• Gegevensopname:
  • Apache Pinot haalt deze gegevens rechtstreeks uit Kafka-onderwerpen, waardoor realtimeverwerking met minimale vertraging mogelijk is.
  • Pinot slaat de gegevens op in een kolomformaat, dat geoptimaliseerd is voor snelle query's en efficiënte opslag.
• bevragen:
  • Pinot fungeert als query-engine, waarmee u complexe query's op realtimegegevens kunt uitvoeren om inzicht te krijgen in de applicatieprestaties.
  • De gedistribueerde architectuur van Pinot zorgt ervoor dat query's snel worden uitgevoerd, zelfs als de hoeveelheid data toeneemt.
• Visualisatie:
  • De resultaten van Pinot-query's kunnen in realtime worden gevisualiseerd met behulp van hulpmiddelen zoals Grafana of Apache Superset, die dynamische dashboards bieden voor het bewaken van KPI's.
  • Visualisatie is essentieel om de gegevens bruikbaar te maken, zodat u KPI's kunt bewaken, waarschuwingen kunt instellen en in realtime kunt reageren op problemen.

Kafka instellen voor realtime datastreaming

De eerste stap is om Apache Kafka in te stellen om realtime streaming van de logs en metrics van onze applicatie te verwerken. Kafka is een gedistribueerd streamingplatform waarmee we streams van records in realtime kunnen publiceren en erop kunnen abonneren. Elke microservice in onze applicatie kan logberichten of metrics produceren voor Kafka-onderwerpen, die Pinot later zal consumeren

Installeer Java

Om Kafka te kunnen draaien, installeren we Java op ons systeem:

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

Controleer de Java-versie

java –version

Kafka downloaden

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

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

We moeten de uitgepakte bestanden ook verplaatsen naar de onderstaande map:

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

De configuratiebestanden opnieuw instellen met de opdracht

sudo systemctl daemon-reload

Kafka starten

Ervan uitgaande dat Kafka en Zookeeper al geïnstalleerd zijn, kan Kafka gestart worden met behulp van onderstaande opdrachten:

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

# Start Kafka server
kafka-server-start.sh config/server.properties

Kafka-onderwerpen maken

Vervolgens het maken van een Kafka-onderwerp voor onze applicatiemetrieken. Onderwerpen zijn de kanalen waardoor gegevens in Kafka stromen. Hier hebben we een onderwerp genaamd app-metrics gemaakt met 3 partities en een replicatiefactor van 1. Het aantal partities verdeelt de gegevens over Kafka-brokers, terwijl de replicatiefactor het redundantieniveau regelt door te bepalen hoeveel kopieën van de gegevens er bestaan.

kafka-topics.sh --create --topic app-metrics --bootstrap-server localhost:9092 --partitions 3 --replication-factor 1

Gegevens publiceren naar Kafka

Onze applicatie kan metrics in real-time publiceren naar het Kafka-onderwerp. Dit script simuleert het verzenden van applicatiemetrics naar het Kafka-onderwerp elke seconde. De metrics bevatten details zoals servicenaam, eindpunt, statuscode, responstijd, CPU-gebruik, geheugengebruik en tijdstempel.

from confluent_kafka import Producer
import json
import time

# Kafka producer configuration
conf = {'bootstrap.servers': "localhost:9092"}
producer = Producer(**conf)

# Function to send a message to Kafka
def send_metrics():
    metrics = {
        "service_name": "auth-service",
        "endpoint": "/login",
        "status_code": 200,
        "response_time_ms": 123.45,
        "cpu_usage": 55.2,
        "memory_usage": 1024.7,
        "timestamp": int(time.time() * 1000)
    }
    producer.produce('app-metrics', value=json.dumps(metrics))
    producer.flush()

# Simulate sending metrics every 2 seconds
while True:
    send_metrics()
    time.sleep(2)

Pinot-schema en tabelconfiguratie definiëren

Nu Kafka is ingesteld en data wordt gestreamd, is de volgende stap het configureren van Apache Pinot om deze data op te nemen en op te slaan. Dit omvat het definiëren van een schema en het maken van een tabel in Pinot.

Schema Definitie

Het schema definieert de structuur van de data die Pinot zal opnemen. Het specificeert de dimensies (attributen) en metrics (meetbare hoeveelheden) die zullen worden opgeslagen, evenals de datatypes voor elk veld. Maak een JSON-bestand met de naam "app_performance_ms_schema.json" met de volgende content:

{
  "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", "dataType": "DOUBLE"},
    {"name": "memory_usage", "dataType": "DOUBLE"}
  ],
  "dateTimeFieldSpecs": [
    {
      "name": "timestamp",
      "dataType": "LONG",
      "format": "1:MILLISECONDS:EPOCH",
      "granularity": "1:MILLISECONDS"
    }
  ]
}

Tabel configuratie

Het tabelconfiguratiebestand vertelt Pinot hoe de gegevens moeten worden beheerd, inclusief details over gegevensopname vanuit Kafka, indexeringsstrategieën en bewaarbeleid.

Maak een ander JSON-bestand met de naam “app_performance_metrics_table.json” met de volgende inhoud:

{
  "tableName": "appPerformanceMetrics",
  "tableType": "REALTIME",
  "segmentsConfig": {
    "timeColumnName": "timestamp",
    "schemaName": "appMetrics",
    "replication": "1"
  },
  "tableIndexConfig": {
    "loadMode": "MMAP",
    "streamConfigs": {
      "streamType": "kafka",
      "stream.kafka.topic.name": "app_performance_metrics",
      "stream.kafka.broker.list": "localhost:9092",
      "stream.kafka.consumer.type": "lowlevel"
    }
  }
}

Deze configuratie specificeert dat de tabel gegevens uit het Kafka-onderwerp app_performance_metrics in realtime zal opnemen. Het gebruikt de timestamp-kolom als de primaire tijdkolom en configureert indexering om efficiënte query's te ondersteunen.

Het schema en de tabelconfiguratie implementeren

Zodra het schema en de tabelconfiguratie klaar zijn, kunnen we deze implementeren in Pinot met behulp van de volgende opdrachten:

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

Na de implementatie begint Apache Pinot met het opnemen van gegevens uit de Kafka-onderwerp-app-metrics en maakt deze beschikbaar voor query's.

Gegevens opvragen om KPI's te monitoren

Terwijl Pinot gegevens opneemt, kunt u deze nu gaan bevragen om de belangrijkste prestatie-indicatoren (KPI's) te monitoren. Pinot ondersteunt SQL-achtige query's, waardoor we snel gegevens kunnen ophalen en analyseren. Hier is een Python-script dat de gemiddelde responstijd en foutpercentage voor elke service in de afgelopen vijf minuten bevraagt:

import requests
import json

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

# SQL query to get average response time and error rate
query = """
SELECT service_name, 
       AVG(response_time_ms) AS avg_response_time,
       SUM(CASE WHEN status_code >= 400 THEN 1 ELSE 0 END) / COUNT(*) AS error_rate
FROM appPerformanceMetrics 
WHERE timestamp >= ago('PT5M') 
GROUP BY service_name
"""

# Execute the query
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))
else:
    print("Query failed with status code:", response.status_code)

Dit script stuurt een SQL-query naar Pinot om de gemiddelde responstijd en foutpercentage voor elke service in de laatste vijf minuten te berekenen. Deze statistieken zijn cruciaal voor het begrijpen van de realtimeprestaties van onze applicatie.

De queryresultaten begrijpen

• Gemiddelde reactietijd: Geeft inzicht in hoe snel elke service reageert op verzoeken. Hogere waarden kunnen prestatieknelpunten aangeven.
• Foutpercentage: Geeft het percentage aanvragen weer dat tot fouten heeft geleid (statuscodes >= 400). Een hoog foutpercentage kan duiden op problemen met de service.

Visualiseren van de data: Pinot integreren met Grafana

Grafana is een populaire open-source visualisatietool die integratie met Apache Pinot ondersteunt. Door Grafana te verbinden met Pinot, kunnen we realtime dashboards maken die statistieken weergeven zoals responstijden, foutpercentages en resourcegebruik. Een voorbeelddashboard kan de volgende informatie bevatten:

• Responstijden frequentie: Een lijndiagram met een gebied waarin de gemiddelde responstijd voor elke service in de afgelopen 24 uur wordt weergegeven.
• Foutpercentages: Een gestapeld staafdiagram dat de services met een hoog foutpercentage weergeeft, zodat u snel probleemgebieden kunt identificeren.
• Sessies Gebruik: Een vlakdiagram waarin de trends in CPU- en geheugengebruik voor verschillende services worden weergegeven.

Deze visualisatie-instelling biedt een compleet overzicht van de status en prestaties van onze applicatie. Hierdoor kunnen we KPI's continu bewaken en proactieve maatregelen nemen wanneer er problemen ontstaan.

Geavanceerde overwegingen

Naarmate ons realtime monitoringsysteem met Apache Pinot groeit, zijn er verschillende geavanceerde aspecten die beheerd moeten worden om de effectiviteit ervan te behouden:

• Gegevensbehoud en archivering:
  • Uitdaging:Naarmate uw applicatie steeds grotere hoeveelheden data genereert, wordt het steeds belangrijker om de opslag efficiënt te beheren. Zo voorkomt u hogere kosten en prestatieverminderingen.
  • Het resultaat: Het implementeren van dataretentiebeleid helpt bij het beheren van datavolume door het archiveren of verwijderen van oudere records die niet langer nodig zijn voor directe analyse. Apache Pinot automatiseert deze processen via zijn segmentbeheer- en dataretentiemechanismen.
• Pinot schalen:
  • Uitdaging:Het groeiende volume aan gegevens en queryverzoeken kan een enkele Pinot-instantie of clusteropstelling zwaar belasten.
  • Het resultaat: Apache Pinot ondersteunt horizontale schaalbaarheid, waardoor u uw cluster kunt uitbreiden door meer knooppunten toe te voegen. Dit zorgt ervoor dat het systeem de toegenomen data-inname en query-loads effectief aankan, en de prestaties behouden blijven naarmate uw applicatie groeit.
• Waarschuwing:
  • Uitdaging:Het detecteren en aanpakken van prestatieproblemen zonder automatische waarschuwingen kan een uitdaging zijn en kan de oplossing van het probleem vertragen.
  • Het resultaat: Integreer waarschuwingssystemen om meldingen te ontvangen wanneer statistieken vooraf gedefinieerde drempels overschrijden. U kunt tools zoals Grafana of Prometheus gebruiken om waarschuwingen in te stellen, zodat u snel op de hoogte wordt gesteld van eventuele afwijkingen of problemen in de prestaties van uw applicatie.
• Prestatieoptimalisatie:
  • Uitdaging:Met een groeiende dataset en complexe query's kan het een uitdaging worden om efficiënte queryprestaties te behouden.
  • Het resultaat: Optimaliseer continu uw schemaontwerp, indexeringsstrategieën en querypatronen. Gebruik de tools van Apache Pinot om prestatieknelpunten te bewaken en aan te pakken. Gebruik partitionerings- en shardingtechnieken om gegevens en query's beter over het cluster te verdelen.

Conclusie

Effectieve realtime monitoring is essentieel om de prestaties en betrouwbaarheid van moderne applicaties te garanderen. Apache Pinot biedt een krachtige oplossing voor realtime dataverwerking en query's, waardoor het zeer geschikt is voor uitgebreide monitoringsystemen. Door de besproken strategieën te implementeren en geavanceerde onderwerpen zoals schalen en beveiliging te overwegen, kunt u een robuust en schaalbaar monitoringsysteem bouwen dat u helpt om potentiële prestatieproblemen voor te blijven, en een soepele ervaring voor uw gebruikers te garanderen.

Key Takeaways

• Apache Pinot is bedreven in het verwerken van realtime data-opname en biedt queryprestaties met lage latentie, waardoor het een krachtig hulpmiddel is voor het monitoren van applicatieprestatiemetrieken. Het integreert goed met streamingplatforms zoals Kafka, waardoor directe analyse van metrieken zoals responstijden, foutpercentages en resourcegebruik mogelijk is.
• Kafka streamt applicatielogs en metrics, die Apache Pinot vervolgens opneemt. Door Kafka-onderwerpen te configureren en ze te koppelen aan Pinot, is continue verwerking en query van prestatiegegevens mogelijk, wat zorgt voor up-to-date inzichten.
• Het correct definiëren van schema's en configureren van tabellen in Apache Pinot is cruciaal voor efficiënt databeheer. Het schema schetst de datastructuur en -typen, terwijl de tabelconfiguratie de data-opname en indexering regelt, en effectieve realtime-analyse ondersteunt.
• Apache Pinot ondersteunt SQL-achtige query's voor diepgaande data-analyse. Wanneer het wordt gebruikt met visualisatietools zoals Grafana of Apache Superset, maakt het de creatie van dynamische dashboards mogelijk die realtime inzicht bieden in de applicatieprestaties, wat helpt bij het snel detecteren en oplossen van problemen.

Veelgestelde Vragen / FAQ

De in dit artikel getoonde media zijn geen eigendom van Analytics Vidhya en worden naar goeddunken van de auteur gebruikt.

Hallo wereld: Ikzelf Kartik Sharma, werkzaam als senior data engineer en business analist voor Zensar Technologies Ltd. Ik ben nieuw met bloggen en probeer het gewoon voor de lol. “Een techno-nerd die per ongeluk verliefd werd op woorden.”

• Door SEO aangedreven content en PR-distributie. Word vandaag nog versterkt.
• PlatoData.Network Verticale generatieve AI. Versterk jezelf. Toegang hier.
• PlatoAiStream. Web3-intelligentie. Kennis versterkt. Toegang hier.
• PlatoESG. carbon, CleanTech, Energie, Milieu, Zonne, Afvalbeheer. Toegang hier.
• Plato Gezondheid. Intelligentie op het gebied van biotech en klinische proeven. Toegang hier.
• Bron: https://www.analyticsvidhya.com/blog/2024/09/real-time-app-performance-monitoring-with-apache-pinot/