Como monitorar

Neste documento, descrevemos as técnicas de monitoramento de componentes compatíveis com uma implantação local do Apigee Edge para nuvem privada.

Visão geral

O Edge oferece suporte a várias maneiras de receber detalhes sobre os serviços e verificar os statuses deles. A tabela a seguir lista os tipos de verificações que podem ser realizadas em cada serviço qualificado:

Monitorar portas e arquivos de configuração

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

Usar a JMX para monitorar componentes

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

Ativar o JMX

Para ativar a 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 precisam ser ativados para fins de segurança.

1. 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

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 mude o valor dela para false. Em seguida, reinicie o componente Edge apropriado.

Autenticação no JMX

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

1. Para ativar a autenticação JMX em um componente edge-*, edite o arquivo de configuração apropriado (consulte a 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 é de propriedade de apigee:apigee.
2. Crie um hash SHA256 da senha:

   echo -n '' | openssl dgst -sha256

3. Crie um arquivo jmxremote.password com credenciais de usuário JMX:
   1. Copie os seguintes arquivos do diretório $JAVA_HOME para o 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 seu nome de usuário e senha do JMX usando a seguinte sintaxe:

      USERNAME <HASH-PASSWORD>

   3. Confira se o arquivo é de propriedade de apigee e se o modo do 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 permissões de usuário JMX:
   1. Copie os seguintes arquivos do 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 do JMX seguido de uma permissão (READONLY/READWRITE)

      USERNAME READONLY

   3. Confira se o arquivo é de propriedade de apigee e se o modo do 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 reinicie o componente Edge apropriado.

SSL no JMX

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

1. Edite o arquivo de configuração apropriado (consulte a 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 contendo a chave do servidor e coloque-o no caminho fornecido na configuração conf_system_javax_net_ssl_keystore acima. Verifique se o arquivo 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 altere o valor para false. Reinicie o componente do Edge apropriado.

Como monitorar pelo Jconsole

As instruções de monitoramento pelo 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, é possível consumir estatísticas JMX expostas pelos servidores e exibi-las em uma interface gráfica. Para mais informações, consulte Como usar o JConsole.

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

O JConsole usa o seguinte URL do serviço para monitorar os atributos JMX (MBeans) oferecidos por 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 monitorar.

Por exemplo, para monitorar o servidor de gerenciamento, emita um comando como este (assumindo que o endereço IP do servidor seja 216.3.128.12):

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

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

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 talvez você precise fazer nos arquivos de configuração do componente Edge para configurações relacionadas ao JMX. Consulte Como monitorar portas e arquivos de configuração para mais informações.

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

• Ativar o agente JMX no componente de borda. O padrão é "falso".

  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 pelo usuário 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. O padrão é "falso".

  conf_system_jmxremote_encrypted_auth=true

Configurações para JMX baseadas em SSL

• Ative o SSL para a comunicação JMX. O padrão é "falso".

  conf_system_jmxremote_ssl=true

• Caminho para o keystore. Deve ser de propriedade e legível apenas pelo usuário 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 JMX opcionais

Os valores listados são padrões 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 verificar serviços nos servidores, bem como verificar usuários, organizações e implantações. Esta seção descreve essas APIs.

Realizar verificações de serviço

A API Management oferece 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 a 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ê estiver conectado ao servidor, use "localhost". Caso contrário, especifique o endereço IP do servidor, bem como o nome de usuário e a senha.
• port_number é a porta da API Management para o servidor que você quer verificar. Essa é uma porta diferente para cada tipo de componente. Por exemplo, a porta da API Management do servidor de gerenciamento é 8080. Para conferir uma lista de números de porta da API Management a serem usados, consulte Portas de monitoramento da API Management e JMX.

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

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

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

O exemplo a seguir mostra 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

É possível usar a API Management para monitorar o status do usuário, da organização e da implantação dos seus proxies 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 o processador de mensagens.

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

O servidor precisa retornar um status "implantado" para todas as chamadas. Se eles falharem, 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 para verificar se o servidor está funcionando corretamente.
3. Remova o servidor do ELB e reinicie-o:

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

   Onde service_name é:

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

Verificar o status com o comando apigee-service

É possível resolver problemas nos serviços do Edge usando o comando apigee-service quando você está 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 comando apigee-service status usado anteriormente ou a API Management descrita em Monitorar com a API Management.

   Exemplo:

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

   em que port_number é a porta da API Management para o serviço.

   Neste exemplo, presumimos que você tenha feito login no servidor e possa usar "localhost" como nome do host. Para verificar o status remotamente com a API Management, especifique o endereço IP do servidor e inclua o nome de usuário e a senha do administrador do sistema na chamada de API.

Monitoramento do Postgres

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

Verificar organizações e ambientes no Postgres

É possível verificar os nomes de organização e ambiente integrados no servidor Postgres emitindo o seguinte comando curl:

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

O sistema mostra 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, conforme o exemplo a seguir:

{
  "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

Nesta seção, descrevemos as técnicas que podem ser usadas especificamente para monitorar o banco de dados do Postgres.

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. É necessário instalar o script check_postgres.pl em cada nó do Postgres.
2. Verifique se você instalou o perl-Time-HiRes.x86_64, um módulo Perl que implementa alarme de alta resolução, sleep, gettimeofday e timers de intervalo. Por exemplo, é possível 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 a RPM perl-Data-Dumper.x86_64.

saída de check_postgres.pl

A saída padrão das chamadas de API que usam check_postgres.pl é compatível com Nagios. 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. Confira o número de conexões recebidas no banco de dados e compare com o número máximo de conexões permitidas:

   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. Confira 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 do banco de dados

Você pode verificar se as tabelas adequadas foram criadas no banco de dados PostgreSQL. Faça login no banco de dados do PostgreSQL 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 realizar verificações de API na máquina Postgres invocando o seguinte comando curl:

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

Esse comando retorna o status ACTIVE quando o processo postgres está ativo. Se o processo do Postgres não estiver em execução, ele retornará o status INACTIVE.

Recursos do Postgres

Para mais informações sobre como monitorar o serviço do 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

É possível ativar a autenticação JMX para o Cassandra. Depois de fazer isso, será necessário passar um nome de usuário e uma senha para todas as chamadas para o utilitário nodetool.

Para ativar a autenticação JMX no Cassandra:

1. Crie e edite o arquivo cassandra.properties:
   1. Edite o arquivo /opt/apigee/customer/application/cassandra.properties. Se o arquivo não existir, 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. Mude o proprietário do arquivo para apigee:apigee, conforme mostrado no 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. Crie e edite 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. Origine o 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 seu nome de usuário e 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 e a senha do JMX que você definiu anteriormente.

   3. Verifique se o arquivo é de "apigee" e se o modo do 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 a criptografia de senha 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 existir, 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 em $APIGEE_ROOT/customer/application/apigee-cassandra/jmxremote.password (criado na seção anterior).
5. Execute o comando 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 JMX com SSL para o Cassandra

Ativar o JMX com SSL oferece mais segurança e criptografia para a 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 aceitar conexões JMX baseadas em SSL. Você também precisa configurar o nodetool (e qualquer outra ferramenta que se comunique com o Cassandra por JMX) para SSL.

O JMX ativado para SSL oferece suporte a senhas JMX criptografadas e de 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 JMX para o Cassandra. conforme descrito acima. Verifique se o nodetool está funcionando com o nome de usuário e a senha configurados.

   /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 o keystore tiver vários pares de chaves, o Cassandra usará o primeiro par para ativar o SSL.

     As senhas para o keystore e a chave precisam 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 (comandos baseados em serviço da Apigee ou nodetool) para se conectarem pelo JMX.

   Depois de verificar os requisitos acima:

   1. Coloque o arquivo do keystore em /opt/apigee/customer/application/apigee-cassandra/.
   2. Para garantir que o arquivo keystore seja legível apenas pelo usuário da Apigee, digite

      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. Pare o nó do Cassandra digitando

      apigee-service apigee-cassandra stop

   2. Ative o SSL no Cassandra 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
      ## On FIPS enabled systems, when you are using non standard keystore, set the following:
      ## These can be skipped otherwise
      ## Possible values are JKS, PKCS12, BCFKS
      conf_cassandra_env_javax.net.ssl.keyStoreType=PKCS12
      conf_cassandra_env_javax.net.ssl.keyStoreAlias=cassjmx-tls-alias

   3. Mude o proprietário do arquivo para apigee:apigee, conforme mostrado no 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. É necessário definir determinadas variáveis de ambiente ao executar comandos apigee-service, incluindo estes:

   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 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 em 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 em 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 principal do usuário da Apigee (/opt/apigee).

   $HOME/.cassandra/nodetool-ssl.properties

   Edite o arquivo e adicione as seguintes linhas:

   -Djavax.net.ssl.trustStore=
   -Djavax.net.ssl.trustStorePassword=
   -Dcom.sun.management.jmxremote.registry.ssl=true
   ## If you are using a non standard truststore, set below, otherwise skip
   ## Possible values are JKS, PKCS12, BCFKS
   -Djavax.net.ssl.trustStoreType=PKCS12

   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 as 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=
   export CASS_JMX_TRUSTSTORE_PASSWORD=
   # If you are using a non standard truststore type, export truststore type as well
   # Possible values are JKS, PKCS12, BCFKS
   export CASS_JMX_TRUSTSTORE_TYPE=PKCS12

   Execute o seguinte comando apigee-service. Se ele for executado sem erros, isso significa que as 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. Não é necessário configurar variáveis de ambiente.

   CASS_JMX_USERNAME=ADMIN CASS_JMX_PASSWORD=PASSWORD CASS_JMX_SSL=Y CASS_JMX_TRUSTSTORE= CASS_JMX_TRUSTSTORE_PASSWORD= CASS_JMX_TRUSTSTORE_TYPE=PKCS12 /opt/apigee/apigee-service/bin/apigee-service apigee-cassandra ring

6. Configure o nodetool. O nodetool exige que os parâmetros JMX sejam transmitidos a ele. Há duas maneiras de configurar o nodetool para ser executado com JMX ativado para SSL, conforme descrito nas opções de configuração abaixo:

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

   As opções diferem na forma como as configurações relacionadas ao SSL são transmitidas para o nodetool. Em ambos os casos, o usuário que executa o nodetool precisa 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=
   -Djavax.net.ssl.trustStorePassword=
   -Dcom.sun.management.jmxremote.registry.ssl=true
   ## If you are using a non standard truststore, set below, otherwise skip
   ## Possible values are JKS, PKCS12, BCFKS
   -Djavax.net.ssl.trustStoreType=PKCS12

   O caminho do repositório de confiança especificado acima precisa ser acessível por qualquer usuário que execute o 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= -Djavax.net.ssl.trustStorePassword= -Dcom.sun.management.jmxremote.registry.ssl=true -Djavax.net.ssl.trustStoreType=PKCS12 -Dssl.enable=true -u  -pw  -h localhost ring

Reverter configurações de SSL

Se você precisar reverter as configurações SSL descritas no procedimento acima, siga estas etapas:

1. Parar apigee-cassandra digitando

   apigee-service apigee-cassandra stop

2. Remova a linha conf_cassandra-env_com.sun.management.jmxremote.ssl=true do 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 a apigee-cassandra digitando

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 JMX do 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 o comando configure 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 URL de serviço a seguir para monitorar os atributos JMX (MBeans) oferecidos pelo JMX:

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

Em que IP_address é o IP do servidor do Cassandra.

Estatísticas do JMX do Cassandra

Usar o nodetool para gerenciar nós de cluster

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

As chamadas a seguir podem ser feitas em todos os nós do cluster do Cassandra:

1. Informações gerais do anel (também possível para um único nó do Cassandra): procure "Up" e "Normal" para todos os nós.

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

   Você só precisa transmitir seu nome de usuário e senha se tiver ativado 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 é 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 de troca (disponibilização da API do cliente)

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

   A saída do comando acima é 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 é 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

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

Monitoramento do Apache Qpid Broker-J

É possível monitorar o Qpid Broker-J no console de gerenciamento do Qpid. Nesta seção, explicamos como acessar o console e usá-lo para executar funções básicas de monitoramento. Para mais 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, aponte o navegador da Web para:

http://QPID_NODE_IP:8090

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

Monitorar filas e mensagens

No painel de navegação à esquerda, navegue até Java-Broker > virtualhosts > queues. Selecione uma fila para conferir os detalhes dela na parte principal da interface. Na visualização detalhada, você pode conferir os atributos e as estatísticas da fila, incluindo informações sobre mensagens entregues, enfileiradas, taxas de mensagens e assim por diante.

Ver e fazer o download de arquivos de registro

No painel de navegação à esquerda, acesse Java-Broker > Brokerloggers > logfile. Na visualização de detalhes da interface principal, é possível conferir detalhes do arquivo de registro e fazer o download dele.

Como usar a API de gerenciamento Qpid

Use a API REST Apache Qpid Broker-J para automatizar tarefas de gerenciamento e monitorar o agente. Para saber mais, consulte a documentação da API REST do Apache Qpid Broker.

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"

Ativar o monitoramento com SSL para Qpid

Para reforçar a segurança no monitoramento e gerenciamento, ative o SSL no portal de gerenciamento do Qpid e nas APIs de gerenciamento da Qpid. Siga as diretrizes abaixo para fornecer uma chave e um certificado.

O Qpid oferece uma opção para um keystore de arquivos, ativado na Apigee. Esse tipo aceita o formato de keystore JKS padrão compreendido pelo Java e pelas ferramentas Java, como keytool.

Preparação do keystore

Além de usar o keytool, você precisa fornecer o arquivo de certificado diretamente para uso por clientes do Qpidd.

Para gerar keystores, consulte a documentação do keytool do Java.

Após a verificação dos requisitos

1. Coloque os arquivos de keystore e certificado em /opt/apigee/customer/application/apigee-qpidd.
2. Verifique se o arquivo de keystore pode ser lido apenas pelo usuário da Apigee:

   chown apigee:apigee /opt/apigee/customer/application/apigee-qpidd/qpidd.keystore
     chmod 400 /opt/apigee/customer/application/apigee-qpidd/qpidd.keystore
       
     chown apigee:apigee /opt/apigee/customer/application/apigee-qpidd/qpidd-cert.pem
     chmod 400 /opt/apigee/customer/application/apigee-qpidd/qpidd-cert.pem

Ativar o SSL no Qpid

Siga as etapas abaixo em um nó Qpid de cada vez:

Abra o arquivo /opt/apigee/customer/application/qpidd.properties e adicione estas linhas:

conf_qpidd_qpid_management.https.enabled=true
  conf_qpidd_qpid.keystore.storeUrl=/opt/apigee/customer/application/apigee-qpidd/qpidd.keystore
  conf_qpidd_qpid.keystore.password=keystore-password
  conf_qpidd_qpid.keystore.certificateAlias=certificate-alias
  conf_qpidd_qpid.keystore.certificate=/opt/apigee/customer/application/apigee-qpidd/qpidd-cert.pem

1. Mude o proprietário do arquivo para apigee:apigee:

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

2. Configurar o Qpidd:

   apigee-service apigee-qpidd configure

3. Reiniciar o Qpidd:

   apigee-service apigee-qpidd restart

4. Verifique o status com wait_for_ready:

   apigee-service apigee-qpidd wait_for_ready

Reverter configuração SSL

Remova ou comente as propriedades do arquivo /opt/apigee/customer/application/qpidd.properties:

conf_qpidd_qpid_management.https.enabled=true
  conf_qpidd_qpid.keystore.storeUrl=/opt/apigee/customer/application/apigee-qpidd/keystore

1. Configurar o Qpidd:

   apigee-service apigee-qpidd configure

2. Reiniciar o Qpidd:

   apigee-service apigee-qpidd restart

3. Verifique o status com wait_for_ready:

   apigee-service apigee-qpidd wait_for_ready

Apache ZooKeeper

Verificar o status do ZooKeeper

1. Verifique se o processo 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 você consegue ler valores do banco de dados do ZooKeeper. Conecte-se usando uma biblioteca de cliente do ZooKeeper (ou /opt/apigee/apigee-zookeeper/bin/zkCli.sh) e leia 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 um pequeno conjunto de comandos (palavras de quatro letras) enviados para a porta 2181 usando o netcat (nc) ou o telnet.

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

Exemplo:

• srvr: lista todos os detalhes do servidor.
• stat: lista detalhes breves 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. Uma resposta bem-sucedida retorna "imok".

   echo ruok | nc host 2181

   Retorna:

   imok

2. Execute o comando de quatro letras, stat, para listar a performance do servidor e as estatísticas dos clientes conectados:

   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. Crie um arquivo chamado zookeeper.py que contenha 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 as seguintes linhas do Python:

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

Teste no nível do LDAP

É possível monitorar o OpenLDAP para saber se as solicitações específicas são atendidas corretamente. Em outras palavras, verifique se há uma pesquisa específica que retorna 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, você precisará digitar 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 servidor de gerenciamento 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, que ajudam a reduzir o número de acessos ao disco e, portanto, melhoram o desempenho do sistema. Monitorar e ajustar o tamanho do cache no servidor OpenLDAP pode ter um grande impacto no desempenho do servidor de diretório. Você pode ver os arquivos de registro (opt/apigee/var/log) para conseguir informações sobre o cache.