Juniper NETWERKEN Streaming API Software

Produkt ynformaasje

Spesifikaasjes

• Produkt Namme: Paragon Active Assurance
• Ferzje: 4.1
• Publisearre Datum: 2023-03-15

Ynlieding:
Dizze hantlieding jout ynstruksjes oer hoe't jo gegevens út Paragon Active Assurance kinne ekstrahearje mei de streaming API fan it produkt. De streamingkliïnt en API binne opnommen yn 'e Paragon Active Assurance-ynstallaasje, mar wat konfiguraasje is fereaske foardat jo de API brûke. It konfiguraasjeproses wurdt behannele yn 'e seksje "De streaming API konfigurearje".

De streaming API konfigurearje:
De folgjende stappen beskriuwe it proses om de streaming API te konfigurearjen:

Oerview
Kafka is in evenemint-streaming-platfoarm ûntworpen foar real-time capture en opslach fan gegevens út ferskate boarnen. It makket it behear fan evenemintestreamen mooglik op in ferdielde, skalberbere, fouttolerante en feilige manier. Dizze hantlieding rjochtet him op it konfigurearjen fan Kafka om de Streaming API-funksje te brûken yn Paragon Active Assurance Control Center.

Terminology
De Streaming API lit eksterne kliïnten metrike ynformaasje fan Kafka ophelje. Metriken sammele troch de Test Agents tidens in test of tafersjochtaak wurde stjoerd nei de Stream-tsjinst. Nei ferwurking publisearret de Stream-tsjinst dizze metriken op Kafka tegearre mei ekstra metadata.

De Streaming API ynskeakelje
Om de Streaming API yn te skeakeljen, folgje dizze stappen:

1. Laad de folgjende kommando's op 'e Control Center-tsjinner mei sudo:

KAFKA_METRICS_ENABLED = Wiere sudo ncc tsjinsten ynskeakelje timescaledb metriken sudo ncc tsjinsten begjinne timescaledb metrics sudo ncc tsjinsten opnij starte

Ferifiearje dat de Streaming API wurket yn Control Center:
Om te kontrolearjen dat jo metriken ûntfange oer de juste Kafka-ûnderwerpen:

1. Ynstallearje it kafkacat-hulpprogramma mei de folgjende kommando's:
   sudo apt-get update
   sudo apt-get install kafkacat

2. Ferfange "myaccount" mei de koarte namme fan jo akkount yn 'e
   Control Center URL:
   eksportearje METRICS_TOPIC=paa.public.accounts.myaccount.metrics
   eksportearje METADATA_TOPIC=paa.public.accounts.myaccount.metadata

3. Rinne it folgjende kommando út nei view metriken:
   kafkacat -b ${KAFKA_FQDN}:9092 -t ${METRICS_TOPIC} -C -e
   Noat: It boppesteande kommando sil de metriken werjaan.
4. Nei view metadata, fier it folgjende kommando út:
   kafkacat -b ${KAFKA_FQDN}:9092 -t ${METADATA_TOPIC} -C -e

Noat: It boppesteande kommando sil metadata werjaan, mar it sil net sa faak bywurkje.

Opdrachtgever Examples
Foar klant eksamples en fierdere ynformaasje, ferwize nei side 14 fan de brûker hânboek.

FAQ (faak stelde fragen)

• F: Wat is Paragon Active Assurance?
  A: Paragon Active Assurance is in produkt dat tafersjoch- en testmooglikheden leveret.
• F: Wat is de Streaming API?
  A: De Streaming API is in funksje yn Paragon Active Assurance wêrmei eksterne kliïnten metrike ynformaasje fan Kafka kinne ophelje.
• F: Hoe kin ik de Streaming API ynskeakelje?
  A: Om de Streaming API yn te skeakeljen, folgje de stappen beskreaun yn 'e seksje "De Streaming API ynskeakelje" fan 'e brûkershantlieding.
• F: Hoe kin ik ferifiearje dat de Streaming API wurket?
  A: Ferwize nei de seksje "Befêstigje dat de Streaming API wurket yn Control Center" foar ynstruksjes oer hoe't jo de funksjonaliteit fan 'e Streaming API kinne ferifiearje.

Ynlieding

Dizze hantlieding beskriuwt hoe't jo gegevens kinne ekstrahearje fan Paragon Active Assurance fia de streaming API fan it produkt.
De API lykas de streamingkliïnt binne opnommen yn 'e Paragon Active Assurance-ynstallaasje. In bytsje konfiguraasje is lykwols nedich foardat jo de API kinne brûke. Dit wurdt behannele yn it "De streaming API konfigurearje" op side 1 haadstik.

Oerview
Dit haadstik beskriuwt hoe't jo de Streaming API konfigurearje om te abonnearjen op metrike berjochten fia Kafka.
pr
Hjirûnder geane wy ​​troch:

