Come monitorare

Questo documento descrive le tecniche di monitoraggio dei componenti supportati da un deployment on-premise di Apigee Edge per cloud privato.

Panoramica

Edge supporta diversi modi per ottenere dettagli sui servizi e per controllarne lo stato. La seguente tabella elenca i tipi di controlli che puoi eseguire su ciascun servizio idoneo:

API di gestione
Componente Utilizzo memoria [JMX*] Controllo di servizio Stato utente/organizzazione/ deployment axstatus Controllo database Stato di apigee-service apigee-monit**
Server di gestione
processore di messaggi
Router
Qpid
Postgres
Ulteriori informazioni Ulteriori informazioni Ulteriori informazioni Ulteriori informazioni Ulteriori informazioni Ulteriori informazioni Ulteriori informazioni

* Prima di poter utilizzare JMX, devi abilitarlo, come descritto in Abilitare JMX.

** Il servizio apigee-monit controlla se un componente è attivo e tenta di riavviarlo in caso contrario. Per ulteriori informazioni, consulta la pagina relativa alla riparazione automatica con apigee-monit.

Porte e file di configurazione per il monitoraggio

Ogni componente supporta le chiamate di monitoraggio Java Management Extensions (JMX) e dell'API di gestione su porte diverse. Nella tabella seguente sono elencate le porte JMX e dell'API di gestione per ciascun tipo di server, nonché le posizioni dei file di configurazione:

Componente Porta JMX Porta API di gestione Posizione 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

Utilizzare JMX per monitorare i componenti

Le sezioni seguenti spiegano come utilizzare JMX per monitorare i componenti Edge.

Abilita JMX

Per attivare JMX senza autenticazione o comunicazione basata su SSL, segui i passaggi riportati di seguito. Nota:nei sistemi di produzione, sia l'autenticazione criptata sia SSL dovrebbero essere abilitate per motivi di sicurezza.

  1. Modifica il file di configurazione appropriato (consulta la sezione Riferimento al file di configurazione). Crea il file di configurazione, se non esiste. 
    conf_system_jmxremote_enable=true
  2. Salva il file di configurazione e assicurati che sia di proprietà di apigee:apigee.
  3. Riavvia il componente Edge appropriato 
    apigee-service edge-management-server restart

Per disattivare JMX, rimuovi la proprietà conf_system_jmxremote_enable o modifica il relativo valore in false. Quindi riavvia il componente Edge appropriato.

Autenticazione in JMX

