Juniper NETWORKS Streaming-API-Software

Produktinformationen

Technische Daten

• Produktname: Paragon Active Assurance
• Version: 4.1
• Erscheinungsdatum: 2023

Einführung:
Dieses Handbuch enthält Anweisungen zum Extrahieren von Daten aus Paragon Active Assurance mithilfe der Streaming-API des Produkts. Der Streaming-Client und die API sind in der Paragon Active Assurance-Installation enthalten, vor der Verwendung der API sind jedoch einige Konfigurationsschritte erforderlich. Der Konfigurationsprozess wird im Abschnitt „Konfigurieren der Streaming-API“ beschrieben.

Konfigurieren der Streaming-API:
Die folgenden Schritte beschreiben den Vorgang zum Konfigurieren der Streaming-API:

Überview
Kafka ist eine Event-Streaming-Plattform, die für die Echtzeiterfassung und -speicherung von Daten aus verschiedenen Quellen entwickelt wurde. Sie ermöglicht die Verwaltung von Event-Streams auf verteilte, skalierbare, fehlertolerante und sichere Weise. Dieser Leitfaden konzentriert sich auf die Konfiguration von Kafka zur Nutzung der Streaming-API-Funktion im Paragon Active Assurance Control Center.

Terminologie
Mit der Streaming-API können externe Clients Metrikinformationen von Kafka abrufen. Von den Test-Agents während eines Tests oder einer Überwachungsaufgabe erfasste Metriken werden an den Stream-Dienst gesendet. Nach der Verarbeitung veröffentlicht der Stream-Dienst diese Metriken zusammen mit zusätzlichen Metadaten auf Kafka.

Aktivieren der Streaming-API
Um die Streaming-API zu aktivieren, führen Sie diese Schritte aus:

1. Führen Sie mit sudo die folgenden Befehle auf dem Control Center-Server aus:

KAFKA_METRICS_ENABLED = True sudo ncc services aktivieren Timescaledb-Metriken sudo ncc services starten Timescaledb-Metriken sudo ncc services starten neu

Überprüfen, ob die Streaming-API im Control Center funktioniert:
So überprüfen Sie, ob Sie Metriken zu den richtigen Kafka-Themen erhalten:

1. Installieren Sie das Dienstprogramm „kafkacat“ mit den folgenden Befehlen:
   sudo apt-get update
   sudo apt-get installiere kafkacat

2. Ersetzen Sie „myaccount“ durch den Kurznamen Ihres Kontos im
   Kontrollzentrum URL:
   exportiere METRICS_TOPIC=paa.public.accounts.myaccount.metrics
   exportiere METADATA_TOPIC=paa.public.accounts.myaccount.metadata

3. Führen Sie den folgenden Befehl aus, um view Metriken:
   kafkacat -b ${KAFKA_FQDN}:9092 -t ${METRICS_TOPIC} -C -e
   Notiz: Der obige Befehl zeigt die Metriken an.
4. Zu view Metadaten, führen Sie den folgenden Befehl aus:
   kafkacat -b ${KAFKA_FQDN}:9092 -t ${METADATA_TOPIC} -C -e

Notiz: Der obige Befehl zeigt Metadaten an, wird aber nicht so häufig aktualisiert.

Kunde Examples
Für Kunden exampDateien und weitere Informationen finden Sie auf Seite 14 des Benutzerhandbuchs.

FAQ (Häufig gestellte Fragen)

• F: Was ist Paragon Active Assurance?
  A: Paragon Active Assurance ist ein Produkt, das Überwachungs- und Testfunktionen bietet.
• F: Was ist die Streaming-API?
  A: Die Streaming-API ist eine Funktion in Paragon Active Assurance, die es externen Clients ermöglicht, Messinformationen von Kafka abzurufen.
• F: Wie aktiviere ich die Streaming-API?
  A: Um die Streaming-API zu aktivieren, befolgen Sie die Schritte im Abschnitt „Aktivieren der Streaming-API“ des Benutzerhandbuchs.
• F: Wie kann ich überprüfen, ob die Streaming-API funktioniert?
  A: Anweisungen zum Überprüfen der Funktionalität der Streaming-API finden Sie im Abschnitt „Überprüfen, ob die Streaming-API im Control Center funktioniert“.

Einführung

In diesem Handbuch wird beschrieben, wie Sie über die Streaming-API des Produkts Daten aus Paragon Active Assurance extrahieren.
Sowohl die API als auch der Streaming-Client sind in der Paragon Active Assurance-Installation enthalten. Bevor Sie die API verwenden können, ist jedoch eine gewisse Konfiguration erforderlich. Dies wird im Kapitel „Konfigurieren der Streaming-API“ auf Seite 1 behandelt.

Überview
In diesem Kapitel wird beschrieben, wie die Streaming-API konfiguriert wird, um das Abonnieren von Metriknachrichten über Kafka zu ermöglichen.
pr
Im Folgenden gehen wir Folgendes durch:

• So aktivieren Sie die Streaming-API
• So konfigurieren Sie Kafka zum Abhören externer Clients
• So konfigurieren Sie Kafka zur Verwendung von ACLs und richten SSL-Verschlüsselung für die genannten Clients ein

