Software de API de streaming Juniper NETWORKS

Informações do produto

Especificações

• Nome do produto: Paragon Active Assurance
• Versão: 4.1
• Data de publicação: 2023/03/15

Introdução:
Este guia fornece instruções sobre como extrair dados do Paragon Active Assurance usando a API de streaming do produto. O cliente de streaming e a API estão incluídos na instalação do Paragon Active Assurance, mas algumas configurações são necessárias antes de usar a API. O processo de configuração é abordado na seção “Configurando a API de streaming”.

Configurando a API de streaming:
As etapas a seguir descrevem o processo de configuração da API de streaming:

Sobreview
Kafka é uma plataforma de streaming de eventos projetada para captura e armazenamento em tempo real de dados de várias fontes. Ele permite o gerenciamento de fluxos de eventos de maneira distribuída, escalável, tolerante a falhas e segura. Este guia se concentra na configuração do Kafka para utilizar o recurso Streaming API no Paragon Active Assurance Control Center.

Terminologia
A API de streaming permite que clientes externos recuperem informações de métricas do Kafka. As métricas coletadas pelos Agentes de Teste durante uma tarefa de teste ou monitoramento são enviadas para o serviço Stream. Após o processamento, o serviço Stream publica essas métricas no Kafka juntamente com metadados adicionais.

Ativando a API de streaming
Para ativar a API de streaming, siga estas etapas:

1. Execute os seguintes comandos no servidor Control Center usando sudo:

KAFKA_METRICS_ENABLED = Verdadeiros serviços sudo ncc ativam métricas timescaledb sudo ncc services iniciam métricas timescaledb sudo ncc services restart

Verificando se a API de streaming funciona no Control Center:
Para verificar se você está recebendo métricas sobre os tópicos corretos do Kafka:

1. Instale o utilitário kafkacat com os seguintes comandos:
   sudo apt-get atualização
   sudo apt-get install kafkacat

2. Substitua “myaccount” pelo nome abreviado da sua conta no
   Centro de controle URL:
   exportar METRICS_TOPIC=paa.public.accounts.myaccount.metrics
   exportar METADATA_TOPIC=paa.public.accounts.myaccount.metadata

3. Execute o seguinte comando para view Métricas:
   kafkacat -b ${KAFKA_FQDN}:9092 -t ${METRICS_TOPIC} -C -e
   Observação: O comando acima exibirá as métricas.
4. Para view metadados, execute o seguinte comando:
   kafkacat -b ${KAFKA_FQDN}:9092 -t ${METADATA_TOPIC} -C -e

Observação: O comando acima exibirá metadados, mas não será atualizado com tanta frequência.

Cliente Exampos
Para ex-clienteamparquivos e mais informações, consulte a página 14 do manual do usuário.

FAQ (Perguntas Frequentes)

• P: O que é o Paragon Active Assurance?
  R: O Paragon Active Assurance é um produto que fornece recursos de monitoramento e teste.
• P: O que é a API de streaming?
  R: A API de streaming é um recurso do Paragon Active Assurance que permite que clientes externos recuperem informações de métricas do Kafka.
• P: Como ativo a API de streaming?
  R: Para ativar a API de streaming, siga as etapas descritas na seção “Ativando a API de streaming” do manual do usuário.
• P: Como posso verificar se a API Streaming está funcionando?
  R: Consulte a seção “Verificando se a API de streaming funciona no Control Center” para obter instruções sobre como verificar a funcionalidade da API de streaming.

Introdução

Este guia descreve como extrair dados do Paragon Active Assurance por meio da API de streaming do produto.
A API, bem como o cliente de streaming, estão incluídos na instalação do Paragon Active Assurance. No entanto, é necessária um pouco de configuração antes de poder usar a API. Isso é abordado no capítulo “Configurando a API de streaming” na página 1.

Sobreview
Este capítulo descreve como configurar a API de streaming para permitir a assinatura de mensagens de métricas via Kafka.
pr
Abaixo iremos passar:

• Como habilitar a API de streaming
• Como configurar o Kafka para ouvir clientes externos
• Como configurar o Kafka para usar ACLs e configurar a criptografia SSL para os referidos clientes

