Routing Active Testing Streaming API
Gids

Inleiding

This guide describes how to extract data from Routing Active Testing via the product’s streaming API.
The API as well as the streaming client are included in the Routing Active Testing installation. However, a bit of configuration is needed before you can use the API. This is covered in the “Configuring the Streaming API” on page 1 chapter.
Konfigureer die Streaming API

verbyview

Hierdie hoofstuk beskryf hoe om die Streaming API op te stel om in te teken op maatstafboodskappe via Kafka.
Hieronder gaan ons deur:

• Hoe om die Streaming API te aktiveer
• Hoe om Kafka op te stel om na eksterne kliënte te luister
• Hoe om Kafka op te stel om ACL's te gebruik en SSL-enkripsie vir genoemde kliënte op te stel

Wat is Kafka?
Kafka is 'n gebeurtenisstromingsplatform wat intydse vaslegging van data moontlik maak wat vanaf verskeie gebeurtenisbronne (sensors, databasisse, mobiele toestelle) gestuur word in die vorm van gebeurtenisstrome, sowel as die duursame berging van hierdie gebeurtenisstrome vir latere herwinning en manipulasie.
Met Kafka is dit moontlik om die gebeurtenisstroming end-tot-end op 'n verspreide, hoogs skaalbare, elastiese, foutverdraagsame en veilige manier te bestuur.
LET WEL: Kafka can be configured in many different ways and was designed for scalability and redundant systems. This document focuses only on how to configure it to make use of the Streaming API feature found in Routing Active Testing Control Center. For more advanced setups we refer to the official Kafka documentation: kafka.apache.org/26/documentation.html.
Terminologie

• Kafka: Gebeurtenisstroomplatform.
• Kafka-onderwerp: Versameling van gebeure.
• Kafka-intekenaar/verbruiker: Komponent verantwoordelik vir die herwinning van gebeure wat in 'n Kafka-onderwerp gestoor is.
• Kafka-makelaar: Bergingslaagbediener van 'n Kafka-kluster.
• SSL/TLS: SSL is 'n veilige protokol wat ontwikkel is om inligting veilig oor die internet te stuur. TLS is die opvolger van SSL, wat in 1999 bekendgestel is.
• SASL: Raamwerk wat meganismes verskaf vir gebruikersverifikasie, data-integriteitkontrolering en enkripsie.
• Streaming API subscriber: Component responsible for retrieval of events stored in topics defined in Routing Active Testing and meant for external access.
• Sertifikaat-owerheid: 'n Betroubare entiteit wat publieke sleutelsertifikate uitreik en herroep.
• Sertifikaat-owerheid-wortelsertifikaat: Publieke sleutelsertifikaat wat 'n sertifikaatowerheid identifiseer.

Hoe die Streaming API werk
Soos voorheen genoem, laat die Streaming API eksterne kliënte toe om inligting oor statistieke van Kafka af te haal.
Alle maatstawwe wat deur die toetsagente tydens 'n toets- of moniteringstaak ingesamel word, word na die stroomdiens gestuur.
Na 'n verwerkingsfase publiseer die Stream-diens daardie maatstawwe op Kafka saam met bykomende metadata.
Kafka Onderwerpe
Kafka has the concept of topics to which all data is published. In Routing Active Testing there are many such Kafka topics available; however, only a subset of these are meant for external access.
Each Routing Active Testing account in Control Center has two dedicated topics. Below, ACCOUNT is the account short name:

• paa.publieke.rekeninge.{REKENING}.metrieke
• Alle maatstafboodskappe vir die gegewe rekening word na hierdie onderwerp gepubliseer
• Groot hoeveelhede data
• Hoë opdateringsfrekwensie
• paa.publieke.rekeninge.{REKENING}.metadata
• Bevat metadata wat verband hou met die maatstawwe data, bvample die toets, monitor of toetsagent wat met die maatstawwe geassosieer word
• Klein hoeveelhede data
• Lae opdateringfrekwensie

Aktiveer die Streaming API
LET WEL: These instructions are to be run on the Control Center server using sudor.
Aangesien die Streaming API 'n bietjie oorhoofse koste by die beheersentrum voeg, is dit nie by verstek geaktiveer nie. Om die API te aktiveer, moet ons eers die publikasie van metrieke aan Kafka in die hoofkonfigurasie aktiveer file:

• /etc/netrounds/netrounds.conf

KAFKA_METRICS_ENABLED = Waar
KAFKA_PUBLISH_METADATA_FOR_STREAMS = True

WAARSKUWING: Deur hierdie kenmerk te aktiveer, kan beheersentrum-werkverrigting beïnvloed. Maak seker dat jy jou instansie daarvolgens gedimensioneer het.
Volgende, om die aanstuur van hierdie maatstawwe na die korrekte Kafka-onderwerpe moontlik te maak:

• /etc/netrounds/metrics.yaml

streaming-api: waar
Om die Streaming API-dienste te aktiveer en te begin, hardloop:

• sudo ncc-dienste maak tydskaalb-metrieke moontlik
• sudo ncc dienste begin timescaledb statistieke

Ten slotte, herbegin die dienste:

• sudo ncc dienste herbegin

LET WEL: The KAFKA_PUBLISH_RESOURCES setting has been deprecated. It should be removed from your configuration. Use KAFKA_PUBLISH_METADATA_FOR_STREAMS = True instead.
Verifieer dat die stroom-API in beheersentrum werk
LET WEL: Hierdie instruksies moet op die Beheersentrumbediener uitgevoer word.
You can now verify that you are receiving metrics on the correct Kafka topics. To do so, install the Kafka cat utility:

• sudo apt-get update
• sudo apt-get install kafkacat

If you have a test or monitor running in Control Center, you should be able to use Kafka cat to receive metrics and metadata on these topics.
Vervang my rekening met die kort naam van jou rekening (dit is wat jy in jou beheersentrum sien URL):

• uitvoer METRICS_TOPIC=paa.public.accounts.myaccount.metrics
• uitvoer METADATA_TOPIC=paa.publieke.rekeninge.myrekening.metadata

Jy behoort nou metrieke te sien deur hierdie opdrag uit te voer:

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

Om view metadata, voer die volgende opdrag uit (let daarop dat dit nie so gereeld sal opdateer nie):

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

LET WEL: This is just a sanity check to make sure things are being published correctly. The data you see being published will be in binary form, which kafkacat will not decode by default. For properly subscribing to these topics, please see the “Client Examples” on page 13 section.
Dit verifieer dat ons 'n werkende stroom-API van binne die beheersentrum het. Dit is egter waarskynlik dat u eerder belangstel om toegang tot die data vanaf 'n eksterne kliënt te verkry. Die volgende afdeling beskryf hoe om Kafka oop te maak vir eksterne toegang.
Kafka oopmaak vir eksterne gashere
LET WEL: Hierdie instruksies moet op die Beheersentrumbediener uitgevoer word.
Kafka wat op die beheersentrum loop, is standaard gekonfigureer om slegs op localhost te luister vir interne gebruik.
Dit is moontlik om Kafka vir eksterne kliënte oop te maak deur Kafka-instellings te verander.
Koppel aan Kafka: Caveats
WAARSKUWING: Lees dit asseblief noukeurig, aangesien dit maklik is om verbindingsprobleme met Kafka te ondervind as jy nie hierdie konsepte verstaan ​​het nie.
In die beheersentrum-opstelling wat in hierdie dokument beskryf word, is daar slegs 'n enkele Kafka-makelaar.
Let egter daarop dat 'n Kafka-makelaar bedoel is om te loop as deel van 'n Kafka-kluster wat uit baie Kafka-makelaars kan bestaan.
Wanneer u aan 'n Kafka-makelaar koppel, word 'n aanvanklike verbinding deur die Kafka-kliënt opgestel. Oor hierdie verband sal die Kafka-makelaar op sy beurt 'n lys van "geadverteerde luisteraars" terugstuur, wat 'n lys van een of meer Kafka-makelaars is.
By ontvangs van hierdie lys sal die Kafka-kliënt ontkoppel en dan weer aan een van hierdie geadverteerde luisteraars koppel. Die geadverteerde luisteraars moet gasheername of IP-adresse bevat wat toeganklik is vir die Kafka-kliënt, anders sal die kliënt versuim om te koppel.
As SSL-enkripsie gebruik word, wat 'n SSL-sertifikaat insluit wat aan 'n spesifieke gasheernaam gekoppel is, is dit selfs belangriker dat die Kafka-kliënt die korrekte adres ontvang om aan te koppel, aangesien die verbinding anders verwerp kan word.
Lees meer oor Kafka-luisteraars hier: www.confluent.io/blog/kafka-listeners-explained
SSL/TLS-enkripsie
Om seker te maak dat slegs vertroude kliënte toegang tot Kafka en die Streaming API mag kry, moet ons die volgende opstel:

• Verifikasie: Kliënte moet gebruikersnaam en wagwoord verskaf deur 'n SSL/TLS veilige verbinding tussen die kliënt en Kafka.
• Magtiging: Geverifieerde kliënte kan take verrig wat deur ACL'e gereguleer word.

Hier is 'n verbyview:
Om ten volle te verstaan ​​hoe die SSL/TLS-kodering vir Kafka werk, verwys asseblief na die amptelike dokumentasie: docs.confluent.io/platform/current/kafka/encryption.html
SSL/TLS-sertifikaat verbyview
LET WEL: In hierdie onderafdeling sal ons die volgende terminologie gebruik:
Sertifikaat: 'n SSL-sertifikaat wat deur 'n sertifikaatowerheid (CA) onderteken is. Elke Kafka-makelaar het een.
Sleutelstoor: Die sleutelstoor file wat die sertifikaat stoor. Die sleutelstoor file bevat die private sleutel van die sertifikaat; daarom moet dit veilig bewaar word.
Trustwinkel: A file wat die vertroude CA-sertifikate bevat.
Om die verifikasie op te stel tussen 'n eksterne kliënt en Kafka wat in Beheersentrum loop, moet beide kante 'n sleutelstoor hê wat gedefinieer word met 'n verwante sertifikaat wat deur 'n sertifikaatowerheid (CA) onderteken is tesame met die CA-wortelsertifikaat.
Hierbenewens moet die kliënt ook 'n trustwinkel hê met die CA-wortelsertifikaat.
Die CA-wortelsertifikaat is algemeen vir die Kafka-makelaar en Kafka-kliënt.
Die skep van die vereiste sertifikate
Dit word in die “Bylaag” op bladsy 16 behandel.
Kafka Broker SSL/TLS-konfigurasie in beheersentrum
LET WEL: Hierdie instruksies moet op die Beheersentrumbediener uitgevoer word.
LET WEL: Before continuing, you must create the keystone which contains the SSL certificate by following the instructions in the “Appendix” on page 16. The paths mentioned below come from these instructions. The SSL keystore is a file gestoor op skyf met die file uitbreiding .jks.
Sodra jy die vereiste sertifikate wat vir beide die Kafka-makelaar en die Kafka-kliënt geskep is beskikbaar het, kan jy voortgaan deur die Kafka-makelaar wat in Beheersentrum loop op te stel. Jy moet die volgende weet:

• : Die publieke gasheernaam van Beheersentrum; dit moet oplosbaar en toeganklik wees vir Kafka-kliënte.
• : Die sleutelstoor wagwoord verskaf wanneer die SSL-sertifikaat geskep word.
• en : Dit is die wagwoorde wat jy vir die admin- en kliëntgebruiker onderskeidelik wil stel. Let daarop dat jy meer gebruikers kan byvoeg, soos aangedui in die bvample.