Edge per Cloud privato supporta l'autenticazione basata su password mediante l'utilizzo di dettagli archiviati nei file. Puoi memorizzare le password come hash per una maggiore sicurezza.

  1. Per abilitare l'autenticazione JMX in un componente perimetrale*, modifica il file di configurazione appropriato (consulta la sezione Riferimento al 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à di apigee:apigee.
  2. Crea un hash SHA256 della password: 
    echo -n '' | openssl dgst -sha256
  3. Crea un file jmxremote.password con le credenziali utente JMX:
    1. 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
    2. Modifica il file e aggiungi il nome utente e la password JMX utilizzando la seguente sintassi: 
      USERNAME <HASH-PASSWORD>
    3. 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
  4. Crea un file jmxremote.access con le autorizzazioni utente JMX:
    1. 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
    2. Modifica il file e aggiungi il tuo nome utente JMX seguito da un'autorizzazione (READONLY/READWRITE) 
      USERNAME READONLY
    3. 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
  5. 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 abilitare JMX basato su SSL in un componente edge-*:

  1. Modifica il file di configurazione appropriato (consulta la sezione Riferimento al 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à di apigee:apigee.
  2. Prepara un archivio chiavi contenente la chiave server e posizionalo nel percorso specificato nella configurazione conf_system_javax_net_ssl_keystore riportata sopra. Assicurati che il file dell'archivio chiavi sia leggibile da apigee:apigee.
  3. Riavvia il componente Edge appropriato: 
    apigee-service edge-management-server restart

Per disabilitare il JMX basato 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.

È possibile aggiungere una riga che indica che "jconsole dovrà essere avviato con la password dell'archivio attendibilità e dell'archivio attendibilità se SSL è abilitato per JMX." Riferimento: https://docs.oracle.com/javase/8/docs/technotes/guides/management/jconsole.html

Monitora con JConsole

Utilizza JConsole (uno strumento conforme a JMX) per gestire e monitorare il controllo di integrità e le statistiche dei processi. Con JConsole puoi utilizzare le statistiche JMX esposte dai tuoi server e visualizzarle in un'interfaccia grafica. Per ulteriori informazioni, consulta Utilizzo di JConsole.

Se SSL è abilitato per JMX, devi avviare JConsole con l'archivio attendibilità e la password dell'archivio attendibilità. Consulta la sezione sull' utilizzo di JConsole.

JConsole utilizza il seguente URL di 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 da monitorare.

Ad esempio, per monitorare il server di gestione, invia 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, ovvero la porta JMX del server di gestione. Per le altre porte, consulta la pagina relativa alle porte di monitoraggio di JMX e dell'API di gestione.

La tabella seguente mostra le statistiche JMX generiche:

JMX MBean Attributi JMX

Memoria

HeapMemoryUsage

NonHeapMemoryUsage

Utilizzo

Riferimento al file di configurazione

Le seguenti sezioni descrivono le modifiche che potrebbe essere necessario apportare ai file di configurazione dei componenti Edge per le configurazioni relative a JMX. Per ulteriori informazioni, consulta Monitoraggio delle porte e dei file di configurazione.

La configurazione JMX da aggiungere al file di configurazione del componente appropriato

  • Abilita l'agente JMX nel componente perimetrale. Falso per impostazione predefinita. 
    conf_system_jmxremote_enable=true

Configurazioni per l'autenticazione basata su password

  • Attiva l'autenticazione basata su password. 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 la memorizzazione delle password in formato criptato. Falso per impostazione predefinita. 
    conf_system_jmxremote_encrypted_auth=true

Configurazioni per JMX basato su SSL

  • Abilita SSL per la comunicazione JMX. 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 valori predefiniti e possono essere modificati.

  • Porta JMX. I valori predefiniti sono elencati nella tabella seguente. 
    conf_system_jmxremote_port=
  • Porta JMX RMI. Per impostazione predefinita, il processo Java selezionerà 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. Valore predefinito false. Applicabile solo se è abilitato SSL. 
    conf_system_jmxremote_registry_ssl=false

Monitorare con l'API di gestione

Edge include diverse API che puoi utilizzare per eseguire i controlli dei servizi sui server, nonché per verificare gli utenti, le organizzazioni e i deployment. Questa sezione descrive le API.

Esegui i controlli di 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 lo hai controllato):

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

Restituisce informazioni sul servizio, tra cui:

  • Proprietà di configurazione
  • Ora di inizio e ora di riposo
  • Informazioni su build, RPM e UUID
  • Nome host e indirizzo IP interni ed esterni
  • Regione e pod
  • <isUp>, che indica se il servizio è in esecuzione

Questa chiamata API richiede l'autenticazione con le credenziali amministrative di 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 effettuato l'accesso al server, puoi utilizzare "localhost", altrimenti specifica l'indirizzo IP del server oltre al nome utente e alla password.
  • port_number è la porta dell'API di gestione del server che vuoi controllare. che ha 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 porte dell'API di gestione da utilizzare, consulta Porte di monitoraggio di JMX e dell'API di gestione

Per modificare il formato della risposta, puoi specificare l'intestazione Accept come "application/json" o "application/xml".

Nell'esempio seguente viene recuperato lo stato del router su localhost (porta 8081):

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

L'esempio seguente recupera informazioni sul processore di messaggi all'indirizzo 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 degli utenti, dell'organizzazione e del deployment dei proxy sui server di gestione e sui processori di messaggi inviando i seguenti comandi:

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

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 di sistema.

