Como monitorar

Este documento descreve as técnicas de monitoramento de componentes compatíveis com uma infraestrutura implantação do Apigee Edge para nuvem privada.

Visão geral

O Edge oferece várias maneiras de obter detalhes sobre os serviços, bem como de status. A tabela a seguir lista os tipos de verificações que podem ser realizadas em cada serviço:

Portas e arquivos de configuração de monitoramento

Cada componente suporta as Java Management Extensions (JMX) e as chamadas de monitoramento da API de gerenciamento em em portas diferentes. A a tabela a seguir lista as portas JMX e da API de gerenciamento para cada tipo de servidor e os locais dos arquivos de configuração:

Usar o JMX para monitorar componentes

As seções a seguir explicam como usar o JMX para monitorar os componentes do Edge.

Ativar JMX

Para ativar o JMX sem autenticação ou comunicação baseada em SSL, siga as etapas abaixo. Observação: em sistemas de produção, a autenticação criptografada e o SSL devem ser ativados para segurança dos dados.

1. Edite o arquivo de configuração apropriado (consulte Referência do arquivo de configuração. Crie o arquivo de configuração, se ele não existir.

   conf_system_jmxremote_enable=true

2. Salve o arquivo de configuração e verifique se ele pertence a apigee:apigee.
3. Reiniciar o componente Edge apropriado

   apigee-service edge-management-server restart

Para desativar o JMX, remova a propriedade conf_system_jmxremote_enable ou altere o valor como false. Em seguida, reinicie o componente Edge apropriado.

Autenticação no JMX

O Edge para nuvem privada oferece suporte à autenticação baseada em senha usando detalhes armazenados em arquivos. É possível armazenar senhas como um hash para aumentar a segurança.

1. Para ativar a autenticação JMX em um componente de borda*, edite o arquivo de configuração adequado (consulte Referência do arquivo de configuração. Crie o arquivo de configuração, se ele não existir:

   conf_system_jmxremote_enable=true
   conf_system_jmxremote_authenticate=true
   conf_system_jmxremote_encrypted_auth=true
   conf_system_jmxremote_access_file=/opt/apigee/customer/application/management-server/jmxremote.access
   conf_system_jmxremote_password_file=/opt/apigee/customer/application/management-server/jmxremote.password

   Salve o arquivo de configuração e verifique se ele pertence a apigee:apigee.
2. Crie um hash SHA256 para a senha:

   echo -n '' | openssl dgst -sha256

3. Crie um arquivo jmxremote.password com as credenciais de usuário do JMX:
   1. Copie os seguintes arquivos do diretório $JAVA_HOME para do diretório /opt/apigee/customer/application/<component>/:

      cp ${JAVA_HOME}/lib/management/jmxremote.password.template $APIGEE_ROOT/customer/application/management-server/jmxremote.password

   2. Edite o arquivo e adicione o nome de usuário e a senha do JMX usando a seguinte sintaxe:

      USERNAME <HASH-PASSWORD>

   3. Verifique se o arquivo pertence a apigee e se o modo de arquivo é 400:

      chown apigee:apigee $APIGEE_ROOT/customer/application/management-server/jmxremote.password
      chmod 400 $APIGEE_ROOT/customer/application/management-server/jmxremote.password

4. Crie um arquivo jmxremote.access com as permissões de usuário do JMX:
   1. Copie os seguintes arquivos do seu diretório $JAVA_HOME para o diretório /opt/apigee/customer/application/<component>/

      
      cp ${JAVA_HOME}/lib/management/jmxremote.access$APIGEE_ROOT/customer/application/management-server/jmxremote.password/jmxremote.access

   2. Edite o arquivo e adicione seu nome de usuário JMX seguido de uma permissão (READONLY/READWRITE)

      USERNAME READONLY

   3. Verifique se o arquivo pertence a apigee e se o modo de arquivo é 400:

      chown apigee:apigee $APIGEE_ROOT/customer/application/management-server/jmxremote.password
      
      chmod 400 $APIGEE_ROOT/customer/application/management-server/jmxremote.access

5. Reinicie o componente Edge apropriado:

   apigee-service edge-management-server restart

Para desativar a autenticação JMX, remova a propriedade conf_system_jmxremote_authenticate ou mude o valor para false e reiniciar o componente Edge apropriado.

SSL no JMX

Para ativar JMX baseado em SSL em um componente de borda*:

1. Editar o arquivo de configuração apropriado (consulte Referência do arquivo de configuração. Crie o arquivo de configuração, se ele não existir:

   conf_system_jmxremote_enable=true
   conf_system_jmxremote_ssl=true
   conf_system_javax_net_ssl_keystore=/opt/apigee/customer/application/management-server/jmxremote.keystore
   conf_system_javax_net_ssl_keystorepassword=<keystore-password>

   Salve o arquivo de configuração e verifique se ele pertence a apigee:apigee.
2. Prepare um keystore que contenha a chave do servidor e coloque-o no caminho fornecido na a configuração conf_system_javax_net_ssl_keystore acima. Verifique se o arquivo de keystore pode ser lido por apigee:apigee.
3. Reinicie o componente Edge apropriado:

   apigee-service edge-management-server restart

Para desativar o JMX baseado em SSL, remova a propriedade conf_system_jmxremote_ssl ou mude o valor para false. Reinicie o componente Edge apropriado.

Como monitorar pelo Jconsole

As instruções de monitoramento via jconsole permanecem as mesmas descritas em https://docs.apigee.com/private-cloud/v4.52.01/how-monitor#jconsole.

Monitorar com o JConsole

Use o JConsole (uma ferramenta compatível com JMX) para gerenciar e monitorar verificações de integridade e processar estatísticas. Com o JConsole, você pode consumir as estatísticas do JMX expostas por seus servidores e exibi-las em um interface gráfica do usuário. Para mais informações, consulte Usar o JConsole.

Você precisará iniciar o JConsole com truststore e senha truststore se o SSL estiver ativado para JMX. Consulte Usar o JConsole.

O JConsole usa o seguinte URL de serviço para monitorar os atributos JMX (MBeans) oferecidos por meio de JMX:

service:jmx:rmi:///jndi/rmi://IP_address:port_number/jmxrmi

Em que:

• IP_address é o endereço IP do servidor que você quer monitorar.
• port_number é o número da porta JMX do servidor que você quer monitor

Por exemplo, para monitorar o servidor de gerenciamento, emita um comando como o seguinte (supondo que endereço IP do servidor é 216.3.128.12):

service:jmx:rmi:///jndi/rmi://216.3.128.12:1099/jmxrmi

Observe que este exemplo especifica a porta 1099, que é a porta JMX do servidor de gerenciamento. Para outros portas, consulte Portas de monitoramento da JMX e da API Management.

A tabela a seguir mostra as estatísticas genéricas do JMX:

Referência do arquivo de configuração

As seções a seguir descrevem as alterações que você talvez precise fazer na configuração do componente do Edge para configurações relacionadas ao JMX. Consulte Monitoramento de portas e arquivos de configuração para mais informações imprecisas ou inadequadas.

Configuração JMX a ser adicionada ao arquivo de configuração do componente apropriado

• Ativar o agente JMX no componente de borda. Falso por padrão.

  conf_system_jmxremote_enable=true

Configurações para autenticação baseada em senha

• Ative a autenticação baseada em senha. Falso por padrão.

  conf_system_jmxremote_authenticate=true

• Caminho para acessar o arquivo. Deve ser de propriedade e legível apenas para usuários da Apigee.

  conf_system_jmxremote_access_file=/opt/apigee/customer/application/management-server/jmxremote.access

• Caminho para o arquivo de senha. Deve ser de propriedade e legível apenas para usuários da Apigee.

  conf_system_jmxremote_password_file=/opt/apigee/customer/application/management-server/jmxremote.password

• Ativar o armazenamento de senhas em formato criptografado. Falso por padrão.

  conf_system_jmxremote_encrypted_auth=true

Configurações para JMX baseado em SSL

• Ativar SSL para comunicação JMX. Falso por padrão.

  conf_system_jmxremote_ssl=true

• Caminho para o keystore. Deve ser de propriedade e legível apenas para usuários da Apigee.

  conf_system_javax_net_ssl_keystore=/opt/apigee/customer/application/management-server/jmxremote.keystore

• Senha do keystore:

  conf_system_javax_net_ssl_keystorepassword=changeme

Configurações opcionais do JMX

Os valores listados são valores padrão e podem ser alterados.

• Porta JMX. Os valores padrão estão listados na tabela abaixo.

  conf_system_jmxremote_port=

• Porta JMX RMI. Por padrão, o processo Java escolhe uma porta aleatória.

  conf_system_jmxremote_rmi_port=

• O nome do host para stubs remotos. Endereço IP padrão do localhost.

  conf_system_java_rmi_server_hostname=

• Proteja o registro JMX com SSL. Padrão false. Aplicável apenas se o SSL estiver ativado.

  conf_system_jmxremote_registry_ssl=false

Monitorar com a API Management

O Edge inclui várias APIs que podem ser usadas para realizar verificações de serviço nos servidores, bem como verificar seus usuários, organizações e implantações. Esta seção descreve essas APIs.

Executar verificações de serviço

A API de gerenciamento fornece vários endpoints para monitorar e diagnosticar problemas com seus serviços. Esses endpoints incluem:

<ServerField>
  <Up>true</Up>
</ServerField>

curl: Failed connect to localhost:port_number; Connection refused

Para usar esses endpoints, invoque um utilitário como curl com comandos que usam o seguinte sintaxe:

curl http://host:port_number/v1/servers/self/up -H "Accept: [application/json|application/xml]"
curl http://host:port_number/v1/servers/self -u username:password -H "Accept: [application/json|application/xml]"

Em que:

• host é o endereço IP do servidor que você quer verificar. Se você tiver feito login no servidor, use "localhost". caso contrário, especifique também o endereço IP como nome de usuário e senha.
• port_number é a porta da API de gerenciamento do servidor que você quer verificar. Isso é uma porta diferente para cada tipo de componente. Por exemplo, o servidor de gerenciamento A porta da API de gerenciamento é 8080. Para ver uma lista dos números de porta da API de gerenciamento a serem usados, consulte Portas de monitoramento JMX e da API Management

Para mudar o formato da resposta, especifique o cabeçalho Accept como "application/json" ou "application/xml".

O exemplo a seguir mostra o status do roteador no localhost (porta 8081):

curl http://localhost:8081/v1/servers/self/up -H "Accept: application/xml"

O exemplo a seguir obtém informações sobre o processador de mensagens em 216.3.128.12 (porta 8082):

curl http://216.3.128.12:8082/v1/servers/self -u sysAdminEmail:password
  -H "Accept: application/xml"

Monitorar o status do usuário, da organização e da implantação

Use a API Management para monitorar o status do usuário, da organização e da implantação da sua em servidores de gerenciamento e processadores de mensagens emitindo os seguintes comandos:

curl http://host:port_number/v1/users -u sysAdminEmail:password
curl http://host:port_number/v1/organizations -u sysAdminEmail:password
curl http://host:port_number/v1/organizations/orgname/deployments -u sysAdminEmail:password

Em que port_number é 8080 para o servidor de gerenciamento ou 8082 para a mensagem Processador

Esta chamada exige uma autenticação com o nome de usuário de administração do sistema e senha.

O servidor deve retornar uma mensagem o status de todas as chamadas. Se isso falhar, faça o seguinte:

1. Verifique se há erros nos registros do servidor. Os registros estão localizados em:
   • Servidor de gerenciamento: opt/apigee/var/log/edge-management-server
   • Processador de mensagens: opt/apigee/var/log/edge-message-processor
2. Faça uma chamada ao servidor para verificar se ele está funcionando corretamente.
3. Remova e reinicie o servidor do ELB:

   /opt/apigee/apigee-service/bin/apigee-service service_name restart

   Onde service_name é:

   • edge-management-server
   • edge-message-processor

Verifique o status com o comando apigee-service

Use o comando apigee-service para resolver problemas nos serviços do Edge conectado ao servidor que executa o serviço.

Para verificar o status de um serviço com apigee-service:

1. Faça login no servidor e execute o seguinte comando:

   /opt/apigee/apigee-service/bin/apigee-service service_name status

   Em que service_name é um dos seguintes:

   • Servidor de gerenciamento: edge-management-server
   • Processador de mensagens: edge-message-processor
   • Postgres: edge-postgres-server
   • Qpid: edge-qpid-server
   • Roteador: edge-router

   Exemplo:

   /opt/apigee/apigee-service/bin/apigee-service edge-message-processor status

2. Se o serviço não estiver em execução, inicie-o:

   /opt/apigee/apigee-service/bin/apigee-service service_name start

3. Depois de reiniciar o serviço, verifique se ele está funcionando usando o O comando apigee-service status que você usou anteriormente ou a API Management descritos em Monitorar com a API de gerenciamento.

   Exemplo:

   curl -v http://localhost:port_number/v1/servers/self/up

   Em que port_number é a porta da API de gerenciamento para o serviço.

   Este exemplo pressupõe que você tenha feito login no servidor e possa usar "localhost" como nome do host. Para verificar o status remotamente com a API de gerenciamento, você deve especificar o IP do servidor e inclua o nome de usuário e a senha de administrador do sistema na sua API a chamada.

Monitoramento do Postgres

O Postgres é compatível com vários utilitários que você pode usar para verificar o status dele. Esses utilitários estão descritas nas seções a seguir.

Verificar organizações e ambientes no Postgres

É possível verificar os nomes de organizações e ambientes integrados ao servidor Postgres emitindo o seguinte comando curl:

curl -v http://postgres_IP:8084/v1/servers/self/organizations

O sistema vai mostrar o nome da organização e do ambiente.

Verificar o status da análise

Para verificar o status dos servidores de análise Postgres e Qpid, emita o seguinte Comando curl:

curl -u userEmail:password http://host:port_number/v1/organizations/orgname/environments/envname/provisioning/axstatus

O sistema precisa exibir um status de sucesso para todos os servidores de análise, como no exemplo a seguir. mostra:

{
  "environments" : [ {
    "components" : [ {
      "message" : "success at Thu Feb 28 10:27:38 CET 2013",
      "name" : "pg",
      "status" : "SUCCESS",
      "uuid" : "[c678d16c-7990-4a5a-ae19-a99f925fcb93]"
     }, {
      "message" : "success at Thu Feb 28 10:29:03 CET 2013",
      "name" : "qs",
      "status" : "SUCCESS",
      "uuid" : "[ee9f0db7-a9d3-4d21-96c5-1a15b0bf0adf]"
     } ],
    "message" : "",
    "name" : "prod"
   } ],
  "organization" : "acme",
  "status" : "SUCCESS"
}

Banco de dados PostgreSQL

Esta seção descreve técnicas que você pode usar especificamente para monitorar o Postgres no seu banco de dados.

Usar o script check_postgres.pl

Para monitorar o banco de dados PostgreSQL, use um script de monitoramento padrão, check_postgres.pl: Para mais informações, consulte http://bucardo.org/wiki/Check_postgres.

Antes de executar o script:

1. Você precisa instalar o script check_postgres.pl em cada nó do Postgres.
2. Verifique se você instalou perl-Time-HiRes.x86_64, um módulo Perl que implementa timers de alarme, suspensão, gettimeofday e intervalo de alta resolução. Por exemplo, pode instalá-lo usando o seguinte comando:
   

   yum install perl-Time-HiRes.x86_64

3. CentOS 7: antes de usar o check_postgres.pl no CentOS v7, instale o perl-Data-Dumper.x86_64 RPM.

Saída de check_postgres.pl

A saída padrão das chamadas de API que usam check_postgres.pl é Nagios compatíveis. Depois de instalar o script, faça as seguintes verificações:

1. Verifique o tamanho do banco de dados:

   check_postgres.pl -H 10.176.218.202 -db apigee -u apigee -dbpass postgres -include=apigee -action database_size --warning='800 GB' --critical='900 GB'

2. Verificar o número de conexões de entrada com o banco de dados e compará-lo ao máximo permitido conexões:

   check_postgres.pl -H 10.176.218.202 -db apigee -u apigee -dbpass postgres -action backends

3. Verifique se o banco de dados está em execução e disponível:

   check_postgres.pl -H 10.176.218.202 -db apigee -u apigee -dbpass postgres -action connection

4. Verifique o espaço em disco:

   check_postgres.pl -H 10.176.218.202 -db apigee -u apigee -dbpass postgres -action disk_space --warning='80%' --critical='90%'

5. Verifique o número de organizações e ambientes integrados em um nó do Postgres:

   check_postgres.pl -H 10.176.218.202 -db apigee -u apigee -dbpass postgres -action=custom_query --query="select count(*) as result from pg_tables where schemaname='analytics' and tablename like '%fact'" --warning='80' --critical='90' --valtype=integer

Executar verificações de banco de dados

Você pode verificar se as tabelas corretas foram criadas no banco de dados PostgreSQL. Fazer login no PostgreSQL no banco de dados usando o seguinte comando:

psql -h /opt/apigee/var/run/apigee-postgresql/ -U apigee -d apigee

Depois, execute:

\d analytics."org.env.fact"

Verificar o status de integridade do processo postgres

É possível executar verificações de API na máquina Postgres invocando o seguinte curl comando:

curl -v http://postgres_IP:8084/v1/servers/self/health

Esse comando retorna o status ACTIVE quando o processo postgres está ativo. Se o O processo do Postgres não está em execução. Ele retorna o status INACTIVE.

Recursos do Postgres

Para mais informações sobre como monitorar o serviço Postgres, consulte:

• http://www.postgresql.org/docs/9.0/static/monitoring.html
• http://www.postgresql.org/docs/9.0/static/diskusage.html
• http://bucardo.org/check_postgres/check_postgres.pl.html

Apache Cassandra

O JMX é ativado por padrão para o Cassandra e o acesso remoto do JMX ao Cassandra não requer uma senha.

Ativar a autenticação JMX para o Cassandra

Você pode ativar a autenticação JMX para o Cassandra. Depois de fazer isso, você vai precisar passar um nome de usuário e uma senha para todas as chamadas ao utilitário nodetool.

Para ativar a autenticação JMX para o Cassandra:

1. Crie e edite o arquivo cassandra.properties:
   1. Edite o arquivo /opt/apigee/customer/application/cassandra.properties. Se o arquivo não existe, crie-o.
   2. Adicione o seguinte ao arquivo:

      conf_cassandra_env_com.sun.management.jmxremote.authenticate=true
      conf_cassandra_env_com.sun.management.jmxremote.password.file=${APIGEE_ROOT}/customer/application/apigee-cassandra/jmxremote.password
      conf_cassandra_env_com.sun.management.jmxremote.access.file=${APIGEE_ROOT}/customer/application/apigee-cassandra/jmxremote.access

   3. Salve o arquivo cassandra.properties.
   4. Altere o proprietário do arquivo para apigee:apigee, conforme o exemplo a seguir:

      chown apigee:apigee /opt/apigee/customer/application/cassandra.properties

   Para mais informações sobre como usar arquivos de propriedades para definir tokens, consulte Como configurar o Edge.

2. Criar e editar jmx_auth.sh:
   1. Crie um arquivo no seguinte local, se ele não existir:

      /opt/apigee/customer/application/jmx_auth.sh

   2. Adicione as seguintes propriedades ao arquivo:

      export CASS_JMX_USERNAME=JMX_USERNAME
      export CASS_JMX_PASSWORD=JMX_PASSWORD

   3. Salve o arquivo jmx_auth.sh.
   4. Origem do arquivo:

      source /opt/apigee/customer/application/jmx_auth.sh

3. Copie e edite o arquivo jmxremote.password:
   1. Copie o seguinte arquivo do diretório $JAVA_HOME para /opt/apigee/customer/application/apigee-cassandra/:

      cp ${JAVA_HOME}/lib/management/jmxremote.password.template $APIGEE_ROOT/customer/application/apigee-cassandra/jmxremote.password

   2. Edite o arquivo jmxremote.password e adicione o nome de usuário e a senha do JMX usando a seguinte sintaxe:

      JMX_USERNAME JMX_PASSWORD

      Em que JMX_USERNAME e JMX_PASSWORD são o nome de usuário do JMX e senha definida anteriormente.

   3. Verifique se o arquivo pertence à "apigee" e se o modo de arquivo é 400:

      chown apigee:apigee /opt/apigee/customer/application/apigee-cassandra/jmxremote.password
      chmod 400 /opt/apigee/customer/application/apigee-cassandra/jmxremote.password

4. Copie e edite o arquivo jmxremote.access:
   1. Copie o seguinte arquivo do diretório $JAVA_HOME para /opt/apigee/customer/application/apigee-cassandra/:

      cp ${JAVA_HOME}/lib/management/jmxremote.access
      $APIGEE_ROOT/customer/application/apigee-cassandra/jmxremote.access

   2. Edite o arquivo jmxremote.access e adicione o seguinte papel:

      JMX_USERNAME readwrite

   3. Verifique se o arquivo pertence à "apigee" e se o modo de arquivo é 400:

      chown apigee:apigee /opt/apigee/customer/application/apigee-cassandra/jmxremote.access
      chmod 400 /opt/apigee/customer/application/apigee-cassandra/jmxremote.access

5. Execute configure no Cassandra:

   /opt/apigee/apigee-service/bin/apigee-service apigee-cassandra configure

6. Reinicie o Cassandra:

   /opt/apigee/apigee-service/bin/apigee-service apigee-cassandra restart

7. Repita esse processo em todos os outros nós do Cassandra.

Ativar criptografia de senha do JMX

Para ativar a criptografia de senha do JMX, siga estas etapas:

1. Abra o arquivo source/conf/casssandra-env.sh.
2. Crie e edite o arquivo cassandra.properties:
   1. Edite o arquivo /opt/apigee/customer/application/cassandra.properties. Se o arquivo não existe, crie-o.
   2. Adicione o seguinte ao arquivo:

      conf_cassandra_env_com.sun.management.jmxremote.encrypted.authenticate=true

   3. Salve o arquivo cassandra.properties.
   4. Altere o proprietário do arquivo para apigee:apigee, conforme o exemplo a seguir:

      chown apigee:apigee /opt/apigee/customer/application/cassandra.properties

3. Na linha de comando, gere hash(s) SHA1 das senhas desejadas inserindo echo -n 'Secret' | openssl dgst -sha1
4. Defina as senhas de acordo com o nome de usuário no $APIGEE_ROOT/customer/application/apigee-cassandra/jmxremote.password (criado em na seção anterior).
5. Execute a configuração no Cassandra:

   /opt/apigee/apigee-service/bin/apigee-service apigee-cassandra configure

6. Reinicie o Cassandra:

   /opt/apigee/apigee-service/bin/apigee-service apigee-cassandra restart

7. Repita esse processo em todos os outros nós do Cassandra.

Ativar JMX com SSL para o Cassandra

Ativar o JMX com SSL proporciona segurança e criptografia adicionais para comunicação baseada em JMX com o Cassandra. Para ativar o JMX com SSL, você precisa fornecer uma chave e um certificado ao Cassandra para aceitam conexões JMX baseadas em SSL. Você também precisa configurar o nodetool (e quaisquer outras ferramentas que se comunicar com o Cassandra por JMX) para SSL.

JMX habilitado para SSL oferece suporte a senhas JMX criptografadas e em texto simples.

Para ativar o JMX com SSL para o Cassandra, use o seguinte procedimento:

1. Ative o JMX. Ative a criptografia de senha, se necessário.
2. Ative a autenticação do JMX para o Cassandra. conforme descrito acima. Verifique se o nodetool está funcionando com o nome de usuário e senha.

   /opt/apigee/apigee-cassandra/bin/nodetool -u <JMX_USER> -pw <JMX_PASS> ring

3. Prepare o keystore e o truststore.

   • O keystore deve conter uma chave e um certificado, e é usado para configurar o servidor do Cassandra. Se keystore contém vários pares de chaves, o Cassandra usa o primeiro par para ativar o SSL.

     Observe que as senhas para o keystore e para a chave devem ser as mesmas (o padrão quando você gera a chave usando o keytool).

   • O Truststore deve conter apenas o certificado e é usado por clientes (com base em serviço da Apigee comandos ou nodetool) para se conectar por JMX.

   Após verificar os requisitos acima:

   1. Coloque o arquivo do keystore em /opt/apigee/customer/application/apigee-cassandra/.
   2. Verifique se o arquivo do keystore pode ser lido apenas pelo usuário da Apigee digitando

      chown apigee:apigee /opt/apigee/customer/application/apigee-cassandra/keystore.node1
      chmod 400 /opt/apigee/customer/application/apigee-cassandra/keystore.node1

4. Configure o Cassandra para JMX com SSL seguindo estas etapas:
   1. Para parar o nó do Cassandra, insira

      apigee-service apigee-cassandra stop

   2. Ative o SSL no Cassandra ao abrindo o arquivo /opt/apigee/customer/application/cassandra.properties e adicionando as seguintes linhas:

      conf_cassandra_env_com.sun.management.jmxremote.ssl=true
      conf_cassandra_env_javax.net.ssl.keyStore=/opt/apigee/customer/application/apigee-cassandra/keystore.node1
      conf_cassandra_env_javax.net.ssl.keyStorePassword=keystore-password

   3. Altere o proprietário do arquivo para apigee:apigee, conforme o exemplo a seguir:

      chown apigee:apigee /opt/apigee/customer/application/cassandra.properties

   4. Execute a configuração no Cassandra:

      /opt/apigee/apigee-service/bin/apigee-service apigee-cassandra configure

   5. Reinicie o Cassandra:

      /opt/apigee/apigee-service/bin/apigee-service apigee-cassandra restart

   6. Repita esse processo em todos os outros nós do Cassandra.
   7. Inicie o nó do Cassandra inserindo

      apigee-service apigee-cassandra start

5. Configure os comandos apigee-service do Cassandra. Você precisa definir algumas variáveis de ambiente durante a execução Comandos apigee-service, incluindo estes abaixo:

   apigee-service apigee-cassandra stop
   apigee-service apigee-cassandra wait_for_ready
   apigee-service apigee-cassandra ring
   apigee-service apigee-cassandra backup

   Há várias opções para configurar o apigee-service para autenticação JMX e SSL. Escolha uma opção com base na usabilidade e nas suas práticas de segurança.

   • Opção 1 (argumentos SSL armazenados no arquivo)
   • Opção 2 (argumentos SSL armazenados em variáveis de ambiente)
   • Opção 3 (argumentos SSL transmitidos diretamente para apigee-service)

   Opção 1 (argumentos SSL armazenados no arquivo)

   Configure as variáveis de ambiente a seguir:

   export CASS_JMX_USERNAME=ADMIN
   # Provide encrypted password here if you have setup JMX password encryption
   export CASS_JMX_PASSWORD=PASSWORD
   export CASS_JMX_SSL=Y

   Crie um arquivo no diretório inicial do usuário da Apigee (/opt/apigee).

   $HOME/.cassandra/nodetool-ssl.properties

   Edite o arquivo e adicione as seguintes linhas:

   -Djavax.net.ssl.trustStore=<path-to-truststore.node1>
   -Djavax.net.ssl.trustStorePassword=<truststore-password>
   -Dcom.sun.management.jmxremote.registry.ssl=true

   Verifique se o arquivo trustore pode ser lido pelo usuário da Apigee.

   Execute o seguinte comando apigee-service. Se ele for executado sem erros, isso significa que suas configurações estão corretas.

   apigee-service apigee-cassandra ring

   Opção 2 (argumentos SSL armazenados em variáveis de ambiente)

   Configure as variáveis de ambiente a seguir:

   export CASS_JMX_USERNAME=ADMIN
   # Provide encrypted password here if you have setup JMX password encryption
   export CASS_JMX_PASSWORD=PASSWORD
   export CASS_JMX_SSL=Y
   # Ensure the truststore file is accessible by Apigee user.
   export CASS_JMX_TRUSTSTORE=<path-to-trustore.node1>
   export CASS_JMX_TRUSTSTORE_PASSWORD=<truststore-password>

   Execute o seguinte comando apigee-service. Se ele for executado sem erros, isso significa que suas configurações estão corretas.

   apigee-service apigee-cassandra ring

   Opção 3 (argumentos SSL transmitidos diretamente para apigee-service)

   Execute qualquer comando apigee-service como o mostrado abaixo. Você não precisa configurar nenhuma variável de ambiente.

   CASS_JMX_USERNAME=ADMIN CASS_JMX_PASSWORD=PASSWORD CASS_JMX_SSL=Y CASS_JMX_TRUSTSTORE=<path-to-trustore.node1> CASS_JMX_TRUSTSTORE_PASSWORD=<trustore-password> /opt/apigee/apigee-service/bin/apigee-service apigee-cassandra ring

6. Configure o nodetool. O Nodetool requer que os parâmetros JMX sejam passados para ele. Há duas maneiras você pode configurar o nodetool para ser executado com JMX habilitado para SSL, conforme descrito no as opções de configuração abaixo:

   • Opção de configuração 1
   • Opção de configuração 2

   As opções diferem na maneira como as configurações relacionadas ao SSL são passadas para o nodetool. Em ambos os casos, o usuário que executa o nodetool deve ter permissões de READ no arquivo truststore. Escolha a opção apropriada com base na usabilidade e nas suas práticas de segurança.

   Para saber mais sobre os parâmetros do nodetool, consulte a Documentação do DataStax.

   Opção de configuração 1

   Crie um arquivo no diretório inicial do usuário que executa o nodetool.

   $HOME/.cassandra/nodetool-ssl.properties

   Adicione as seguintes linhas ao arquivo:

   -Djavax.net.ssl.trustStore=<path-to-truststore.node1>
   -Djavax.net.ssl.trustStorePassword=<truststore-password>
   -Dcom.sun.management.jmxremote.registry.ssl=true

   O caminho do truststore especificado acima deve ser acessado por qualquer usuário que esteja executando nodetool.

   Execute nodetool com a opção --ssl.

   /opt/apigee/apigee-cassandra/bin/nodetool --ssl -u <jmx-user-name> -pw <jmx-user-password> -h localhost ring

   Opção de configuração 2

   Execute nodetool como um único comando com os parâmetros extras listados abaixo.

   /opt/apigee/apigee-cassandra/bin/nodetool -Djavax.net.ssl.trustStore=<path-to-truststore.node1> -Djavax.net.ssl.trustStorePassword=<truststore-password> -Dcom.sun.management.jmxremote.registry.ssl=true -Dssl.enable=true -u <jmx-user-name> -pw <jmx-user-password> -h localhost ring

Reverter configurações de SSL

Se for preciso reverter as configurações de SSL descritas no procedimento acima, siga estas etapas:

1. Para interromper apigee-cassandraao inserir

   apigee-service apigee-cassandra stop

2. Remova a linha conf_cassandra-env_com.sun.management.jmxremote.ssl=true de o arquivo /opt/apigee/customer/application/cassandra.properties.
3. Marque as seguintes linhas como comentários em /opt/apigee/apigee-cassandra/source/conf/cassandra-env.sh

   # JVM_OPTS="$JVM_OPTS -Djavax.net.ssl.keyStore=/opt/apigee/data/apigee-cassandra/keystore.node0"
   # JVM_OPTS="$JVM_OPTS -Djavax.net.ssl.keyStorePassword=keypass"
   # JVM_OPTS="$JVM_OPTS -Dcom.sun.management.jmxremote.registry.ssl=true”

4. Comece apigee-cassandra inserindo

apigee-service apigee-cassandra start

5. Remova a variável de ambiente CASS_JMX_SSL, se ela estiver definida.

   unset CASS_JMX_SSL

6. Verifique se os comandos baseados em apigee-service, como ring, stop, backup e assim por diante estão funcionando.
7. Parar de usar a chave --ssl com o nodetool

Desativar a autenticação JMX para o Cassandra

Para desativar a autenticação do JMX no Cassandra:

1. Editar /opt/apigee/customer/application/cassandra.properties.
2. Remova a seguinte linha do arquivo:

   conf_cassandra-env_com.sun.management.jmxremote.authenticate=true

3. Execute a configuração no Cassandra:

   /opt/apigee/apigee-service/bin/apigee-service apigee-cassandra configure

4. Reinicie o Cassandra:

   /opt/apigee/apigee-service/bin/apigee-service apigee-cassandra restart

5. Repita esse processo em todos os outros nós do Cassandra.

Use o JConsole: monitore as estatísticas das tarefas

Use o JConsole e o seguinte URL de serviço para monitorar os atributos JMX (MBeans) oferecidos por meio do JMX:

service:jmx:rmi:///jndi/rmi://IP_address:7199/jmxrmi

Em que IP_address é o IP do servidor do Cassandra.

Estatísticas do Cassandra JMX

Usar o nodetool para gerenciar os nós do cluster

O utilitário nodetool é uma interface de linha de comando do Cassandra que gerencia nós do cluster. O utilitário pode ser encontrado em /opt/apigee/apigee-cassandra/bin.

As seguintes chamadas podem ser feitas em todos os nós de cluster do Cassandra:

1. Informações gerais do toque (também possíveis para um único nó do Cassandra): procure o "Para cima" e "Normal" para todos os nós.

   nodetool [-u username -pw password] -h localhost ring

   Você só precisará passar seu nome de usuário e sua senha se ativou a autenticação JMX para o Cassandra.

   A saída do comando acima tem a seguinte aparência:

   Datacenter: dc-1
   ==========
   Address            Rack     Status State   Load    Owns    Token
   192.168.124.201    ra1      Up     Normal  1.67 MB 33,33%  0
   192.168.124.202    ra1      Up     Normal  1.68 MB 33,33%  5671...5242
   192.168.124.203    ra1      Up     Normal  1.67 MB 33,33%  1134...0484

2. Informações gerais sobre nós (chamada por nó)

   nodetool [-u username -pw password]  -h localhost info

   A saída do comando acima vai ser semelhante a esta:

   ID                     : e2e42793-4242-4e82-bcf0-oicu812
   Gossip active          : true
   Thrift active          : true
   Native Transport active: true
   Load                   : 273.71 KB
   Generation No          : 1234567890
   Uptime (seconds)       : 687194
   Heap Memory (MB)       : 314.62 / 3680.00
   Off Heap Memory (MB)   : 0.14
   Data Center            : dc-1
   Rack                   : ra-1
   Exceptions             : 0
   Key Cache              : entries 150, size 13.52 KB, capacity 100 MB, 1520781 hits, 1520923 requests, 1.000 recent hit rate, 14400 save period in seconds
   Row Cache              : entries 0, size 0 bytes, capacity 0 bytes, 0 hits, 0 requests, NaN recent hit rate, 0 save period in seconds
   Counter Cache          : entries 0, size 0 bytes, capacity 50 MB, 0 hits, 0 requests, NaN recent hit rate, 7200 save period in seconds
   Token                  : 0

3. Status do servidor thrift (disponibilização da API do cliente)

   nodetool [-u username -pw password] -h localhost statusthrift

   A saída do comando acima vai ser semelhante a esta:
   

   running

4. Status das operações de streaming de dados: observe o tráfego dos nós do Cassandra:

   nodetool [-u username -pw password] -h localhost netstats

   A saída do comando acima vai ser semelhante a esta:
   

   Mode: NORMAL
   Not sending any streams.
   Read Repair Statistics:
   Attempted: 151612
   Mismatch (Blocking): 0
   Mismatch (Background): 0
   Pool Name                    Active   Pending      Completed   Dropped
   Commands                        n/a         0              0         0
   Responses                       n/a         0              0       n/a

Para mais informações sobre o nodetool, consulte Sobre o utilitário nodetool.

Recurso do Cassandra

Acesse o seguinte URL: http://www.datastax.com/docs/1.0/operations/monitoring.

Como monitorar o Apache Qpid Broker-J

Você pode monitorar o Qpid Broker-J no console de gerenciamento do Qpid. Esta seção explica como acessar o console e usá-lo para executar funções básicas de monitoramento. Para mais detalhes informações sobre como usar o console de gerenciamento, consulte Console de gerenciamento da Web na documentação do Apache Qpid.

Acessar o console de gerenciamento

A porta padrão do console de gerenciamento é 8090. Para acessar o console nessa porta padrão, direcione seu navegador da web para:

http://QPID_NODE_IP:8090

Para fazer login no console, use as credenciais padrão definidas pela Apigee ou definidas no Arquivo de configuração de borda. Para mais detalhes, consulte Referência do arquivo de configuração do Edge.

Monitorar filas e mensagens

No painel de navegação esquerdo, vá até Java-Broker > virtualhosts > filas. Selecionar uma fila para visualizar os detalhes na parte principal da interface. Na visualização de detalhes, é possível Atributos e estatísticas da fila, incluindo informações sobre mensagens entregues, enfileiradas, taxas de mensagens etc.

Ver e fazer o download de arquivos de registro

No painel de navegação esquerdo, vá até Java-Broker > agente de registradores > logfile. Na visualização principal de detalhes da interface, você pode conferir os detalhes do arquivo de registro e fazer o download deles.

Como usar a API de gerenciamento Qpid

Use a API REST do Apache Qpid Broker-J para automatizar tarefas de gerenciamento e monitorar o agente. Para mais detalhes, consulte a Documentação da API REST do Apache Qpid Broker (em inglês).

Também é possível usar ferramentas de linha de comando para monitorar o agente. Exemplo:

curl "QPID_NODE_IP":"8090"/api/latest/broker -u "USERNAME":"PASSWORD"

Apache ZooKeeper

Verificar o status do ZooKeeper

1. Verifique se o processo do ZooKeeper está em execução. O ZooKeeper grava um arquivo PID em opt/apigee/var/run/apigee-zookeeper/apigee-zookeeper.pid:
2. Teste as portas do ZooKeeper para garantir que você possa estabelecer uma conexão TCP com as portas 2181 e 3888 em todos os servidores do ZooKeeper.
3. Verifique se é possível ler valores do banco de dados do ZooKeeper. Conectar-se usando um ZooKeeper biblioteca de cliente (ou /opt/apigee/apigee-zookeeper/bin/zkCli.sh) e ler um valor do banco de dados.
4. Verifique o status:

   /opt/apigee/apigee-service/bin/apigee-service apigee-zookeeper status

Usar palavras de quatro letras do ZooKeeper

O ZooKeeper pode ser monitorado por meio de um pequeno conjunto de comandos (palavras de quatro letras) que são enviados a porta 2181 usando netcat (nc) ou telnet.

Para mais informações sobre os comandos do ZooKeeper, consulte: Referência do comando do Apache ZooKeeper.

Exemplo:

• srvr: lista os detalhes completos do servidor.
• stat: lista breves detalhes do servidor e dos clientes conectados.

Os seguintes comandos podem ser emitidos para a porta do ZooKeeper:

1. Execute o comando de quatro letras ruok para testar se o servidor está sendo executado em um estado sem erro. Um bem-sucedida, retornará "imok".

   echo ruok | nc host 2181

   Retorna:

   imok

2. Execute o comando de quatro letras, stat, para listar o desempenho do servidor e se conectou estatísticas dos clientes:

   echo stat | nc host 2181

   Retorna:

   Zookeeper version: 3.4.5-1392090, built on 09/30/2012 17:52 GMT
   Clients:
   /0:0:0:0:0:0:0:1:33467[0](queued=0,recved=1,sent=0)
   /192.168.124.201:42388[1](queued=0,recved=8433,sent=8433)
   /192.168.124.202:42185[1](queued=0,recved=1339,sent=1347)
   /192.168.124.204:39296[1](queued=0,recved=7688,sent=7692)
   Latency min/avg/max: 0/0/128
   Received: 26144
   Sent: 26160
   Connections: 4
   Outstanding: 0
   Zxid: 0x2000002c2
   Mode: follower
   Node count: 283

3. Se o netcat (nc) não estiver disponível, use o Python como alternativa. Criar um arquivo chamado zookeeper.py, que contém o seguinte:

   import time, socket,
   sys c = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
   c.connect((sys.argv[1], 2181))
   c.send(sys.argv[2])
   time.sleep(0.1)
   print c.recv(512)

   Agora execute estas linhas Python:

   python zookeeper.py 192.168.124.201 ruok
   python zookeeper.py 192.168.124.201 stat

Teste de nível LDAP

É possível monitorar o OpenLDAP para ver se as solicitações específicas são exibidas corretamente. Em outras palavras, procure uma pesquisa específica que retorne o resultado correto.

1. Use ldapsearch (yum install openldap-clients) para consultar a entrada do administrador do sistema. Essa entrada é usada para autenticar todas as chamadas de API.

   ldapsearch -b "uid=admin,ou=users,ou=global,dc=apigee,dc=com" -x -W -D "cn=manager,dc=apigee,dc=com" -H ldap://localhost:10389 -LLL

   Em seguida, será solicitada a senha de administrador do LDAP:

   Enter LDAP Password:

   Depois de inserir a senha, você verá uma resposta no formulário:

   dn:
   uid=admin,ou=users,ou=global,dc=apigee,dc=com
   objectClass: organizationalPerson
   objectClass: person
   objectClass: inetOrgPerson
   objectClass: top
   uid: admin
   cn: admin
   sn: admin
   userPassword:: e1NTSEF9bS9xbS9RbVNXSFFtUWVsU1F0c3BGL3BQMkhObFp2eDFKUytmZVE9PQ=
    =
   mail: opdk@google.com

2. Verifique se o Management Server ainda está conectado ao LDAP com o seguinte comando:

   curl -u userEMail:password http://localhost:8080/v1/users/ADMIN

   Retorna:

   {
     "emailId" : ADMIN,
     "firstName" : "admin",
     "lastName" : "admin"
   }

Também é possível monitorar os caches do OpenLDAP, o que reduz o número de acessos ao disco e, assim, melhorar o desempenho do sistema. O monitoramento e o ajuste do tamanho do cache na O servidor OpenLDAP pode afetar muito o desempenho do servidor de diretório. Para consultar o registro (opt/apigee/var/log) para obter informações sobre o cache.