O que é Kafka?
Kafka é uma plataforma de streaming de eventos que permite a captura em tempo real de dados enviados de várias fontes de eventos (sensores, bancos de dados, dispositivos móveis) na forma de fluxos de eventos, bem como armazenamento durável desses fluxos de eventos para posterior recuperação e manipulação.
Com o Kafka é possível gerenciar o streaming de eventos de ponta a ponta de forma distribuída, altamente escalável, elástica, tolerante a falhas e segura.

OBSERVAÇÃO: O Kafka pode ser configurado de muitas maneiras diferentes e foi projetado para escalabilidade e sistemas redundantes. Este documento se concentra apenas em como configurá-lo para usar o recurso Streaming API encontrado no Paragon Active Assurance Control Center. Para configurações mais avançadas, consulte a documentação oficial do Kafka: kafka.apache.org/26/documentation.html.

Terminologia

• Kafka: plataforma de transmissão de eventos.
• Tópico Kafka: Coleção de eventos.
• Assinante/consumidor Kafka: Componente responsável pela recuperação de eventos armazenados em um tópico Kafka.
• Broker Kafka: servidor de camada de armazenamento de um cluster Kafka.
• SSL/TLS: SSL é um protocolo seguro desenvolvido para enviar informações de forma segura pela Internet. O TLS é o sucessor do SSL, introduzido em 1999.
• SASL: Framework que fornece mecanismos para autenticação de usuários, verificação de integridade de dados e criptografia.
• Assinante da API de streaming: Componente responsável pela recuperação dos eventos armazenados em tópicos definidos no Paragon Active Assurance e destinados ao acesso externo.
• Autoridade de Certificação: Uma entidade confiável que emite e revoga certificados de chave pública.
• Certificado raiz da Autoridade de Certificação: Certificado de chave pública que identifica uma Autoridade de Certificação.

Como funciona a API de streaming
Conforme mencionado anteriormente, a API de streaming permite que clientes externos recuperem informações sobre métricas do Kafka.

Todas as métricas coletadas pelos Agentes de Teste durante uma tarefa de teste ou monitoramento são enviadas para o serviço Stream. Após uma fase de processamento, o serviço Stream publica essas métricas no Kafka juntamente com metadados adicionais.

Tópicos Kafka
Kafka tem o conceito de tópicos para os quais todos os dados são publicados. No Paragon Active Assurance, há muitos desses tópicos Kafka disponíveis; no entanto, apenas um subconjunto deles é destinado ao acesso externo.
Cada conta Paragon Active Assurance no Control Center tem dois tópicos dedicados. Abaixo, ACCOUNT é o nome abreviado da conta:

• paa.public.accounts.{ACCOUNT}.metrics
  • Todas as mensagens de métricas para a conta especificada são publicadas neste tópico
  • Grandes quantidades de dados
  • Alta frequência de atualização
• paa.public.accounts.{ACCOUNT}.metadata
  • Contém metadados relacionados aos dados de métricas, por exemploample o teste, monitor ou Agente de teste associado às métricas
  • Pequenas quantidades de dados
  • Baixa frequência de atualização

Ativando a API de streaming

OBSERVAÇÃO: Estas instruções devem ser executadas no servidor Control Center usando sudo.

Como a API de streaming adiciona alguma sobrecarga ao Centro de controle, ela não é habilitada por padrão. Para habilitar a API, devemos primeiro habilitar a publicação de métricas para Kafka na configuração principal file:

• /etc/netrounds/netrounds.conf

KAFKA_METRICS_ENABLED = Verdadeiro

AVISO: A ativação desse recurso pode afetar o desempenho do Control Center. Certifique-se de ter dimensionado sua instância de acordo.

Em seguida, para habilitar o encaminhamento dessas métricas para os tópicos Kafka corretos:

• /etc/netrounds/metrics.yaml

streaming-api: verdadeiro

Para ativar e iniciar os serviços da API de streaming, execute:

• Os serviços sudo ncc permitem métricas timescaledb
• serviços sudo ncc iniciam métricas timescaledb

Por fim, reinicie os serviços:

• reinicialização dos serviços sudo ncc

Verificando se a API de streaming funciona no Control Center

OBSERVAÇÃO: Essas instruções devem ser executadas no servidor do Centro de Controle.

Agora você pode verificar se está recebendo métricas nos tópicos Kafka corretos. Para fazer isso, instale o utilitário kafkacat:

• sudo apt-get atualização
• sudo apt-get install kafkacat

Se você tiver um teste ou monitor em execução no Control Center, poderá usar o kafkacat para receber métricas e metadados sobre esses tópicos.
Substitua myaccount pelo nome abreviado da sua conta (isso é o que você vê no seu Centro de Controle URL):

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

Agora você deve ver as métricas executando este comando:

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

Para view metadados, execute o seguinte comando (observe que isso não será atualizado com tanta frequência):

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

OBSERVAÇÃO:
kafkacat”Cliente Examples ”na página 14

Isso verifica se temos uma API de streaming funcionando no Control Center. No entanto, provavelmente você está interessado em acessar os dados de um cliente externo. A próxima seção descreve como abrir o Kafka para acesso externo.

Abrindo o Kafka para hosts externos

OBSERVAÇÃO: Essas instruções devem ser executadas no servidor do Centro de Controle.

Por padrão, o Kafka em execução no Control Center é configurado para escutar apenas no host local para uso interno. É possível abrir o Kafka para clientes externos modificando as configurações do Kafka.

Conectando-se ao Kafka: advertências

CUIDADO: Leia com atenção, pois é fácil ter problemas de conexão com o Kafka se você não entender esses conceitos.

Na configuração do Control Center descrita neste documento, há apenas um único agente Kafka.
No entanto, observe que um agente Kafka deve ser executado como parte de um cluster Kafka, que pode consistir em muitos agentes Kafka.
Ao conectar-se a um agente Kafka, uma conexão inicial é configurada pelo cliente Kafka. Por meio dessa conexão, o corretor Kafka, por sua vez, retornará uma lista de “ouvintes anunciados”, que é uma lista de um ou mais corretores Kafka.
Ao receber essa lista, o cliente Kafka se desconectará e se reconectará a um desses ouvintes anunciados. Os ouvintes anunciados devem conter nomes de host ou endereços IP acessíveis ao cliente Kafka ou o cliente falhará ao se conectar.
Se a criptografia SSL for usada, envolvendo um certificado SSL vinculado a um nome de host específico, é ainda mais importante que o cliente Kafka receba o endereço correto para se conectar, pois, caso contrário, a conexão poderá ser rejeitada.
Leia mais sobre os ouvintes Kafka aqui: www.confluent.io/blog/kafka-listeners-explained

Criptografia SSL/TLS
Para garantir que apenas clientes confiáveis ​​tenham permissão para acessar o Kafka e a API de streaming, devemos configurar o seguinte:

• Autenticação: os clientes devem fornecer nome de usuário e senha por meio de uma conexão segura SSL/TLS entre o cliente e o Kafka.
• Autorização: clientes autenticados podem executar tarefas reguladas por ACLs.

Aqui está um overview:

*) Autenticação de nome de usuário/senha realizada em um canal criptografado por SSL

Para entender completamente como funciona a criptografia SSL/TLS para Kafka, consulte a documentação oficial: docs.confluent.io/platform/current/kafka/encryption.html

Certificado SSL/TLS sobreview

OBSERVAÇÃO: Nesta subseção, usaremos a seguinte terminologia:

Certificado: Um certificado SSL assinado por uma Autoridade de Certificação (CA). Cada corretor Kafka possui um.
Armazenamento de chaves: O armazenamento de chaves file que armazena o certificado. O armazenamento de chaves file contém a chave privada do certificado; portanto, ele precisa ser mantido com segurança.
Loja confiável: Um file contendo os certificados de CA confiáveis.

Para configurar a autenticação entre um cliente externo e o Kafka em execução no Control Center, ambos os lados devem ter um keystore definido com um certificado relacionado assinado por uma Autoridade de Certificação (CA) junto com o certificado raiz da CA.
Além disso, o cliente também deve ter um armazenamento confiável com o certificado raiz da CA.
O certificado raiz da CA é comum ao agente Kafka e ao cliente Kafka.