Il server dovrebbe restituire lo stato "implementato" per tutte le chiamate. Se il problema persiste:

  1. Verifica la presenza di errori nei log del server. I log si trovano in:
    • Server di gestione: opt/apigee/var/log/edge-management-server
    • Processore dei messaggi: opt/apigee/var/log/edge-message-processor
  2. Effettua una chiamata al server per verificare se funziona correttamente.
  3. Rimuovi il server da 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 Edge 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:

  1. Accedi al server ed esegui questo comando: 
    /opt/apigee/apigee-service/bin/apigee-service service_name status

    Dove service_name corrisponde a uno dei seguenti valori:

    • Server di gestione: edge-management-server
    • Processore dei messaggi: edge-message-processor
    • Postgres: edge-postgres-server
    • QP: edge-qpid-server
    • Router: edge-router

    Ad esempio:

    /opt/apigee/apigee-service/bin/apigee-service edge-message-processor status
  2. Se il servizio non è in esecuzione, avvialo: 
    /opt/apigee/apigee-service/bin/apigee-service service_name start
  3. Dopo aver riavviato il servizio, verifica che funzioni utilizzando il comando apigee-service status che hai utilizzato in precedenza o l'API di gestione descritta in Monitoraggio 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 che tu possa utilizzare "localhost" come nome host. Per controllare lo stato da 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 Postgres

Postgres supporta diverse utilità che puoi usare per verificarne lo stato. Queste utilità sono descritte nelle sezioni seguenti.

Controlla organizzazioni e ambienti su Postgres

Puoi controllare i nomi delle organizzazioni e dell'ambiente inseriti nel server Postgres inviando il seguente comando curl:

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

Il sistema dovrebbe visualizzare 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 mostrare uno stato di operazione riuscita per tutti i server di analisi, come illustrato nell'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 in modo specifico per il monitoraggio del database Postgres.

Utilizza lo script check_postgres.pl

Per monitorare il database PostgreSQL, puoi utilizzare uno script di monitoraggio standard, check_postgres.pl. Per saperne di più, visita la pagina http://bucardo.org/wiki/Check_postgres.

Prima di eseguire lo script:

  1. Devi installare lo script check_postgres.pl su ciascun nodo Postgres.
  2. Assicurati di aver installato perl-Time-HiRes.x86_64, un modulo Perl che implementa sveglia ad alta risoluzione, sospensione, gettimeofday e timer a intervalli. Ad esempio, puoi installarlo utilizzando il seguente comando:
    yum install perl-Time-HiRes.x86_64
  3. 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, esegui questi controlli:

  1. 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'
  2. Controlla il numero di connessioni in entrata al database e confronta il numero massimo di connessioni consentite: 
    check_postgres.pl -H 10.176.218.202 -db apigee -u apigee -dbpass postgres -action backends
  3. Controlla se il database è in esecuzione e disponibile: 
    check_postgres.pl -H 10.176.218.202 -db apigee -u apigee -dbpass postgres -action connection
  4. 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%'
  5. Controlla il numero di organizzazione e ambiente inseriti 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 i controlli del database

Puoi verificare che nel database PostgreSQL vengano create le tabelle corrette. Accedi al database PostgreSQL utilizzando questo 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 è in esecuzione, restituisce lo stato INACTIVE.

Risorse Postgres

Per ulteriori informazioni sul monitoraggio del servizio Postgres, consulta quanto segue:

Apache Cassandra

JMX è abilitato per impostazione predefinita per Cassandra e l'accesso remoto JMX a Cassandra non richiede una password.

Abilita l'autenticazione JMX per Cassandra

Puoi attivare l'autenticazione JMX per Cassandra. Dopo averlo fatto, ti verrà chiesto di passare un nome utente e una password a tutte le chiamate all'utilità NodeTool.

