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 conseguir detalhes sobre serviços, bem como verificar os status deles. Na tabela a seguir, listamos os tipos de verificações que podem ser realizadas em cada serviço qualificado:
API Mgmt | |||||||
Componente | Uso da memória [JMX*] | Verificação do serviço | Status do usuário/organização/ implantaçã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 usar o JMX, você precisa ativá-lo, conforme descrito em Ativar JMX. ** O serviço |
Como monitorar portas e arquivos de configuração
Cada componente é compatível com JMX (Java Management Extensions) e chamadas de monitoramento da API Management em diferentes portas. A tabela a seguir lista as portas da API JMX e a API Management para cada tipo de servidor e os locais dos arquivos de configuração:
Componente | Porta JMX | Porta da API Management | 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 componentes do Edge.
Ativar JMX
Para ativar o JMX sem autenticação ou comunicação baseada em SSL, execute as etapas abaixo. Observação: nos sistemas de produção, a autenticação criptografada e o SSL precisam estar ativados para segurança.
- 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
- Salve o arquivo de configuração e verifique se ele pertence a
apigee:apigee
. - Reiniciar o componente apropriado do Edge
apigee-service edge-management-server restart
Para desativar o JMX, remova a propriedade conf_system_jmxremote_enable
ou altere o valor para false
. Em seguida, reinicie o componente do Edge.
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.
- Para ativar a autenticação JMX em um componente Edge-*, 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 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 aapigee:apigee
. - Crie um hash SHA256 da senha:
echo -n '
' | openssl dgst -sha256 - Crie um arquivo
jmxremote.password
com as credenciais de usuário JMX:- 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
- Edite o arquivo e adicione o nome de usuário e a senha do JMX usando a seguinte sintaxe:
USERNAME <HASH-PASSWORD>
- Verifique se o arquivo é de propriedade de
apigee
e se o modo é 400:chown apigee:apigee $APIGEE_ROOT/customer/application/management-server/jmxremote.password chmod 400 $APIGEE_ROOT/customer/application/management-server/jmxremote.password
- Copie os seguintes arquivos do diretório
- Crie um arquivo
jmxremote.access
com permissões de usuário JMX:- 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
- Edite o arquivo e adicione seu nome de usuário JMX seguido de uma permissão (READSOMENTE/READWRITE)
USERNAME READONLY
- Verifique se o arquivo é de propriedade de
apigee
e se o modo é 400:chown apigee:apigee $APIGEE_ROOT/customer/application/management-server/jmxremote.password chmod 400 $APIGEE_ROOT/customer/application/management-server/jmxremote.access
- Copie os seguintes arquivos do diretório $JAVA_HOME para
o diretório
- 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 apropriado do Edge.
SSL no JMX
Para ativar o JMX baseado em SSL 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_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 aapigee:apigee
. - Prepare um keystore que contém a chave do servidor e coloque-a no caminho fornecido na
configuração
conf_system_javax_net_ssl_keystore
acima. Verifique se o arquivo de keystore pode ser lido porapigee:apigee
. - 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 altere o valor para false
. Reinicie o componente do Edge adequado.
Como monitorar pelo Jconsole
As instruções de monitoramento pelo jconsole continuam iguais, conforme descrito em https://docs.apigee.com/private-cloud/v4.50.00/how-monitor#jconsole.
É possível adicionar uma linha dizendo que “o jconsole precisará ser iniciado com a senha do truststore e do truststore se o SSL estiver ativado para o JMX”. Referência: https://docs.oracle.com/javase/8/docs/technotes/guides/management/jconsole.htmlMonitorar com JConsole
Use o JConsole (uma ferramenta compatível com JMX) para gerenciar e monitorar a verificação de integridade e as estatísticas do processo. Com o JConsole, é possível consumir estatísticas do JMX expostas por seus servidores e exibi-las em uma interface gráfica. Para ver mais informações, consulte Como usar o JConsole.
É necessário iniciar o JConsole com a senha do truststore e do truststore se o SSL estiver ativado para o JMX. Consulte Como usar o JConsole.
O JConsole usa o seguinte URL de serviço para monitorar os atributos JMX (MBeans) oferecidos por meio do 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
Observe que esse exemplo especifica a porta 1099, que é a porta JMX do servidor de gerenciamento. Para outras portas, consulte Portas de monitoramento do JMX e da API Management.
A tabela a seguir mostra as estatísticas genéricas do JMX:
MBeans do JMX | Atributos JMX |
---|---|
Memória |
HeapMemoryUsage |
NonHeapMemoryUsage |
|
Uso |
|
Referência do arquivo de configuração
As seções a seguir descrevem as mudanças que você pode precisar fazer nos arquivos de configuração do componente do 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 adequado
- 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 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 pelo usuário 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
- Ative o SSL para a comunicação do JMX. Falso por padrão.
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 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 escolherá 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=
- Proteger 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 tem várias APIs que podem ser usadas para realizar verificações de serviços nos servidores e 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 nos 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 requer autenticação. 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 a esta (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:
Essa chamada de API requer a autenticação com suas credenciais de administrador da Apigee. |
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ê tiver feito login no servidor, poderá usar "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 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 dos números de porta da API de gerenciamento a serem usados, consulte Portas de monitoramento do JMX e da API Management.
Para alterar o formato da resposta, especifique o cabeçalho Accept
como "application/json" ou "application/xml".
O exemplo a seguir mostra o status do roteador no localhost (porta 8081):
curl http://localhost:8081/v1/servers/self/up -H "Accept: application/xml"
O exemplo a seguir 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
Use a API Management para monitorar o status do usuário, da organização e da implantação dos proxies nos servidores de gerenciamento e nos processadores de mensagens executando os seguintes comandos:
curl http://host:port_number/v1/users -u sysAdminEmail:passwordcurl 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 o nome de usuário e a senha de administração do sistema.
O servidor deve retornar um status "implantado" para todas as chamadas. Se elas falharem, faça o seguinte:
- 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
- Servidor de gerenciamento:
- Faça uma chamada no servidor para verificar se ele está funcionando corretamente.
- 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
Você pode solucionar problemas dos serviços de borda usando 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
:
- 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
- Servidor de gerenciamento:
- Se o serviço não estiver em execução, inicie-o:
/opt/apigee/apigee-service/bin/apigee-service service_name start
- Depois de reiniciar o serviço, verifique se ele está funcionando com 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ê 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 oferece suporte a 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
É possível verificar os nomes da organização e do ambiente integrados no servidor Postgres
emitindo o seguinte comando curl
:
curl -v http://postgres_IP:8084/v1/servers/self/organizations
O sistema vai exibir o nome da organização e do ambiente.
Verificar o status da análise
Você pode verificar o status dos servidores de análise Postgres e Qpid emitindo 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 êxito 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, acesse http://bucardo.org/wiki/Check_postgres.
Antes de executar o script:
- É necessário instalar o script check_postgres.pl em cada nó do Postgres.
- Verifique se você instalou
perl-Time-HiRes.x86_64
, um módulo Perl que implementa timers de alarme de alta resolução, suspensão, gettimeofday e intervalo. Por exemplo, é possível instalá-lo usando o seguinte comando:
yum install perl-Time-HiRes.x86_64
- CentOS 7: antes de usar o check_postgres.pl no CentOS v7, instale a
RPM
perl-Data-Dumper.x86_64
.
Saída check_postgres.pl
A saída padrão das chamadas de API que usam check_postgres.pl
é compatível com o Nagios. Depois de instalar o script, faça as seguintes verificações:
- 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'
- Verifica o número de conexões de entrada com o banco de dados e compara 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
- 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
- Confira 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%'
- Verifique o número de organização e ambiente integrados a 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 corretas foram criadas no banco de dados PostgreSQL. Faça login no banco de dados 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 a integridade do processo postgres
Para realizar verificações de API na máquina Postgres, invoque 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 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 exige uma senha.
Ativar a autenticação JMX para o Cassandra
É possível ativar a autenticação JMX para o Cassandra. Depois disso, será necessário transmitir um nome de usuário e uma senha a todas as chamadas para o utilitário nodetool.
Para ativar a autenticação JMX para o Cassandra:
- Crie e edite o arquivo
cassandra.properties
:- Edite o arquivo
/opt/apigee/customer/application/cassandra.properties
. Se o arquivo não existir, crie-o. - Adicione o código abaixo 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
- Salve o arquivo
cassandra.properties
. - Mude o proprietário do arquivo para
apigee:apigee
, como no exemplo a seguir:chown apigee:apigee /opt/apigee/customer/application/cassandra.properties
Para mais informações sobre o uso de arquivos de propriedades para definir tokens, consulte Como configurar o Edge.
- Edite o arquivo
- Criar e editar
jmx_auth.sh
:- Crie um arquivo no seguinte local, se ele não existir:
/opt/apigee/customer/application/jmx_auth.sh
- Adicione as propriedades abaixo ao arquivo:
export CASS_JMX_USERNAME=JMX_USERNAME export CASS_JMX_PASSWORD=JMX_PASSWORD
- Salve o arquivo
jmx_auth.sh
. - Insira o arquivo:
source /opt/apigee/customer/application/jmx_auth.sh
- Crie um arquivo no seguinte local, se ele não existir:
- Copie e edite o arquivo
jmxremote.password
:- 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
- Edite o arquivo
jmxremote.password
e adicione seu nome de usuário e senha JMX usando esta 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.
- Verifique se o arquivo é de propriedade "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
- Copie o seguinte arquivo do diretório
- Copie e edite o arquivo
jmxremote.access
:- 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
- Edite o arquivo
jmxremote.access
e adicione o seguinte papel:JMX_USERNAME readwrite
- Verifique se o arquivo é de propriedade "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
- Copie o seguinte arquivo do diretório
- Execute
configure
no Cassandra:/opt/apigee/apigee-service/bin/apigee-service apigee-cassandra configure
- Reinicie o Cassandra:
/opt/apigee/apigee-service/bin/apigee-service apigee-cassandra restart
- Repita esse processo em todos os outros nós do Cassandra.
Ativar a criptografia de senha do JMX
Para ativar a criptografia de senha do JMX, siga estas etapas:
- Abra o arquivo
source/conf/casssandra-env.sh
. - Crie e edite o arquivo
cassandra.properties
:- Edite o arquivo
/opt/apigee/customer/application/cassandra.properties
. Se o arquivo não existir, crie-o. - Adicione o código abaixo ao arquivo:
conf_cassandra_env_com.sun.management.jmxremote.encrypted.authenticate=true
- Salve o arquivo cassandra.properties.
- Altere o proprietário do arquivo para apigee:apigee, conforme o seguinte exemplo:
chown apigee:apigee /opt/apigee/customer/application/cassandra.properties
- Edite o arquivo
- Na linha de comando, gere hashes SHA1 das senhas desejadas inserindo
echo -n 'Secret' | openssl dgst -sha1
. - Defina a(s) senha(s) para o nome de usuário em
$APIGEE_ROOT/customer/application/apigee-cassandra/jmxremote.password
(criado na seção anterior). - Execute a configuração no Cassandra:
/opt/apigee/apigee-service/bin/apigee-service apigee-cassandra configure
- Reinicie o Cassandra:
/opt/apigee/apigee-service/bin/apigee-service apigee-cassandra restart
- Repita esse processo em todos os outros nós do Cassandra.
Ativar JMX com SSL para o Cassandra
A ativação do JMX com SSL fornece segurança e criptografia adicionais 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 quaisquer outras ferramentas que se comuniquem com o Cassandra por JMX) para SSL.
O JMX com SSL ativado aceita senhas de texto simples e JMX criptografadas.
Para ativar o JMX com SSL para o Cassandra, use o seguinte procedimento:
- Ative o JMX. Ative a criptografia de senha, se necessário.
- 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
Prepare keystore e truststore.
O keystore precisa conter uma chave e um certificado, além de ser usado para configurar o servidor do Cassandra. Se o keystore tiver vários pares de chaves, o Cassandra usará o primeiro para ativar o SSL.
As senhas do keystore e da chave precisam ser as mesmas (o padrão quando você gera a chave usando o keytool).
- O Truststore precisa conter apenas o certificado e é usado pelos clientes (comandos baseados em serviços da Apigee ou Nodetool) para se conectar pelo JMX.
Depois de verificar os requisitos acima:
- Coloque o arquivo de keystore em
/opt/apigee/customer/application/apigee-cassandra/
. - Verifique se o arquivo de 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
- Configure o Cassandra para JMX com SSL seguindo estas etapas:
- Interrompa o nó do Cassandra inserindo
apigee-service apigee-cassandra stop
- 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
- Altere o proprietário do arquivo para apigee:apigee, conforme o seguinte exemplo:
chown apigee:apigee /opt/apigee/customer/application/cassandra.properties
- Execute a configuração no Cassandra:
/opt/apigee/apigee-service/bin/apigee-service apigee-cassandra configure
- Reinicie o Cassandra:
/opt/apigee/apigee-service/bin/apigee-service apigee-cassandra restart
- Repita esse processo em todos os outros nós do Cassandra.
- Inicie o nó do Cassandra inserindo
apigee-service apigee-cassandra start
- Interrompa o nó do Cassandra inserindo
- configurar os comandos
apigee-service
do Cassandra. É necessário definir algumas variáveis de ambiente ao executar comandosapigee-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 no arquivo)
- Opção 2 (argumentos SSL armazenados em variáveis de ambiente)
- Opção 3 (argumentos SSL transmitidos diretamente para
apigee-service
)
Opção 1 (argumentos SSL armazenados no arquivo)
Configure as variáveis de ambiente a seguir:
export CASS_JMX_USERNAME=ADMIN # Provide encrypted password here if you have setup JMX password encryption export CASS_JMX_PASSWORD=PASSWORD export CASS_JMX_SSL=Y
Crie um arquivo no diretório inicial do usuário da Apigee (
/opt/apigee
).$HOME/.cassandra/nodetool-ssl.properties
Edite o arquivo e adicione estas 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 está legível para o usuário da Apigee.
Execute o seguinte comando
apigee-service
. Se ele for executado sem erros, suas configurações estarã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, suas configurações estarã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 é preciso 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
Configure o nodetool. O Nodetool requer que os parâmetros JMX sejam transmitidos para ele. Há duas maneiras de configurar o nodetool para ser executado com o JMX ativado para SSL, conforme descrito nas opções de configuração abaixo:
As opções diferem na maneira 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 READ no arquivo truststore. Escolha uma 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 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
O caminho do truststore 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=<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 você precisar reverter as configurações de SSL descritas no procedimento acima, siga estas etapas:
- Para parar
apigee-cassandra
, insiraapigee-service apigee-cassandra stop
- Remova a linha
conf_cassandra-env_com.sun.management.jmxremote.ssl=true
do arquivo/opt/apigee/customer/application/cassandra.properties
. - Comente as seguintes linhas 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”
- Inicie
apigee-cassandra
inserindo - Remova a variável de ambiente
CASS_JMX_SSL
, se ela tiver sido definida.unset CASS_JMX_SSL
- Confira se os comandos baseados em
apigee-service
, comoring
,stop
,backup
e assim por diante, estão funcionando. - Parar de usar a chave
--ssl
com o nodetool
apigee-service apigee-cassandra start
Desativar a autenticação JMX para o Cassandra
Para desativar a autenticação JMX para o Cassandra:
- Editar
/opt/apigee/customer/application/cassandra.properties
. - Remova a seguinte linha do arquivo:
conf_cassandra-env_com.sun.management.jmxremote.authenticate=true
- Execute a configuração no Cassandra:
/opt/apigee/apigee-service/bin/apigee-service apigee-cassandra configure
- Reinicie o Cassandra:
/opt/apigee/apigee-service/bin/apigee-service apigee-cassandra restart
- Repita esse processo em todos os outros nós do Cassandra.
Use o JConsole: monitore as estatísticas de 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
MBeans do JMX | Atributos JMX |
---|---|
ColumnFamilies/apprepo/environments ColumnFamilies/apprepo/organizations ColumnFamilies/apprepo/apiproxy_revisions ColumnFamilies/apprepo/apiproxies ColumnFamilies/auditoria/auditorias ColumnFamilies/audit/audits_ref |
PendingTasks |
MemtableColumnsCount |
|
MemtableDataSize |
|
ReadCount |
|
RecentReadLatencyMicros |
|
TotalReadLatencyMicros |
|
WriteCount |
|
RecentWriteLatencyMicros |
|
TotalWriteLatencyMicros |
|
TotalDiskSpaceUsed |
|
LiveDiskSpaceUsed |
|
LiveSSTableCount |
|
BloomFilterFalsePositives |
|
RecentBloomFilterFalseRatio |
|
BloomFilterFalseRatio |
Usar o nodetool para gerenciar 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
.
É possível fazer as seguintes chamadas em todos os nós do cluster do Cassandra:
- Informações gerais de toque (também possíveis para um único nó do Cassandra): procure "Para cima" e "Normal" em todos os nós.
nodetool [-u username -pw password] -h localhost ring
Você só precisará passar seu nome de usuário e senha se ativar 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
- Informações gerais sobre nós (chamada por nó)
nodetool [-u username -pw password] -h localhost info
A saída do comando acima será parecida com 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
- Status do servidor thrift (API do cliente disponibilizado)
nodetool [-u username -pw password] -h localhost statusthrift
A saída do comando acima vai ser parecida com esta:
running
- 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 parecida com 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.
Apache ZooKeeper
Verificar o status do ZooKeeper
- 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
. - Teste as portas do ZooKeeper para garantir que é possível estabelecer uma conexão TCP com as portas 2181 e 3888 em cada servidor do ZooKeeper.
- Certifique-se de que você possa 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. - 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 à 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:
- Execute o comando ruok de quatro letras 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
- Execute o comando de quatro letras,
stat
, para listar o desempenho 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
- 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 Python:
python zookeeper.py 192.168.124.201 ruok
python zookeeper.py 192.168.124.201 stat
Teste de nível de LDAP
Monitore o OpenLDAP para ver se as solicitações específicas estão sendo exibidas corretamente. Em outras palavras, procure uma pesquisa específica que retorne o resultado certo.
- 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
Será solicitada a senha de administrador 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
- 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, o que ajuda a reduzir o número de acessos ao disco e, assim, melhorar o desempenho do sistema. Monitorar e ajustar o tamanho do cache no servidor OpenLDAP pode afetar muito o desempenho do servidor de diretório. Você pode ver os arquivos de registro (opt/apigee/var/log
) para receber informações sobre o cache.