Criando os certificados necessários
Isso é abordado no “Apêndice” na página 17.

Configuração SSL/TLS do Kafka Broker no Centro de Controle

OBSERVAÇÃO: Essas instruções devem ser executadas no servidor do Centro de Controle.

OBSERVAÇÃO: Antes de continuar, você deve criar o keystore que contém o certificado SSL seguindo as instruções no “Apêndice” na página 17. Os caminhos mencionados abaixo vêm dessas instruções.
O armazenamento de chaves SSL é um file armazenados em disco com o file extensão .jks.

Depois de ter os certificados necessários criados para o agente Kafka e o cliente Kafka disponíveis, você pode continuar configurando o agente Kafka em execução no Centro de Controle. Você precisa saber o seguinte:

• : O nome de host público do Centro de Controle; isso deve ser resolvido e acessível por clientes Kafka.
• : A senha do keystore fornecida ao criar o certificado SSL.
• e : Estas são as senhas que você deseja definir para o usuário administrador e cliente, respectivamente. Observe que você pode adicionar mais usuários, conforme indicado no exampeu.

Edite ou anexe (com acesso sudo) as propriedades abaixo em /etc/kafka/server.properties, inserindo as variáveis ​​acima conforme mostrado:

AVISO: Não remova PLAINTEXT://localhost:9092; isso interromperá a funcionalidade do Control Center, pois os serviços internos não poderão se comunicar.

• …
• # Os endereços que o corretor Kafka escuta.
• ouvintes=PLAINTEXT://localhost:9092,SASL_SSL://0.0.0.0:9093
• # Estes são os hosts anunciados de volta para qualquer conexão de cliente.
• anunciado.listeners=PLAINTEXT://localhost:9092,SASL_SSL:// :9093…
• ####### CONFIGURAÇÃO PERSONALIZADA
• # CONFIGURAÇÃO SSL
• ssl.endpoint.identification.algorithm=
  ssl.keystore.location=/var/ssl/private/kafka.server.keystore.jks
• ssl.keystore.password=
• ssl.key.password=
• ssl.client.auth=nenhum
• ssl.protocol=TLSv1.2
• #Configuração SASL
• sasl.enabled.mechanisms=PLAIN
• nome de usuário=”admin” \
• senha =” ”\
• usuário_admin=” ”\
• usuário_cliente=” ”;
• # NOTA mais usuários podem ser adicionados com user_ =
• # Autorização, ative ACLs
• authorizer.class.name=kafka.security.authorizer.AclAuthorizer super.users=Usuário:admin

Configurando listas de controle de acesso (ACLs)

Ativando ACLs no localhost

AVISO: Devemos primeiro configurar ACLs para localhost, para que o próprio Control Center ainda possa acessar o Kafka. Se isso não for feito, as coisas irão quebrar.

• –autorizador kafka.security.authorizer.AclAuthorizer \
• –autorizador-propriedades zookeeper.connect=localhost:2181 \
• –add –allow-principal Usuário:ANÔNIMO –allow-host 127.0.0.1 –cluster
• /usr/lib/kafka/bin/kafka-acls.sh\
• –autorizador kafka.security.authorizer.AclAuthorizer \
• –autorizador-propriedades zookeeper.connect=localhost:2181 \
• –add –allow-principal Usuário:ANÔNIMO –allow-host 127.0.0.1 –tópico '*'
• /usr/lib/kafka/bin/kafka-acls.sh\
• –autorizador kafka.security.authorizer.AclAuthorizer \
• –autorizador-propriedades zookeeper.connect=localhost:2181 \
• –add –allow-principal Usuário:ANÔNIMO –allow-host 127.0.0.1 –group '*'

Em seguida, precisamos habilitar as ACLs para acesso somente leitura externo, para que os usuários externos tenham permissão para ler os tópicos paa.public.*.

### Entradas de ACLs para usuários anônimos /usr/lib/kafka/bin/kafka-acls.sh \

