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:

API de gerenciamento
Componente Uso da memória [JMX*] Verificação de serviço Status da implantação do usuário/organização/ axstatus (link em inglês) Verificação do banco de dados Status de apigee-service apigee-monit**
Servidor de gerenciamento
processador de mensagens
Roteador
Qpid
Postgres
Mais informações Mais informações Mais informações Mais informações Mais informações Mais informações Mais informações

* Antes de poder usar o JMX, você deve ativá-lo, pois descritos em Ativar JMX.

** O serviço apigee-monit verifica se um componente está ativo e tenta reinicie-o se não estiver. Para mais informações, consulte Autocorreção com apigee-monit.

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:

Componente Porta JMX Porta da API de gerenciamento Local do arquivo de configuração
Servidor de gerenciamento 1099 8080 $APIGEE_ROOT/customer/application/management-server.properties
processador de mensagens 1101 8082 $APIGEE_ROOT/customer/application/message-processor.properties
Roteador 1100 8081 $APIGEE_ROOT/customer/application/router.properties
Qpid 1102 8083 $APIGEE_ROOT/customer/application/qpid-server.properties
Postgres 1103 8084 $APIGEE_ROOT/customer/application/postgres-server.properties

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.50.00/how-monitor#jconsole.

Uma linha pode ser adicionada informando que “o jconsole precisará ser iniciado com a senha do truststore e do truststore se o SSL estiver ativado para JMX”. Referência: https://docs.oracle.com/javase/8/docs/technotes/guides/management/jconsole.html

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:

JMX MBeans Atributos JMX

Memória

HeapMemoryUsage

NonHeapMemoryUsage

Uso

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:

Endpoint Descrição
/servers/self/up

Verifica se um serviço está em execução. Essa chamada de API não exige se autenticar.

Se o serviço estiver em execução, esse endpoint retornará a seguinte resposta:

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

Se o serviço não estiver em execução, você receberá uma resposta semelhante à seguinte (dependendo do serviço e de como você o verificou):

curl: Failed connect to localhost:port_number; Connection refused
/servers/self

Retorna informações sobre o serviço, incluindo:

  • Propriedades de configuração
  • Horário de início e horário de atividade
  • Informações de build, RPM e UUID
  • Nome do host interno e externo e endereço IP
  • Região e conjunto
  • <isUp>, indicando se o serviço está em execução

Esta chamada de API exige que você faça a autenticação com suas credenciais de administrador da Apigee.

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 &quot;application/json&quot; 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:

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)

    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:

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

JMX MBeans Atributos JMX

ColumnFamilies/apprepo/environments

ColumnFamilies/apprepo/organizations

ColumnFamilies/apprepo/apiproxy_revisions

ColumnFamilies/apprepo/apiproxies

ColumnFamilies/audit/audits

ColumnFamilies/audit/audits_ref

PendingTasks

MemtableColumnsCount

MemtableDataSize

ReadCount

RecentReadLatencyMicros

TotalReadLatencyMicros

WriteCount

RecentWriteLatencyMicros

TotalWriteLatencyMicros

TotalDiskSpaceUsed

LiveDiskSpaceUsed

LiveSSTableCount

BloomFilterFalsePositives

RecentBloomFilterFalseRatio

BloomFilterFalseRatio

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.

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.