Was ist Kafka?
Kafka ist eine Event-Streaming-Plattform, die die Echtzeiterfassung von Daten verschiedener Ereignisquellen (Sensoren, Datenbanken, Mobilgeräte) in Form von Ereignisströmen sowie die dauerhafte Speicherung dieser Ereignisströme zum späteren Abrufen und Bearbeiten ermöglicht.
Mit Kafka ist es möglich, das Event-Streaming End-to-End auf verteilte, hoch skalierbare, elastische, fehlertolerante und sichere Weise zu verwalten.

NOTIZ: Kafka kann auf viele verschiedene Arten konfiguriert werden und wurde für Skalierbarkeit und redundante Systeme entwickelt. Dieses Dokument konzentriert sich nur auf die Konfiguration zur Nutzung der Streaming-API-Funktion im Paragon Active Assurance Control Center. Für fortgeschrittenere Konfigurationen verweisen wir auf die offizielle Kafka-Dokumentation: kafka.apache.org/26/documentation.html.

Terminologie

• Kafka: Event-Streaming-Plattform.
• Kafka-Thema: Sammlung von Ereignissen.
• Kafka-Abonnent/-Verbraucher: Komponente, die für den Abruf von in einem Kafka-Thema gespeicherten Ereignissen verantwortlich ist.
• Kafka-Broker: Speicherschichtserver eines Kafka-Clusters.
• SSL/TLS: SSL ist ein sicheres Protokoll, das für die sichere Übermittlung von Informationen über das Internet entwickelt wurde. TLS ist der Nachfolger von SSL und wurde 1999 eingeführt.
• SASL: Framework, das Mechanismen zur Benutzerauthentifizierung, Datenintegritätsprüfung und Verschlüsselung bereitstellt.
• Streaming-API-Abonnent: Komponente, die für den Abruf von Ereignissen verantwortlich ist, die in Themen gespeichert sind, die in Paragon Active Assurance definiert sind und für den externen Zugriff bestimmt sind.
• Zertifizierungsstelle: Eine vertrauenswürdige Stelle, die öffentliche Schlüsselzertifikate ausstellt und widerruft.
• Stammzertifikat der Zertifizierungsstelle: Öffentliches Schlüsselzertifikat, das eine Zertifizierungsstelle identifiziert.

So funktioniert die Streaming-API
Wie bereits erwähnt, ermöglicht die Streaming-API externen Clients, Informationen zu Metriken von Kafka abzurufen.

Alle von den Test-Agents während eines Tests oder einer Überwachungsaufgabe gesammelten Metriken werden an den Stream-Dienst gesendet. Nach einer Verarbeitungsphase veröffentlicht der Stream-Dienst diese Metriken zusammen mit zusätzlichen Metadaten auf Kafka.

Kafka-Themen
Kafka verfügt über das Konzept von Themen, in denen alle Daten veröffentlicht werden. In Paragon Active Assurance sind viele solcher Kafka-Themen verfügbar; allerdings ist nur eine Teilmenge davon für den externen Zugriff vorgesehen.
Jedes Paragon Active Assurance-Konto im Control Center verfügt über zwei eigene Themen. Im Folgenden ist KONTO der Kurzname des Kontos:

• paa.public.accounts.{KONTO}.metrics
  • Alle Metrikmeldungen für das angegebene Konto werden in diesem Thema veröffentlicht.
  • Große Datenmengen
  • Hohe Updatefrequenz
• paa.public.accounts.{KONTO}.metadata
  • Enthält Metadaten zu den Messdaten, z. B.ampden mit den Metriken verknüpften Test, Monitor oder Test-Agenten
  • Kleine Datenmengen
  • Niedrige Update-Frequenz

Aktivieren der Streaming-API

NOTIZ: Diese Anweisungen sind mit sudo auf dem Control Center-Server auszuführen.

Da die Streaming-API dem Control Center etwas Mehraufwand hinzufügt, ist sie standardmäßig nicht aktiviert. Um die API zu aktivieren, müssen wir zunächst die Veröffentlichung von Metriken in Kafka in der Hauptkonfiguration aktivieren. file:

• /etc/netrounds/netrounds.conf

KAFKA_METRICS_ENABLED = Wahr

WARNUNG: Das Aktivieren dieser Funktion kann die Leistung des Control Centers beeinträchtigen. Stellen Sie sicher, dass Sie Ihre Instanz entsprechend dimensioniert haben.

Um als Nächstes die Weiterleitung dieser Metriken an die richtigen Kafka-Themen zu aktivieren:

• /etc/netrounds/metrics.yaml

Streaming-API: wahr

Um die Streaming-API-Dienste zu aktivieren und zu starten, führen Sie Folgendes aus:

• sudo ncc services aktivieren Timescaledb-Metriken
• sudo ncc services starten timescaledb-Metriken

Starten Sie abschließend die Dienste neu:

• sudo ncc-Dienste neu starten

Überprüfen, ob die Streaming-API im Control Center funktioniert

NOTIZ: Diese Anweisungen müssen auf dem Control Center-Server ausgeführt werden.

Sie können jetzt überprüfen, ob Sie Metriken zu den richtigen Kafka-Themen erhalten. Installieren Sie dazu das Dienstprogramm kafkacat:

• sudo apt-get update
• sudo apt-get installiere kafkacat

Wenn Sie im Control Center einen Test oder Monitor ausführen, sollten Sie mit Kafkacat Messdaten und Metadaten zu diesen Themen abrufen können.
Ersetzen Sie myaccount durch den Kurznamen Ihres Kontos (dies ist, was Sie in Ihrem Control Center sehen URL):

• exportiere METRICS_TOPIC=paa.public.accounts.myaccount.metrics
• exportiere METADATA_TOPIC=paa.public.accounts.myaccount.metadata

Wenn Sie den folgenden Befehl ausführen, sollten Sie nun die Messwerte sehen:

• kafkacat -b ${KAFKA_FQDN}:9092 -t ${METRICS_TOPIC} -C -e

Zu view Metadaten, führen Sie den folgenden Befehl aus (beachten Sie, dass die Aktualisierung nicht so häufig erfolgt):

• kafkacat -b ${KAFKA_FQDN}:9092 -t ${METADATA_TOPIC} -C -e

NOTIZ:
kafkacat“Client Examples“ auf Seite 14

Damit wird bestätigt, dass wir über eine funktionierende Streaming-API im Control Center verfügen. Wahrscheinlich möchten Sie jedoch stattdessen von einem externen Client auf die Daten zugreifen. Im nächsten Abschnitt wird beschrieben, wie Sie Kafka für den externen Zugriff öffnen.

Öffnen von Kafka für externe Hosts

NOTIZ: Diese Anweisungen müssen auf dem Control Center-Server ausgeführt werden.

Standardmäßig ist Kafka, das im Control Center ausgeführt wird, so konfiguriert, dass es nur für den internen Gebrauch auf localhost lauscht. Es ist möglich, Kafka für externe Clients zu öffnen, indem Sie die Kafka-Einstellungen ändern.

Herstellen einer Verbindung mit Kafka: Einschränkungen

VORSICHT: Bitte lesen Sie dies sorgfältig durch, da leicht Verbindungsprobleme mit Kafka auftreten können, wenn Sie diese Konzepte nicht verstanden haben.

Im in diesem Dokument beschriebenen Control Center-Setup gibt es nur einen einzigen Kafka-Broker.
Beachten Sie jedoch, dass ein Kafka-Broker als Teil eines Kafka-Clusters ausgeführt werden soll, der aus vielen Kafka-Brokern bestehen kann.
Bei der Verbindung mit einem Kafka-Broker wird zunächst eine Verbindung vom Kafka-Client hergestellt. Über diese Verbindung gibt der Kafka-Broker wiederum eine Liste mit „angekündigten Listenern“ zurück, also eine Liste mit einem oder mehreren Kafka-Brokern.
Nach Erhalt dieser Liste trennt der Kafka-Client die Verbindung und stellt sie dann mit einem dieser angekündigten Listener wieder her. Die angekündigten Listener müssen Hostnamen oder IP-Adressen enthalten, auf die der Kafka-Client zugreifen kann, sonst kann der Client keine Verbindung herstellen.
Wenn eine SSL-Verschlüsselung mit einem an einen bestimmten Hostnamen gebundenen SSL-Zertifikat zum Einsatz kommt, ist es umso wichtiger, dass der Kafka-Client die richtige Adresse für die Verbindung erhält, da die Verbindung sonst möglicherweise abgelehnt wird.
Lesen Sie hier mehr über Kafka-Listener: www.confluent.io/blog/kafka-listeners-explained

SSL/TLS-Verschlüsselung
Um sicherzustellen, dass nur vertrauenswürdige Clients auf Kafka und die Streaming-API zugreifen dürfen, müssen wir Folgendes konfigurieren:

• Authentifizierung: Clients müssen Benutzernamen und Passwort über eine sichere SSL/TLS-Verbindung zwischen dem Client und Kafka bereitstellen.
• Genehmigung: Authentifizierte Clients können durch ACLs geregelte Aufgaben ausführen.

Hier ist ein Overview:

*) Benutzername/Passwort-Authentifizierung erfolgt über einen SSL-verschlüsselten Kanal

Um vollständig zu verstehen, wie die SSL/TLS-Verschlüsselung für Kafka funktioniert, lesen Sie bitte die offizielle Dokumentation: docs.confluent.io/platform/current/kafka/encryption.html

SSL/TLS-Zertifikat überview

NOTIZ: In diesem Unterabschnitt verwenden wir die folgende Terminologie:

Zertifikat: Ein von einer Zertifizierungsstelle (CA) signiertes SSL-Zertifikat. Jeder Kafka-Broker hat eines.
Schlüsselspeicher: Der Schlüsselspeicher file in dem das Zertifikat gespeichert ist. Der Schlüsselspeicher file enthält den privaten Schlüssel des Zertifikats und muss daher sicher aufbewahrt werden.
Truststore: A file enthält die vertrauenswürdigen CA-Zertifikate.

Um die Authentifizierung zwischen einem externen Client und Kafka einzurichten, das im Control Center ausgeführt wird, müssen beide Seiten einen Schlüsselspeicher mit einem zugehörigen, von einer Zertifizierungsstelle (CA) signierten Zertifikat sowie dem CA-Stammzertifikat definiert haben.
Darüber hinaus muss der Client über einen Truststore mit dem CA-Stammzertifikat verfügen.
Das CA-Stammzertifikat ist für den Kafka-Broker und den Kafka-Client gleich.