OBSERVAÇÃO: Para um controle mais refinado, consulte a documentação oficial do Kafka.

• –autorizador kafka.security.authorizer.AclAuthorizer \
• –autorizador-propriedades zookeeper.connect=localhost:2181 \
• –add –allow-principal Usuário:* –operação lida –operação descrição \ –grupo 'NCC'
• /usr/lib/kafka/bin/kafka-acls.sh\
• –autorizador kafka.security.authorizer.AclAuthorizer \
• –autorizador-propriedades zookeeper.connect=localhost:2181 \
• –add –allow-principal Usuário:* –operação leitura –operação descrição \ –topic paa.public. –tipo de padrão de recurso prefixado

Uma vez feito isso, você precisa reiniciar os serviços:

### Entradas de ACLs para usuários externos /usr/lib/kafka/bin/kafka-acls.sh \

• reinicialização dos serviços sudo ncc

Para verificar se um cliente pode estabelecer uma conexão segura, execute o seguinte comando em um computador externo
computador cliente (não no servidor Control Center). Abaixo, PUBLIC_HOSTNAME é o nome do host do Control Center:

• openssl s_client -debug -connect ${PUBLIC_HOSTNAME}:9093 -tls1_2 | grep “A renegociação segura é suportada”

Na saída do comando, você deve ver o certificado do servidor, bem como o seguinte:

• A renegociação segura é suportada

Para garantir que os serviços internos tenham acesso ao servidor Kafka, verifique o seguinte logfiles:

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

Validando a conectividade do cliente externo

gato kafka

OBSERVAÇÃO: Estas instruções devem ser executadas em um computador cliente (não no servidor do Control Center).
OBSERVAÇÃO: para exibir informações de métricas, certifique-se de que pelo menos um monitor esteja em execução no Control Center.

Para verificar e validar a conectividade como um cliente externo, é possível usar o utilitário kafkacat que foi instalado na seção “Verificando se a API de streaming funciona no centro de controle” na página 4.
Execute os seguintes passos:

OBSERVAÇÃO: Abaixo, CLIENT_USER é o usuário previamente especificado no file /etc/kafka/server.properties no Control Center: ou seja, user_client e a senha definida lá.
O certificado raiz da CA usado para assinar o certificado SSL do lado do servidor deve estar presente no cliente.

Criar um file client.properties com o seguinte conteúdo:

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

onde

• {PATH_TO_CA_CERT} é o local do certificado raiz da CA usado pelo corretor Kafka
• {CLIENT_USER} e {CLIENT_PASSWORD} são as credenciais de usuário do cliente.

Execute o seguinte comando para ver a mensagem consumida pelo kafkacat:

• exportar KAFKA_FQDN=
• export METRICS_TOPIC=paa.public.accounts. .Métricas
• kafkacat -b ${KAFKA_FQDN}:9093 -F cliente.propriedades -t ${METRICS_TOPIC} -C -e

onde {METRICS_TOPIC} é o nome do tópico Kafka com o prefixo “paa.public.”.

OBSERVAÇÃO: As versões mais antigas do kafkacat não fornecem a opção -F para ler as configurações do cliente de um file. Se você estiver usando essa versão, deverá fornecer as mesmas configurações na linha de comando, conforme mostrado abaixo.

kafkacat -b${KAFKA_FQDN}:9093\

• X segurança.protocol=SASL_SSL \
• X ssl.ca.location={PATH_TO_CA_CERT} \
• X sasl.mecanismos=PLAIN \
• X sasl.nomedeusuário={CLIENT_USER} \
• X sasl.password={CLIENT_PASSWORD} \
• t ${METRICS_TOPIC} -C -e

Para depurar a conectividade, você pode usar a opção -d:

Depurar as comunicações do consumidor
kafkacat -d consumidor -b ${KAFKA_FQDN}:9093 -F cliente.propriedades -t ${METRICS_TOPIC} -C -e
# Depurar comunicações do corretor
kafkacat -d corretor -b ${KAFKA_FQDN}:9093 -F cliente.propriedades -t ${METRICS_TOPIC} -C -e

Certifique-se de consultar a documentação da biblioteca cliente Kafka em uso, pois as propriedades podem diferir daquelas em client.properties.