• Hoe kinne jo de Streaming API ynskeakelje
• Hoe Kafka konfigurearje om nei eksterne kliïnten te harkjen
• Hoe kinne jo Kafka konfigurearje om ACL's te brûken en SSL-fersifering yn te stellen foar neamde kliïnten

Wat is Kafka?
Kafka is in platfoarm foar streaming fan eveneminten wêrmei't real-time opname fan gegevens mooglik makket fan ferskate eveneminteboarnen (sensors, databases, mobile apparaten) yn 'e foarm fan evenemintstreamen, lykas ek duorsume opslach fan dizze evenemintstreamen foar letter opheljen en manipulaasje.
Mei Kafka is it mooglik om it evenemint streaming ein-oan-ein te behearjen op in ferspraat, heul skalberber, elastysk, fouttolerant en feilige manier.

NOAT: Kafka kin op in protte ferskillende manieren konfigureare wurde en is ûntworpen foar skalberens en oerstallige systemen. Dit dokumint rjochtet him allinich op hoe't jo it konfigurearje om gebrûk te meitsjen fan 'e Streaming API-funksje fûn yn Paragon Active Assurance Control Center. Foar mear avansearre opsetten ferwize wy nei de offisjele Kafka-dokumintaasje: kafka.apache.org/26/documentation.html.

Terminology

• Kafka: Event-streaming platfoarm.
• Kafka ûnderwerp: Samling fan eveneminten.
• Kafka abonnee / konsumint: Komponint ferantwurdlik foar opheljen fan eveneminten opslein yn in Kafka ûnderwerp.
• Kafka broker: Storage laach tsjinner fan in Kafka kluster.
• SSL/TLS: SSL is in feilich protokol ûntwikkele foar it feilich ferstjoeren fan ynformaasje oer it ynternet. TLS is de opfolger fan SSL, yntrodusearre yn 1999.
• SASL: Framework dat meganismen leveret foar brûkersautentikaasje, kontrôle fan gegevensintegriteit en fersifering.
• Streaming API abonnee: Komponint ferantwurdlik foar opheljen fan eveneminten opslein yn ûnderwerpen definiearre yn Paragon Active Assurance en bedoeld foar eksterne tagong.
• Sertifikaasjeautoriteit: In fertroude entiteit dy't sertifikaten foar iepenbiere kaaien útjout en ynlûkt.
• Certificate Authority root sertifikaat: Iepenbiere kaai sertifikaat dat identifisearret in Certificate Authority.

Hoe't de Streaming API wurket
Lykas earder neamd, lit de Streaming API eksterne kliïnten ynformaasje oer metriken fan Kafka ophelje.

Alle metriken sammele troch de Test Agents tidens in test of tafersjochtaak wurde stjoerd nei de Stream-tsjinst. Nei in ferwurkingsfaze publisearret de Stream-tsjinst dy metriken op Kafka tegearre mei ekstra metadata.

Kafka ûnderwerpen
Kafka hat it konsept fan ûnderwerpen wêrop alle gegevens wurde publisearre. Yn Paragon Active Assurance binne der in protte sokke Kafka-ûnderwerpen beskikber; lykwols, mar in subset fan dizze binne bedoeld foar eksterne tagong.
Elk Paragon Active Assurance-akkount yn Control Center hat twa tawijd ûnderwerpen. Hjirûnder is ACCOUNT de koarte namme fan it akkount:

• paa.public.accounts.{ACCOUNT}.metrics
  • Alle metrike berjochten foar it opjûne akkount wurde publisearre foar dit ûnderwerp
  • Grutte hoemannichten gegevens
  • Hege update frekwinsje
• paa.public.accounts.{ACCOUNT}.metadata
  • Befettet metadata relatearre oan de metrike gegevens, bygelyksample de test, monitor of Test Agent ferbûn mei de metriken
  • Lytse hoemannichten gegevens
  • Low update frekwinsje

De Streaming API ynskeakelje

NOAT: Dizze ynstruksjes moatte wurde útfierd op 'e Control Center-tsjinner mei sudo.

Sûnt de Streaming API wat overhead tafoeget oan it Control Center, is it net standert ynskeakele. Om de API yn te skeakeljen, moatte wy earst publisearjen fan metriken nei Kafka ynskeakelje yn 'e haadkonfiguraasje file:

• /etc/netrounds/netrounds.conf

KAFKA_METRICS_ENABLED = Wier

WARSKÔGING: It ynskeakeljen fan dizze funksje kin ynfloed hawwe op de prestaasjes fan Control Center. Soargje derfoar dat jo jo eksimplaar dien hawwe dimensionearre.