Erstellen der erforderlichen Zertifikate
Dies wird im „Anhang“ auf Seite 17 behandelt.

Kafka Broker SSL/TLS-Konfiguration im Control Center

NOTIZ: Diese Anweisungen müssen auf dem Control Center-Server ausgeführt werden.

NOTIZ: Bevor Sie fortfahren, müssen Sie den Schlüsselspeicher erstellen, der das SSL-Zertifikat enthält. Folgen Sie dazu den Anweisungen im „Anhang“ auf Seite 17. Die unten genannten Pfade stammen aus diesen Anweisungen.
Der SSL-Schlüsselspeicher ist ein file gespeichert auf der Festplatte mit dem file Erweiterung .jks.

Sobald Sie die erforderlichen Zertifikate sowohl für den Kafka-Broker als auch für den Kafka-Client erstellt haben, können Sie mit der Konfiguration des im Control Center ausgeführten Kafka-Brokers fortfahren. Sie müssen Folgendes wissen:

• : Der öffentliche Hostname des Control Centers. Dieser muss für Kafka-Clients auflösbar und zugänglich sein.
• : Das Keystore-Passwort, das beim Erstellen des SSL-Zertifikats angegeben wurde.
• Und : Dies sind die Passwörter, die Sie für den Administrator bzw. den Client-Benutzer festlegen möchten. Beachten Sie, dass Sie weitere Benutzer hinzufügen können, wie im Beispiel angegeben.ample.

Bearbeiten oder ergänzen Sie (mit Sudo-Zugriff) die folgenden Eigenschaften in /etc/kafka/server.properties und fügen Sie die obigen Variablen wie gezeigt ein:

WARNUNG: Entfernen Sie PLAINTEXT://localhost:9092 nicht. Dadurch wird die Funktionalität des Control Centers beeinträchtigt, da die internen Dienste nicht kommunizieren können.

• …
• # Die Adressen, auf denen der Kafka-Broker lauscht.
• Listener = PLAINTEXT://localhost:9092,SASL_SSL://0.0.0.0:9093
• # Dies sind die Hosts, die jedem Client, der eine Verbindung herstellt, zurückgemeldet werden.
• beworben.listeners=PLAINTEXT://localhost:9092,SASL_SSL:// :9093 …
• ####### BENUTZERDEFINIERTE KONFIGURATION
• # SSL-KONFIGURATION
• ssl.endpoint.identification.algorithm=
  ssl.keystore.location=/var/ssl/private/kafka.server.keystore.jks
• ssl.keystore.password=
• ssl.key.password=
• ssl.client.auth=keine
• ssl.protocol=TLSv1.2
• # SASL-Konfiguration
• sasl.enabled.mechanisms=PLAIN
• Benutzername=”admin” \
• Passwort=” ” \
• Benutzer_Administrator=” ” \
• Benutzerclient = ” ”;
• # HINWEIS: Weitere Benutzer können mit user_ hinzugefügt werden. =
• # Autorisierung, ACLs aktivieren
• authorizer.class.name=kafka.security.authorizer.AclAuthorizer super.users=Benutzer:admin

Einrichten von Zugriffskontrolllisten (ACLs)

Aktivieren von ACLs auf dem lokalen Host

WARNUNG: Wir müssen zuerst ACLs für den lokalen Host einrichten, damit das Control Center selbst weiterhin auf Kafka zugreifen kann. Wenn dies nicht getan wird, kommt es zu Problemen.

• –authorizer kafka.security.authorizer.AclAuthorizer \
• –authorizer-properties zookeeper.connect=localhost:2181 \
• –add –allow-principal Benutzer:ANONYMOUS –allow-host 127.0.0.1 –cluster
• /usr/lib/kafka/bin/kafka-acls.sh \
• –authorizer kafka.security.authorizer.AclAuthorizer \
• –authorizer-properties zookeeper.connect=localhost:2181 \
• –add –allow-principal Benutzer:ANONYMOUS –allow-host 127.0.0.1 –topic '*'
• /usr/lib/kafka/bin/kafka-acls.sh \
• –authorizer kafka.security.authorizer.AclAuthorizer \
• –authorizer-properties zookeeper.connect=localhost:2181 \
• –add –allow-principal Benutzer:ANONYMOUS –allow-host 127.0.0.1 –group '*'

Anschließend müssen wir ACLs für den externen schreibgeschützten Zugriff aktivieren, damit externe Benutzer die paa.public.*-Themen lesen dürfen.

### ACL-Einträge für anonyme Benutzer /usr/lib/kafka/bin/kafka-acls.sh \

NOTIZ: Eine genauere Steuerung finden Sie in der offiziellen Kafka-Dokumentation.

• –authorizer kafka.security.authorizer.AclAuthorizer \
• –authorizer-properties zookeeper.connect=localhost:2181 \
• –add –allow-principal Benutzer:* –operation read –operation describe \ –group 'NCC'
• /usr/lib/kafka/bin/kafka-acls.sh \
• –authorizer kafka.security.authorizer.AclAuthorizer \
• –authorizer-properties zookeeper.connect=localhost:2181 \
• –add –allow-principal Benutzer:* –operation read –operation describe \ –topic paa.public. –resource-pattern-type mit Präfix

