Questo documento descrive le tecniche di monitoraggio dei componenti supportati da un deployment on-premise di Apigee Edge per il cloud privato.
Panoramica
Edge supporta diversi modi per ottenere dettagli sui servizi e per controllarne lo stato. Nella tabella seguente sono elencati i tipi di controlli che puoi eseguire su ciascun servizio idoneo:
API di gestione | |||||||
Componente | Memoria utilizzata [JMX*] | Controllo di servizio | Stato utente/organizzazione/ implementazione | statoax | Controllo del database | Stato di apigee-service |
apigee-monit ** |
Server di gestione | |||||||
processore di messaggi | |||||||
Router | |||||||
Qpid | |||||||
Postgres | |||||||
Scopri di più | Scopri di più | Scopri di più | Scopri di più | Scopri di più | Scopri di più | Scopri di più | |
* Prima di poter utilizzare JMX, devi abilitarlo, come descritto in Abilitare JMX. ** Il servizio |
Porte e file di configurazione di monitoraggio
Ogni componente supporta le chiamate di monitoraggio di Java Management Extensions (JMX) e dell'API di gestione su porte diverse. Nella tabella seguente sono elencate le porte JMX e l'API di gestione per ciascun tipo di server, nonché le posizioni dei file di configurazione:
Componente | Porta JMX | Porta API di gestione | Posizione del file di configurazione |
---|---|---|---|
Server di gestione | 1099 | 8080 | $APIGEE_ROOT/customer/application/management-server.properties |
processore di messaggi | 1101 | 8082 | $APIGEE_ROOT/customer/application/message-processor.properties |
Router | 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 |
Utilizza JMX per monitorare i componenti
Le sezioni seguenti spiegano come utilizzare JMX per monitorare i componenti di Edge.
Attiva JMX
Per attivare JMX senza autenticazione o comunicazione basata su SSL, procedi nel seguente modo. Nota:nei sistemi di produzione, per motivi di sicurezza dovrebbero essere abilitate sia l'autenticazione criptata sia SSL.
- Modifica il file di configurazione appropriato (consulta
Riferimento al file di configurazione). Crea il file di configurazione se non esiste.
conf_system_jmxremote_enable=true
- Salva il file di configurazione e assicurati che sia di proprietà di
apigee:apigee
. - Riavvia il componente Edge appropriato
apigee-service edge-management-server restart
Per disattivare JMX, rimuovi la proprietà conf_system_jmxremote_enable
o modifica
il valore in false
. Quindi riavvia il componente Edge appropriato.
Autenticazione in JMX
Edge per il cloud privato supporta l'autenticazione basata su password che utilizza dettagli archiviati nei file. Puoi memorizzare le password come hash per una maggiore sicurezza.
- Per attivare l'autenticazione JMX in un componente edge-*, modifica il file di configurazione appropriato
(vedi
Riferimento file di configurazione). Crea il file di configurazione se non esiste:
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
Salva il file di configurazione e assicurati che sia di proprietà diapigee:apigee
. - Crea un hash SHA256 della password:
echo -n '
' | openssl dgst -sha256 - Crea un file
jmxremote.password
con le credenziali utente JMX:- Copia i seguenti file dalla directory
$JAVA_HOME
alla directory/opt/apigee/customer/application/<component>/
:cp ${JAVA_HOME}/lib/management/jmxremote.password.template $APIGEE_ROOT/customer/application/management-server/jmxremote.password
- Modifica il file e aggiungi il nome utente e la password JMX utilizzando la seguente sintassi:
USERNAME <HASH-PASSWORD>
- Assicurati che il file sia di proprietà di
apigee
e che la modalità file sia 400:chown apigee:apigee $APIGEE_ROOT/customer/application/management-server/jmxremote.password chmod 400 $APIGEE_ROOT/customer/application/management-server/jmxremote.password
- Copia i seguenti file dalla directory
- Crea un file
jmxremote.access
con le autorizzazioni utente JMX:- Copia i seguenti file dalla directory $JAVA_HOME alla directory
/opt/apigee/customer/application/<component>/
cp ${JAVA_HOME}/lib/management/jmxremote.access$APIGEE_ROOT/customer/application/management-server/jmxremote.password/jmxremote.access
- Modifica il file e aggiungi il tuo nome utente JMX seguito da un'autorizzazione (READONLY/READWRITE)
USERNAME READONLY
- Assicurati che il file sia di proprietà di
apigee
e che la modalità file sia 400:chown apigee:apigee $APIGEE_ROOT/customer/application/management-server/jmxremote.password chmod 400 $APIGEE_ROOT/customer/application/management-server/jmxremote.access
- Copia i seguenti file dalla directory $JAVA_HOME alla directory
- Riavvia il componente Edge appropriato:
apigee-service edge-management-server restart
Per disabilitare l'autenticazione JMX, rimuovi la proprietà conf_system_jmxremote_authenticate
o modifica il valore in false
e riavvia il componente Edge appropriato.
SSL in JMX
Per attivare JMX basato su SSL in un componente edge-*:
- Modifica il file di configurazione appropriato (consulta
Riferimento del file di configurazione). Crea il file di configurazione se non esiste:
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>
Salva il file di configurazione e assicurati che sia di proprietà diapigee:apigee
. - Prepara un archivio chiavi contenente la chiave server e posizionalo nel percorso fornito nella configurazione
conf_system_javax_net_ssl_keystore
riportata sopra. Assicurati che il file dell'archivio chiavi sia leggibile daapigee:apigee
. - Riavvia il componente Edge appropriato:
apigee-service edge-management-server restart
Per disabilitare la tecnologia JMX basata su SSL, rimuovi la proprietà conf_system_jmxremote_ssl
o modifica il valore in false
. Riavvia il componente Edge appropriato.
Monitoraggio tramite Jconsole
Le istruzioni di monitoraggio tramite jconsole rimangono le stesse descritte in https://docs.apigee.com/private-cloud/v4.52.01/how-monitor#jconsole.
Si può aggiungere una riga che indica che "jconsole dovrà essere avviato con truststore e la password truststore se SSL è abilitato per JMX". Riferimento: https://docs.oracle.com/javase/8/docs/technotes/guides/management/jconsole.htmlMonitora con JConsole
Utilizza JConsole (uno strumento conforme a JMX) per gestire e monitorare il controllo di integrità e le statistiche relative all'elaborazione. Con JConsole, puoi utilizzare le statistiche JMX esposte dai server e visualizzarle in un'interfaccia grafica. Per maggiori informazioni, consulta Utilizzare JConsole.
Devi avviare JConsole con l'archivio e la password dell'archivio attendibilità se SSL è abilitato per JMX. Vedi Utilizzare JConsole.
JConsole utilizza il seguente URL del servizio per monitorare gli attributi JMX (MBean) offerti tramite JMX:
service:jmx:rmi:///jndi/rmi://IP_address:port_number/jmxrmi
Dove:
- IP_address è l'indirizzo IP del server che vuoi monitorare.
- port_number è il numero di porta JMX del server che vuoi monitorare.
Ad esempio, per monitorare il server di gestione, esegui un comando simile al seguente (supponendo che l'indirizzo IP del server sia 216.3.128.12):
service:jmx:rmi:///jndi/rmi://216.3.128.12:1099/jmxrmi
Tieni presente che questo esempio specifica la porta 1099, che è la porta JMX di Management Server. Per altre porte, consulta la documentazione relativa alle porte di monitoraggio dell'API JMX e dell'API di gestione.
La tabella seguente mostra le statistiche JMX generiche:
MBean JMX | Attributi JMX |
---|---|
Memoria |
HeapMemoryUsage |
NonHeapMemoryUsage |
|
Utilizzo |
|
Riferimento file di configurazione
Le seguenti sezioni descrivono le modifiche che potresti dover apportare ai file di configurazione dei componenti Edge per le configurazioni relative a JMX. Per ulteriori informazioni, consulta Porte e file di configurazione di monitoraggio.
la configurazione JMX da aggiungere al file di configurazione del componente appropriato.
- Abilita l'agente JMX sul componente perimetrale. Il valore è falso per impostazione predefinita.
conf_system_jmxremote_enable=true
Configurazioni per l'autenticazione basata su password
- Attiva l'autenticazione basata su password. Il valore è falso per impostazione predefinita.
conf_system_jmxremote_authenticate=true
- Percorso per accedere al file. Deve essere di proprietà e leggibile solo dall'utente Apigee.
conf_system_jmxremote_access_file=/opt/apigee/customer/application/management-server/jmxremote.access
- Percorso del file delle password. Deve essere di proprietà e leggibile solo dall'utente Apigee.
conf_system_jmxremote_password_file=/opt/apigee/customer/application/management-server/jmxremote.password
- Attiva l'archiviazione delle password in formato criptato. Il valore è falso per impostazione predefinita.
conf_system_jmxremote_encrypted_auth=true
Configurazioni per JMX basata su SSL
- Attiva SSL per la comunicazione JMX. Il valore è falso per impostazione predefinita.
conf_system_jmxremote_ssl=true
- Percorso dell'archivio chiavi. Deve essere di proprietà e leggibile solo dall'utente Apigee.
conf_system_javax_net_ssl_keystore=/opt/apigee/customer/application/management-server/jmxremote.keystore
- Password dell'archivio chiavi:
conf_system_javax_net_ssl_keystorepassword=changeme
Configurazioni JMX facoltative
I valori elencati sono predefiniti e possono essere modificati.
- Porta JMX. I valori predefiniti sono elencati nella tabella seguente.
conf_system_jmxremote_port=
- Porta RMI JMX. Per impostazione predefinita, il processo Java sceglierà una porta casuale.
conf_system_jmxremote_rmi_port=
- Il nome host per gli stub remoti. Indirizzo IP predefinito di localhost.
conf_system_java_rmi_server_hostname=
- Proteggi il registro JMX con SSL. Il valore predefinito è false. Applicabile solo se SSL è abilitato.
conf_system_jmxremote_registry_ssl=false
Monitoraggio con l'API di gestione
Edge include diverse API che puoi utilizzare per eseguire controlli dei servizi sui server, nonché per controllare utenti, organizzazioni e deployment. In questa sezione vengono descritte le API.
Esegui i controlli del servizio
L'API di gestione fornisce diversi endpoint per il monitoraggio e la diagnosi dei problemi relativi ai servizi. Questi endpoint includono:
Endpoint | Descrizione |
---|---|
/servers/self/up |
Verifica se un servizio è in esecuzione. Questa chiamata API non richiede l'autenticazione. Se il servizio è in esecuzione, questo endpoint restituisce la seguente risposta: <ServerField> <Up>true</Up> </ServerField> Se il servizio non è in esecuzione, riceverai una risposta simile alla seguente (a seconda del servizio e di come l'hai controllato): curl: Failed connect to localhost:port_number; Connection refused |
/servers/self |
Restituisce informazioni sul servizio, tra cui:
Questa chiamata API richiede l'autenticazione con le tue credenziali di amministratore Apigee. |
Per utilizzare questi endpoint, richiama un'utilità come curl
con comandi che utilizzano la seguente sintassi:
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]"
Dove:
- host è l'indirizzo IP del server che vuoi controllare. Se hai eseguito l'accesso al server, puoi utilizzare "localhost"; in caso contrario, specifica l'indirizzo IP del server, oltre a nome utente e password.
- port_number è la porta dell'API di gestione del server che vuoi controllare. Si tratta di una porta diversa per ogni tipo di componente. Ad esempio, la porta dell'API di gestione del server di gestione è 8080. Per un elenco dei numeri di porta dell'API di gestione da utilizzare, consulta Porte di monitoraggio JMX e API di gestione
Per modificare il formato della risposta, puoi specificare l'intestazione Accept
come
"application/json" o "application/xml".
L'esempio seguente restituisce lo stato del router su localhost (porta 8081):
curl http://localhost:8081/v1/servers/self/up -H "Accept: application/xml"
L'esempio seguente restituisce informazioni sul processore di messaggi alla porta 216.3.128.12 (porta 8082):
curl http://216.3.128.12:8082/v1/servers/self -u sysAdminEmail:password -H "Accept: application/xml"
Monitora lo stato degli utenti, dell'organizzazione e del deployment
Puoi utilizzare l'API di gestione per monitorare lo stato di utenti, organizzazione e deployment dei tuoi proxy sui server di gestione e sui processori di messaggi utilizzando i seguenti comandi:
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
Dove port_number è 8080 per il server di gestione o 8082 per il processore di messaggi.
Questa chiamata richiede l'autenticazione con nome utente e password di amministratore del sistema.
Il server dovrebbe restituire lo stato "Deployment eseguito" per tutte le chiamate. Se il problema persiste:
- Verifica la presenza di eventuali errori nei log del server. I log si trovano in:
- Server di gestione:
opt/apigee/var/log/edge-management-server
- Processore di messaggi:
opt/apigee/var/log/edge-message-processor
- Server di gestione:
- Effettua una chiamata al server per verificare che funzioni correttamente.
- Rimuovi il server dall'ELB e riavvialo:
/opt/apigee/apigee-service/bin/apigee-service service_name restart
Dove si trova service_name:
edge-management-server
edge-message-processor
Controlla lo stato con il comando apigee-service
Puoi risolvere i problemi dei servizi perimetrali utilizzando il comando apigee-service
dopo aver eseguito l'accesso al server che esegue il servizio.
Per controllare lo stato di un servizio con apigee-service
:
- Accedi al server ed esegui questo comando:
/opt/apigee/apigee-service/bin/apigee-service service_name status
Dove service_name è uno dei seguenti:
- Server di gestione:
edge-management-server
- Processore di messaggi:
edge-message-processor
- Postgres:
edge-postgres-server
- Qpid:
edge-qpid-server
- Router:
edge-router
Ad esempio:
/opt/apigee/apigee-service/bin/apigee-service edge-message-processor status
- Server di gestione:
- Se il servizio non è in esecuzione, avvialo:
/opt/apigee/apigee-service/bin/apigee-service service_name start
- Dopo aver riavviato il servizio, verifica che funzioni utilizzando il comando
apigee-service status
usato in precedenza oppure l'API di gestione descritta in Monitorare con l'API di gestione.Ad esempio:
curl -v http://localhost:port_number/v1/servers/self/up
Dove port_number è la porta dell'API di gestione per il servizio.
Questo esempio presuppone che tu abbia eseguito l'accesso al server e puoi utilizzare "localhost" come nome host. Per verificare lo stato in remoto con l'API di gestione, devi specificare l'indirizzo IP del server e includere il nome utente e la password dell'amministratore di sistema nella chiamata API.
Monitoraggio di Postgres
Postgres supporta diverse utilità che puoi utilizzare per controllare il suo stato. Queste utilità sono descritte nelle sezioni seguenti.
Controlla organizzazioni e ambienti su Postgres
Puoi verificare i nomi delle organizzazioni e degli ambienti inseriti nel server Postgres
utilizzando il seguente comando curl
:
curl -v http://postgres_IP:8084/v1/servers/self/organizations
Nel sistema dovrebbe essere visualizzato il nome dell'organizzazione e dell'ambiente.
Verifica lo stato dei dati e delle analisi
Puoi verificare lo stato dei server di analisi Postgres e Qpid inviando il seguente
comando curl
:
curl -u userEmail:password http://host:port_number/v1/organizations/orgname/environments/envname/provisioning/axstatus
Il sistema dovrebbe visualizzare uno stato di operazione riuscita per tutti i server di analisi, come mostra l'esempio seguente:
{ "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" }
Database PostgreSQL
Questa sezione descrive le tecniche che puoi utilizzare nello specifico per monitorare il database Postgres.
Utilizza lo script check_postgres.pl
Per monitorare il database PostgreSQL, puoi utilizzare uno script di monitoraggio standard,
check_postgres.pl
. Per maggiori informazioni, visita la pagina
http://bucardo.org/wiki/Check_postgres.
Prima di eseguire lo script:
- Devi installare lo script check_postgres.pl su ciascun nodo Postgres.
- Assicurati di aver installato
perl-Time-HiRes.x86_64
, un modulo Perl che implementa timer ad alta risoluzione per sveglie, sospensione, gettimeofday e intervallo. Ad esempio, puoi installarlo utilizzando il seguente comando:
yum install perl-Time-HiRes.x86_64
- CentOS 7: prima di utilizzare check_postgres.pl su CentOS v7, installa l'RPM
perl-Data-Dumper.x86_64
.
Output check_postgres.pl
L'output predefinito delle chiamate API che utilizzano check_postgres.pl
è compatibile con Nagios. Dopo aver installato lo script, verifica quanto segue:
- Controlla le dimensioni del database:
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'
- Controlla il numero di connessioni in entrata nel database e confrontalo con il numero massimo consentito di connessioni:
check_postgres.pl -H 10.176.218.202 -db apigee -u apigee -dbpass postgres -action backends
- Controlla se il database è in esecuzione e disponibile:
check_postgres.pl -H 10.176.218.202 -db apigee -u apigee -dbpass postgres -action connection
- Controlla lo spazio su disco:
check_postgres.pl -H 10.176.218.202 -db apigee -u apigee -dbpass postgres -action disk_space --warning='80%' --critical='90%'
- Controlla il numero di organizzazioni e ambienti di cui è stato eseguito l'onboarding in un nodo 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
Esegui controlli del database
Puoi verificare che nel database PostgreSQL vengano create le tabelle corrette. Accedi al database PostgreSQL utilizzando il seguente comando:
psql -h /opt/apigee/var/run/apigee-postgresql/ -U apigee -d apigee
Dopodiché, esegui:
\d analytics."org.env.fact"
Controlla lo stato di integrità del processo Postgres
Puoi eseguire i controlli API sulla macchina Postgres richiamando il seguente comando curl
:
curl -v http://postgres_IP:8084/v1/servers/self/health
Questo comando restituisce lo stato ACTIVE
quando il processo postgres è attivo. Se il processo Postgres non è attivo e in esecuzione, restituisce lo stato INACTIVE
.
Risorse Postgres
Per ulteriori informazioni sul monitoraggio del servizio Postgres, consulta quanto segue:
- 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
JMX è abilitato per impostazione predefinita per Cassandra e l'accesso JMX remoto a Cassandra non richiede una password.
Abilita l'autenticazione JMX per Cassandra
Puoi attivare l'autenticazione JMX per Cassandra. Dopodiché, ti verrà richiesto di passare un nome utente e una password a tutte le chiamate all'utilità nodetool.
Per attivare l'autenticazione JMX per Cassandra:
- Crea e modifica il file
cassandra.properties
:- Modifica il file
/opt/apigee/customer/application/cassandra.properties
. Se il file non esiste, crealo. - Aggiungi quanto segue al file:
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
- Salva il file
cassandra.properties
. - Modifica il proprietario del file in
apigee:apigee
, come illustrato nell'esempio seguente:chown apigee:apigee /opt/apigee/customer/application/cassandra.properties
Per ulteriori informazioni sull'utilizzo dei file delle proprietà per impostare i token, consulta Come configurare Edge.
- Modifica il file
- Crea e modifica
jmx_auth.sh
:- Crea un file nel seguente percorso se non esiste:
/opt/apigee/customer/application/jmx_auth.sh
- Aggiungi le seguenti proprietà al file:
export CASS_JMX_USERNAME=JMX_USERNAME export CASS_JMX_PASSWORD=JMX_PASSWORD
- Salva il file
jmx_auth.sh
. - Crea il file di origine:
source /opt/apigee/customer/application/jmx_auth.sh
- Crea un file nel seguente percorso se non esiste:
- Copia e modifica il file
jmxremote.password
:- Copia il seguente file dalla directory
$JAVA_HOME
in/opt/apigee/customer/application/apigee-cassandra/
:cp ${JAVA_HOME}/lib/management/jmxremote.password.template $APIGEE_ROOT/customer/application/apigee-cassandra/jmxremote.password
- Modifica il file
jmxremote.password
e aggiungi il nome utente e la password JMX utilizzando la seguente sintassi:JMX_USERNAME JMX_PASSWORD
Dove JMX_USERNAME e JMX_PASSWORD sono il nome utente e la password JMX che hai impostato in precedenza.
- Assicurati che il file sia di proprietà di "apigee" e che la modalità file sia 400:
chown apigee:apigee /opt/apigee/customer/application/apigee-cassandra/jmxremote.password
chmod 400 /opt/apigee/customer/application/apigee-cassandra/jmxremote.password
- Copia il seguente file dalla directory
- Copia e modifica il file
jmxremote.access
:- Copia il seguente file dalla directory
$JAVA_HOME
in/opt/apigee/customer/application/apigee-cassandra/
:cp ${JAVA_HOME}/lib/management/jmxremote.access
$APIGEE_ROOT/customer/application/apigee-cassandra/jmxremote.access
- Modifica il file
jmxremote.access
e aggiungi il ruolo seguente:JMX_USERNAME readwrite
- Assicurati che il file sia di proprietà di "apigee" e che la modalità file sia 400:
chown apigee:apigee /opt/apigee/customer/application/apigee-cassandra/jmxremote.access
chmod 400 /opt/apigee/customer/application/apigee-cassandra/jmxremote.access
- Copia il seguente file dalla directory
- Esegui
configure
su Cassandra:/opt/apigee/apigee-service/bin/apigee-service apigee-cassandra configure
- Riavvia Cassandra:
/opt/apigee/apigee-service/bin/apigee-service apigee-cassandra restart
- Ripeti questo processo su tutti gli altri nodi Cassandra.
Attiva la crittografia delle password JMX
Per attivare la crittografia della password JMX, segui questi passaggi:
- Apri il file
source/conf/casssandra-env.sh
. - Crea e modifica il file
cassandra.properties
:- Modifica il file
/opt/apigee/customer/application/cassandra.properties
. Se il file non esiste, crealo. - Aggiungi quanto segue al file:
conf_cassandra_env_com.sun.management.jmxremote.encrypted.authenticate=true
- Salva il file cassandra.properties.
- Modifica il proprietario del file in apigee:apigee, come mostra l'esempio seguente:
chown apigee:apigee /opt/apigee/customer/application/cassandra.properties
- Modifica il file
- Nella riga di comando, genera hash SHA1 delle password desiderate inserendo il valore
echo -n 'Secret' | openssl dgst -sha1
. - Imposta le password in base al nome utente in
$APIGEE_ROOT/customer/application/apigee-cassandra/jmxremote.password
(creato nella sezione precedente). - Esegui la configurazione su Cassandra:
/opt/apigee/apigee-service/bin/apigee-service apigee-cassandra configure
- Riavvia Cassandra:
/opt/apigee/apigee-service/bin/apigee-service apigee-cassandra restart
- Ripeti questo processo su tutti gli altri nodi Cassandra.
Abilita JMX con SSL per Cassandra
L'abilitazione di JMX con SSL fornisce ulteriore sicurezza e crittografia per le comunicazioni basate su JMX con Cassandra. Per attivare JMX con SSL, devi fornire una chiave e un certificato a Cassandra per accettare connessioni JMX basate su SSL. Devi inoltre configurare nodetool (e qualsiasi altro strumento che comunica con Cassandra tramite JMX) per SSL.
JMX abilitato per SSL supporta password JMX in testo non crittografato e password JMX criptate.
Per attivare JMX con SSL per Cassandra, utilizza la procedura seguente:
- Abilita JMX. Se necessario, abilita la crittografia delle password.
- Attiva l'autenticazione JMX per Cassandra.
come descritto sopra. Assicurati che nodetool funzioni con il nome utente e la password configurati.
/opt/apigee/apigee-cassandra/bin/nodetool -u <JMX_USER> -pw <JMX_PASS> ring
Preparare un archivio chiavi e un archivio attendibili
L'archivio chiavi deve contenere una chiave e un certificato e viene utilizzato per configurare il server Cassandra. Se l'archivio chiavi contiene più coppie di chiavi, Cassandra utilizza la prima coppia di chiavi per abilitare SSL.
Tieni presente che le password per l'archivio chiavi e la chiave devono essere le stesse (quelle predefinite quando generi la chiave utilizzando keytool).
- L'archivio attendibili deve contenere solo il certificato e viene utilizzato dai client (comandi basati su Apigee o nodetool) per la connessione tramite JMX.
Dopo aver verificato i requisiti di cui sopra:
- Inserisci il file dell'archivio chiavi in
/opt/apigee/customer/application/apigee-cassandra/
. - Assicurati che il file dell'archivio chiavi sia leggibile solo dall'utente Apigee inserendo
chown apigee:apigee /opt/apigee/customer/application/apigee-cassandra/keystore.node1
chmod 400 /opt/apigee/customer/application/apigee-cassandra/keystore.node1
- Per configurare Cassandra per JMX con SSL:
- Arresta il nodo Cassandra inserendo
apigee-service apigee-cassandra stop
- Per abilitare SSL in Cassandra, apri il file
/opt/apigee/customer/application/cassandra.properties
e aggiungi le seguenti righe: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
- Modifica il proprietario del file in apigee:apigee, come mostra l'esempio seguente:
chown apigee:apigee /opt/apigee/customer/application/cassandra.properties
- Esegui la configurazione su Cassandra:
/opt/apigee/apigee-service/bin/apigee-service apigee-cassandra configure
- Riavvia Cassandra:
/opt/apigee/apigee-service/bin/apigee-service apigee-cassandra restart
- Ripeti questo processo su tutti gli altri nodi Cassandra.
- Avvia il nodo Cassandra inserendo
apigee-service apigee-cassandra start
- Arresta il nodo Cassandra inserendo
- Configura i comandi Cassandra
apigee-service
. Devi impostare alcune variabili di ambiente durante l'esecuzione dei comandiapigee-service
, tra cui quelle riportate di seguito:apigee-service apigee-cassandra stop apigee-service apigee-cassandra wait_for_ready apigee-service apigee-cassandra ring apigee-service apigee-cassandra backup
Esistono diverse opzioni per configurare
apigee-service
per l'autenticazione JMX e SSL. Scegli un'opzione in base all'usabilità e alle prassi di sicurezza.- Opzione 1 (argomenti SSL archiviati nel file)
- Opzione 2 (argomenti SSL archiviati nelle variabili di ambiente)
- Opzione 3 (argomenti SSL passati direttamente a
apigee-service
)
Opzione 1 (argomenti SSL archiviati nel file)
Imposta le seguenti variabili di ambiente:
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
Crea un file nella home directory dell'utente Apigee (
/opt/apigee
).$HOME/.cassandra/nodetool-ssl.properties
Modifica il file e aggiungi le seguenti righe:
-Djavax.net.ssl.trustStore=<path-to-truststore.node1> -Djavax.net.ssl.trustStorePassword=<truststore-password> -Dcom.sun.management.jmxremote.registry.ssl=true
Assicurati che il file Trustore sia leggibile dall'utente Apigee.
Esegui questo comando
apigee-service
. Se viene eseguita senza errori, le configurazioni sono corrette.apigee-service apigee-cassandra ring
Opzione 2 (argomenti SSL archiviati nelle variabili di ambiente)
Imposta le seguenti variabili di ambiente:
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>
Esegui questo comando
apigee-service
. Se viene eseguita senza errori, le configurazioni sono corrette.apigee-service apigee-cassandra ring
Opzione 3 (argomenti SSL passati direttamente a
apigee-service
)Esegui qualsiasi comando
apigee-service
come quello riportato di seguito. Non è necessario configurare le variabili di 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
Configura nodetool. Nodetool richiede che vengano passati i parametri JMX. Esistono due modi per configurare nodetool per l'esecuzione con JMX abilitato per SSL, come descritto nelle seguenti opzioni di configurazione:
Le opzioni sono diverse nel modo in cui le configurazioni relative a SSL vengono passate a nodetool. In entrambi i casi, l'utente che esegue nodetool deve disporre delle autorizzazioni di lettura sul file dell'archivio di attendibilità. Scegliere un'opzione appropriata in base all'usabilità e alle prassi di sicurezza.
Per scoprire di più sui parametri nodetool, consulta la documentazione di DataStax.
Opzione di configurazione 1
Crea un file nella home directory dell'utente che esegue nodetool.
$HOME/.cassandra/nodetool-ssl.properties
Aggiungi le seguenti righe al file:
-Djavax.net.ssl.trustStore=<path-to-truststore.node1> -Djavax.net.ssl.trustStorePassword=<truststore-password> -Dcom.sun.management.jmxremote.registry.ssl=true
Il percorso del truststore specificato sopra deve essere accessibile a qualsiasi utente che esegue nodetool.
Esegui
nodetool
con l'opzione--ssl
./opt/apigee/apigee-cassandra/bin/nodetool --ssl -u <jmx-user-name> -pw <jmx-user-password> -h localhost ring
Opzione di configurazione 2
Esegui
nodetool
come singolo comando con i parametri aggiuntivi elencati di seguito./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
Ripristina configurazioni SSL
Se devi ripristinare le configurazioni SSL descritte nella procedura precedente, segui questi passaggi:
- Interrompi
apigee-cassandra
inserendoapigee-service apigee-cassandra stop
- Rimuovi la riga
conf_cassandra-env_com.sun.management.jmxremote.ssl=true
dal file/opt/apigee/customer/application/cassandra.properties
. - Commenta le seguenti righe in
/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”
- Inizia
apigee-cassandra
inserendo - Rimuovi la variabile di ambiente
CASS_JMX_SSL
, se è stata impostata.unset CASS_JMX_SSL
- Verifica che i comandi basati su
apigee-service
, comering
,stop
,backup
e così via, funzionino. - Interrompi l'utilizzo dell'opzione
--ssl
con nodetool
apigee-service apigee-cassandra start
Disattiva l'autenticazione JMX per Cassandra
Per disattivare l'autenticazione JMX per Cassandra:
- Modifica
/opt/apigee/customer/application/cassandra.properties
. - Rimuovi la seguente riga dal file:
conf_cassandra-env_com.sun.management.jmxremote.authenticate=true
- Esegui la configurazione su Cassandra:
/opt/apigee/apigee-service/bin/apigee-service apigee-cassandra configure
- Riavvia Cassandra:
/opt/apigee/apigee-service/bin/apigee-service apigee-cassandra restart
- Ripeti questo processo su tutti gli altri nodi Cassandra.
Usa JConsole: monitorare le statistiche delle attività
Utilizza JConsole e il seguente URL del servizio per monitorare gli attributi JMX (MBean) offerti tramite JMX:
service:jmx:rmi:///jndi/rmi://IP_address:7199/jmxrmi
Dove IP_address è l'IP del server Cassandra.
Statistiche JMX Cassandra
MBean JMX | Attributi JMX |
---|---|
ColonnaFamiglie/apprepo/ambienti ColonnaFamiglie/apprepo/organizzazioni ColumnFamilies/apprepo/apiproxy_revisions ColonnaFamiglie/apprepo/apiproxies ColonnaFamiglie/controlli/controlli ColonnaFamiglie/controllo/controlli_ref |
PendingTasks |
MemtableColumnsCount |
|
MemtableDataSize |
|
ReadCount |
|
RecentReadLatencyMicros |
|
TotalReadLatencyMicros |
|
WriteCount |
|
RecentWriteLatencyMicros |
|
TotalWriteLatencyMicros |
|
TotalDiskSpaceUsed |
|
LiveDiskSpaceUsed |
|
LiveSSTableCount |
|
BloomFilterFalsePositives |
|
RecentBloomFilterFalseRatio |
|
BloomFilterFalseRatio |
Usa nodetool per gestire i nodi del cluster
L'utilità nodetool è un'interfaccia a riga di comando per Cassandra che gestisce i nodi dei cluster. L'utilità è disponibile all'indirizzo /opt/apigee/apigee-cassandra/bin
.
Le chiamate seguenti possono essere effettuate su tutti i nodi del cluster Cassandra:
- Informazioni sulla suoneria generiche (possibili anche per un singolo nodo Cassandra): cerca i valori
"Up" e "Normal" per tutti i nodi.
nodetool [-u username -pw password] -h localhost ring
Devi trasmettere il nome utente e la password solo se hai attivato l'autenticazione JMX per Cassandra.
L'output del comando precedente è simile all'esempio seguente:
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
- Informazioni generali sui nodi (chiamata per nodo)
nodetool [-u username -pw password] -h localhost info
L'output del comando precedente è simile al seguente:
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
- Stato del server dell'usato (API client di pubblicazione)
nodetool [-u username -pw password] -h localhost statusthrift
L'output del comando riportato sopra è simile al seguente:
running
- Stato delle operazioni di flusso di dati: osserva il traffico per i nodi Cassandra:
nodetool [-u username -pw password] -h localhost netstats
L'output del comando riportato sopra è simile al seguente:
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
Per maggiori informazioni su nodetool, consulta Informazioni sull'utilità nodetool.
Risorsa Cassandra
Fai riferimento al seguente URL: http://www.datastax.com/docs/1.0/operations/monitoring.
Monitoraggio del broker Apache Qpid-J
Puoi monitorare Qpid Broker-J dalla console di gestione Qpid. Questa sezione spiega come accedere alla console e come utilizzarla per eseguire funzioni di monitoraggio di base. Per informazioni più dettagliate sull'utilizzo della console di gestione, consulta Console di gestione web nella documentazione di Apache Qpid.
Accedi alla console di gestione
La porta predefinita della console di gestione è 8090. Per accedere alla console su questa porta predefinita, punta il browser web su:
http://QPID_NODE_IP:8090
Per accedere alla console, utilizza le credenziali predefinite impostate da Apigee o quelle impostate nel file di configurazione di Edge. Per maggiori dettagli, consulta Riferimento al file di configurazione Edge.
Monitorare code e messaggi
Nel riquadro di navigazione a sinistra, vai a Java-Broker > virtualhosts > code. Seleziona una coda per visualizzarne i dettagli nella parte principale della UI. Nella visualizzazione dei dettagli puoi vedere statistiche e attributi della coda, incluse le informazioni sui messaggi recapitati, in coda, sulle tariffe dei messaggi e così via.
Visualizzare e scaricare file di log
Nel riquadro di navigazione a sinistra, vai a Java-Broker > brokerlogger > file di log. Nella visualizzazione dei dettagli dell'interfaccia utente principale, puoi visualizzare i dettagli dei file di log e scaricare i file di log.
Utilizzo dell'API Qpid Management
Puoi utilizzare l'API REST Apache Qpid Broker-J per automatizzare le attività di gestione e monitorare il broker. Per maggiori dettagli, consulta la documentazione relativa all'API REST Apache Qpid Broker.
Puoi anche utilizzare strumenti a riga di comando per monitorare il broker. Ad esempio:
curl "QPID_NODE_IP":"8090"/api/latest/broker -u "USERNAME":"PASSWORD"
Abilita il monitoraggio con SSL per Qpid
Per garantire maggiore sicurezza per il monitoraggio e la gestione, abilita il protocollo SSL sul portale di gestione di Qpid e sulle API di gestione di Qpid. Segui le linee guida riportate di seguito per fornire una chiave e un certificato.
Qpid fornisce un'opzione per un archivio chiavi di file, abilitato in Apigee. Questo tipo accetta il formato standard dell'archivio chiavi JKS compreso da strumenti Java e Java come keytool.
Preparazione dell'archivio chiavi
Oltre a utilizzare lo strumento keytool, devi fornire direttamente il file del certificato per l'utilizzo da parte dei client di Qpidd.
Per la generazione di archivi chiavi, consulta la documentazione di Java Keytool.
Dopo la verifica dei requisiti
- Inserisci l'archivio chiavi e i file dei certificati in
/opt/apigee/customer/application/apigee-qpidd
. - Assicurati che il file dell'archivio chiavi sia leggibile solo dall'utente Apigee:
chown apigee:apigee /opt/apigee/customer/application/apigee-qpidd/qpidd.keystore chmod 400 /opt/apigee/customer/application/apigee-qpidd/qpidd.keystore chown apigee:apigee /opt/apigee/customer/application/apigee-qpidd/qpidd-cert.pem chmod 400 /opt/apigee/customer/application/apigee-qpidd/qpidd-cert.pem
Abilita SSL in Qpid
Esegui i passaggi che seguono su un nodo Qpid alla volta:
Apri il file /opt/apigee/customer/application/qpidd.properties
e aggiungi le seguenti righe:
conf_qpidd_qpid_management.https.enabled=true conf_qpidd_qpid.keystore.storeUrl=/opt/apigee/customer/application/apigee-qpidd/qpidd.keystore conf_qpidd_qpid.keystore.password=keystore-password conf_qpidd_qpid.keystore.certificateAlias=certificate-alias conf_qpidd_qpid.keystore.certificate=/opt/apigee/customer/application/apigee-qpidd/qpidd-cert.pem
- Modifica il proprietario del file in apigee:apigee:
chown apigee:apigee /opt/apigee/customer/application/qpidd.properties
- Configura Qpidd:
apigee-service apigee-qpidd configure
- Riavvia Qpidd:
apigee-service apigee-qpidd restart
- Controlla lo stato con wait_for_ready:
apigee-service apigee-qpidd wait_for_ready
Ripristina configurazione SSL
Rimuovi o commenta le proprietà dal file /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
- Configura Qpidd:
apigee-service apigee-qpidd configure
- Riavvia Qpidd:
apigee-service apigee-qpidd restart
- Controlla lo stato con wait_for_ready:
apigee-service apigee-qpidd wait_for_ready
Apache ZooKeeper
Controllare lo stato di ZooKeeper
- Assicurati che il processo ZooKeeper sia in esecuzione. ZooKeeper scrive un file PID in
opt/apigee/var/run/apigee-zookeeper/apigee-zookeeper.pid
. - Testa le porte di ZooKeeper per assicurarti di poter stabilire una connessione TCP con le porte 2181 e 3888 su ogni server ZooKeeper.
- Assicurati di poter leggere i valori del database ZooKeeper. Connettiti utilizzando una libreria client di ZooKeeper (o
/opt/apigee/apigee-zookeeper/bin/zkCli.sh
) e leggi un valore dal database. - Controlla lo stato:
/opt/apigee/apigee-service/bin/apigee-service apigee-zookeeper status
Usa parole di quattro lettere di ZooKeeper
ZooKeeper può essere monitorato tramite un piccolo insieme di comandi (parole di quattro lettere) che vengono inviati alla porta 2181 utilizzando netcat (nc) o telnet.
Per ulteriori informazioni sui comandi ZooKeeper, consulta: Riferimento per i comandi di Apache ZooKeeper.
Ad esempio:
srvr
: elenca i dettagli completi del server.stat
: elenca brevi dettagli relativi al server e ai client connessi.
I seguenti comandi possono essere inviati alla porta ZooKeeper:
- Esegui il comando ruok di quattro lettere per verificare se il server è in esecuzione in uno stato diverso da errore. Una risposta corretta restituisce "imok".
echo ruok | nc host 2181
Resi:
imok
- Esegui il comando a quattro lettere
stat
per elencare le prestazioni del server e le statistiche dei client connessi:echo stat | nc host 2181
Resi:
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 netcat (nc) non è disponibile, puoi utilizzare Python in alternativa. Crea un file denominato
zookeeper.py
che contenga quanto segue: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)
Ora esegui le seguenti linee Python:
python zookeeper.py 192.168.124.201 ruok
python zookeeper.py 192.168.124.201 stat
Test del livello LDAP
Puoi monitorare OpenLDAP per verificare se le richieste specifiche vengono gestite correttamente. In altre parole, verifica se esiste una ricerca specifica che restituisca il risultato corretto.
- Utilizza
ldapsearch
(yum install openldap-clients
) per eseguire una query sulla voce dell'amministratore di sistema. Questa voce viene utilizzata per autenticare tutte le chiamate 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
Ti verrà quindi richiesta la password dell'amministratore LDAP:
Enter LDAP Password:
Dopo aver inserito la password, vedrai una risposta nel modulo:
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
- Controlla se il server di gestione è ancora connesso a LDAP con il seguente comando:
curl -u userEMail:password http://localhost:8080/v1/users/ADMIN
Resi:
{ "emailId" : ADMIN, "firstName" : "admin", "lastName" : "admin" }
Puoi anche monitorare le cache OpenLDAP, che aiutano a ridurre il numero di accessi al disco e quindi a migliorare le prestazioni del sistema. Il monitoraggio e la successiva ottimizzazione delle dimensioni della cache nel server OpenLDAP possono influire notevolmente sulle prestazioni del server di directory. Puoi visualizzare i file di log (opt/apigee/var/log
) per ottenere informazioni sulla cache.