Folgjende, om it trochstjoeren fan dizze metriken yn te skeakeljen nei de juste Kafka-ûnderwerpen:

• /etc/netrounds/metrics.yaml

streaming-api: wier

Om de Streaming API-tsjinsten yn te skeakeljen en te begjinnen, útfiere:

• sudo ncc tsjinsten ynskeakelje timescaledb metriken
• sudo ncc tsjinsten begjinne timescaledb metriken

As lêste, start de tsjinsten opnij:

• sudo ncc tsjinsten opnij starte

Ferifiearje dat de streaming API wurket yn Control Center

NOAT: Dizze ynstruksjes moatte wurde útfierd op 'e Control Center-tsjinner.

Jo kinne no ferifiearje dat jo metriken ûntfange oer de juste Kafka-ûnderwerpen. Om dit te dwaan, ynstallearje it kafkacat-hulpprogramma:

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

As jo ​​​​in test of monitor hawwe dy't rint yn Control Center, moatte jo kafkacat kinne brûke om metriken en metadata oer dizze ûnderwerpen te ûntfangen.
Ferfang myn akkount mei de koarte namme fan jo akkount (dit is wat jo sjogge yn jo kontrôlesintrum URL):

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

Jo moatte no metriken sjen troch dit kommando út te fieren:

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

Nei view metadata, it folgjende kommando útfiere (notysje dat dit net sa faak sil bywurkje):

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

NOAT:
kafkacat"Client Examples ”op side 14

Dit ferifiearret dat wy in wurkjende Streaming API hawwe fanút Control Center. Jo binne lykwols wierskynlik ynteressearre yn tagong ta de gegevens fan in eksterne kliïnt ynstee. De folgjende paragraaf beskriuwt hoe't jo Kafka iepenje kinne foar eksterne tagong.

Kafka iepenje foar eksterne hosts

NOAT: Dizze ynstruksjes moatte wurde útfierd op 'e Control Center-tsjinner.

Standert is Kafka dy't rint op it Control Center konfigureare om allinich te harkjen op localhost foar yntern gebrûk. It is mooglik Kafka te iepenjen foar eksterne kliïnten troch Kafka-ynstellingen te feroarjen.

Ferbine mei Kafka: Caveats

FOARSICHTIGENS: Lês dit asjebleaft foarsichtich, om't it maklik is om ferbiningsproblemen te krijen mei Kafka as jo dizze begripen net hawwe begrepen.

Yn 'e Control Center opset beskreaun yn dit dokumint is d'r mar ien Kafka-broker.
Tink derom dat in Kafka-makelaar bedoeld is om te rinnen as ûnderdiel fan in Kafka-kluster dy't kin bestean út in protte Kafka-makelaars.
By it ferbinen mei in Kafka-broker wurdt in earste ferbining ynsteld troch de Kafka-kliïnt. Oer dizze ferbining sil de Kafka-makelaar op syn beurt in list fan "advertearre harkers" weromjaan, dat is in list fan ien of mear Kafka-makelaars.
By ûntfangst fan dizze list sil de Kafka-kliïnt de ferbining losmeitsje, en dan opnij ferbine mei ien fan dizze geadverteerde harkers. De oankundige harkers moatte hostnammen of IP-adressen befetsje dy't tagonklik binne foar de Kafka-kliïnt, oars sil de kliïnt net ferbine.
As SSL-fersifering brûkt wurdt, wêrby't in SSL-sertifikaat is ferbûn oan in bepaalde hostnamme, is it noch wichtiger dat de Kafka-kliïnt it juste adres krijt om mei te ferbinen, om't oars de ferbining kin wurde ôfwiisd.
Lês hjir mear oer Kafka-harkers: www.confluent.io/blog/kafka-listeners-explained

SSL / TLS fersifering
Om derfoar te soargjen dat allinich fertroude kliïnten tagong krije ta Kafka en de Streaming API, moatte wy it folgjende konfigurearje:

• Autentikaasje: Klanten moatte brûkersnamme en wachtwurd leverje fia in SSL / TLS feilige ferbining tusken de kliïnt en Kafka.
• Machtiging: Autentisearre kliïnten kinne taken útfiere regele troch ACL's.

Hjir is in oerview:

*) Ferifikaasje fan brûkersnamme/wachtwurd útfierd op in SSL-fersifere kanaal

Om folslein te begripen hoe't de SSL / TLS-fersifering wurket foar Kafka, ferwize asjebleaft nei de offisjele dokumintaasje: docs.confluent.io/platform/current/kafka/encryption.html

SSL / TLS-sertifikaat oerview

NOAT: Yn dizze subseksje sille wy de folgjende terminology brûke:

Sertifikaat: In SSL-sertifikaat tekene troch in sertifikaatautoriteit (CA). Elke Kafka-makelaar hat ien.
Keystore: De keystore file dat bewarret it sertifikaat. De keystore file befettet de privee kaai fan it sertifikaat; dêrom moat it feilich bewarre wurde.
Truststore: A file mei de fertroude CA-sertifikaten.

Om de autentikaasje yn te stellen tusken in eksterne kliïnt en Kafka dy't rint yn Control Center, moatte beide kanten in keystore hawwe definieare mei in relatearre sertifikaat ûndertekene troch in Certificate Authority (CA) tegearre mei it CA root sertifikaat.
Njonken dit moat de kliïnt ek in truststore hawwe mei it CA-rootsertifikaat.
It CA-rootsertifikaat is mienskiplik foar de Kafka-broker en Kafka-kliïnt.

It oanmeitsjen fan de fereaske sertifikaten
Dit wurdt behannele yn 'e "Talage" op side 17.

Kafka Broker SSL / TLS konfiguraasje yn Control Center

NOAT: Dizze ynstruksjes moatte wurde útfierd op 'e Control Center-tsjinner.

NOAT: Foardat jo trochgean, moatte jo de keystore oanmeitsje dy't it SSL-sertifikaat befettet troch de ynstruksjes te folgjen yn 'e "Talage" op side 17. De hjirûnder neamde paden komme út dizze ynstruksjes.
De SSL keystore is in file opslein op skiif mei de file extension .jks.

As jo ​​​​ienris de fereaske sertifikaten hawwe makke foar sawol de Kafka-broker as de Kafka-kliïnt beskikber, kinne jo trochgean troch de Kafka-broker te konfigurearjen dy't rint yn Control Center. Jo moatte it folgjende witte:

• : De iepenbiere hostnamme fan Control Center; dit moat oplosber en tagonklik wêze foar Kafka-kliïnten.
• : It wachtwurd foar keystore dat wurdt jûn by it meitsjen fan it SSL-sertifikaat.
• en : Dit binne de wachtwurden dy't jo ynstelle wolle foar respektivelik de admin- en kliïntbrûker. Tink derom dat jo mear brûkers tafoegje kinne, lykas oanjûn yn 'e eksample.

Bewurkje of taheakje (mei sudo tagong) de eigenskippen hjirûnder yn /etc/kafka/server.properties, ynfoegje de boppesteande fariabelen lykas werjûn:

WARSKÔGING: Net fuortsmite PLAINTEXT: // localhost: 9092; dit sil de funksjonaliteit fan Control Center brekke, om't ynterne tsjinsten net kinne kommunisearje.

• …
• # De adressen dêr't de Kafka-makelaar nei harket.
• listeners=PLAINTEXT://localhost:9092,SASL_SSL://0.0.0.0:9093
• # Dit binne de hosts dy't werom binne advertearre nei elke klant dy't ferbine.
• advertised.listeners=PLAINTEXT://localhost:9092,SASL_SSL:// :9093 …
• ####### CUSTOM CONFIG
• # SSL KONFIGURASJE
• ssl.endpoint.identification.algorithm=
  ssl.keystore.location=/var/ssl/private/kafka.server.keystore.jks
• ssl.keystore.password=
• ssl.key.password=
• ssl.client.auth=gjin
• ssl.protocol=TLSv1.2
• # SASL-konfiguraasje
• sasl.enabled.mechanisms=PLAIN
• brûkersnamme = "admin" \
• wachtwurd = " ”\
• user_admin =" ”\
• user_client =" ”;
• # OPMERKING kinne mear brûkers wurde tafoege mei user_ =
• # Autorisaasje, ynskeakelje ACL's
• authorizer.class.name=kafka.security.authorizer.AclAuthorizer super.users=Brûker:admin