Edit or append (with sudo access) the properties below in /etc/kafka/server.properties, inserting the above
variables as shown:
WAARSKUWING: Moenie PLAINTEXT://localhost:9092 verwyder nie; dit sal beheersentrum-funksionaliteit verbreek aangesien interne dienste nie sal kan kommunikeer nie.
…
# Die adresse waarna die Kafka-makelaar luister.
luisteraars=PLAINTEXT://localhost:9092,SASL_SSL://0.0.0.0:9093
# Dit is die gashere wat geadverteer word na enige kliënt wat verbind.
advertised.listeners=PLAINTEXT://localhost:9092,SASL_SSL:// :9093
… ####### CUSTOM CONFIG
# SSL KONFIGURASIE
ssl.endpoint.identification.algorithm=
ssl.keystore.location=/var/ssl/private/kafka.server.keystore.jks
ssl.keystore.password=
ssl.key.password=
ssl.client.auth=geen
ssl.protocol=TLSv1.2
# SASL-konfigurasie
sasl.enabled.mechanisms=PLAIN
listener.name.sasl_ssl.plain.sasl.jaas.config=org.apache.kafka.common.security.plain.PlainLoginMo
dule vereis \
gebruikersnaam = "admin" \
wagwoord = " ” \
User:admin=”<admin_pwd>” \
user client=”<client_pwd>”;
# LET WEL meer gebruikers kan bygevoeg word met user_ =
# Magtiging, skakel ACL's aan
authorizer.class.name=kafka.security.authorizer.AclAuthorizer
superusers=User:admin
Die opstel van toegangsbeheerlyste (ACL's)
Skakel ACL's aan op localhost
  WAARSKUWING: Ons moet eers ACL's vir localhost opstel, sodat beheersentrum self steeds toegang tot Kafka kan kry. As dit nie gedoen word nie, sal dinge breek.
######### ACLs-inskrywings vir anonieme gebruikers
/usr/lib/kafka/bin/kafka-acls.sh \
–authoriser 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 \
–authoriser kafka.security.authorizer.AclAuthorizer \
–authorizer-properties zookeeper.connect=localhost:2181 \
–add –allow-principal User:ANONYMOUS –allow-host 127.0.0.1 –onderwerp '*'
/usr/lib/kafka/bin/kafka-acls.sh \
–authoriser kafka.security.authorizer.AclAuthorizer \
–authorizer-properties zookeeper.connect=localhost:2181 \
–add –allow-principal User: ANONYMOUS –allow-host 127.0.0.1 –group ‘*’
Ons moet dan ACL's aktiveer vir eksterne leesalleen-toegang, sodat eksterne gebruikers toegelaat word om die paa.public.*-onderwerpe te lees.
LET WEL: Vir meer fynkorrelige beheer, verwys asseblief na die amptelike Kafka-dokumentasie.
######### ACLs-inskrywings vir eksterne gebruikers
/usr/lib/kafka/bin/kafka-acls.sh \
–authoriser kafka.security.authorizer.AclAuthorizer \
–authorizer-properties zookeeper.connect=localhost:2181 \
–add –allow-principal Gebruiker:* –operation read –operation describe \
-groep 'NCC'
/usr/lib/kafka/bin/kafka-acls.sh \
–authoriser kafka.security.authorizer.AclAuthorizer \
–authorizer-properties zookeeper.connect=localhost:2181 \
–add –allow-principal Gebruiker:* –operation read –operation describe \
–onderwerp paa.publiek. –hulpbron-patroon-tipe voorvoegsel
Sodra u hiermee klaar is, moet u die dienste herbegin:
sudo ncc dienste herbegin
Om te verifieer dat 'n kliënt 'n veilige verbinding kan vestig, voer die volgende opdrag op 'n eksterne kliëntrekenaar uit (nie op die Beheersentrumbediener nie). Hieronder is PUBLIC_HOSTNAME die beheersentrum-gasheernaam:
openssl s_client -debug -connect ${PUBLIC_HOSTNAME}:9093 -tls1_2 | grep "Veilige heronderhandeling IS ondersteun"
In die opdraguitvoer moet u die bedienersertifikaat sowel as die volgende sien:
Veilige heronderhandeling IS ondersteun
Gaan asseblief die volgende logboek na om te verseker dat interne dienste toegang tot die Kafka-bediener verleen isfiles:

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

Bekragtiging van eksterne kliëntkonnektiwiteit
kafkaat
LET WEL: Hierdie instruksies moet op 'n kliëntrekenaar uitgevoer word (nie op die Beheersentrumbediener nie).
LET WEL: Om metrieke inligting te vertoon, maak seker dat ten minste een monitor in Beheersentrum loop.
Om konnektiwiteit as 'n eksterne kliënt te verifieer en te valideer, is dit moontlik om die kafkacat-hulpmiddel te gebruik wat in die afdeling "Verifieer dat die stroom-API in beheersentrum werk" op bladsy 4 geïnstalleer is.
Voer die volgende stappe uit:
LET WEL: Hieronder is CLIENT_USER die gebruiker wat voorheen in die file /etc/kafka/ server.properties in Control Center: namely, user_client and the password set there. The CA root certificate used to sign the server side SSL certificate must be present on the client.
Skep 'n file client.properties met die volgende inhoud:
security.protocol=SASL_SSL
ssl.ca.location={PATH_TO_CA_CERT}
sasl.mechanisms=PLAIN
sasl.username={CLIENT_USER}
sasl.password={CLIENT_PASSWORD}
waar

• {PATH_TO_CA_CERT} is die ligging van die CA-wortelsertifikaat wat deur die Kafka-makelaar gebruik word
• {CLIENT_USER} en {CLIENT_PASSWORD} is die gebruikerbewyse vir die kliënt.
• Voer die volgende opdrag uit om die boodskap te sien wat deur kafkacat verbruik word:

uitvoer KAFKA_FQDN=
uitvoer METRICS_TOPIC=paa.publieke.rekeninge. .metrieke
kafkacat -b ${KAFKA_FQDN}:9093 -F client.properties -t ${METRICS_TOPIC} -C -e
waar {METRICS_TOPIC} die naam is van die Kafka-onderwerp met voorvoegsel "paa.public".
LET WEL: Ouer weergawes van kafkacat bied nie die -F-opsie vir die lees van die kliëntinstellings vanaf a file. As jy so 'n weergawe gebruik, moet jy dieselfde instellings vanaf die opdragreël verskaf soos hieronder getoon.
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
Om die konneksie te ontfout, kan jy die -d opsie gebruik:
Ontfout verbruikerskommunikasie
kafkacat -d verbruiker -b ${KAFKA_FQDN}:9093 -F client.properties -t ${METRICS_TOPIC} -C -e
# Ontfout makelaarkommunikasie
kafkacat -d makelaar -b ${KAFKA_FQDN}:9093 -F client.properties -t ${METRICS_TOPIC} -C -e
Maak seker dat u na die dokumentasie verwys vir die Kafka-kliëntbiblioteek wat gebruik word, aangesien die eienskappe kan verskil van dié in client.properties.
Boodskapformaat
The messages used for the metrics and metadata topics are serialized in the Protocol buffers (protobuf)format (see developers.google.com/protocol-buffers). Die skemas vir hierdie boodskappe voldoen aan die volgende formaat:
Metrieke Protobuf Skema
sintaksis = "proto3";
invoer "google/protobuf/timestamp.proto";
pakkie paa.streamingapi;
opsie go_package = ".;paa_streamingapi";
boodskap Metrics {
google.protobuf.Timestamp tyeamp = 1;
kaart waardes = 2;
int32 stroom_id = 3;
}
/**
* 'n Metrieke waarde kan óf 'n heelgetal óf 'n dryfkrag wees.
*/
boodskap MetricValue {
een van tipe {
int64 int_val = 1;
float float_val = 2;
}
}
Metadata Protobuf Skema
sintaksis = "proto3";
pakkie paa.streamingapi;
opsie go_package = ".;paa_streamingapi";
boodskap Metadata {
int32 stroom_id = 1;
string stroomnaam = 2;
kaart tags = 13;
}
Kliënt Bvamples
LET WEL: Hierdie opdragte is bedoel om op 'n eksterne kliënt te loop, bvample jou skootrekenaar of soortgelyke, en nie in beheersentrum nie.
LET WEL: Om metrieke inligting te vertoon, maak seker dat ten minste een monitor in Beheersentrum loop.
Die beheersentrum-tarball bevat die argief paa-streaming-api-client-examples.tar.gz (kliënt-bvamples), wat 'n example Python-skrip wat wys hoe om die Streaming API te gebruik.
Installeer en konfigureer kliënt Bvamples
Jy vind kliënt-eksamples in the Routing Active Testing Control Center folder:
uitvoer CC_VERSION=4.6.0
cd ./paa-control-center_${CC_VERSION}
ls paa-streaming-api-kliënt-eksamples*
Om kliënt-examples op u eksterne kliëntrekenaar, gaan soos volg voort:
# Skep gids om die inhoud van die kliënt bvamples tarball
mkdir paa-streaming-api-kliënt-eksamples
# Onttrek die inhoud van die kliënt bvamples tarball
tar xzf paa-streaming-api-kliënt-eksamples.tar.gz -C paa-streaming-api-kliënt-eksamples
# Gaan na die nuutgeskepte gids
cd paa-streaming-api-kliënt-eksamples
kliënt-eksamples vereis dat Docker loop. Aflaai- en installasie-instruksies vir Docker kan gevind word by https://docs.docker.com/engine/install.
Gebruik kliënt Examples
Die kliënt-eksamples gereedskap kan in óf basiese óf gevorderde modus hardloop om examplesings van verskillende kompleksiteit. In beide gevalle is dit ook moontlik om die ex uit te voeramples met 'n konfigurasie file wat bykomende eienskappe bevat vir verdere aanpassing van die kliëntkant.
Basiese modus
In basiese modus word die metrieke en hul metadata afsonderlik gestroom. Vir hierdie doel luister die kliënt na elke Kafka-onderwerp wat beskikbaar is vir eksterne toegang en druk eenvoudig die ontvangde boodskappe na die konsole.
Om die uitvoering van die basiese examples, hardloop:
./build.sh run-basic –kafka-makelaars localhost:9092 –rekening ACCOUNT_SHORTNAME
waar ACCOUNT_SHORTNAME die kort naam is van die rekening waaruit jy die maatstawwe wil kry.
Om die teregstelling van die example, druk Ctrl + C. (Daar kan 'n effense vertraging wees voordat die uitvoering stop omdat die kliënt wag vir 'n uittelgebeurtenis.)
Gevorderde modus
LET WEL: Metrieke word slegs vertoon vir HTTP-monitors wat in beheersentrum loop.
Uitvoering in gevorderde modus toon die korrelasie tussen metrieke en metadataboodskappe. Dit is moontlik danksy die teenwoordigheid in elke maatstafboodskap van 'n stroom-ID-veld wat na die ooreenstemmende metadataboodskap verwys.
Om die gevorderde examples, hardloop:
./build.sh run-advanced –kafka-brokers localhost:9092 –rekening ACCOUNT_SHORTNAME
waar ACCOUNT_SHORTNAME die kort naam is van die rekening waaruit jy die maatstawwe wil kry.
Om die teregstelling van die example, druk Ctrl + C. (Daar kan 'n effense vertraging wees voordat die uitvoering stop omdat die kliënt wag vir 'n uittelgebeurtenis.)
Bykomende instellings
Dit is moontlik om die examples met bykomende konfigurasie van die kliënt met behulp van die –config-file opsie gevolg deur 'n file naam wat eienskappe bevat in die vorm sleutel=waarde.
./build.sh run-gevorderde \
–kafka-makelaars localhost:9092 \
–rekening ACCOUNT_SHORTNAME \
-konfigurasie-file client_config.properties
LET WEL: Almal files waarna verwys word in die opdrag hierbo moet in die huidige gids geleë wees en verwys word deur slegs relatiewe paaie te gebruik. Dit geld beide vir die –config-file argument en aan alle inskrywings in die konfigurasie file wat beskryf file liggings.
Valideer eksterne kliënt-verifikasie
Om kliënt-verifikasie van buite die beheersentrum te bekragtig met behulp van kliënt-examples, voer die volgende stappe uit:

• From the Routing Active Testing Control Center folder, switch to the paa-streaming-api-client-examples gids:
  cd paa-streaming-api-kliënt-eksamples
• Kopieer die CA-wortelsertifikaat ca-cert na die huidige gids.
• Skep 'n client.properties file met die volgende inhoud:
  security.protocol=SASL_SSL
  ssl.ca.location=ca-sert
  sasl.mechanism=PLAIN
  sasl.username={CLIENT_USER}
  sasl.password={CLIENT_PASSWORD}
  waar {CLIENT_USER} en {CLIENT_PASSWORD} die gebruikerbewyse vir die kliënt is.
• Begin basiese examples:
  uitvoer KAFKA_FQDN=
  ./build.sh run-basic –kafka-makelaars ${KAFKA_FQDN}:9093 \
  –rekening ACCOUNT_SHORTNAME
  -konfigurasie-file kliënt.eiendomme
  waar ACCOUNT_SHORTNAME die kort naam is van die rekening waaruit jy die maatstawwe wil kry.
• Begin gevorderde examples:
  uitvoer KAFKA_FQDN=
  ./build.sh run-advanced –kafka-brokers ${KAFKA_FQDN}:9093 \
  –rekening ACCOUNT_SHORTNAME
  -konfigurasie-file kliënt.eiendomme

Bylaag

In hierdie bylaag beskryf ons hoe om te skep:

• 'n sleutelstoor file vir die stoor van die Kafka-makelaar SSL-sertifikaat
• 'n trustwinkel file vir die berging van die Sertifikaat-owerheid (CA)-wortelsertifikaat wat gebruik is om die Kafka-makelaarsertifikaat te onderteken.

Skep 'n Kafka-makelaarsertifikaat
Skep 'n sertifikaat deur 'n regte sertifikaatowerheid te gebruik (aanbeveel)
Dit word aanbeveel dat jy 'n regte SSL-sertifikaat van 'n betroubare CA kry.
Sodra jy op 'n CA besluit het, kopieer hul CA wortelsertifikaat ca-cert file na jou eie pad soos hieronder getoon:
uitvoer CA_PATH=~/my-ca
mkdir ${CA_PATH}
cp-sertifikaat ${CA_PATH}
Skep jou eie sertifikaatowerheid
LET WEL: Normaalweg moet jy jou sertifikaat laat onderteken deur 'n regte Sertifikaat-owerheid; sien die voorafgaande onderafdeling. Wat volg is net 'n eksample.
Hier skep ons ons eie Certificate Authority (CA) wortelsertifikaat file geldig vir 999 dae (nie aanbeveel in produksie):
# Skep 'n gids om die CA te stoor
uitvoer CA_PATH=~/my-ca
mkdir ${CA_PATH}
# Genereer die CA-sertifikaat
openssl req -new -x509 -keyout ${CA_PATH}/ca-key -out ${CA_PATH}/ca-cert -days 999
Die skep van die Client Truststore
Nou kan jy 'n trustwinkel skep file wat die ca-cert bevat wat hierbo gegenereer is. Hierdie file will be needed by the Kafka client that will access the Streaming API: keytool -keystore kafka.client.truststore.jks \
-alias CARoot \
-invoersertifikaat -file ${CA_PATH}/ca-sert
Noudat die CA-sertifikaat in die truststoor is, sal die kliënt enige sertifikaat wat daarmee onderteken is, vertrou.
Jy moet die kopieer file kafka.client.truststore.jks na 'n bekende plek op jou kliëntrekenaar en wys daarna in die instellings.
Die skep van die sleutelwinkel vir die Kafka-makelaar
Om die Kafka-makelaar SSL-sertifikaat en dan die sleutelstoor kafka.server.keystore.jks te genereer, gaan soos volg voort:
Genereer die SSL-sertifikaat
Use these commands to generate the SSL certificate. Below, 999 is the number of days of validity of the keystore.
sudo mkdir -p /var/ssl/privaat
sudo chown -R $USER: /var/ssl/privaat
cd /var/ssl/privaat
export CC_IP=<Control Center IP>
keytool -keystore kafka.server.keystore.jks \
-alias bediener \
-geldigheid 999 \
-genkey -keyalg RSA -ext SAN=ip:${CC_IP}
To verify the SSL certificate, you can use the following command:
keytool -v -list -keystore kafka.server.keystore.jks -alias server
You should ensure that the port 9093 is accessible from external clients.
Skep 'n sertifikaatondertekeningversoek en stoor dit in die file genaamd sert-bediener-versoek:
keytool -keystore kafka.server.keystore.jks \
-alias bediener \
-sertreq \
-file sert-bediener-versoek
Jy moet nou die file cert-server-versoek aan jou sertifikaatowerheid (CA) as jy 'n regte een gebruik. Hulle sal dan die getekende sertifikaat terugstuur. Ons sal hierna verwys as sertifikaat-bediener-onderteken hieronder.
Ondertekening van die SSL-sertifikaat deur 'n selfgeskepte CA-sertifikaat te gebruik
LET WEL: Weereens, die gebruik van jou eie CA word nie aanbeveel in 'n produksiestelsel nie.
Teken die sertifikaat deur die CA deur middel van die file cert-server-request, wat die ondertekende sertifikaat cert-server-signed produseer. Sien onder; ca-wagwoord is die wagwoord wat gestel is wanneer die CA-sertifikaat geskep word.
cd /var/ssl/privaat
openssl x509 -req \

• -CA ${CA_PATH}/ca-cert \
• -CAkey ${CA_PATH}/ca-sleutel \
• -in sert-bediener-versoek \
• -uit sert-bediener-onderteken \
• -dae 999 -CAcreateserial \
• -passin pas:{ca-wagwoord}

Voer die ondertekende sertifikaat in die sleutelstoor in
Voer die ca-cert-wortelsertifikaat in die sleutelstoor in:
keytool -keystore kafka.server.keystore.jks \
-alias ca-cert \
-invoer \
-file ${CA_PATH}/ca-sert
Voer die getekende sertifikaat in waarna verwys word as cert-server-signed:
keytool -keystore kafka.server.keystore.jks \
-alias bediener \
-invoer \
-file sert-bediener-onderteken
Die file kafka.server.keystore.jks moet na 'n bekende plek op die beheersentrumbediener gekopieer word, en daarna verwys word in /etc/kafka/server.properties.
Gebruik die Streaming API

Algemeen

Die streaming API haal beide toets- en monitordata. Dit is nie moontlik om een ​​van hierdie kategorieë uit te sonder nie.
Die stroom-API haal nie data van skripgebaseerde toetse (dié wat deur 'n reghoek in plaas van 'n figuursaagstuk in die beheersentrum GUI) voorgestel word, soos Ethernet-diensaktiveringstoetse en deursigtigheidstoetse.

Kafka Onderwerp Name

Die Kafka-onderwerpname vir die stroom-API is soos volg, waar %s die kort naam van die beheersentrumrekening is (aangedui wanneer die rekening geskep word):
konst (
uitvoerdernaam = "kafka"
metadataTopicTpl = "paa.public.accounts.%s.metadata"
metricsTopicTpl = "paa.public.accounts.%s.metrics"
)
Examples van die gebruik van die Streaming API
Die eksamples wat volg word gevind in die tarball paa-streaming-api-client-examples.tar.gz vervat in die beheersentrum-tarball.
Eerstens is daar 'n basiese example demonstreer hoe die metrieke en hul metadata afsonderlik gestroom word en druk eenvoudig die ontvangde boodskappe na die konsole. Jy kan dit soos volg laat loop:
sudo ./build.sh run-basic –kafka-brokers localhost:9092 –account ACCOUNT_SHORTNAME There is also a more advanced example waar metrieke en metadataboodskappe gekorreleer word. Gebruik hierdie opdrag om dit uit te voer:
sudo ./build.sh run-advanced –kafka-brokers localhost:9092 –account ACCOUNT_SHORTNAME You need to use sudo to run Docker commands such as the ones above. Optionally, you can follow the Linux post-installation steps to be able to run Docker commands without sudo. For details, go to docs.docker.com/engine/install/linux-postinstall.
Juniper Networks, die Juniper Networks-logo, Juniper en Junos is geregistreerde handelsmerke van Juniper Networks, Inc. in die Verenigde State en ander lande. Alle ander handelsmerke, diensmerke, geregistreerde handelsmerke of geregistreerde diensmerke is die eiendom van hul onderskeie eienaars. Juniper Networks aanvaar geen verantwoordelikheid vir enige onakkuraathede in hierdie dokument nie. Juniper Networks behou die reg voor om hierdie publikasie sonder kennisgewing te verander, te wysig, oor te dra of andersins te hersien. Kopiereg © 2025 Juniper Networks,
Inc. Alle regte voorbehou.

Dokumente / Hulpbronne

JUNIPER NETWORKS Routing Active Testing Solution Brief [pdf] Gebruikersgids Routing Active Testing Solution Brief, Active Testing Solution Brief, Testing Solution Brief, Solution Brief

Verwysings

• Gebruikershandleiding