Formato de Mensagem
As mensagens usadas para os tópicos de métricas e metadados são serializadas no formato Protocol buffers (protobuf) (consulte desenvolvedores.google.com/protocol-buffers). Os esquemas para essas mensagens seguem o seguinte formato:

Esquema Protobuf de Métricas

• sintaxe = “proto3”;
• importar “google/protobuf/timestamp.proto”;
• pacote paa.streamingapi;
• opção go_package = “.;paa_streamingapi”;
• Métricas de mensagem {
• google.protobuf.Timestamp tempoamp = 1;
• mapa valores = 2;
• int32 stream_id = 3;
• }
• /**
• * Um valor de métrica pode ser um número inteiro ou flutuante.
• */
• mensagem MetricValue {
• um do tipo {
• int64 int_val = 1;
• float float_val = 2;
• }
• }

Esquema Protobuf de metadados

• sintaxe = “proto3”;
• pacote paa.streamingapi;
• opção go_package = “.;paa_streamingapi”;
• mensagem Metadados {
• int32 stream_id = 1;
• string stream_name = 2;
• mapa tags = 13;
• }

Cliente Exampos

OBSERVAÇÃO: Esses comandos devem ser executados em um cliente externo, por exemploample seu laptop ou similar, e não no Centro de Controle.
OBSERVAÇÃO: Para exibir informações de métricas, certifique-se de que pelo menos um monitor esteja em execução no Control Center.

O tarball do Control Center inclui o arquivo paa-streaming-api-client-examples.tar.gz (cliente-examples), que contém um example script Python mostrando como usar a API de Streaming.

Instalando e Configurando o Cliente Exampos
Você encontra cliente-examparquivos na pasta Paragon Active Assurance Control Center:

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

Para instalar o cliente-examparquivos em seu computador cliente externo, faça o seguinte:

• # Cria diretório para extrair o conteúdo do cliente exampo tarball
• mkdir paa-streaming-api-client-exampos
• # Extraia o conteúdo do cliente exampo tarball
• tar xzf paa-streaming-api-client-examples.tar.gz -C paa-streaming-api-client-exampos
• #Vá para o diretório recém-criado
• cd paa-streaming-api-client-exampos

cliente-examples requer que o Docker seja executado. Downloads e instruções de instalação para o Docker podem ser encontrados em https://docs.docker.com/engine/install.

Usando Cliente Exampos
o cliente-exampAs ferramentas les podem ser executadas no modo básico ou avançado para criar examparquivos de complexidade variada. Em ambos os casos, também é possível executar o examparquivos com uma configuração file contendo propriedades adicionais para personalização adicional do lado do cliente.

Modo Básico
No modo básico, as métricas e seus metadados são transmitidos separadamente. Para tanto, o cliente escuta cada tópico Kafka disponível para acesso externo e simplesmente imprime as mensagens recebidas no console.
Para iniciar a execução do ex básicoamples, execute:

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

onde ACCOUNT_SHORTNAME é o nome abreviado da conta da qual você deseja obter as métricas.
Para encerrar a execução do example, pressione Ctrl + C. (Pode haver um pequeno atraso antes que a execução pare porque o cliente espera por um evento de tempo limite.)

Modo avançado

OBSERVAÇÃO: as métricas são exibidas apenas para monitores HTTP em execução no Control Center.

A execução em modo avançado mostra a correlação entre métricas e mensagens de metadados. Isso é
possível graças à presença em cada mensagem de métrica de um campo de identificação de fluxo que se refere à mensagem de metadados correspondente.
Para executar o ex avançadoamples, execute:

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

onde ACCOUNT_SHORTNAME é o nome abreviado da conta da qual você deseja obter as métricas.
Para encerrar a execução do example, pressione Ctrl + C. (Pode haver um pequeno atraso antes que a execução pare porque o cliente espera por um evento de tempo limite.)

Configurações adicionais
É possível executar o examparquivos com configuração adicional do cliente usando o comando –config-file opção seguida por um file nome contendo propriedades no formato chave=valor.