Sobald dies erledigt ist, müssen Sie die Dienste neu starten:

### ACL-Einträge für externe Benutzer /usr/lib/kafka/bin/kafka-acls.sh \

• sudo ncc-Dienste neu starten

Um zu überprüfen, ob ein Client eine sichere Verbindung herstellen kann, führen Sie den folgenden Befehl auf einem externen
Client-Computer (nicht auf dem Control Center-Server). Im Folgenden ist PUBLIC_HOSTNAME der Control Center-Hostname:

• openssl s_client -debug -connect ${PUBLIC_HOSTNAME}:9093 -tls1_2 | grep „Sichere Neuverhandlung wird unterstützt“

In der Befehlsausgabe sollten Sie das Serverzertifikat sowie Folgendes sehen:

• Sichere Neuverhandlung wird unterstützt

Um sicherzustellen, dass internen Diensten Zugriff auf den Kafka-Server gewährt wurde, überprüfen Sie bitte das folgende Protokollfiles:

• /var/log/kafka/server.log
• /var/log/kafka/kafka-authorizer.log

Überprüfen der externen Clientkonnektivität

kafkacat

NOTIZ: Diese Anweisungen müssen auf einem Client-Computer ausgeführt werden (nicht auf dem Control Center-Server).
NOTIZ: Um Messinformationen anzuzeigen, stellen Sie sicher, dass mindestens ein Monitor im Control Center ausgeführt wird.

Um die Konnektivität als externer Client zu überprüfen und zu validieren, können Sie das Dienstprogramm Kafkacat verwenden, das im Abschnitt „Überprüfen, ob die Streaming-API im Control Center funktioniert“ auf Seite 4 installiert wurde.
Führen Sie die folgenden Schritte aus:

NOTIZ: Im Folgenden ist CLIENT_USER der Benutzer, der zuvor in der file /etc/kafka/server.properties im Control Center: nämlich user_client und das dort festgelegte Passwort.
Das CA-Stammzertifikat, das zum Signieren des serverseitigen SSL-Zertifikats verwendet wird, muss auf dem Client vorhanden sein.

Erstellen Sie ein file client.properties mit folgendem Inhalt:

• Sicherheit.Protokoll=SASL_SSL
• ssl.ca.location={PFAD_ZUM_CA_CERT}
• sasl.mechanisms=PLAIN
• sasl.username={CLIENT_USER}
• sasl.password={CLIENT_PASSWORT}

Wo

• {PATH_TO_CA_CERT} ist der Speicherort des vom Kafka-Broker verwendeten CA-Stammzertifikats.
• {CLIENT_USER} und {CLIENT_PASSWORD} sind die Benutzeranmeldeinformationen für den Client.

Führen Sie den folgenden Befehl aus, um die von Kafkacat verarbeitete Nachricht anzuzeigen:

• exportiere KAFKA_FQDN=
• exportieren Sie METRICS_TOPIC=paa.public.accounts. .Metriken
• kafkacat -b ${KAFKA_FQDN}:9093 -F client.properties -t ${METRICS_TOPIC} -C -e

wobei {METRICS_TOPIC} der Name des Kafka-Themas mit dem Präfix „paa.public.“ ist.

NOTIZ: Ältere Versionen von Kafkacat bieten nicht die Option -F zum Lesen der Clienteinstellungen aus einem fileWenn Sie eine solche Version verwenden, müssen Sie in der Befehlszeile dieselben Einstellungen vornehmen, wie unten gezeigt.

kafkacat -b ${KAFKA_FQDN}:9093 \

• X Sicherheit.Protokoll=SASL_SSL \
• X ssl.ca.location={PFAD_ZUM_CA_CERT} \
• X sasl.mechanisms=PLAIN \
• X sasl.username={CLIENT_USER} \
• X sasl.password={CLIENT_PASSWORD} \
• t ${METRICS_TOPIC} -C -e

Zum Debuggen der Konnektivität können Sie die Option -d verwenden:

Debuggen der Verbraucherkommunikation
kafkacat -d Verbraucher -b ${KAFKA_FQDN}:9093 -F Client.Eigenschaften -t ${METRICS_TOPIC} -C -e
# Debuggen der Broker-Kommunikation
kafkacat -d Broker -b ${KAFKA_FQDN}:9093 -F Client.Eigenschaften -t ${METRICS_TOPIC} -C -e

Lesen Sie unbedingt die Dokumentation zur verwendeten Kafka-Clientbibliothek, da die Eigenschaften von denen in „client.properties“ abweichen können.

Nachrichtenformat
Die für die Metriken und Metadatenthemen verwendeten Nachrichten werden im Protokollpufferformat (protobuf) serialisiert (siehe developer.google.com/protocol-buffers). Die Schemata für diese Nachrichten entsprechen dem folgenden Format:

Metriken-Protobuf-Schema