Ynstelle fan Access Control Lists (ACL's)

ACL's ynskeakelje op localhost

WARSKUWING: Wy moatte earst ACL's ynstelle foar localhost, sadat Control Center sels noch tagong kin ta Kafka. As dit net dien wurdt, sille dingen brekke.

• –authorizer kafka.security.authorizer.AclAuthorizer \
• –authorizer-properties zookeeper.connect=localhost:2181 \
• –add –allow-principal Brûker: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 Brûker:ANONYMOUS –allow-host 127.0.0.1 –group '*'

Wy moatte dan ACLs ynskeakelje foar eksterne allinnich-lês tagong, sadat eksterne brûkers meie lêze de paa.public.* ûnderwerpen.

### ACLs-yngongen foar anonime brûkers /usr/lib/kafka/bin/kafka-acls.sh \

NOAT: Foar mear fynkorrelige kontrôle, nim dan ferwize nei de offisjele Kafka dokumintaasje.

• –authorizer kafka.security.authorizer.AclAuthorizer \
• –authorizer-properties zookeeper.connect=localhost:2181 \
• –add –allow-principal Brûker:* –operation read –operation beskriuw \ –group 'NCC'
• /usr/lib/kafka/bin/kafka-acls.sh \
• –authorizer kafka.security.authorizer.AclAuthorizer \
• –authorizer-properties zookeeper.connect=localhost:2181 \
• –add –allow-principal Brûker:* –operation read –operation beskriuwe \ –topic paa.public. -resource-pattern-type foarheaksel

Ienris dien mei dit, moatte jo de tsjinsten opnij starte:

### ACLs-yngongen foar eksterne brûkers /usr/lib/kafka/bin/kafka-acls.sh \

• sudo ncc tsjinsten opnij starte

Om te ferifiearjen dat in kliïnt in feilige ferbining kin meitsje, fier it folgjende kommando op in eksterne
client kompjûter (net op de Control Center tsjinner). Hjirûnder is PUBLIC_HOSTNAME de hostnamme fan it Control Center:

• openssl s_client -debug -ferbine ${PUBLIC_HOSTNAME}:9093 -tls1_2 | grep "Secure Renegotiation IS stipe"

Yn 'e kommando-útfier moatte jo it serversertifikaat sjen en ek it folgjende:

• Secure Renegotiation IS stipe

Om te soargjen dat ynterne tsjinsten tagong krigen hawwe ta de Kafka-tsjinner, kontrolearje asjebleaft it folgjende logfiles:

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

Validearjen fan eksterne kliïntferbining

kafkacat

NOAT: Dizze ynstruksjes moatte wurde útfierd op in kliïntkompjûter (net op 'e Control Center-tsjinner).
NOAT: Om metrike ynformaasje wer te jaan, soargje derfoar dat op syn minst ien monitor rint yn Control Center.

Om de ferbining as in eksterne kliïnt te ferifiearjen en te falidearjen, is it mooglik om it kafkacat-hulpprogramma te brûken dat is ynstalleare yn 'e seksje "Befêstigje dat de streaming-API wurket yn Control Center" op side 4.
Fier de folgjende stappen út:

NOAT: Hjirûnder is CLIENT_USER de brûker earder oantsjutte yn de file /etc/kafka/server.properties yn Control Center: nammentlik user_client en it wachtwurd dat dêr ynsteld is.
It CA-rootsertifikaat dat brûkt wurdt om it SSL-sertifikaat fan 'e serverside te ûndertekenjen moat oanwêzich wêze op' e client.

Meitsje in file client.properties mei de folgjende ynhâld:

• security.protocol=SASL_SSL
• ssl.ca.location={PATH_TO_CA_CERT}
• sasl.mechanisms=PLAIN
• sasl.username={CLIENT_USER}
• sasl.password={CLIENT_PASSWORD}

wêr

• {PATH_TO_CA_CERT} is de lokaasje fan it CA-rootsertifikaat brûkt troch de Kafka-makelaar
• {CLIENT_USER} en {CLIENT_PASSWORD} binne de brûkersbewizen foar de kliïnt.

Rin it folgjende kommando út om it berjocht te sjen dat troch kafkacat konsumearre is:

• eksportearje KAFKA_FQDN=
• eksportearje METRICS_TOPIC=paa.public.accounts. .metrics
• kafkacat -b ${KAFKA_FQDN}:9093 -F client.properties -t ${METRICS_TOPIC} -C -e

wêr't {METRICS_TOPIC} de namme is fan it Kafka-ûnderwerp mei foarheaksel "paa.public.".

NOAT: Aldere ferzjes fan kafkacat jouwe de opsje -F net foar it lêzen fan de kliïntynstellingen fan in file. As jo ​​sa'n ferzje brûke, moatte jo deselde ynstellings leverje fanút de kommandorigel lykas hjirûnder werjûn.

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 de ferbining te debuggen, kinne jo de opsje -d brûke:

Debug konsumint kommunikaasje
kafkacat -d konsumint -b ${KAFKA_FQDN}:9093 -F client.properties -t ${METRICS_TOPIC} -C -e
# Debug brokerkommunikaasje
kafkacat -d broker -b ${KAFKA_FQDN}:9093 -F client.properties -t ${METRICS_TOPIC} -C -e

Wês wis te ferwizen nei de dokumintaasje foar de Kafka client bibleteek yn gebrûk, as de eigenskippen kinne ferskille fan dy yn client.properties.

Berjochtformaat
De berjochten dy't brûkt wurde foar de metriken en metadata-ûnderwerpen wurde serialisearre yn it protokolbuffers (protobuf)-formaat (sjoch developers.google.com/protocol-buffers). De skema's foar dizze berjochten folgje it folgjende formaat:

Metrics Protobuf Schema

• syntaksis = "proto3";
• ymportearje "google/protobuf/timestamp.proto";
• pakket paa.streamingapi;
• option go_package = ".;paa_streamingapi";
• berjocht Metrics {
• google.protobuf.Timestamp kearstamp = 1;
• map wearden = 2;
• int32 stream_id = 3;
• }
• /**
• * In metrike wearde kin in hiel getal of in float wêze.
• */
• berjocht MetricValue {
• ien fan type {
• int64 int_val = 1;
• float float_val = 2;
• }
• }

Metadata Protobuf Skema

• syntaksis = "proto3";
• pakket paa.streamingapi;
• option go_package = ".;paa_streamingapi";
• berjocht Metadata {
• int32 stream_id = 1;
• string stream_name = 2;
• map tags = 13;
• }

Opdrachtgever Examples

NOAT: Dizze kommando's binne bedoeld om te rinnen op in eksterne kliïnt, bygelyksample jo laptop of ferlykber, en net yn Control Center.
NOAT: Om metrike ynformaasje werjûn te hawwen, soargje derfoar dat op syn minst ien monitor rint yn Control Center.

De tarball fan it Control Center omfettet it argyf paa-streaming-api-client-examples.tar.gz (client-examples), dy't in eksample Python-skript dat lit sjen hoe't jo de Streaming API brûke kinne.

Ynstallearje en konfigurearje Client Examples
Jo fine client-examples yn 'e map Paragon Active Assurance Control Center:

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

Om client-examples op jo eksterne kliïntkompjûter, gean dan as folget:

• # Meitsje map foar it ekstrahearjen fan de ynhâld fan 'e kliïnt eksamples tarball
• mkdir paa-streaming-api-client-examples
• # Ekstrahearje de ynhâld fan 'e kliïnt eksamples tarball
• tar xzf paa-streaming-api-client-examples.tar.gz -C paa-streaming-api-client-examples
• # Gean nei de nij oanmakke map
• cd paa-streaming-api-client-examples

client-eksamples fereasket Docker om te rinnen. Downloads en ynstallaasje-ynstruksjes foar Docker kinne fûn wurde op https://docs.docker.com/engine/install.

It brûken fan Client Examples
De klant-eksamples ark kinne rinne yn beide basis of avansearre modus te bouwen examples fan wikseljende kompleksiteit. Yn beide gefallen is it ek mooglik om de eks út te fierenamples mei in konfiguraasje file befettet ekstra eigenskippen foar fierdere oanpassing fan de klant kant.

Basismodus
Yn basismodus wurde de metriken en har metadata apart streamd. Dêrta harket de kliïnt nei elk Kafka-ûnderwerp beskikber foar eksterne tagong en drukt gewoan de ûntfongen berjochten nei de konsole.
Om te begjinnen útfiering fan de basis examples, run:

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

wêr't ACCOUNT_SHORTNAME de koarte namme is fan it akkount wêrfan jo de metriken krije wolle.
Om de útfiering fan 'e eksample, druk op Ctrl + C. (Der kin in lichte fertraging wêze foardat de útfiering stopt, om't de kliïnt wachtet op in time-out-evenemint.)

Avansearre modus

NOAT: Metriken wurde allinich werjûn foar HTTP-monitors dy't rinne yn Control Center.

Utfiering yn avansearre modus toant de korrelaasje tusken metriken en metadata-berjochten. Dit is
mooglik troch de oanwêzigens yn elke metriken berjocht fan in stream id fjild dat ferwiist nei de oerienkommende metadata berjocht.
Om de avansearre eks út te fierenamples, run:

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

wêr't ACCOUNT_SHORTNAME de koarte namme is fan it akkount wêrfan jo de metriken krije wolle.
Om de útfiering fan 'e eksample, druk op Ctrl + C. (Der kin in lichte fertraging wêze foardat de útfiering stopt, om't de kliïnt wachtet op in time-out-evenemint.)