• build.sh execução avançada \
• –kafka-corretores localhost:9092 \
• –conta CONTA_SHORTNAME \
• –config-file client_config.properties

OBSERVAÇÃO: Todos files referenciados no comando acima devem estar localizados no diretório atual e referenciados usando apenas caminhos relativos. Isso se aplica tanto ao –config-file argumento e para todas as entradas na configuração file que descrevem file localizações.

Validando a Autenticação do Cliente Externo
Para validar a autenticação do cliente de fora do Centro de Controle usando client-examparquivos, execute os seguintes passos:

Na pasta Paragon Active Assurance Control Center, mude para paa-streaming-api-client-examppasta les:

cd paa-streaming-api-client-exampos

• Copie o certificado raiz da CA ca-cert para o diretório atual.
• Crie um cliente.propriedades file com o seguinte conteúdo:

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

onde {CLIENT_USER} e {CLIENT_PASSWORD} são as credenciais do usuário para o cliente.

Executar ex básicoampos:

• exportar KAFKA_FQDN=
• build.sh run-basic –kafka-brokers ${KAFKA_FQDN}:9093 \
• –conta ACCOUNT_SHORTNAME
• –config-file cliente.propriedades

onde ACCOUNT_SHORTNAME é o nome abreviado da conta da qual você deseja obter as métricas.

Executar ex avançadoampos:

• exportar KAFKA_FQDN=
• build.sh run-advanced –kafka-brokers ${KAFKA_FQDN}:9093\
• –conta ACCOUNT_SHORTNAME
• –config-file cliente.propriedades

Apêndice

Neste apêndice, descrevemos como criar:

• um armazenamento de chaves file para armazenar o certificado SSL do corretor Kafka
• um truststore file para armazenar o certificado raiz da Autoridade de Certificação (CA) usado para assinar o certificado do agente Kafka.

Criando um certificado Kafka Broker
Criando um certificado usando uma autoridade de certificação real (recomendado)
É recomendável obter um certificado SSL real de uma CA confiável.
Depois de decidir sobre uma CA, copie o certificado raiz da CA ca-cert file para o seu próprio caminho, conforme mostrado abaixo:

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

Crie sua própria autoridade de certificação

OBSERVAÇÃO: Normalmente, você deve ter seu certificado assinado por uma autoridade de certificação real; consulte a subseção anterior. O que se segue é apenas um exampeu.

Aqui criamos nosso próprio certificado raiz de Autoridade de Certificação (CA) file válido por 999 dias (não recomendado em produção):

• # Cria um diretório para armazenar a CA
• exportar CA_PATH=~/my-ca
• mkdir${CA_PATH}
• #Gerar o certificado CA
• openssl req -new -x509 -keyout ${CA_PATH}/ca-key -out ${CA_PATH}/ca-cert -days 999

Criando o armazenamento confiável do cliente
Agora você pode criar um truststore file que contém o ca-cert gerado acima. Esse file será necessário para o cliente Kafka que acessará a API de Streaming:

• keytool -keystore kafka.client.truststore.jks\
  • alias CARoot \
  • certificado de importação -file ${CA_PATH}/ca-cert

Agora que o certificado CA está no armazenamento confiável, o cliente confiará em qualquer certificado assinado com ele.
Você deve copiar o file kafka.client.truststore.jks para um local conhecido no computador cliente e aponte para ele nas configurações.

Criando o Keystore para o Kafka Broker
Para gerar o certificado SSL do agente Kafka e, em seguida, o keystore kafka.server.keystore.jks, proceda da seguinte forma:

Gerando o Certificado SSL
Abaixo, 999 é o número de dias de validade do keystore e FQDN é o nome de domínio totalmente qualificado do cliente (nome do host público do nó).

OBSERVAÇÃO: É importante que o FQDN corresponda ao nome de host exato que o cliente Kafka usará para se conectar ao Control Center.

• sudo mkdir -p /var/ssl/privado
• sudo chown -R $USER: /var/ssl/private
• cd /var/ssl/privado
• exportar FQDN = keytool -keystore kafka.server.keystore.jks \
• – servidor de alias \
• – validade 999\
• –genkey -keyalg RSA -ext SAN=dns:${FQDN}

