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 várias maneiras de receber detalhes sobre os serviços e verificar os status deles. A tabela a seguir lista os tipos de verificações que podem ser realizadas em cada serviço qualificado:

Como monitorar portas e arquivos de configuração

Cada componente é compatível com extensões de gerenciamento Java (JMX) e chamadas de monitoramento da API Management em portas diferentes. A tabela a seguir lista as portas JMX e da API Management 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 componentes do Edge.

Ativar o 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 precisam ser ativados para garantir a 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. Reinicie o componente Edge adequado

   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 do Edge apropriado.

Autenticação em JMX

O Edge para nuvem privada oferece suporte à autenticação baseada em senha usando detalhes armazenados em arquivos. Você pode armazenar senhas como um hash para ter mais segurança.

1. Para ativar a autenticação JMX em um componente edge-*, 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 da senha:

   echo -n '' | openssl dgst -sha256

3. Crie um arquivo jmxremote.password com as credenciais do 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. Verifique se o arquivo pertence a 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 do 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 por uma permissão (READONLY/READWRITE).

      USERNAME READONLY

   3. Verifique se o arquivo pertence a 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 do Edge adequado:

   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 do Edge apropriado.

SSL em JMX

Para ativar o JMX baseado em SSL em um componente edge-*:

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
   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 configuração conf_system_javax_net_ssl_keystore acima. Verifique se o arquivo keystore pode ser lido por apigee:apigee.
3. Reinicie o componente do Edge adequado:

   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 do Edge adequado.

Monitoramento via 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 a verificação de integridade e as estatísticas de processo. Com o JConsole, é possível consumir estatísticas JMX expostas pelos servidores e mostrá-las em uma interface gráfica. Para mais informações, consulte Como usar o JConsole.

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