Per abilitare l'autenticazione JMX per Cassandra:

  1. Crea e modifica il file cassandra.properties:
    1. Modifica il file /opt/apigee/customer/application/cassandra.properties. Se il file non esiste, crealo.
    2. 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
    3. Salva il file cassandra.properties.
    4. Modifica il proprietario del file in apigee:apigee, come illustrato nell'esempio seguente: 
      chown apigee:apigee /opt/apigee/customer/application/cassandra.properties

    Per maggiori informazioni sull'utilizzo dei file delle proprietà per impostare i token, consulta Come configurare Edge.

  2. Crea e modifica jmx_auth.sh:
    1. Se non esiste, crea un file nel seguente percorso: 
      /opt/apigee/customer/application/jmx_auth.sh
    2. Aggiungi le seguenti proprietà al file: 
      export CASS_JMX_USERNAME=JMX_USERNAME
export CASS_JMX_PASSWORD=JMX_PASSWORD
    3. Salva il file jmx_auth.sh.
    4. Origine del file: 
      source /opt/apigee/customer/application/jmx_auth.sh
  3. Copia e modifica il file jmxremote.password:
    1. Copia il seguente file dalla directory $JAVA_HOME a /opt/apigee/customer/application/apigee-cassandra/: 
      cp ${JAVA_HOME}/lib/management/jmxremote.password.template $APIGEE_ROOT/customer/application/apigee-cassandra/jmxremote.password
    2. 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.

    3. 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
  4. Copia e modifica il file jmxremote.access:
    1. Copia il seguente file dalla directory $JAVA_HOME a /opt/apigee/customer/application/apigee-cassandra/: 
      cp ${JAVA_HOME}/lib/management/jmxremote.access
$APIGEE_ROOT/customer/application/apigee-cassandra/jmxremote.access
    2. Modifica il file jmxremote.access e aggiungi il seguente ruolo: 
      JMX_USERNAME readwrite
    3. 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
  5. Esegui configure su Cassandra: 
    /opt/apigee/apigee-service/bin/apigee-service apigee-cassandra configure
  6. Riavvia Cassandra: 
    /opt/apigee/apigee-service/bin/apigee-service apigee-cassandra restart
  7. Ripeti questo processo su tutti gli altri nodi Cassandra.

Abilita la crittografia delle password JMX

Per attivare la crittografia delle password JMX, segui questi passaggi:

  1. Apri il file source/conf/casssandra-env.sh.
  2. Crea e modifica il file cassandra.properties:
    1. Modifica il file /opt/apigee/customer/application/cassandra.properties. Se il file non esiste, crealo.
    2. Aggiungi quanto segue al file: 
      conf_cassandra_env_com.sun.management.jmxremote.encrypted.authenticate=true
    3. Salva il file cassandra.properties.
    4. Cambia il proprietario del file in apigee:apigee, come mostrato nell'esempio seguente: 
      chown apigee:apigee /opt/apigee/customer/application/cassandra.properties
  3. Nella riga di comando, genera gli hash SHA1 delle password desiderate inserendo echo -n 'Secret' | openssl dgst -sha1
  4. Imposta le password sul nome utente in $APIGEE_ROOT/customer/application/apigee-cassandra/jmxremote.password (creato nella sezione precedente).
  5. Esegui configurazione su Cassandra: 
    /opt/apigee/apigee-service/bin/apigee-service apigee-cassandra configure
  6. Riavvia Cassandra: 
    /opt/apigee/apigee-service/bin/apigee-service apigee-cassandra restart
  7. Ripeti questo processo su tutti gli altri nodi Cassandra.

Abilita JMX con SSL per Cassandra

L'abilitazione di JMX con SSL offre sicurezza e crittografia aggiuntive per le comunicazioni basate su JMX con Cassandra. Per abilitare 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.

Il protocollo JMX abilitato per SSL supporta le password JMX criptate e in testo non crittografato.