Oanfoljende ynstellings
It is mooglik om de eks út te fierenamples mei ekstra konfiguraasje fan 'e kliïnt mei de -config-file opsje folge troch in file namme mei eigenskippen yn 'e foarm kaai = wearde.

• build.sh run-avansearre \
• –kafka-brokers localhost:9092 \
• –account ACCOUNT_SHORTNAME \
• -konfiguraasje-file client_config.properties

NOAT: allegear files ferwiisd yn it kommando hjirboppe moat lizze yn de aktuele map en ferwiisd allinnich mei help fan relative paden. Dit jildt sawol foar de -config-file argumint en oan alle yngongen yn 'e konfiguraasje file dat beskriuwe file lokaasjes.

Validearjen fan eksterne kliïntautentikaasje
Om klantferifikaasje fan bûten it Control Center te falidearjen mei client-examples, útfiere de folgjende stappen:

Skeakelje út de map Paragon Active Assurance Control Center nei de paa-streaming-api-client-examples map:

cd paa-streaming-api-client-examples

• Kopiearje it CA-rootsertifikaat ca-cert nei de aktuele map.
• Meitsje in client.properties file mei de folgjende ynhâld:

security.protocol=SASL_SSL ssl.ca.location=ca-cert
sasl.mechanism=PLAIN
sasl.username={CLIENT_USER}
sasl.password={CLIENT_PASSWORD}