O JConsole usa o seguinte URL de serviço para monitorar os atributos JMX (MBeans) oferecidos via 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 o seguinte (supondo 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 JMX e 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 mudanças que talvez seja necessário fazer nos arquivos de configuração de componentes do Edge para configurações relacionadas ao JMX. Consulte Como monitorar portas e arquivos de configuração para mais informações.

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

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

  conf_system_jmxremote_enable=true

Configurações para autenticação com senha

• Ative a autenticação baseada em senha. O padrão é "falso".

  conf_system_jmxremote_authenticate=true

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

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

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

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

• Ative o armazenamento de senhas em formato criptografado. O padrão é "falso".

  conf_system_jmxremote_encrypted_auth=true

Configurações para JMX baseado em SSL

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

  conf_system_jmxremote_ssl=true

• Caminho para o armazenamento de chaves. Precisa ser de propriedade e legível apenas para o 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 opcionais do JMX

Os valores listados são padrões e podem ser mudados.

• 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 de 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 seus servidores, além de 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, o nome de usuário e a senha.
• port_number é a porta da API Management do 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 uma lista de números de porta da API Management a serem usados, consulte Portas de monitoramento da API JMX e Management

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 recebe 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 nos 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 que você faça a autenticação com seu nome de usuário e 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 no servidor para verificar se ele 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

Para resolver problemas nos serviços do Edge, use o comando apigee-service quando estiver 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 do serviço.

   Neste exemplo, presumimos que você fez login no servidor e pode usar "localhost" como o 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 podem ser usados para verificar o status dele. Esses utilitários são descritos nas seções a seguir.

Verificar organizações e ambientes no Postgres

Para verificar os nomes de organização e ambiente integrados ao servidor Postgres, execute 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 do Postgres e do Qpid, execute o seguinte comando curl:

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

O sistema vai mostrar um status de sucesso para todos os servidores de análise, como mostra 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 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. Confira se você instalou o perl-Time-HiRes.x86_64, um módulo Perl que implementa alarmes, suspensão, gettimeofday e temporizadores de intervalo de alta resolução. Por exemplo, você pode instalar usando o seguinte comando:
   

   yum install perl-Time-HiRes.x86_64

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

Saída de check_postgres.pl

A saída padrão das chamadas de API usando check_postgres.pl é compatível com o 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. Verifique o número de conexões de entrada com o 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. 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 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 do postgres

É possível realizar verificações de API na máquina do 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 do postgres está ativo. Se o processo do Postgres não estiver em execução, ele vai retornar o status INACTIVE.

Recursos do Postgres

Para mais informações sobre o monitoramento do 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 ao JMX não exige uma senha.

Ativar a autenticação JMX para o Cassandra

É possível ativar a autenticação JMX para o Cassandra. Depois disso, você precisará transmitir um nome de usuário e uma senha para todas as chamadas do 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, como mostra 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. 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 definidos anteriormente.

   3. Verifique se o arquivo pertence a "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 a seguinte função:

      JMX_USERNAME readwrite

   3. Verifique se o arquivo pertence a "apigee" e se o modo do 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 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. Mude o proprietário do arquivo para apigee:apigee, conforme mostrado no exemplo a seguir:

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

3. Na linha de comando, gere os hashes SHA1 das senhas desejadas digitando echo -n 'Secret' | openssl dgst -sha1
4. Defina as senhas para o nome de usuário em $APIGEE_ROOT/customer/application/apigee-cassandra/jmxremote.password (criado 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 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. Também é necessário configurar o nodetool (e outras ferramentas que se comunicam com o Cassandra por JMX) para SSL.

O JMX habilitado para SSL é compatível com senhas JMX criptografadas e de texto simples.

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

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 precisa conter uma chave e um certificado e é usado para configurar o servidor do Cassandra. Se o keystore contiver vários pares de chaves, o Cassandra usará o primeiro par para ativar o SSL.

     As senhas do keystore e da chave precisam ser iguais (o padrão ao gerar a chave usando o keytool).

   • O truststore precisa conter apenas o certificado e é usado por clientes (comandos baseados em apigee-service ou nodetool) para se conectar via JMX.

   Depois de verificar os requisitos acima:

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

      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 inserindo

      apigee-service apigee-cassandra stop

   2. Para ativar o SSL no Cassandra, abra o arquivo /opt/apigee/customer/application/cassandra.properties e adicione estas 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 algumas variáveis de ambiente ao executar comandos apigee-service, incluindo os seguintes:

   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 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
   ## 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 de trustore pode ser lido pelo usuário da Apigee.

   Execute o seguinte comando apigee-service. Se ele for executado sem erros, 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>
   # 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, 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 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=<path-to-trustore.node1> CASS_JMX_TRUSTSTORE_PASSWORD=<trustore-password> CASS_JMX_TRUSTSTORE_TYPE=PKCS12 /opt/apigee/apigee-service/bin/apigee-service apigee-cassandra ring

6. Configure o nodetool. A Nodetool exige que os parâmetros JMX sejam transmitidos a ela. Há duas maneiras de configurar o nodetool para ser executado com JMX habilitado 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 LEITURA no arquivo truststore. Escolha uma opção adequada 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 (em inglês).

   Opção de configuração 1

   Crie um arquivo no diretório inicial do usuário que está executando 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
   ## 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 truststore especificado acima precisa estar acessível a qualquer usuário que execute 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 -Djavax.net.ssl.trustStoreType=PKCS12 -Dssl.enable=true -u <jmx-user-name> -pw <jmx-user-password> -h localhost ring

Reverter configurações SSL

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

1. Parar apigee-cassandrainserindo

   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 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. Pare de usar a opção --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 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.

Usar o JConsole: monitorar estatísticas de tarefas

Use o JConsole e o seguinte URL de serviço para monitorar os atributos JMX (MBeans) oferecidos via 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 do 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 seguintes chamadas 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" em todos os nós.

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

   Só é necessário transmitir seu nome de usuário e senha se você ativou a autenticação JMX para o Cassandra.

   A saída do comando acima é mostrada abaixo:

   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 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 (API do cliente de serviço)

   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.

Monitorar o agente Apache Qpid Broker-J

É possível monitorar o Qpid Broker-J no console de gerenciamento do Qpid. Esta seção explica como acessar o console e usá-lo para realizar 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 seu navegador da Web para:

http://QPID_NODE_IP:8090

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

Monitorar filas e mensagens

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

Acessar e fazer o download de arquivos de registros

No painel de navegação à esquerda, acesse Java-Broker > brokerloggers > logfile. Na visualização de detalhes da interface principal, é possível conferir e baixar os arquivos de registro.

Como usar a API de gerenciamento do Qpid

É possível usar a API REST do Apache Qpid Broker-J para automatizar tarefas de gerenciamento e monitorar o broker. Para mais detalhes, consulte a documentação da API REST do Apache Qpid Broker.

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

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

Ativar o monitoramento com SSL para o Qpid

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

O Qpid oferece uma opção para um keystore de arquivo, que é ativada na Apigee. Esse tipo aceita o formato padrão de keystore JKS compreendido pelo Java e ferramentas Java, como keytool. Ele também pode aceitar um keystore PKCS12, que pode ser gerado usando ferramentas como o OpenSSL.

Preparação do keystore

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

Para gerar keystores PKCS12, consulte a documentação do OpenSSL.

Depois de verificar os requisitos

1. Coloque o arquivo de keystore em /opt/apigee/customer/application/apigee-qpidd.
2. Verifique se o arquivo do keystore só pode ser lido 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

Ativar SSL no Qpid

Siga as etapas abaixo em um nó do Qpid por vez:

Abra o arquivo /opt/apigee/customer/application/qpidd.properties e adicione as seguintes 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
## If you are using a PKCS12 keystore, specify the keystore type
conf_qpidd_qpid.keystore.keyStoreType=PKCS12

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

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

2. Configure o Qpidd:

   apigee-service apigee-qpidd configure

3. Reinicie o Qpidd:

   apigee-service apigee-qpidd restart

4. Verifique o status com wait_for_ready:

   apigee-service apigee-qpidd wait_for_ready

Reverter a 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. Configure o Qpidd:

   apigee-service apigee-qpidd configure

2. Reinicie 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 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. 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 com um pequeno conjunto de comandos (palavras de quatro letras) enviados à porta 2181 usando netcat (nc) ou 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 comandos a seguir podem ser emitidos para a porta do ZooKeeper:

1. Execute o comando de quatro letras ruok para testar se o servidor está em execução em um estado sem erros. Uma resposta bem-sucedida retorna "imok".

   echo ruok | nc host 2181

   Retorna:

   imok

2. Execute o comando de quatro letras, stat, para listar o desempenho do servidor e as estatísticas de 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 de nível do LDAP

Monitore o SymasLDAP para verificar se as solicitações específicas estão sendo atendidas corretamente. Em outras palavras, verifique se uma pesquisa específica retorna o resultado certo.

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

   /opt/symas/bin/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ê vai precisar inserir a senha de administrador do LDAP:

   Enter LDAP Password:

   Depois de inserir a senha, você vai ver uma resposta no formato:

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

Você também pode monitorar os caches do SymasLDAP, 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 SymasLDAP pode afetar muito a performance do servidor de diretório. É possível conferir os arquivos de registro (opt/apigee/var/log) para obter informações sobre o cache.