Come monitorare

Questo documento descrive le tecniche di monitoraggio dei componenti supportati da un deployment on-premise di Apigee Edge for Private Cloud.

Panoramica

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

Monitoraggio delle porte e dei file di configurazione

Ogni componente supporta le chiamate di monitoraggio JMX (Java Management Extensions) 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:

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, svolgi i passaggi riportati di seguito. Nota:nei sistemi di produzione, sia l'autenticazione criptata sia SSL devono essere abilitati per motivi di sicurezza.

1. Modifica il file di configurazione appropriato (vedi Documentazione di riferimento dei 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 valore in false. Quindi riavvia il componente Edge appropriato.

Autenticazione in JMX

Edge for Private Cloud supporta l'autenticazione basata su password utilizzando i dettagli archiviati nei file. Per una maggiore sicurezza, puoi memorizzare le password sotto forma di hash.

1. Per abilitare l'autenticazione JMX in un componente edge-*, modifica il file di configurazione appropriato (consulta la sezione Referenza 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à 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 disattivare 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-*:

1. Modifica il file di configurazione appropriato (consulta la documentazione di riferimento dei 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 keystore contenente la chiave del server e posizionalo nel percorso specificato nella configurazione conf_system_javax_net_ssl_keystore sopra. Assicurati che il file del keystore sia leggibile da apigee:apigee.
3. Riavvia il componente Edge appropriato:

   apigee-service edge-management-server restart

Per disattivare 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 invariate come descritto in https://docs.apigee.com/private-cloud/v4.52.01/how-monitor#jconsole.

Monitoraggio 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 tuoi server e visualizzarle in un'interfaccia grafica. Per ulteriori informazioni, consulta Utilizzare JConsole.

Devi avviare JConsole con il truststore e la password del truststore se SSL è abilitato per JMX. Vedi Utilizzare 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 che vuoi monitorare.

Ad esempio, per monitorare il server di gestione, esegui un comando come il 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 del server di gestione. Per altre porte, consulta Porte di monitoraggio JMX e API di gestione.

La tabella seguente mostra le statistiche JMX generiche:

Riferimento al file di configurazione

Le sezioni seguenti descrivono le modifiche che potresti dover apportare ai file di configurazione dei componenti Edge per le configurazioni JMX. Per ulteriori informazioni, consulta Porte e file di configurazione di monitoraggio.

la configurazione JMX da aggiungere al file di configurazione del componente appropriato.

• Attiva l'agente JMX nel componente edge. False 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 del file di accesso. 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 della 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 della password in formato criptato. False per impostazione predefinita.

  conf_system_jmxremote_encrypted_auth=true

Configurazioni per JMX basata su SSL

• Attiva SSL per la comunicazione JMX. False 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 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 registry 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 tuoi server, nonché per controllare gli utenti, le organizzazioni e le implementazioni. Questa sezione descrive queste 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:

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

curl: Failed connect to localhost:port_number; Connection refused

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, nonché il nome utente e la password.
• port_number è la porta dell'API di gestione per il 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 di utenti, organizzazioni e 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: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 il nome utente e la password di amministrazione del sistema.

Il server deve restituire uno stato "implementato" per tutte le chiamate. Se questi passaggi non risolvono il problema, procedi nel seguente modo:

1. Verifica la presenza di eventuali errori nei log del server. I log si trovano all'indirizzo:
   • Server di gestione: opt/apigee/var/log/edge-management-server
   • Processore di messaggi: opt/apigee/var/log/edge-message-processor
2. Esegui una chiamata al server per verificare se funziona correttamente.
3. Rimuovi il server dall'ELB e riavvialo:

   /opt/apigee/apigee-service/bin/apigee-service service_name restart

   Dove service_name è:

   • edge-management-server
   • edge-message-processor

Controlla lo stato con il comando apigee-service

Puoi risolvere i problemi relativi ai servizi Edge utilizzando il comando apigee-service dopo aver eseguito l'accesso al server su cui è in esecuzione il servizio.

Per controllare lo stato di un servizio con apigee-service:

1. Accedi al server ed esegui il seguente comando:

   /opt/apigee/apigee-service/bin/apigee-service service_name status

   dove service_name è uno dei seguenti valori:

   • 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

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 Management descritta in Monitorare con l'API Management.

   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 Management, devi specificare l'indirizzo IP del server e includere il nome utente e la password dell'amministratore di sistema nella chiamata dell'API.

Monitoraggio di Postgres

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

Controllare organizzazioni e ambienti su Postgres

Puoi controllare i nomi di organizzazioni e ambienti di cui è stato eseguito l'onboarding sul server Postgres eseguendo il seguente comando curl:

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

Il sistema deve mostrare 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 emettendo il seguente curl comando:

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 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 specificamente per il monitoraggio del database Postgres.

Utilizzare 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:

1. Devi installare lo script check_postgres.pl su ogni nodo Postgres.
2. Assicurati di aver installato perl-Time-HiRes.x86_64, un modulo Perl che implementa timer di sveglia, di sospensione, gettimeofday e intervalli ad alta risoluzione. 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 7, installa il pacchetto RPM perl-Data-Dumper.x86_64.

Output di 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:

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 confrontalo con 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 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 le tabelle appropriate siano create nel database PostgreSQL. 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 controlli dell'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, viene restituito 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.

Attivare l'autenticazione JMX per Cassandra

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

Per attivare 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, creane uno.
   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 mostrato 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.

2. Creare e modificare jmx_auth.sh:
   1. Se non esiste, crea un file nella seguente posizione:

      /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 in /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 tuo nome utente e la tua 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à del 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.

Attiva la crittografia delle password JMX

Per attivare la crittografia delle password JMX:

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, creane uno.
   2. Aggiungi quanto segue al file:

      conf_cassandra_env_com.sun.management.jmxremote.encrypted.authenticate=true

   3. Salva il file cassandra.properties.
   4. Modifica 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 per il nome utente in $APIGEE_ROOT/customer/application/apigee-cassandra/jmxremote.password (creato nella sezione precedente).
5. Esegui la 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 questa procedura su tutti gli altri nodi Cassandra.

Attivare JMX con SSL per Cassandra

L'attivazione di JMX con SSL offre sicurezza e crittografia aggiuntive per la comunicazione basata su JMX con Cassandra. Per attivare JMX con SSL, devi fornire una chiave e un certificato a Cassandra per accettare le connessioni JMX basate su SSL. Devi anche configurare nodetool (e qualsiasi altro strumento che comunichi con Cassandra tramite JMX) per SSL.

JMX con SSL abilitato supporta le password JMX sia in testo normale che criptate.

Per attivare JMX con SSL per Cassandra, segui la procedura riportata di seguito:

1. Abilita JMX. Se necessario, attiva la crittografia della password.
2. Abilita 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. Prepara l'archivio chiavi e l'archivio attendibile.

   • Il keystore deve contenere una chiave e un certificato e viene utilizzato per configurare il server Cassandra. Se il keystore contiene più coppie di chiavi, Cassandra utilizza la prima coppia di chiavi per attivare 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 precedenti:

   1. Inserisci il file del keystore in /opt/apigee/customer/application/apigee-cassandra/.
   2. Assicurati che il file del keystore 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, segui questi passaggi:
   1. Interrompi il nodo Cassandra inserendo

      apigee-service apigee-cassandra stop

   2. 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
      ## On FIPS enabled systems, when you are using non standard keystore, set the following:
      ## These can be skipped otherwise
      ## Possible values are JKS, PKCS12, BCFKS
      conf_cassandra_env_javax.net.ssl.keyStoreType=PKCS12
      conf_cassandra_env_javax.net.ssl.keyStoreAlias=cassjmx-tls-alias

   3. Modifica il proprietario del file in apigee:apigee, come mostrato nell'esempio seguente:

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

   4. Esegui la 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 apigee-service Cassandra. Devi impostare alcune variabili di ambiente durante l'esecuzione dei comandi apigee-service, tra cui 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

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

   • Opzione 1 (argomenti SSL memorizzati in un file)
   • Opzione 2 (argomenti SSL memorizzati nelle variabili di ambiente)
   • Opzione 3 (argomenti SSL passati direttamente a apigee-service)

   Opzione 1 (argomenti SSL memorizzati in un 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=
   -Djavax.net.ssl.trustStorePassword=
   -Dcom.sun.management.jmxremote.registry.ssl=true
   ## If you are using a non standard truststore, set below, otherwise skip
   ## Possible values are JKS, PKCS12, BCFKS
   -Djavax.net.ssl.trustStoreType=PKCS12

   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=
   export CASS_JMX_TRUSTSTORE_PASSWORD=
   # If you are using a non standard truststore type, export truststore type as well
   # Possible values are JKS, PKCS12, BCFKS
   export CASS_JMX_TRUSTSTORE_TYPE=PKCS12

   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 alcuna variabile di ambiente.

   CASS_JMX_USERNAME=ADMIN CASS_JMX_PASSWORD=PASSWORD CASS_JMX_SSL=Y CASS_JMX_TRUSTSTORE= CASS_JMX_TRUSTSTORE_PASSWORD= CASS_JMX_TRUSTSTORE_TYPE=PKCS12 /opt/apigee/apigee-service/bin/apigee-service apigee-cassandra ring

6. 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:

   • Opzione di configurazione 1
   • Opzione di configurazione 2

   Le opzioni differiscono per il 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 del truststore. Scegliere un'opzione appropriata in base all'usabilità e alle prassi di sicurezza.

   Per scoprire di più sui parametri di 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=
   -Djavax.net.ssl.trustStorePassword=
   -Dcom.sun.management.jmxremote.registry.ssl=true
   ## If you are using a non standard truststore, set below, otherwise skip
   ## Possible values are JKS, PKCS12, BCFKS
   -Djavax.net.ssl.trustStoreType=PKCS12

   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= -Djavax.net.ssl.trustStorePassword= -Dcom.sun.management.jmxremote.registry.ssl=true -Djavax.net.ssl.trustStoreType=PKCS12 -Dssl.enable=true -u  -pw  -h localhost ring

Ripristinare le configurazioni SSL

Se devi ripristinare le configurazioni SSL descritte nella procedura precedente, segui questi passaggi:

1. Interrompi apigee-cassandra inserendo

   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

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

Disattivare 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 nel file:

   conf_cassandra-env_com.sun.management.jmxremote.authenticate=true

3. Esegui la 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 questa procedura 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 di Cassandra

Usa nodetool per gestire i nodi del cluster

L'utilità nodetool è un'interfaccia a riga di comando per Cassandra che gestisce i nodi del cluster. L'utilità è disponibile all'indirizzo /opt/apigee/apigee-cassandra/bin.

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

1. Informazioni generali sull'anello (possibile anche per un singolo nodo Cassandra): cerca "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 riportato sopra è il 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

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

3. Stato del server Thrift (che serve l'API client)

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

   L'output del comando riportato sopra è il 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 è il 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 ulteriori 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 di Apache Qpid Broker-J

Puoi monitorare Qpid Broker-J dalla console di gestione Qpid. Questa sezione spiega come accedere alla console e 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.

Accedere alla console di gestione

La porta predefinita della console di gestione è 8090. Per accedere alla console su questa porta predefinita, imposta 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_queue. Seleziona una coda per visualizzarne i dettagli nella parte principale dell'interfaccia utente. 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 i file di log

Nel riquadro di navigazione a sinistra, vai a Java-Broker > brokerloggers > logfile. 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 di gestione Qpid

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 dell'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"

Attivare 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 File Keystore, abilitato in Apigee. Questo tipo accetta il formato JKS standard compreso da Java e dagli strumenti Java come keytool.

Preparazione dell'archivio chiavi

Oltre a utilizzare keytool, devi fornire il file del certificato direttamente per l'utilizzo da parte dei client di Qpidd.

Per la generazione di archivi chiavi, consulta la documentazione di Java Keytool.

Dopo aver verificato i requisiti

1. Inserisci i file del keystore e del certificato in /opt/apigee/customer/application/apigee-qpidd.
2. Assicurati che il file del keystore 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

Attivare SSL in Qpid

Esegui i passaggi riportati di seguito 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

1. Modifica il proprietario del file in apigee:apigee:

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

2. Configura Qpidd:

   apigee-service apigee-qpidd configure

3. Riavvia Qpidd:

   apigee-service apigee-qpidd restart

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

1. Configura Qpidd:

   apigee-service apigee-qpidd configure

2. Riavvia Qpidd:

   apigee-service apigee-qpidd restart

3. Controlla lo stato con wait_for_ready:

   apigee-service apigee-qpidd wait_for_ready

Apache ZooKeeper

Controllare 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 alle 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

Utilizza 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 Apache ZooKeeper.

Ad esempio:

• srvr: elenca i dettagli completi del server.
• stat: elenca brevi dettagli sul server e sui client collegati.

I seguenti comandi possono essere emessi alla porta ZooKeeper:

1. Esegui il comando ruok di quattro lettere per verificare se il server è in esecuzione in uno stato diverso da errore. Una risposta positiva restituisce "imok".

   echo ruok | nc host 2181

   Restituisce:

   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

   Restituisce:

   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 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 righe di Python:

   python zookeeper.py 192.168.124.201 ruok
   python zookeeper.py 192.168.124.201 stat

Test di livello LDAP

Puoi monitorare OpenLDAP per verificare se le richieste specifiche vengono eseguite correttamente. In altre parole, verifica se esiste una ricerca specifica che restituisca il risultato corretto.

1. Utilizza ldapsearch (yum install openldap-clients) per eseguire 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 chiesta la password di amministrazione 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 con il seguente comando:

   curl -u userEMail:password http://localhost:8080/v1/users/ADMIN

   Restituisce:

   {
     "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 della dimensione 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.