Per abilitare JMX con SSL per Cassandra, utilizza la seguente procedura:

  1. Abilita JMX. Abilita la crittografia della password, se necessario.
  2. 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

  3. Preparare l'archivio chiavi e l'archivio di attendibilità.

    • 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 (l'impostazione predefinita quando generi la chiave utilizzando lo strumento chiavi).

    • L'archivio attendibilità deve contenere solo il certificato ed è utilizzato dai client (comandi basati su Apigee-service o nodetool) per la connessione tramite JMX.

    Dopo aver verificato i requisiti di cui sopra:

    1. Posiziona il file dell'archivio chiavi in /opt/apigee/customer/application/apigee-cassandra/.
    2. 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
  4. Per configurare Cassandra per JMX con SSL:
    1. Interrompi il nodo Cassandra inserendo 
      apigee-service apigee-cassandra stop
    2. Abilita SSL in Cassandra aprendo il file /opt/apigee/customer/application/cassandra.properties e aggiungendo 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
    3. Cambia il proprietario del file in apigee:apigee, come mostrato nell'esempio seguente: 
      chown apigee:apigee /opt/apigee/customer/application/cassandra.properties
    4. Esegui configurazione su Cassandra: 
      /opt/apigee/apigee-service/bin/apigee-service apigee-cassandra configure
    5. Riavvia Cassandra: 
      /opt/apigee/apigee-service/bin/apigee-service apigee-cassandra restart
    6. Ripeti questo processo su tutti gli altri nodi Cassandra.
    7. Avvia il nodo Cassandra inserendo 
      apigee-service apigee-cassandra start
  5. Configura i comandi Cassandra di apigee-service. Devi impostare determinate variabili di ambiente durante l'esecuzione dei comandi apigee-service, inclusi quelli riportati di seguito: 
    apigee-service apigee-cassandra stop
apigee-service apigee-cassandra wait_for_ready
apigee-service apigee-cassandra ring
apigee-service apigee-cassandra backup

    Sono disponibili diverse opzioni per configurare apigee-service per l'autenticazione JMX e SSL. Scegli un'opzione in base all'usabilità e alle pratiche di sicurezza.

    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 di 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 di Apigee.

    Esegui questo comando apigee-service. Se viene eseguito senza errori, le configurazioni sono corrette.

    apigee-service apigee-cassandra ring

    Opzione 2 (argomenti SSL memorizzati in 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 eseguito 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 devi configurare alcuna variabile 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

  6. Configura nodetool. Nodetool richiede l'invio di parametri JMX. Esistono due modi per configurare NodeTool in modo che venga eseguito con JMX abilitato per SSL, come descritto nelle opzioni di configurazione riportate di seguito:

    Le opzioni variano 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 per il file dell'archivio attendibilità. Scegli un'opzione appropriata in base all'usabilità e alle pratiche di sicurezza.

    Per saperne 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 dell'archivio attendibilità 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:

  1. Interrompi apigee-cassandraentrando in 
    apigee-service apigee-cassandra stop
  2. Rimuovi la riga conf_cassandra-env_com.sun.management.jmxremote.ssl=true dal file /opt/apigee/customer/application/cassandra.properties.
  3. 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”
  4. Inizia apigee-cassandra inserendo
    5. apigee-service apigee-cassandra start
  5. Rimuovi la variabile di ambiente CASS_JMX_SSL, se impostata.

    unset CASS_JMX_SSL
  6. Verifica che i comandi basati su apigee-service come ring, stop, backup e così via funzionino.
  7. Interrompi l'utilizzo dell'opzione --ssl con nodeTool

Disabilita l'autenticazione JMX per Cassandra

Per disattivare l'autenticazione JMX per Cassandra:

  1. Modifica /opt/apigee/customer/application/cassandra.properties.
  2. Rimuovi la seguente riga dal file: 
    conf_cassandra-env_com.sun.management.jmxremote.authenticate=true
  3. Esegui configurazione su Cassandra: 
    /opt/apigee/apigee-service/bin/apigee-service apigee-cassandra configure
  4. Riavvia Cassandra: 
    /opt/apigee/apigee-service/bin/apigee-service apigee-cassandra restart
  5. Ripeti questo processo su tutti gli altri nodi Cassandra.

Utilizzare 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 Cassandra JMX

JMX MBean Attributi JMX

ColonnaFamiglie/app/ambienti

ColonnaFamiglie/apprepo/organizzazioni

ColonnaFamilies/apprepo/apiproxy_revisions

ColonnaFamiglie/apprepo/apiproxie

ColonnaFamiglie/controlli/controlli

ColonnaFamilies/audit/audit_rif

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 cluster. L'utilità è disponibile all'indirizzo /opt/apigee/apigee-cassandra/bin.

Le seguenti chiamate possono essere effettuate su tutti i nodi del cluster Cassandra:

  1. Informazioni generali sulla suoneria (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 passare il nome utente e la password solo se hai attivato l'autenticazione JMX per Cassandra.

    L'output del comando precedente ha il seguente aspetto: 

    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. Informazioni generali sui nodi (chiamata per nodo) 
    nodetool [-u username -pw password]  -h localhost info

    L'output del comando riportato sopra è 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
  3. Stato del server usato (API client di pubblicazione) 
    nodetool [-u username -pw password] -h localhost statusthrift

    L'output del comando riportato sopra è simile al seguente:

    running

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

Consulta il seguente URL: http://www.datastax.com/docs/1.0/operations/monitoring.

Monitoraggio di Apache Qpid Broker-J

Puoi monitorare Qpid Broker-J dalla console di gestione di Qpid. Questa sezione spiega come accedere alla console e utilizzarla per eseguire le funzioni di monitoraggio di base. Per informazioni più dettagliate sull'utilizzo della console di gestione, vedi Console di gestione web nella documentazione di Apache Qpid.

Accedere 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 Edge. Per maggiori dettagli, consulta Riferimento ai file di configurazione di Edge.

Monitorare code e messaggi

Nel pannello di navigazione a sinistra, vai a Java-Broker > virtualhosts > code. Seleziona una coda per visualizzarne i dettagli nella parte principale dell'interfaccia utente. Nella visualizzazione dei dettagli puoi vedere le statistiche e gli attributi delle code, incluse informazioni sui messaggi recapitati, accodati, sulle tariffe dei messaggi e così via.

Visualizzare e scaricare i file di log

Nel pannello di navigazione a sinistra, vai a Java-Broker > brokerlogger > logfile. Nella visualizzazione dei dettagli dell'interfaccia utente principale, puoi visualizzare i dettagli del 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 gli strumenti a riga di comando per monitorare il broker. Ad esempio:

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

Apache ZooKeeper

Controlla lo stato di ZooKeeper

  1. Assicurati che il processo ZooKeeper sia in esecuzione. ZooKeeper scrive un file PID in opt/apigee/var/run/apigee-zookeeper/apigee-zookeeper.pid.
  2. Testa le porte ZooKeeper per assicurarti di poter stabilire una connessione TCP con le porte 2181 e 3888 su ogni server ZooKeeper.
  3. Assicurati di poter leggere i valori dal database ZooKeeper. Connettiti utilizzando una libreria client di ZooKeeper (o /opt/apigee/apigee-zookeeper/bin/zkCli.sh) e leggi un valore dal database.
  4. 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) inviati alla porta 2181 utilizzando netcat (nc) o telnet.

Per ulteriori informazioni sui comandi ZooKeeper, consulta: Riferimento per i comandi di ZooKeeper.

Ad esempio:

  • srvr: elenca i dettagli completi del server.
  • stat: elenca brevi dettagli relativi al server e ai client connessi.

Puoi inviare i seguenti comandi alla porta ZooKeeper:

  1. Esegui il comando a quattro lettere ruok 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
  2. 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
  3. Se netcat (nc) non è disponibile, puoi utilizzare Python come alternativa. Crea un file denominato zookeeper.py contenente 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 la presenza di una ricerca specifica che restituisca il risultato corretto.

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

    Viene quindi richiesta la password amministratore LDAP:

    Enter LDAP Password:

    Dopo aver inserito la password, viene visualizzata 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
  2. Controlla se il server di gestione è ancora connesso a LDAP utilizzando 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 di OpenLDAP, che aiutano a ridurre il numero di accessi al disco e, di conseguenza, a migliorare le prestazioni del sistema. Il monitoraggio e l'ottimizzazione delle dimensioni della cache nel server OpenLDAP può influire notevolmente sulle prestazioni del server di directory. Puoi visualizzare i file di log (opt/apigee/var/log) per ottenere informazioni sulla cache.