Konfigurieren der Streaming-API
Überblick
In diesem Kapitel wird beschrieben, wie die Streaming-API so konfiguriert wird, dass das Abonnieren von Metriknachrichten über Kafka möglich ist.
PR
Im Folgenden gehen wir durch:
- So aktivieren Sie die Streaming-API
- Konfigurieren von Kafka zum Abhören externer Clients
- Konfigurieren von Kafka für die Verwendung von ACLs und Einrichten der SSL-Verschlüsselung für diese Clients
Was ist Kafka?
Kafka ist eine Event-Streaming-Plattform, die die Echtzeiterfassung von Daten, die von verschiedenen Ereignisquellen (Sensoren, Datenbanken, mobile Geräte) in Form von Ereignisströmen gesendet werden, sowie die dauerhafte Speicherung dieser Ereignisströme für einen späteren Abruf und eine spätere Bearbeitung ermöglicht.
Mit Kafka ist es möglich, das Ereignis-Streaming durchgängig verteilt, hoch skalierbar, elastisch, fehlertolerant und sicher zu verwalten.
Kafka ist vielseitig konfigurierbar und wurde für Skalierbarkeit und redundante Systeme konzipiert. Dieses Dokument konzentriert sich nur darauf, wie es konfiguriert wird, um die Streaming-API-Funktion im Paragon Active Assurance Control Center zu nutzen. Für fortgeschrittenere Setups verweisen wir auf die offizielle Kafka-Dokumentation: kafka.apache.org/26/documentation.html.
Terminologie
- Kafka: Event-Streaming-Plattform.
- Kafka Thema: Sammlung von Ereignissen.
- Kafka-Anwender/-Verbraucher: Komponente, die für den Abruf von Ereignissen verantwortlich ist, die in einem Kafka-Thema gespeichert sind.
- Kafka-Broker: Speicherschichtserver eines Kafka-Clusters.
- SSL/TLS: SSL ist ein sicheres Protokoll, das für das sichere Senden von Informationen über das Internet entwickelt wurde. TLS ist der Nachfolger von SSL, das 1999 eingeführt wurde.
- SASL: Framework, das Mechanismen für die Benutzer Authentifizierung, die Überprüfung der Datenintegrität und die Verschlüsselung bereitstellt.
- Streaming-API-Anwender: Komponente, die für den Abruf von Ereignissen verantwortlich ist, die in in Paragon Active Assurance definierten Themen gespeichert sind und für den externen Zugriff bestimmt sind.
- Zertifizierungsstelle: Eine vertrauenswürdige Entität, die Zertifikate mit öffentlichem Schlüssel ausstellt und widerruft.
- Stammzertifikat der Zertifizierungsstelle: Zertifikat mit öffentlichem Schlüssel, das eine Zertifizierungsstelle identifiziert.
Funktionsweise der Streaming-API
Wie bereits erwähnt, ermöglicht die Streaming-API externen Clients, Informationen zu Metriken aus Kafka abzurufen.
Alle Metriken, die von den Test-Agents während einer Test- oder Überwachungsaufgabe erfasst werden, 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 hat das Konzept der Themen , zu denen alle Daten veröffentlicht werden. In Paragon Active Assurance stehen viele solcher Kafka-Themen zur Verfügung; Allerdings ist nur eine Teilmenge davon für den Zugriff von außen vorgesehen.
Jedes Paragon Active Assurance-Konto im Control Center hat zwei spezielle Themen. Nachfolgend ACCOUNT finden Sie den Kurznamen des Kontos:
paa.public.accounts.{ACCOUNT}.metrics- Alle Metrikmeldungen für das angegebene Konto werden in diesem Thema veröffentlicht
- Große Datenmengen
- Hohe Aktualisierungsfrequenz
paa.public.accounts.{ACCOUNT}.metadata- Enthält Metadaten zu den Metrikdaten, z. B. zum Test, Monitor oder Testagenten, der den Metriken zugeordnet ist
- Kleine Datenmengen
- Geringe Aktualisierungshäufigkeit
Aktivieren der Streaming-API
Diese Anweisungen sind auf dem Control Center-Server mit sudoauszuführen.
Da die Streaming-API dem Kontrollzentrum einen gewissen Aufwand hinzufügt, ist sie standardmäßig nicht aktiviert. Um die API zu aktivieren, müssen wir zuerst die Veröffentlichung von Metriken in Kafka in der Hauptkonfigurationsdatei aktivieren:
/etc/netrounds/netrounds.conf
KAFKA_METRICS_ENABLED = True
Die Aktivierung dieser Funktion kann sich auf die Leistung von Control Center auswirken. Stellen Sie sicher, dass Sie Ihre Instanz entsprechend dimensioniert haben.
Um als Nächstes die Weiterleitung dieser Metriken an die richtigen Kafka-Themen zu ermöglichen:
/etc/netrounds/metrics.yaml
streaming-api: true
Führen Sie Folgendes aus, um die Streaming-API-Dienste zu aktivieren und zu starten:
sudo ncc services enable timescaledb metrics sudo ncc services start timescaledb metrics
Starten Sie schließlich die Dienste neu:
sudo ncc services restart
Überprüfen, ob die Streaming-API im Kontrollzentrum funktioniert
Diese Anweisungen sind auf dem Control Center-Server auszuführen.
Sie können jetzt überprüfen, ob Sie Metriken zu den richtigen Kafka-Themen erhalten. Installieren Sie dazu das kafkacat Dienstprogramm:
sudo apt-get update sudo apt-get install kafkacat
Wenn Sie einen Test oder Monitor im Control Center ausführen, sollten Sie in der Lage kafkacat sein, Metriken und Metadaten zu diesen Themen zu erhalten.
Ersetzen Sie myaccount durch den Kurznamen Ihres Kontos (dies sehen Sie in Ihrer Control Center-URL):
export METRICS_TOPIC=paa.public.accounts.myaccount.metrics export METADATA_TOPIC=paa.public.accounts.myaccount.metadata
Sie sollten jetzt Metriken sehen, indem Sie diesen Befehl ausführen:
kafkacat -b ${KAFKA_FQDN}:9092 -t ${METRICS_TOPIC} -C -e
Um Metadaten anzuzeigen, führen Sie den folgenden Befehl aus (beachten Sie, dass dies nicht so häufig aktualisiert wird):
kafkacat -b ${KAFKA_FQDN}:9092 -t ${METADATA_TOPIC} -C -e
kafkacat standardmäßig nicht decodiert wird. Informationen zum ordnungsgemäßen Abonnieren dieser Themen finden Sie im Abschnitt
Kundenbeispiele.
Dadurch wird überprüft, ob wir über eine funktionierende Streaming-API im Control Center verfügen. Höchstwahrscheinlich sind Sie jedoch daran interessiert, stattdessen von einem externen Client auf die Daten zuzugreifen. Im nächsten Abschnitt wird beschrieben, wie Sie Kafka für den externen Zugriff öffnen.
Öffnung von Kafka für externe Hosts
Diese Anweisungen sind auf dem Control Center-Server auszuführen.
Standardmäßig ist Kafka, das im Control Center ausgeführt wird, so konfiguriert, dass es nur auf localhost für den internen Gebrauch lauscht. Es ist möglich, Kafka für externe Clients zu öffnen, indem Sie die Kafka-Einstellungen ändern.
- Verbindung zu Kafka: Vorbehalte
- SSL/TLS-Verschlüsselung
- SSL/TLS-Zertifikate im Überblick
- Erstellen der erforderlichen Zertifikate
- Kafka Broker SSL/TLS-Konfiguration im Control Center
- Einrichten von Zugriffssteuerungslisten (ACLs)
Verbindung zu Kafka: Vorbehalte
Bitte lesen Sie dies sorgfältig durch, da es leicht zu Verbindungsproblemen mit Kafka kommen kann, wenn Sie diese Konzepte nicht verstanden haben.
In der in diesem Dokument beschriebenen Control Center-Einrichtung 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 eine erste Verbindung vom Kafka-Client aufgebaut. Über diese Verbindung gibt der Kafka-Broker wiederum eine Liste von "angekündigten Listenern" zurück, bei der es sich um eine Liste eines oder mehrerer Kafka-Broker handelt.
Beim Empfang dieser Liste trennt der Kafka-Client die Verbindung zu einem dieser angekündigten Listener und stellt dann die Verbindung zu 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, da der Client sonst keine Verbindung herstellen kann.
Wenn eine SSL-Verschlüsselung verwendet wird, bei der ein SSL-Zertifikat verwendet wird, das an einen bestimmten Hostnamen gebunden ist, ist es noch wichtiger, dass der Kafka-Client die richtige Adresse erhält, mit der er sich verbinden kann, da sonst die Verbindung abgelehnt werden kann.
Lesen Sie hier mehr über Kafka-Hörer: 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 können, müssen wir Folgendes konfigurieren:
- Authentifizierung: Clients müssen Benutzername und Passwort über eine sichere SSL/TLS-Verbindung zwischen dem Client und Kafka angeben.
- Autorisierung: Authentifizierte Clients können Aufgaben ausführen, die durch ACLs geregelt werden.
Hier ein Überblick:
Um die Funktionsweise der SSL/TLS-Verschlüsselung für Kafka vollständig zu verstehen, lesen Sie bitte die offizielle Dokumentation: docs.confluent.io/platform/current/kafka/encryption.html
SSL/TLS-Zertifikate im Überblick
In diesem Unterabschnitt werden wir die folgende Terminologie verwenden:
Zertifikat: Ein SSL-Zertifikat, das von einer Zertifizierungsstelle (Certificate Authority, CA) signiert wurde. Jeder Kafka-Broker hat einen.
Keystore: Die Keystore-Datei, in der das Zertifikat gespeichert ist. Die Keystore-Datei enthält den privaten Schlüssel des Zertifikats. daher muss es sicher aufbewahrt werden.
Truststore: Eine Datei mit den Zertifikaten der vertrauenswürdigen CA.
Um die Authentifizierung zwischen einem externen Client und Kafka einzurichten, das im Control Center ausgeführt wird, müssen beide Seiten über einen Schlüsselspeicher mit einem zugehörigen Zertifikat verfügen, das von einer Zertifizierungsstelle (CA) zusammen mit dem CA-Root-Zertifikat signiert wurde.
Darüber hinaus muss der Client über einen Truststore mit dem CA-Root-Zertifikat verfügen.
Das CA-Stammzertifikat ist für den Kafka-Broker und den Kafka-Client gleich.
Erstellen der erforderlichen Zertifikate
Dies wird im Anhang behandelt.
Kafka Broker SSL/TLS-Konfiguration im Control Center
Diese Anweisungen sind auf dem Control Center-Server auszuführen.
Bevor Sie fortfahren, müssen Sie den Keystore erstellen, der das SSL-Zertifikat enthält, indem Sie den Anweisungen im Anhang folgen. Die unten genannten Pfade stammen aus diesen Anweisungen.
Der SSL-Keystore ist eine auf der Festplatte gespeicherte Datei mit der Dateierweiterung .jks.
Sobald Sie die erforderlichen Zertifikate sowohl für den Kafka-Broker als auch für den Kafka-Client erstellt haben, können Sie fortfahren, indem Sie den Kafka-Broker konfigurieren, der im Kontrollzentrum ausgeführt wird. Sie müssen Folgendes wissen:
<public_hostname>: Der öffentliche Hostname von Control Center; dies muss auflösbar und für Kafka-Clients zugänglich sein.<keystore_pwd>: Das Keystore-Passwort, das beim Erstellen des SSL-Zertifikats angegeben wurde.<admin_pwd>und<client_pwd>: Dies sind die Kennwö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 gezeigt.
Bearbeiten oder hängen sudo Sie die folgenden Eigenschaften in /etc/kafka/server.propertiesan und fügen Sie die obigen Variablen wie gezeigt ein:
Nicht entfernen PLAINTEXT://localhost:9092; Dies unterbricht die Funktionalität des Control Center, da interne Dienste nicht kommunizieren können.
...
# The addresses that the Kafka broker listens on.
listeners=PLAINTEXT://localhost:9092,SASL_SSL://0.0.0.0:9093
# These are the hosts advertised back to any client connecting.
advertised.listeners=PLAINTEXT://localhost:9092,SASL_SSL://<public_hostname>:9093
...
####### CUSTOM CONFIG
# SSL CONFIGURATION
ssl.endpoint.identification.algorithm=
ssl.keystore.location=/var/ssl/private/kafka.server.keystore.jks
ssl.keystore.password=<keystore_pwd>
ssl.key.password=<keystore_pwd>
ssl.client.auth=none
ssl.protocol=TLSv1.2
# SASL configuration
sasl.enabled.mechanisms=PLAIN
listener.name.sasl_ssl.plain.sasl.jaas.config=org.apache.kafka.common.security.plain.PlainLoginModule required \
username="admin" \
password="<admin_pwd>" \
user_admin="<admin_pwd>" \
user_client="<client_pwd>";
# NOTE more users can be added with user_<name>=
# Authorization, turn on ACLs
authorizer.class.name=kafka.security.authorizer.AclAuthorizer
super.users=User:admin
Einrichten von Zugriffssteuerungslisten (ACLs)
ACLs auf localhost aktivieren
Wir müssen zuerst ACLs für localhost einrichten, damit Control Center selbst weiterhin auf Kafka zugreifen kann. Wenn dies nicht getan wird, werden die Dinge kaputt gehen.
######### ACLs entries for anonymous users /usr/lib/kafka/bin/kafka-acls.sh \ --authorizer kafka.security.authorizer.AclAuthorizer \ --authorizer-properties zookeeper.connect=localhost:2181 \ --add --allow-principal User: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 User: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 User:ANONYMOUS --allow-host 127.0.0.1 --group '*'
Dann müssen wir ACLs für den externen schreibgeschützten Zugriff aktivieren, damit externe Benutzer die paa.public.* Themen lesen können.
Eine genauere Steuerung finden Sie in der offiziellen Kafka-Dokumentation.
######### ACLs entries for external users /usr/lib/kafka/bin/kafka-acls.sh \ --authorizer kafka.security.authorizer.AclAuthorizer \ --authorizer-properties zookeeper.connect=localhost:2181 \ --add --allow-principal User:* --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 User:* --operation read --operation describe \ --topic paa.public. --resource-pattern-type prefixed
Sobald Sie damit fertig sind, müssen Sie die Dienste neu starten:
sudo ncc services restart
Um zu überprüfen, ob ein Client eine sichere Verbindung herstellen kann, führen Sie den folgenden Befehl auf einem externen Clientcomputer (nicht auf dem Control Center-Server) aus. Unten PUBLIC_HOSTNAME ist der Hostname des Control Centers:
openssl s_client -debug -connect ${PUBLIC_HOSTNAME}:9093 -tls1_2 | grep "Secure Renegotiation IS supported"
Secure Renegotiation IS supported
Um sicherzustellen, dass interne Dienste Zugriff auf den Kafka-Server erhalten haben, überprüfen Sie bitte die folgenden Logfiles:
/var/log/kafka/server.log/var/log/kafka/kafka-authorizer.log
Prüfen der externen Clientkonnektivität
KafkaCat
Diese Anweisungen müssen auf einem Client-Computer (nicht auf dem Control-Center-Server) ausgeführt werden.
Um Metrikinformationen 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 kafkacat Dienstprogramm verwenden, das im Abschnitt Überprüfen der Funktionsweise der Streaming-API im Kontrollzentrum installiert wurdeÜberprüfen der Funktionsweise der Streaming-API im Kontrollzentrum.
Führen Sie die folgenden Schritte aus:
Unten sehen Sie den Benutzer, CLIENT_USER der zuvor in der Datei /etc/kafka/server.properties im Kontrollzentrum angegeben wurde: user_client nämlich und das dort festgelegte Passwort.
Das CA-Root-Zertifikat, das zum Signieren des serverseitigen SSL-Zertifikats verwendet wird, muss auf dem Client vorhanden sein.
-
Erstellen Sie eine Datei
client.propertiesmit folgendem Inhalt:security.protocol=SASL_SSL ssl.ca.location={PATH_TO_CA_CERT} sasl.mechanisms=PLAIN sasl.username={CLIENT_USER} sasl.password={CLIENT_PASSWORD}Dabei ist
{PATH_TO_CA_CERT}ist der Speicherort des CA-Stammzertifikats, das vom Kafka-Broker verwendet wird.{CLIENT_USER}und{CLIENT_PASSWORD}sind die Benutzeranmeldeinformationen für den Client.
-
Führen Sie den folgenden Befehl aus, um die Nachricht anzuzeigen, die von verwendet wird
kafkacat:export KAFKA_FQDN=<Control Center hostname> export METRICS_TOPIC=paa.public.accounts.<account short name>.metrics kafkacat -b ${KAFKA_FQDN}:9093 -F client.properties -t ${METRICS_TOPIC} -C -eDabei
{METRICS_TOPIC}ist der Name des Kafka-Themas mit Präfix"paa.public.".
Ältere Versionen von kafkacat bieten keine -F Möglichkeit, die Client-Einstellungen aus einer Datei zu lesen. Wenn Sie eine solche Version verwenden, müssen Sie die gleichen Einstellungen über die Befehlszeile wie unten gezeigt angeben.
kafkacat -b ${KAFKA_FQDN}:9093 \
-X security.protocol=SASL_SSL \
-X ssl.ca.location={PATH_TO_CA_CERT} \
-X sasl.mechanisms=PLAIN \
-X sasl.username={CLIENT_USER} \
-X sasl.password={CLIENT_PASSWORD} \
-t ${METRICS_TOPIC} -C -e
Um die Konnektivität zu debuggen, können Sie die -d folgende Option verwenden:
Debug consumer communications
kafkacat -d consumer -b ${KAFKA_FQDN}:9093 -F client.properties -t ${METRICS_TOPIC} -C -e
# Debug broker communications
kafkacat -d broker -b ${KAFKA_FQDN}:9093 -F client.properties -t ${METRICS_TOPIC} -C -e
Lesen Sie unbedingt die Dokumentation für die verwendete Kafka-Clientbibliothek, da sich die Eigenschaften von denen in client.propertiesunterscheiden können.
Format der Nachricht
Die Nachrichten, die für die Metrik- und Metadatenthemen verwendet werden, werden im Format Protokollpuffer (protobuf) serialisiert (siehe developers.google.com/protocol-buffers). Die Schemas für diese Nachrichten entsprechen dem folgenden Format:
Metriken Protobuf-Schema
syntax = "proto3";
import "google/protobuf/timestamp.proto";
package paa.streamingapi;
option go_package = ".;paa_streamingapi";
message Metrics {
google.protobuf.Timestamp timestamp = 1;
map<string, MetricValue> values = 2;
int32 stream_id = 3;
}
/**
* A metric value can be either an integer or a float.
*/
message MetricValue {
oneof type {
int64 int_val = 1;
float float_val = 2;
}
}
Metadaten-Protobuf-Schema
syntax = "proto3";
package paa.streamingapi;
option go_package = ".;paa_streamingapi";
message Metadata {
int32 stream_id = 1;
string stream_name = 2;
map <string, string> tags = 13;
}
Beispiele für Kunden
Diese Befehle sollen auf einem externen Client, z. B. Ihrem Laptop oder ähnlichem, und nicht im Control Center ausgeführt werden.
Damit Metrikinformationen angezeigt werden, stellen Sie sicher, dass mindestens ein Monitor im Control Center ausgeführt wird.
Der Control Center-Tarball enthält das Archiv paa-streaming-api-client-examples.tar.gz (client-examples), das ein Python-Beispielskript enthält, das die Verwendung der Streaming-API zeigt.
- Clientbeispiele für die Installation und Konfiguration
- anhand von Clientbeispielen
- Validieren der externen Clientauthentifizierung
Clientbeispiele für die Installation und Konfiguration
Sie finden client-examples im Ordner "Paragon Active Assurance Control Center":
export CC_VERSION=4.4.0
cd ./paa-control-center_${CC_VERSION}
ls paa-streaming-api-client-examples*
Für die Installation client-examples auf Ihrem externen Client-Computer gehen Sie wie folgt vor:
# Create directory for extracting the content of the client examples tarball mkdir paa-streaming-api-client-examples # Extract the content of the client examples tarball tar xzf paa-streaming-api-client-examples.tar.gz -C paa-streaming-api-client-examples # Go to the newly created directory cd paa-streaming-api-client-examples
client-examples erfordert die Ausführung von Docker. Downloads und Installationsanleitungen für Docker finden Sie unter https://docs.docker.com/engine/install.
anhand von Clientbeispielen
Die client-examples Tools können entweder im einfachen oder im erweiterten Modus ausgeführt werden, um Beispiele unterschiedlicher Komplexität zu erstellen. In beiden Fällen ist es auch möglich, die Beispiele mit einer Konfigurationsdatei auszuführen, die zusätzliche Eigenschaften zur weiteren Anpassung der Client-Seite enthält.
Basis-Modus
Im einfachen Modus werden die Metriken und ihre Metadaten separat gestreamt. Dazu hört sich der Client jedes Kafka-Thema an, das für den externen Zugriff verfügbar ist, und druckt die empfangenen Nachrichten einfach in die Konsole.
Um die Ausführung der grundlegenden Beispiele zu starten, führen Sie Folgendes aus:
./build.sh run-basic --kafka-brokers localhost:9092 --account ACCOUNT_SHORTNAME
Dabei ACCOUNT_SHORTNAME ist der Kurzname des Kontos, von dem Sie die Metriken abrufen möchten.
Um die Ausführung des Beispiels zu beenden, drücken Sie STRG+C. (Es kann zu einer leichten Verzögerung kommen, bevor die Ausführung beendet wird, da der Client auf ein Timeoutereignis wartet.)
Erweiterter Modus
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 Metadatenmeldungen. Dies ist möglich, weil in jeder Metrikmeldung ein stream id Feld vorhanden ist, das sich auf die entsprechende Metadatenmeldung bezieht.
Führen Sie zum Ausführen der erweiterten Beispiele Folgendes aus:
./build.sh run-advanced --kafka-brokers localhost:9092 --account ACCOUNT_SHORTNAME
Dabei ACCOUNT_SHORTNAME ist der Kurzname des Kontos, von dem Sie die Metriken abrufen möchten.
Um die Ausführung des Beispiels zu beenden, drücken Sie STRG+C. (Es kann zu einer leichten Verzögerung kommen, bevor die Ausführung beendet wird, da der Client auf ein Timeoutereignis wartet.)
Zusätzliche Einstellungen
Es ist möglich, die Beispiele mit zusätzlicher Konfiguration des Clients auszuführen, indem Sie die --config-file Option gefolgt von einem Dateinamen mit Eigenschaften im Format key=value.
./build.sh run-advanced \ --kafka-brokers localhost:9092 \ --account ACCOUNT_SHORTNAME \ --config-file client_config.properties
Alle Dateien, auf die im obigen Befehl verwiesen wird, müssen sich im aktuellen Verzeichnis befinden und nur über relative Pfade referenziert werden. Dies gilt sowohl für das --config-file Argument als auch für alle Einträge in der Konfigurationsdatei, die Dateispeicherorte beschreiben.
Validieren der externen Clientauthentifizierung
Um die Client-Authentifizierung von außerhalb des Kontrollzentrums mit client-exampleszu validieren, führen Sie die folgenden Schritte aus:
-
Wechseln Sie im Ordner "Paragon Active Assurance Control Center" zum
paa-streaming-api-client-examplesOrdner:cd paa-streaming-api-client-examples
- Kopieren Sie das CA-Stammzertifikat
ca-certin das aktuelle Verzeichnis. -
Erstellen Sie eine
client.propertiesDatei mit folgendem Inhalt:security.protocol=SASL_SSL ssl.ca.location=ca-cert sasl.mechanism=PLAIN sasl.username={CLIENT_USER} sasl.password={CLIENT_PASSWORD}wobei
{CLIENT_USER}und{CLIENT_PASSWORD}die Benutzeranmeldeinformationen für den Client sind. -
Führen Sie grundlegende Beispiele durch:
export KAFKA_FQDN=<Control Center hostname> ./build.sh run-basic --kafka-brokers ${KAFKA_FQDN}:9093 \ --account ACCOUNT_SHORTNAME --config-file client.propertiesDabei
ACCOUNT_SHORTNAMEist der Kurzname des Kontos, von dem Sie die Metriken abrufen möchten. -
Führen Sie erweiterte Beispiele aus:
export KAFKA_FQDN=<Control Center hostname> ./build.sh run-advanced --kafka-brokers ${KAFKA_FQDN}:9093 \ --account ACCOUNT_SHORTNAME --config-file client.properties
Anhang
In diesem Anhang wird beschrieben, wie Sie Folgendes erstellen:
- eine Keystore-Datei zum Speichern des SSL-Zertifikats des Kafka-Brokers
- eine Truststore-Datei zum Speichern des Stammzertifikats der Zertifizierungsstelle (CA), das zum Signieren des Kafka-Brokerzertifikats verwendet wird.
- Erstellen eines Kafka-Brokerzertifikats
- Erstellen des Kunden-Truststores
- Erstellen des Keystores für den Kafka-Broker
Erstellen eines Kafka-Brokerzertifikats
Erstellen eines Zertifikats mit einer echten Zertifizierungsstelle (empfohlen)
Es wird empfohlen, ein echtes SSL-Zertifikat von einer vertrauenswürdigen CA zu erhalten.
Nachdem Sie sich für eine CA entschieden haben, kopieren Sie deren CA-Stammzertifikatdatei ca-cert in Ihren eigenen Pfad, wie unten gezeigt:
export CA_PATH=~/my-ca
mkdir ${CA_PATH}
cp ca-cert ${CA_PATH}
Erstellen Sie Ihre eigene Zertifizierungsstelle
Normalerweise sollten Sie Ihr Zertifikat von einer echten Zertifizierungsstelle signieren lassen; siehe den vorherigen Unterabschnitt. Das Folgende ist nur ein Beispiel.
Hier erstellen wir unsere eigene Stammzertifikatsdatei der Zertifizierungsstelle (CA), die 999 Tage gültig ist (in der Produktion nicht empfohlen):
# Create a directory for storing the CA
export CA_PATH=~/my-ca
mkdir ${CA_PATH}
# Generate the CA certificate
openssl req -new -x509 -keyout ${CA_PATH}/ca-key -out ${CA_PATH}/ca-cert -days 999
Erstellen des Kunden-Truststores
Jetzt können Sie eine Truststore-Datei erstellen, die die ca-cert oben generierten enthält. Diese Datei wird vom Kafka-Client benötigt, der auf die Streaming-API zugreift:
keytool -keystore kafka.client.truststore.jks \
-alias CARoot \
-importcert -file ${CA_PATH}/ca-cert
Da sich das CA-Zertifikat nun im Truststore befindet, vertraut der Client jedem damit signierten Zertifikat.
Sie sollten die Datei kafka.client.truststore.jks an einen bekannten Speicherort auf Ihrem Clientcomputer kopieren und in den Einstellungen darauf zeigen.
Erstellen des Keystores für den Kafka-Broker
Um das Kafka-Broker-SSL-Zertifikat und dann den Keystore kafka.server.keystore.jkszu generieren, gehen Sie wie folgt vor:
Generieren des SSL-Zertifikats
Unten ist 999 die Anzahl der Tage Gültigkeit des Keystores und FQDN der vollqualifizierte Domänenname des Clients (öffentlicher Hostname des Knotens).
Es ist wichtig, dass der FQDN genaue Hostname ü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/private
export FQDN=<Control Center hostname>
keytool -keystore kafka.server.keystore.jks \
-alias server \
-validity 999 \
-genkey -keyalg RSA -ext SAN=dns:${FQDN}
Erstellen Sie eine Zertifikatsignieranforderung und speichern Sie sie in der Datei mit dem Namen cert-server-request:
keytool -keystore kafka.server.keystore.jks \
-alias server \
-certreq \
-file cert-server-request
Sie sollten die Datei cert-server-request nun an Ihre Zertifizierungsstelle (CA) senden, wenn Sie eine echte Zertifizierungsstelle verwenden. Sie senden dann das signierte Zertifikat zurück. Wir werden uns wie cert-server-signed folgt darauf beziehen.
Signieren des SSL-Zertifikats mit einem selbst erstellten CA-Zertifikat
Auch hier wird die Verwendung einer eigenen CA in einem Produktivsystem nicht empfohlen.
Signieren Sie das Zertifikat mit der CA mithilfe der Datei cert-server-request, die das signierte Zertifikat cert-server-signederzeugt. Siehe unten; ca-password ist das Kennwort, das beim Erstellen des CA-Zertifikats festgelegt wird.
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 \
-days 999 -CAcreateserial \
-passin pass:{ca-password}
Importieren des signierten Zertifikats in den Keystore
Importieren Sie das ca-cert Stammzertifikat in den Keystore:
keytool -keystore kafka.server.keystore.jks \
-alias ca-cert \
-import \
-file ${CA_PATH}/ca-cert
Importieren Sie das signierte Zertifikat mit der Bezeichnung :cert-server-signed
keytool -keystore kafka.server.keystore.jks \
-alias server \
-import \
-file cert-server-signed
Die Datei kafka.server.keystore.jks sollte an einen bekannten Speicherort auf dem Control Center-Server kopiert und dann in /etc/kafka/server.propertiesreferenziert werden.