wêr't {CLIENT_USER} en {CLIENT_PASSWORD} de brûkersbewizen binne foar de kliïnt.

Run basic examples:

• eksportearje KAFKA_FQDN=
• build.sh run-basic –kafka-brokers ${KAFKA_FQDN}:9093 \
• -account ACCOUNT_SHORTNAME
• -konfiguraasje-file client.properties

wêr't ACCOUNT_SHORTNAME de koarte namme is fan it akkount wêrfan jo de metriken krije wolle.

Run avansearre eksamples:

• eksportearje KAFKA_FQDN=
• build.sh run-advanced –kafka-brokers ${KAFKA_FQDN}:9093 \
• -account ACCOUNT_SHORTNAME
• -konfiguraasje-file client.properties

Taheakke

Yn dizze taheaksel beskriuwe wy hoe te meitsjen:

• in keystore file foar it bewarjen fan it Kafka-broker SSL-sertifikaat
• in truststore file foar it bewarjen fan it Certificate Authority (CA) root-sertifikaat dat brûkt wurdt om it Kafka-broker-sertifikaat te ûndertekenjen.

It meitsjen fan in Kafka Broker-sertifikaat
In sertifikaat oanmeitsje mei in echte sertifikaatautoriteit (oanrikkemandearre)
It wurdt oanrikkemandearre dat jo in echt SSL-sertifikaat krije fan in fertroude CA.
Sadree't jo hawwe besletten op in CA, kopiearje harren CA root sertifikaat ca-cert file nei jo eigen paad lykas hjirûnder werjûn:

• eksportearje CA_PATH=~/my-ca
• mkdir ${CA_PATH}
• cp ca-sert ${CA_PATH}

Meitsje jo eigen sertifikaatautoriteit

NOAT: Normaal moatte jo jo sertifikaat tekene hawwe troch in echte sertifikaatautoriteit; sjoch de foargeande subseksje. Wat folget is gewoan in eksample.

Hjir meitsje wy ús eigen Certificate Authority (CA) root-sertifikaat file jildich foar 999 dagen (net oanrikkemandearre yn produksje):

• # Meitsje in map foar it opslaan fan de CA
• eksportearje CA_PATH=~/my-ca
• mkdir ${CA_PATH}
• # Generearje it CA-sertifikaat
• openssl req -new -x509 -keyout ${CA_PATH}/ca-key -out ${CA_PATH}/ca-cert -days 999

De Client Truststore oanmeitsje
No kinne jo in truststore oanmeitsje file dat befettet de ca-cert generearre hjirboppe. Dit file sil nedich wêze troch de Kafka-kliïnt dy't tagong sil ta de Streaming API:

• keytool -keystore kafka.client.truststore.jks \
  • alias CARoot \
  • importcert -file ${CA_PATH}/ca-cert

No't it CA-sertifikaat yn 'e truststore is, sil de kliïnt elk sertifikaat dat dêrmei tekene is, fertrouwe.
Jo moatte kopiearje de file kafka.client.truststore.jks nei in bekende lokaasje op jo kliïntkompjûter en wiis dêrop yn 'e ynstellings.

De Keystore oanmeitsje foar de Kafka Broker
Om it Kafka-broker SSL-sertifikaat te generearjen en dan de keystore kafka.server.keystore.jks, gean dan as folget:

It generearjen fan it SSL-sertifikaat
Hjirûnder is 999 it oantal dagen fan jildichheid fan 'e keystore, en FQDN is de folslein kwalifisearre domeinnamme fan' e kliïnt (iepenbiere hostnamme fan 'e knooppunt).

NOAT: It is wichtich dat de FQDN oerienkomt mei de krekte hostnamme dy't de Kafka-kliïnt sil brûke om te ferbinen mei it Control Center.

• sudo mkdir -p /var/ssl/private
• sudo chown -R $USER: /var/ssl/privee
• cd /var/ssl/private
• eksportearje FQDN= keytool -keystore kafka.server.keystore.jks \
• - alias tsjinner \
• - jildichheid 999 \
• – genkey -keyalg RSA -ext SAN=dns:${FQDN}

Meitsje in sertifikaat ûndertekening fersyk en bewarje it yn de file neamd cert-server-request:

• keytool -keystore kafka.server.keystore.jks \
  • - alias tsjinner \
  • - sertifikaat \
  • – file cert-tsjinner-fersyk

Jo moatte no stjoere de file cert-server-fersyk oan jo Certificate Authority (CA) as jo in echte brûke. Se sille dan it ûndertekene sertifikaat weromjaan. Wy sille hjirnei ferwize as cert-server-ûndertekene hjirûnder.

It SSL-sertifikaat ûndertekenje mei in sels oanmakke CA-sertifikaat

NOAT: Nochris, it brûken fan jo eigen CA is net oan te rieden yn in produksjesysteem.

Undertekenje it sertifikaat mei de CA troch middel fan de file cert-server-request, dy't it ûndertekene sertifikaat produsearret cert-server-ûndertekene. Sjoch hjirûnder; ca-wachtwurd is it wachtwurd ynsteld by it meitsjen fan it CA-sertifikaat.

• cd /var/ssl/private openssl x509 -req \
  • – CA ${CA_PATH}/ca-cert \
  • – CAkey ${CA_PATH}/ca-key \
  • – in cert-server-request \
  • - út cert-server-ûndertekene \
  • – dagen 999 -CAcreateserial \
  • – passin pass:{ca-wachtwurd}

It ûndertekene sertifikaat ymportearje yn 'e Keystore

Ymportearje it ca-cert root-sertifikaat yn 'e keystore:

• keytool -keystore kafka.server.keystore.jks \
  • – alias ca-cert \
  • - ymportearje \
  • – file ${CA_PATH}/ca-cert

Ymportearje it ûndertekene sertifikaat neamd as cert-server-ûndertekene:

• keytool -keystore kafka.server.keystore.jks \
  • - alias tsjinner \
  • - ymportearje \
  • – file cert-tsjinner-ûndertekene

De file kafka.server.keystore.jks moatte wurde kopiearre nei in bekende lokaasje op de Control Center tsjinner, en dan ferwiisd nei yn /etc/kafka/server.properties.

Mei help fan de Streaming API

YN DIT OFDELING

• Algemien | 20
• Kafka Underwerpnammen | 21
• Examples fan it brûken fan de Streaming API | 21

Algemien
De streaming API hellet sawol test- as monitorgegevens op. It is net mooglik om ien fan dizze kategoryen út te lizzen.
De streaming API hellet gjin gegevens fan skript-basearre tests (dy fertsjintwurdige troch in rjochthoek ynstee fan in puzelstik yn 'e Control Center GUI), lykas Ethernet-tsjinstaktivearringstests en transparânsjetests.

Kafka Underwerpnammen
De Kafka-ûnderwerpnammen foar de streaming API binne as folget, wêrby't %s de koarte namme is fan it Control Center-akkount (oanjûn by it meitsjen fan it akkount):

• const (
• exporterName = "kafka"
• metadataTopicTpl = "paa.public.accounts.%s.metadata" metricsTopicTpl = "paa.public.accounts.%s.metrics")

Examples fan it brûken fan de Streaming API
De eksampLes dy't folgje binne te finen yn 'e tarball paa-streaming-api-client-examples.tar.gz befette binnen de Control Center tarball.
Earst is d'r in basis eksample demonstrearje hoe't de metriken en har metadata apart wurde streamd en gewoan de ûntfongen berjochten printsje nei de konsole. Jo kinne it as folgjend útfiere:

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

Der is ek in mear avansearre eksample dêr't metriken en metadata berjochten wurde korrelearre. Brûk dit kommando om it út te fieren:

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

Jo moatte sudo brûke om Docker-kommando's út te fieren lykas de hjirboppe. Opsjoneel kinne jo de Linux post-ynstallaasjestappen folgje om Docker-kommando's sûnder sudo út te fieren. Foar details, gean nei docs.docker.com/engine/install/linux-postinstall.

Juniper Networks, it Juniper Networks-logo, Juniper, en Junos binne registrearre hannelsmerken fan Juniper Networks, Inc. yn 'e Feriene Steaten en oare lannen. Alle oare hannelsmerken, tsjinstmerken, registrearre merken, as registrearre tsjinstmerken binne it eigendom fan har respektive eigners. Juniper Networks nimt gjin ferantwurdlikens foar eventuele ûnkrektens yn dit dokumint. Juniper Networks behâldt it rjocht foar om dizze publikaasje sûnder notice te feroarjen, te feroarjen, oer te bringen of oars te feroarjen. Copyright © 2023 Juniper Networks, Inc. Alle rjochten foarbehâlden.

Dokuminten / Resources

Juniper NETWERKEN Streaming API Software [pdf] Brûkersgids Streaming API Software, API Software, Software

Referinsjes

• User Manual