• Syntax = „proto3“;
• importiere „google/protobuf/timestamp.proto”;
• Paket paa.streamingapi;
• Option go_package = „.;paa_streamingapi“;
• Nachrichtenmetriken {
• google.protobuf.Timestamp Zeitamp = 1;
• Karte Werte = 2;
• int32 stream_id = 3;
• }
• /**
• * Ein Metrikwert kann entweder eine Ganzzahl oder eine Gleitkommazahl sein.
• */
• Nachricht Metrikwert {
• oneof-Typ {
• int64 int_val = 1;
• Float Float_Wert = 2;
• }
• }

Metadaten-Protobuf-Schema

• Syntax = „proto3“;
• Paket paa.streamingapi;
• Option go_package = „.;paa_streamingapi“;
• Nachrichtenmetadaten {
• int32 stream_id = 1;
• Zeichenfolge Streamname = 2;
• Karte tags = 13;
• }

Kunde Examples

NOTIZ: Diese Befehle sind für die Ausführung auf einem externen Client vorgesehen, z. B.ample Ihren Laptop oder ähnliches und nicht im Kontrollcenter.
NOTIZ: Um Messinformationen anzuzeigen, stellen Sie sicher, dass mindestens ein Monitor im Control Center ausgeführt wird.

Das Control Center-Tarball enthält das Archiv paa-streaming-api-client-examples.tar.gz (Client-Beispielamples), das eine Ex enthältampDas Python-Skript zeigt, wie die Streaming-API verwendet wird.

Installieren und Konfigurieren von Client Examples
Sie finden client-exampDateien im Ordner „Paragon Active Assurance Control Center“:

• export CC_VERSION=4.1.0
• cd ./paa-control-center_${CC_VERSION}
• ls paa-streaming-api-client-exampweniger*

So installieren Sie client-exampUm Dateien auf Ihrem externen Client-Rechner zu speichern, gehen Sie wie folgt vor:

• # Verzeichnis zum Extrahieren des Inhalts des Clients erstellen (Beispiel)amples-Tarball
• mkdir paa-streaming-api-client-examples
• # Extrahieren Sie den Inhalt des Clients examples-Tarball
• tar xzf paa-streaming-api-client-examples.tar.gz -C paa-streaming-api-client-examples
• # Gehen Sie in das neu erstellte Verzeichnis
• CD PAA-Streaming-API-Client-Examples

Client-Examples erfordert Docker zum Ausführen. Downloads und Installationsanweisungen für Docker finden Sie unter https://docs.docker.com/engine/install.

Verwenden von Client Examples
Der Kunde-Examples Tools können entweder im Basis- oder im erweiterten Modus ausgeführt werden, um z. B.ampDateien unterschiedlicher Komplexität. In beiden Fällen ist es auch möglich, die ExampDateien mit einer Konfiguration file enthält zusätzliche Eigenschaften zur weiteren Anpassung der Clientseite.

Basismodus
Im Basismodus werden die Metriken und ihre Metadaten separat gestreamt. Zu diesem Zweck hört der Client jedes für den externen Zugriff verfügbare Kafka-Thema ab und druckt die empfangenen Nachrichten einfach auf der Konsole aus.
Um die Ausführung der grundlegenden ex zu startenamples, führe aus:

• build.sh run-basic –kafka-brokers localhost:9092 –account ACCOUNT_SHORTNAME

wobei ACCOUNT_SHORTNAME der Kurzname des Kontos ist, von dem Sie die Metriken abrufen möchten.
Um die Ausführung des Ex zu beendenample, drücken Sie Strg + C. (Es kann zu einer kleinen Verzögerung kommen, bevor die Ausführung stoppt, da der Client auf ein Timeout-Ereignis wartet.)

Erweiterter Modus

NOTIZ: Metriken werden nur für HTTP-Monitore angezeigt, die im Control Center ausgeführt werden.

Die Ausführung im erweiterten Modus zeigt die Korrelation zwischen Metriken und Metadatennachrichten. Dies ist
Möglich ist dies durch das Vorhandensein eines Stream-ID-Felds in jeder Metriknachricht, das auf die entsprechende Metadatennachricht verweist.
So führen Sie die erweiterte Übung ausamples, führe aus:

• build.sh run-advanced –kafka-brokers localhost:9092 –account ACCOUNT_SHORTNAME

wobei ACCOUNT_SHORTNAME der Kurzname des Kontos ist, von dem Sie die Metriken abrufen möchten.
Um die Ausführung des Ex zu beendenample, drücken Sie Strg + C. (Es kann zu einer kleinen Verzögerung kommen, bevor die Ausführung stoppt, da der Client auf ein Timeout-Ereignis wartet.)

Zusätzliche Einstellungen
Es ist möglich, die Ex auszuführenampDateien mit zusätzlicher Konfiguration des Clients über den Befehl –config-file Option gefolgt von einem file Name, der Eigenschaften in der Form Schlüssel=Wert enthält.

• build.sh run-advanced \
• –kafka-brokers localhost:9092 \
• –account KONTO_KURZNAME \
• –Konfiguration-file client_config.properties

NOTIZ: Alle files, auf die im obigen Befehl verwiesen wird, müssen sich im aktuellen Verzeichnis befinden und dürfen nur mit relativen Pfaden referenziert werden. Dies gilt sowohl für die –config-file Argument und auf alle Einträge in der Konfiguration file das beschreiben file Standorte.