Crie uma solicitação de assinatura de certificado e armazene-a no file chamado cert-server-request:

• keytool -keystore kafka.server.keystore.jks\
  • – servidor de alias \
  • – certreq \
  • – file solicitação de servidor certificado

Agora você deve enviar o file cert-server-request para sua Autoridade de Certificação (CA) se você estiver usando uma autoridade real. Eles então devolverão o certificado assinado. Iremos nos referir a isso como certificado assinado pelo servidor abaixo.

Assinando o certificado SSL usando um certificado CA autocriado

OBSERVAÇÃO: Novamente, usar sua própria CA não é recomendado em um sistema de produção.

Assine o certificado usando a CA por meio do file cert-server-request, que produz o certificado assinado cert-server-signed. Veja abaixo; ca-password é a senha definida ao criar o certificado CA.

• cd /var/ssl/private openssl x509 -req \
  • – CA ${CA_PATH}/ca-cert\
  • – CAkey ${CA_PATH}/ca-key \
  • – em solicitação de servidor de certificado \
  • – out cert-server-assinado \
  • – dias 999 -CAcreateserial\
  • – senha de passagem:{ca-senha}

Importando o Certificado Assinado para o Keystore

Importe o certificado raiz ca-cert para o keystore:

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

Importe o certificado assinado conhecido como cert-server-signed:

• keytool -keystore kafka.server.keystore.jks\
  • – servidor de alias \
  • – importar \
  • – file certificado-servidor-assinado

O file kafka.server.keystore.jks deve ser copiado para um local conhecido no servidor do Centro de Controle e, em seguida, referido em /etc/kafka/server.properties.

Usando a API de streaming

NESTA SEÇÃO

• Geral | 20
• Nomes de tópicos Kafka | 21
• Examparquivos de uso da API de streaming | 21

Em geral
A API de streaming busca dados de teste e monitoramento. Não é possível destacar uma dessas categorias.
A API de streaming não busca dados de testes baseados em script (aqueles representados por um retângulo em vez de uma peça de quebra-cabeça na GUI do Centro de Controle), como testes de ativação de serviço Ethernet e testes de transparência.

Nomes de tópicos do Kafka
Os nomes dos tópicos Kafka para a API de streaming são os seguintes, onde %s é o nome abreviado da conta do Control Center (indicado ao criar a conta):

• const (
• exportadorName = “kafka”
• metadataTopicTpl = “paa.public.accounts.%s.metadata” métricasTopicTpl = “paa.public.accounts.%s.metrics” )

ExampLess of Using the Streaming API
O exampos arquivos a seguir são encontrados no tarball paa-streaming-api-client-examples.tar.gz contido no tarball do Centro de Controle.
Primeiro, há um ex básicoample demonstrando como as métricas e seus metadados são transmitidos separadamente e simplesmente imprimem as mensagens recebidas no console. Você pode executá-lo da seguinte maneira:

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

Há também um ex mais avançadoamparquivo onde métricas e mensagens de metadados são correlacionadas. Use este comando para executá-lo:

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

Você precisa usar sudo para executar comandos do Docker como os acima. Opcionalmente, você pode seguir as etapas de pós-instalação do Linux para poder executar comandos do Docker sem sudo. Para obter detalhes, vá para docs.docker.com/engine/install/linux-postinstall.

Juniper Networks, o logotipo da Juniper Networks, Juniper e Junos são marcas registradas da Juniper Networks, Inc. nos Estados Unidos e em outros países. Todas as outras marcas comerciais, marcas de serviço, marcas registradas ou marcas de serviço registradas são propriedade de seus respectivos proprietários. A Juniper Networks não assume nenhuma responsabilidade por quaisquer imprecisões neste documento. A Juniper Networks reserva-se o direito de alterar, modificar, transferir ou revisar esta publicação sem aviso prévio. Copyright © 2023 Juniper Networks, Inc. Todos os direitos reservados.

Documentos / Recursos

Software de API de streaming Juniper NETWORKS [pdf] Guia do Usuário Software API de streaming, Software API, Software

Referências

• Manual do usuário