Überprüfen der externen Clientauthentifizierung
So validieren Sie die Client-Authentifizierung von außerhalb des Control Centers mit client-exampdateien, führen Sie die folgenden Schritte aus:

Wechseln Sie im Ordner „Paragon Active Assurance Control Center“ zum Ordner „paa-streaming-api-client-ex“amples-Ordner:

CD PAA-Streaming-API-Client-Examples

• Kopieren Sie das CA-Stammzertifikat ca-cert in das aktuelle Verzeichnis.
• Erstellen Sie eine client.properties file mit folgendem Inhalt:

Sicherheit.Protokoll=SASL_SSL ssl.ca.location=ca-cert
sasl.mechanism=PLAIN
sasl.username={CLIENT_USER}
sasl.password={CLIENT_PASSWORT}

wobei {CLIENT_USER} und {CLIENT_PASSWORD} die Benutzeranmeldeinformationen für den Client sind.

Führen Sie das Basic-Ex ausamples:

• exportiere KAFKA_FQDN=
• build.sh run-basic –kafka-brokers ${KAFKA_FQDN}:9093 \
• –account KONTO_KURZNAME
• –Konfiguration-file Client-Eigenschaften

wobei ACCOUNT_SHORTNAME der Kurzname des Kontos ist, von dem Sie die Metriken abrufen möchten.

Führen Sie das erweiterte Ex ausamples:

• exportiere KAFKA_FQDN=
• build.sh run-advanced –kafka-brokers ${KAFKA_FQDN}:9093 \
• –account KONTO_KURZNAME
• –Konfiguration-file Client-Eigenschaften

Anhang

In diesem Anhang beschreiben wir, wie Sie Folgendes erstellen:

• ein Schlüsselspeicher file zur Speicherung des Kafka-Broker-SSL-Zertifikats
• ein Truststore file zum Speichern des Stammzertifikats der Zertifizierungsstelle (CA), das zum Signieren des Kafka-Broker-Zertifikats verwendet wird.

Erstellen eines Kafka-Broker-Zertifikats
Erstellen eines Zertifikats mithilfe einer echten Zertifizierungsstelle (empfohlen)
Es wird empfohlen, ein echtes SSL-Zertifikat von einer vertrauenswürdigen Zertifizierungsstelle zu erwerben.
Wenn Sie sich für eine Zertifizierungsstelle entschieden haben, kopieren Sie deren CA-Stammzertifikat ca-cert file zu Ihrem eigenen Pfad, wie unten gezeigt:

• export CA_PATH=~/my-ca
• mkdir ${CA_PATH}
• cp ca-cert ${CA_PATH}

Erstellen Sie Ihre eigene Zertifizierungsstelle

NOTIZ: Normalerweise sollte Ihr Zertifikat von einer echten Zertifizierungsstelle signiert sein; siehe den vorhergehenden Unterabschnitt. Was folgt, ist nur ein Beispielample.

Hier erstellen wir unser eigenes Certificate Authority (CA)-Stammzertifikat file gültig für 999 Tage (in der Produktion nicht empfohlen):

• # Erstellen Sie ein Verzeichnis zum Speichern der CA
• export CA_PATH=~/my-ca
• mkdir ${CA_PATH}
• # Generieren Sie das CA-Zertifikat
• openssl req -new -x509 -keyout ${CA_PATH}/ca-key -out ${CA_PATH}/ca-cert -days 999

Erstellen des Client-Truststore
Jetzt können Sie einen Truststore erstellen file das das oben generierte CA-Zertifikat enthält. file wird vom Kafka-Client benötigt, der auf die Streaming-API zugreift:

• keytool -keystore kafka.client.truststore.jks \
  • Alias ​​CARoot \
  • Importzertifikat -file ${CA_PATH}/ca-cert

Da sich das CA-Zertifikat nun im Truststore befindet, vertraut der Client jedem damit signierten Zertifikat.
Du solltest die kopieren file kafka.client.truststore.jks an einen bekannten Speicherort auf Ihrem Client-Computer und verweisen Sie in den Einstellungen darauf.

Erstellen des Keystores für den Kafka Broker
Um das Kafka-Broker-SSL-Zertifikat und anschließend den Keystore kafka.server.keystore.jks zu generieren, gehen Sie wie folgt vor:

Generieren des SSL-Zertifikats
Im Folgenden steht 999 für die Anzahl der Tage, die der Schlüsselspeicher gültig ist, und FQDN ist der vollqualifizierte Domänenname des Clients (öffentlicher Hostname des Knotens).

NOTIZ: Es ist wichtig, dass der FQDN genau mit dem Hostnamen übereinstimmt, den der Kafka-Client für die Verbindung mit dem Control Center verwendet.

• sudo mkdir -p /var/ssl/private
• sudo chown -R $USER: /var/ssl/private
• cd /var/ssl/privat
• FQDN exportieren= keytool -keystore kafka.server.keystore.jks \
• – Aliasserver \
• – Gültigkeit 999 \
• – genkey -keyalg RSA -ext SAN=dns:${FQDN}

Erstellen Sie eine Zertifikatsignieranforderung und speichern Sie diese im file benannte Cert-Server-Anforderung:

• keytool -keystore kafka.server.keystore.jks \
  • – Aliasserver \
  • – certreq \
  • – file Zertifikat-Server-Anforderung

Senden Sie nun die file cert-server-request an Ihre Zertifizierungsstelle (CA), wenn Sie eine echte verwenden. Sie wird Ihnen dann das signierte Zertifikat zurücksenden. Wir werden es im Folgenden als cert-server-signed bezeichnen.

Signieren des SSL-Zertifikats mit einem selbst erstellten CA-Zertifikat

NOTIZ: Auch hier wird die Verwendung einer eigenen Zertifizierungsstelle in einem Produktionssystem nicht empfohlen.

Signieren Sie das Zertifikat bei der CA mit dem file cert-server-request, das das signierte Zertifikat cert-server-signed erzeugt. Siehe unten; ca-password ist das Passwort, das beim Erstellen des CA-Zertifikats festgelegt wurde.

• cd /var/ssl/private openssl x509 -req \
  • – CA ${CA_PATH}/ca-cert \
  • – CAkey ${CA_PATH}/ca-key \
  • – in cert-server-request \
  • – out cert-server-signed \
  • – Tage 999 -CAcreateserial \
  • – passin pass:{ca-password}

Importieren des signierten Zertifikats in den Keystore

Importieren Sie das ca-cert-Stammzertifikat in den Schlüsselspeicher:

• keytool -keystore kafka.server.keystore.jks \
  • – Alias ​​ca-cert \
  • - importieren \
  • – file ${CA_PATH}/ca-cert

Importieren Sie das signierte Zertifikat mit der Bezeichnung „cert-server-signed“:

• keytool -keystore kafka.server.keystore.jks \
  • – Aliasserver \
  • - importieren \
  • – file Zertifikat-Server-signiert

Der file kafka.server.keystore.jks sollte an einen bekannten Speicherort auf dem Control Center-Server kopiert und dann in /etc/kafka/server.properties referenziert werden.

Verwenden der Streaming-API

IN DIESEM ABSCHNITT

• Allgemein | 20
• Kafka-Themennamen | 21
• Exampdateien zur Verwendung der Streaming-API | 21

Allgemein
Die Streaming-API ruft sowohl Test- als auch Monitordaten ab. Eine Zuordnung zu einer dieser Kategorien ist nicht möglich.
Die Streaming-API ruft keine Daten aus skriptbasierten Tests ab (die in der GUI des Control Centers durch ein Rechteck statt durch ein Puzzleteil dargestellt werden), wie etwa Tests zur Aktivierung von Ethernet-Diensten und Transparenztests.

Kafka-Themennamen
Die Kafka-Themennamen für die Streaming-API lauten wie folgt, wobei %s der Kurzname des Control Center-Kontos ist (bei der Kontoerstellung angegeben):

• Konstante (
• Exporteurname = „kafka“
• metadataTopicTpl = „paa.public.accounts.%s.metadata“ metricsTopicTpl = „paa.public.accounts.%s.metrics“ )

Exampdateien zur Verwendung der Streaming-API
Der ExampDie folgenden Dateien finden Sie im Tarball paa-streaming-api-client-examples.tar.gz, enthalten im Tarball des Control Centers.
Erstens gibt es eine grundlegendeample demonstriert, wie die Metriken und ihre Metadaten separat gestreamt werden und gibt die empfangenen Nachrichten einfach auf der Konsole aus. Sie können es wie folgt ausführen:

• sudo ./build.sh run-basic –kafka-brokers localhost:9092 –account ACCOUNT_SHORTNAME

Es gibt auch eine fortgeschrittenere ExampDatei, in der Metriken und Metadatennachrichten korreliert werden. Verwenden Sie diesen Befehl, um sie auszuführen:

• sudo ./build.sh run-advanced –kafka-brokers localhost:9092 –account ACCOUNT_SHORTNAME

Sie müssen sudo verwenden, um Docker-Befehle wie die oben genannten auszuführen. Optional können Sie die Schritte nach der Linux-Installation befolgen, um Docker-Befehle ohne sudo ausführen zu können. Weitere Informationen finden Sie unter docs.docker.com/engine/install/linux-postinstall.

Juniper Networks, das Juniper Networks-Logo, Juniper und Junos sind eingetragene Marken von Juniper Networks, Inc. in den Vereinigten Staaten und anderen Ländern. Alle anderen Marken, Dienstleistungsmarken, eingetragenen Marken oder eingetragenen Dienstleistungsmarken sind Eigentum ihrer jeweiligen Inhaber. Juniper Networks übernimmt keine Verantwortung für Ungenauigkeiten in diesem Dokument. Juniper Networks behält sich das Recht vor, diese Veröffentlichung ohne vorherige Ankündigung zu ändern, zu modifizieren, zu übertragen oder anderweitig zu überarbeiten. Copyright © 2023 Juniper Networks, Inc. Alle Rechte vorbehalten.

Dokumente / Ressourcen

Juniper NETWORKS Streaming-API-Software [pdf] Benutzerhandbuch Streaming-API-Software, API-Software, Software

Verweise

• Bedienungsanleitung