Cómo supervisar

En este documento, se describen las técnicas de supervisión de los componentes que admite una implementación local de Apigee Edge para nube privada.

Descripción general

Edge admite varias formas de obtener detalles sobre los servicios y verificar sus estados. En la siguiente tabla, se enumeran los tipos de verificaciones que puedes realizar en cada servicio elegible:

API de administración
Componente Uso de memoria [JMX*] Verificación de servicio Estado del usuario, la organización o la implementación axstatus Verificación de la base de datos Estado de apigee-service apigee-monit**
Servidor de administración
Message Processor
Router
Qpid
Postgres
Más información Más información Más información Más información Más información Más información Más información

* Antes de poder usar JMX, debes habilitarlo, como se describe en Habilita JMX.

** El servicio apigee-monit verifica si un componente está activo y, si no lo está, intentará reiniciarlo. Para obtener más información, consulta Recuperación automática con apigee-monit.

Supervisa puertos y archivos de configuración

Cada componente admite las extensiones de administración de Java (JMX) y las llamadas de supervisión de API de Management en diferentes puertos. En la siguiente tabla, se enumeran los puertos de la API de JMX y de administración para cada tipo de servidor y las ubicaciones de los archivos de configuración:

Componente Puerto de JMX Puerto de la API de administración Ubicación del archivo de configuración
Servidor de administración 1099 8080 $APIGEE_ROOT/customer/application/management-server.properties
Message Processor 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

Usa JMX para supervisar componentes

En las siguientes secciones, se explica cómo usar JMX para supervisar los componentes de Edge.

Habilita JMX

Para habilitar JMX sin autenticación ni comunicación basada en SSL, sigue los pasos que se indican a continuación. Nota: En los sistemas de producción, tanto la autenticación encriptada como SSL deben estar habilitadas para la seguridad.

  1. Edita el archivo de configuración adecuado (consulta la referencia del archivo de configuración). Crea el archivo de configuración si no existe. 
    conf_system_jmxremote_enable=true
  2. Guarda el archivo de configuración y asegúrate de que sea propiedad de apigee:apigee.
  3. Reinicia el componente de Edge adecuado 
    apigee-service edge-management-server restart

Para inhabilitar JMX, quita la propiedad conf_system_jmxremote_enable o cambia su valor a false. Luego, reinicia el componente de Edge adecuado.

Autenticación en JMX

Edge para nube privada admite la autenticación basada en contraseñas con los detalles almacenados en archivos. Puedes almacenar contraseñas como un hash para mayor seguridad.

  1. Para habilitar la autenticación de JMX en un componente edge-*, edita el archivo de configuración adecuado (consulta la referencia del archivo de configuración). Crea el archivo de configuración si no existe: 
    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
     Guarda el archivo de configuración y asegúrate de que sea propiedad de apigee:apigee.
  2. Crea un hash SHA256 de la contraseña: 
    echo -n '' | openssl dgst -sha256
  3. Crea un archivo jmxremote.password con las credenciales de usuario de JMX:
    1. Copia los siguientes archivos de tu directorio $JAVA_HOME al directorio /opt/apigee/customer/application/<component>/: 
      cp ${JAVA_HOME}/lib/management/jmxremote.password.template $APIGEE_ROOT/customer/application/management-server/jmxremote.password
    2. Edita el archivo y agrega tu nombre de usuario y contraseña de JMX con la siguiente sintaxis: 
      USERNAME <HASH-PASSWORD>
    3. Asegúrate de que el archivo pertenezca a apigee y de que el modo de archivo sea 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 archivo jmxremote.access con permisos de usuario de JMX:
    1. Copia los siguientes archivos de tu directorio $JAVA_HOME al directorio /opt/apigee/customer/application/<component>/ 
      
cp ${JAVA_HOME}/lib/management/jmxremote.access$APIGEE_ROOT/customer/application/management-server/jmxremote.password/jmxremote.access
    2. Edita el archivo y agrega tu nombre de usuario de JMX seguido de un permiso (READONLY/READWRITE). 
      USERNAME READONLY
    3. Asegúrate de que el archivo pertenezca a apigee y de que el modo de archivo sea 400: 
      chown apigee:apigee $APIGEE_ROOT/customer/application/management-server/jmxremote.password

chmod 400 $APIGEE_ROOT/customer/application/management-server/jmxremote.access
  5. Reinicia el componente de Edge adecuado: 
    apigee-service edge-management-server restart

Para inhabilitar la autenticación de JMX, quita la propiedad conf_system_jmxremote_authenticate o cambia el valor a false y reinicia el componente de Edge correspondiente.

SSL en JMX

Para habilitar JMX basado en SSL en un componente edge-*, haz lo siguiente:

  1. Edita el archivo de configuración adecuado (consulta la referencia del archivo de configuración). Crea el archivo de configuración si no existe: 
    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>
     Guarda el archivo de configuración y asegúrate de que sea propiedad de apigee:apigee.
  2. Prepara un almacén de claves que contenga la clave del servidor y colócalo en la ruta de acceso proporcionada en la configuración conf_system_javax_net_ssl_keystore anterior. Asegúrate de que apigee:apigee pueda leer el archivo del almacén de claves.
  3. Reinicia el componente de Edge adecuado: 
    apigee-service edge-management-server restart

Para inhabilitar JMX basado en SSL, quita la propiedad conf_system_jmxremote_ssl o cambia el valor a false. Reinicia el componente de Edge correspondiente.

Supervisión a través de Jconsole

Las instrucciones de supervisión a través de jconsole siguen siendo las mismas que se describen en https://docs.apigee.com/private-cloud/v4.50.00/how-monitor#jconsole.

Se puede agregar una línea que indique que “jconsole deberá iniciarse con el almacén de certificados de confianza y la contraseña del almacén de certificados de confianza si SSL está habilitado para JMX”. Referencia: https://docs.oracle.com/javase/8/docs/technotes/guides/management/jconsole.html

Supervisa con JConsole

Usa JConsole (una herramienta compatible con JMX) para administrar y supervisar las estadísticas de procesos y verificaciones de estado. Con JConsole, puedes consumir las estadísticas de JMX que exponen tus servidores y mostrarlas en una interfaz gráfica. Para obtener más información, consulta Usa JConsole.

Si SSL está habilitado para JMX, debes iniciar JConsole con el almacén de certificados de confianza y su contraseña. Consulta Cómo usar JConsole.

JConsole usa la siguiente URL de servicio para supervisar los atributos de JMX (MBeans) que se ofrecen a través de JMX:

service:jmx:rmi:///jndi/rmi://IP_address:port_number/jmxrmi

Donde:

  • IP_address es la dirección IP del servidor que quieres supervisar.
  • port_number es el número de puerto de JMX del servidor que deseas supervisar.

Por ejemplo, para supervisar el servidor de administración, emite un comando como el siguiente (suponiendo que la dirección IP del servidor es 216.3.128.12):

service:jmx:rmi:///jndi/rmi://216.3.128.12:1099/jmxrmi

Ten en cuenta que, en este ejemplo, se especifica el puerto 1099, que es el puerto JMX del servidor de administración. Para conocer otros puertos, consulta Puertos de supervisión de JMX y de la API de Management.

En la siguiente tabla, se muestran las estadísticas genéricas de JMX:

MBeans de JMX Atributos de JMX

Memoria

HeapMemoryUsage

NonHeapMemoryUsage

Uso

Referencia del archivo de configuración

En las siguientes secciones, se describen los cambios que tal vez debas realizar en los archivos de configuración de los componentes de Edge para las configuraciones relacionadas con JMX. Consulta Puertos de supervisión y archivos de configuración para obtener más información.

Configuración de JMX que se agregará al archivo de configuración del componente correspondiente

  • Habilita el agente de JMX en el componente de Edge. Es falso de forma predeterminada. 
    conf_system_jmxremote_enable=true

Parámetros de configuración para la autenticación basada en contraseñas

  • Habilitar la autenticación basada en contraseñas Es falso de forma predeterminada. 
    conf_system_jmxremote_authenticate=true
  • Ruta de acceso al archivo. Solo el usuario de Apigee debe ser el propietario y poder leerlo. 
    conf_system_jmxremote_access_file=/opt/apigee/customer/application/management-server/jmxremote.access
  • Es la ruta de acceso al archivo de contraseña. Solo el usuario de Apigee debe ser el propietario y poder leerlo. 
    conf_system_jmxremote_password_file=/opt/apigee/customer/application/management-server/jmxremote.password
  • Habilita el almacenamiento de contraseñas en formato encriptado. Es falso de forma predeterminada. 
    conf_system_jmxremote_encrypted_auth=true

Parámetros de configuración para JMX basado en SSL

  • Habilita SSL para la comunicación de JMX. Es falso de forma predeterminada. 
    conf_system_jmxremote_ssl=true
  • Es la ruta de acceso al almacén de claves. Solo el usuario de Apigee debe ser el propietario y poder leerlo. 
    conf_system_javax_net_ssl_keystore=/opt/apigee/customer/application/management-server/jmxremote.keystore
  • Contraseña del almacén de claves: 
    conf_system_javax_net_ssl_keystorepassword=changeme

Parámetros de configuración opcionales de JMX

Los valores que se indican son los predeterminados y se pueden cambiar.

  • Puerto de JMX. Los valores predeterminados se indican en la siguiente tabla. 
    conf_system_jmxremote_port=
  • Puerto de JMX RMI. De forma predeterminada, el proceso de Java elegirá un puerto aleatorio. 
    conf_system_jmxremote_rmi_port=
  • Es el nombre de host de los stubs remotos. Dirección IP predeterminada de localhost. 
    conf_system_java_rmi_server_hostname=
  • Protege el registro de JMX con SSL. El valor predeterminado es falso. Solo se aplica si SSL está habilitado. 
    conf_system_jmxremote_registry_ssl=false

Supervisa con la API de Management

Edge incluye varias APIs que puedes usar para realizar verificaciones de servicio en tus servidores, así como verificar tus usuarios, organizaciones e implementaciones. En esta sección, se describen estas APIs.

Realiza verificaciones del servicio

La API de Management proporciona varios extremos para supervisar y diagnosticar problemas con tus servicios. Estos extremos incluyen lo siguiente:

Extremo Descripción
/servers/self/up

Comprueba si se está ejecutando un servicio. Esta llamada a la API no requiere que te autentiques.

Si el servicio se está ejecutando, este extremo devuelve la siguiente respuesta:

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

Si el servicio no se está ejecutando, obtendrás una respuesta similar a la siguiente (según el servicio y cómo lo verificaste):

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

Muestra información sobre el servicio, como la siguiente:

  • Propiedades de configuración
  • Hora de inicio y tiempo de actividad
  • Información de compilación, RPM y UUID
  • Nombre de host y dirección IP internos y externos
  • Región y pod
  • Propiedad <isUp>, que indica si el servicio se está ejecutando

Esta llamada a la API requiere que te autentiques con tus credenciales de administrador de Apigee.

Para usar estos extremos, invoca una utilidad como curl con comandos que usen la siguiente sintaxis:

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]"

Donde:

  • host es la dirección IP del servidor que deseas verificar. Si accediste al servidor, puedes usar "localhost"; de lo contrario, especifica la dirección IP del servidor, así como el nombre de usuario y la contraseña.
  • port_number es el puerto de la API de Management para el servidor que deseas verificar. Este es un puerto diferente para cada tipo de componente. Por ejemplo, el puerto de la API de Management del servidor de administración es 8080. Para obtener una lista de los números de puerto de la API de Management que se usarán, consulta Puertos de supervisión de JMX y de la API de Management.

Para cambiar el formato de la respuesta, puedes especificar el encabezado Accept como "application/json" o "application/xml".

En el siguiente ejemplo, se obtiene el estado del router en localhost (puerto 8081):

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

En el siguiente ejemplo, se obtiene información sobre el Message Processor en 216.3.128.12 (puerto 8082):

curl http://216.3.128.12:8082/v1/servers/self -u sysAdminEmail:password
  -H "Accept: application/xml"

Supervisa el estado de los usuarios, la organización y la implementación

Puedes usar la API de Management para supervisar el estado de los usuarios, las organizaciones y las implementaciones de tus proxies en los servidores de administración y los Message Processors con los siguientes comandos:

curl http://host:port_number/v1/users -u sysAdminEmail:password
curl http://host:port_number/v1/organizations -u sysAdminEmail:password
curl http://host:port_number/v1/organizations/orgname/deployments -u sysAdminEmail:password

En el ejemplo anterior, port_number es 8080 para el servidor de administración o 8082 para el Message Processor.

Esta llamada requiere que te autentiques con tu nombre de usuario y contraseña de administración del sistema.

El servidor debería devolver un estado "implementado" para todas las llamadas. Si estos fallan, haz lo siguiente:

  1. Revisa los registros del servidor para buscar errores. Los registros se encuentran en la siguiente ubicación:
    • Servidor de administración: opt/apigee/var/log/edge-management-server
    • Message Processor: opt/apigee/var/log/edge-message-processor
  2. Realiza una llamada al servidor para verificar si funciona correctamente.
  3. Quita el servidor del ELB y, luego, reinícialo: 
    /opt/apigee/apigee-service/bin/apigee-service service_name restart

    En el ejemplo anterior, service_name es:

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

Verifica el estado con el comando apigee-service

Puedes solucionar problemas de tus servicios de Edge con el comando apigee-service cuando accedes al servidor que ejecuta el servicio.

Para verificar el estado de un servicio con apigee-service, haz lo siguiente:

  1. Accede al servidor y ejecuta el siguiente comando: 
    /opt/apigee/apigee-service/bin/apigee-service service_name status

    En el ejemplo anterior, service_name es una de las siguientes opciones:

    • Servidor de administración: edge-management-server
    • Message Processor: edge-message-processor
    • Postgres: edge-postgres-server
    • Qpid: edge-qpid-server
    • Router: edge-router

    Por ejemplo:

    /opt/apigee/apigee-service/bin/apigee-service edge-message-processor status
  2. Si el servicio no se está ejecutando, inícialo: 
    /opt/apigee/apigee-service/bin/apigee-service service_name start
  3. Después de reiniciar el servicio, verifica que funcione, ya sea con el comando apigee-service status que usaste antes o con la API de Management que se describe en Supervisa con la API de Management.

    Por ejemplo:

    curl -v http://localhost:port_number/v1/servers/self/up

    Donde port_number es el puerto de la API de administración para el servicio.

    En este ejemplo, se supone que accediste al servidor y que puedes usar "localhost" como nombre de host. Para verificar el estado de forma remota con la API de Management, debes especificar la dirección IP del servidor y, además, incluir el nombre de usuario y la contraseña del administrador del sistema en la llamada a la API.

Supervisión de Postgres

Postgres admite varias utilidades que puedes usar para verificar su estado. Estas utilidades se describen en las siguientes secciones.

Verifica las organizaciones y los entornos en Postgres

Puedes verificar los nombres de la organización y del entorno que se incorporaron en el servidor de Postgres emitiendo el siguiente comando curl:

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

El sistema debería mostrar el nombre de la organización y del entorno.

Verifica el estado de las estadísticas

Puedes verificar el estado de los servidores de estadísticas de Postgres y Qpid con el siguiente comando de curl:

curl -u userEmail:password http://host:port_number/v1/organizations/orgname/environments/envname/provisioning/axstatus

El sistema debería mostrar un estado de éxito para todos los servidores de estadísticas, como se muestra en el siguiente ejemplo:

{
  "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"
}

Base de datos de PostgreSQL

En esta sección, se describen las técnicas que puedes usar específicamente para supervisar la base de datos de Postgres.

Usa la secuencia de comandos check_postgres.pl

Para supervisar la base de datos de PostgreSQL, puedes usar una secuencia de comandos de supervisión estándar, check_postgres.pl. Para obtener más información, consulta http://bucardo.org/wiki/Check_postgres.

Antes de ejecutar la secuencia de comandos, haz lo siguiente:

  1. Debes instalar la secuencia de comandos check_postgres.pl en cada nodo de Postgres.
  2. Asegúrate de haber instalado perl-Time-HiRes.x86_64, un módulo de Perl que implementa alarmas de alta resolución, suspensión, gettimeofday y temporizadores de intervalos. Por ejemplo, puedes instalarlo con el siguiente comando:
    yum install perl-Time-HiRes.x86_64
  3. CentOS 7: Antes de usar check_postgres.pl en CentOS v7, instala el RPM perl-Data-Dumper.x86_64.

Resultado de check_postgres.pl

El resultado predeterminado de las llamadas a la API con check_postgres.pl es compatible con Nagios. Después de instalar la secuencia de comandos, realiza las siguientes verificaciones:

  1. Verifica el tamaño de la base de datos: 
    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. Verifica la cantidad de conexiones entrantes a la base de datos y compárala con la cantidad máxima de conexiones permitidas: 
    check_postgres.pl -H 10.176.218.202 -db apigee -u apigee -dbpass postgres -action backends
  3. Verifica si la base de datos está en ejecución y disponible: 
    check_postgres.pl -H 10.176.218.202 -db apigee -u apigee -dbpass postgres -action connection
  4. Verifica el espacio en el disco: 
    check_postgres.pl -H 10.176.218.202 -db apigee -u apigee -dbpass postgres -action disk_space --warning='80%' --critical='90%'
  5. Verifica la cantidad de organizaciones y entornos incorporados en un nodo de 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

Ejecuta verificaciones de la base de datos

Puedes verificar que se creen las tablas adecuadas en la base de datos de PostgreSQL. Accede a la base de datos de PostgreSQL con el siguiente comando:

psql -h /opt/apigee/var/run/apigee-postgresql/ -U apigee -d apigee

Luego, ejecute lo siguiente:

\d analytics."org.env.fact"

Verifica el estado del proceso de Postgres

Puedes realizar verificaciones de la API en la máquina de Postgres invocando el siguiente comando de curl:

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

Este comando devuelve el estado ACTIVE cuando el proceso de postgres está activo. Si el proceso de Postgres no está en funcionamiento, se devuelve el estado INACTIVE.

Recursos de Postgres

Para obtener información adicional sobre la supervisión del servicio de Postgres, consulta lo siguiente:

Apache Cassandra

JMX está habilitado de forma predeterminada para Cassandra, y el acceso remoto de JMX a Cassandra no requiere una contraseña.

Habilita la autenticación de JMX para Cassandra

Puedes habilitar la autenticación de JMX para Cassandra. Después de hacerlo, se te pedirá que pases un nombre de usuario y una contraseña a todas las llamadas a la utilidad nodetool.

Para habilitar la autenticación de JMX para Cassandra, sigue estos pasos:

  1. Crea y edita el archivo cassandra.properties:
    1. Edita el archivo /opt/apigee/customer/application/cassandra.properties. Si el archivo no existe, créalo.
    2. Agrega lo siguiente al archivo. 
      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. Guarda el archivo cassandra.properties.
    4. Cambia el propietario del archivo a apigee:apigee, como se muestra en el siguiente ejemplo: 
      chown apigee:apigee /opt/apigee/customer/application/cassandra.properties

    Para obtener más información sobre el uso de archivos de propiedades para configurar tokens, consulta Cómo configurar Edge.

  2. Crea y edita jmx_auth.sh:
    1. Crea un archivo en la siguiente ubicación si no existe: 
      /opt/apigee/customer/application/jmx_auth.sh
    2. Agrega las siguientes propiedades al archivo: 
      export CASS_JMX_USERNAME=JMX_USERNAME
export CASS_JMX_PASSWORD=JMX_PASSWORD
    3. Guarda el archivo jmx_auth.sh.
    4. Carga el archivo: 
      source /opt/apigee/customer/application/jmx_auth.sh
  3. Copia y edita el archivo jmxremote.password:
    1. Copia el siguiente archivo de tu directorio $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. Edita el archivo jmxremote.password y agrega tu nombre de usuario y contraseña de JMX con la siguiente sintaxis: 
      JMX_USERNAME JMX_PASSWORD

      Donde JMX_USERNAME y JMX_PASSWORD son el nombre de usuario y la contraseña de JMX que configuraste anteriormente.

    3. Asegúrate de que el archivo sea propiedad de "apigee" y de que el modo de archivo sea 400: 
      chown apigee:apigee /opt/apigee/customer/application/apigee-cassandra/jmxremote.password
chmod 400 /opt/apigee/customer/application/apigee-cassandra/jmxremote.password
  4. Copia y edita el archivo jmxremote.access:
    1. Copia el siguiente archivo de tu directorio $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. Edita el archivo jmxremote.access y agrega el siguiente rol: 
      JMX_USERNAME readwrite
    3. Asegúrate de que el archivo sea propiedad de "apigee" y de que el modo de archivo sea 400: 
      chown apigee:apigee /opt/apigee/customer/application/apigee-cassandra/jmxremote.access
chmod 400 /opt/apigee/customer/application/apigee-cassandra/jmxremote.access
  5. Ejecuta configure en Cassandra: 
    /opt/apigee/apigee-service/bin/apigee-service apigee-cassandra configure
  6. Reinicia Cassandra: 
    /opt/apigee/apigee-service/bin/apigee-service apigee-cassandra restart
  7. Repite este proceso en todos los demás nodos de Cassandra.

Habilita la encriptación de contraseñas de JMX

Para habilitar la encriptación de contraseñas de JMX, sigue estos pasos:

  1. Abre el archivo source/conf/casssandra-env.sh.
  2. Crea y edita el archivo cassandra.properties:
    1. Edita el archivo /opt/apigee/customer/application/cassandra.properties. Si el archivo no existe, créalo.
    2. Agrega lo siguiente al archivo. 
      conf_cassandra_env_com.sun.management.jmxremote.encrypted.authenticate=true
    3. Guarda el archivo cassandra.properties.
    4. Cambia el propietario del archivo a apigee:apigee, como se muestra en el siguiente ejemplo: 
      chown apigee:apigee /opt/apigee/customer/application/cassandra.properties
  3. En la línea de comandos, genera los hashes SHA1 de las contraseñas deseadas ingresando echo -n 'Secret' | openssl dgst -sha1
  4. Establece las contraseñas para el nombre de usuario en $APIGEE_ROOT/customer/application/apigee-cassandra/jmxremote.password (creado en la sección anterior).
  5. Ejecuta configure en Cassandra: 
    /opt/apigee/apigee-service/bin/apigee-service apigee-cassandra configure
  6. Reinicia Cassandra: 
    /opt/apigee/apigee-service/bin/apigee-service apigee-cassandra restart
  7. Repite este proceso en todos los demás nodos de Cassandra.

Habilita JMX con SSL para Cassandra

Habilitar JMX con SSL proporciona seguridad y encriptación adicionales para la comunicación basada en JMX con Cassandra. Para habilitar JMX con SSL, debes proporcionar una clave y un certificado a Cassandra para aceptar conexiones de JMX basadas en SSL. También debes configurar nodetool (y cualquier otra herramienta que se comunique con Cassandra a través de JMX) para SSL.

JMX habilitado para SSL admite contraseñas de JMX en texto simple y encriptadas.

Para habilitar JMX con SSL para Cassandra, usa el siguiente procedimiento:

  1. Habilita JMX. Habilita la encriptación de contraseñas si es necesario.
  2. Habilita la autenticación de JMX para Cassandra. como se describió anteriormente. Asegúrate de que nodetool funcione con el nombre de usuario y la contraseña configurados. 
    /opt/apigee/apigee-cassandra/bin/nodetool -u <JMX_USER> -pw <JMX_PASS> ring

  3. Prepara el almacén de claves y el almacén de certificados de confianza.

    • El almacén de claves debe contener una clave y un certificado, y se usa para configurar el servidor de Cassandra. Si el almacén de claves contiene varios pares de claves, Cassandra usa el primer par de claves para habilitar SSL.

      Ten en cuenta que las contraseñas del almacén de claves y de la clave deben ser las mismas (el valor predeterminado cuando generas la clave con keytool).

    • El almacén de certificados de confianza debe contener solo el certificado y lo usan los clientes (comandos basados en apigee-service o nodetool) para conectarse a través de JMX.

    Después de verificar los requisitos anteriores, haz lo siguiente:

    1. Coloca el archivo del almacén de claves en /opt/apigee/customer/application/apigee-cassandra/.
    2. Asegúrate de que solo el usuario de Apigee pueda leer el archivo del almacén de claves ingresando lo siguiente: 
      chown apigee:apigee /opt/apigee/customer/application/apigee-cassandra/keystore.node1
chmod 400 /opt/apigee/customer/application/apigee-cassandra/keystore.node1
  4. Configura Cassandra para JMX con SSL siguiendo estos pasos:
    1. Ingresa lo siguiente para detener el nodo de Cassandra: 
      apigee-service apigee-cassandra stop
    2. Para habilitar SSL en Cassandra, abre el archivo /opt/apigee/customer/application/cassandra.properties y agrega las siguientes líneas: 
      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 el propietario del archivo a apigee:apigee, como se muestra en el siguiente ejemplo: 
      chown apigee:apigee /opt/apigee/customer/application/cassandra.properties
    4. Ejecuta configure en Cassandra: 
      /opt/apigee/apigee-service/bin/apigee-service apigee-cassandra configure
    5. Reinicia Cassandra: 
      /opt/apigee/apigee-service/bin/apigee-service apigee-cassandra restart
    6. Repite este proceso en todos los demás nodos de Cassandra.
    7. Inicia el nodo de Cassandra ingresando lo siguiente: 
      apigee-service apigee-cassandra start
  5. Configura los comandos de Cassandra de apigee-service. Debes configurar ciertas variables de entorno mientras ejecutas los comandos de apigee-service, incluidos los siguientes: 
    apigee-service apigee-cassandra stop
apigee-service apigee-cassandra wait_for_ready
apigee-service apigee-cassandra ring
apigee-service apigee-cassandra backup

    Existen varias opciones para configurar apigee-service para la autenticación de JMX y SSL. Elige una opción según la usabilidad y tus prácticas de seguridad.

    Opción 1 (argumentos de SSL almacenados en un archivo)

    Configura las siguientes variables de entorno:

    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 archivo en el directorio principal del usuario de Apigee (/opt/apigee). 

    $HOME/.cassandra/nodetool-ssl.properties

    Edita el archivo y agrega las siguientes líneas:

    -Djavax.net.ssl.trustStore=<path-to-truststore.node1>
-Djavax.net.ssl.trustStorePassword=<truststore-password>
-Dcom.sun.management.jmxremote.registry.ssl=true

    Asegúrate de que el usuario de Apigee pueda leer el archivo del almacén de confianza.

    Ejecuta el siguiente comando apigee-service: Si se ejecuta sin errores, tus parámetros de configuración son correctos.

    apigee-service apigee-cassandra ring

    Opción 2 (argumentos de SSL almacenados en variables de entorno)

    Configura las siguientes variables de entorno:

    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>

    Ejecuta el siguiente comando apigee-service: Si se ejecuta sin errores, tus parámetros de configuración son correctos. 

    apigee-service apigee-cassandra ring

    Opción 3 (argumentos de SSL pasados directamente a apigee-service)

    Ejecuta cualquier comando apigee-service como el que se muestra a continuación. No es necesario configurar ninguna variable de entorno.

    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 requiere que se le pasen parámetros de JMX. Hay dos maneras en las que puedes configurar nodetool para que se ejecute con JMX habilitado para SSL, como se describe en las opciones de configuración que se indican a continuación:

    Las opciones difieren en la forma en que se pasan las configuraciones relacionadas con SSL a nodetool. En ambos casos, el usuario que ejecuta nodetool debe tener permisos de LECTURA en el archivo del almacén de certificados de confianza. Elige una opción adecuada según la usabilidad y tus prácticas de seguridad.

    Para obtener más información sobre los parámetros de nodetool, consulta la documentación de DataStax.

    Opción de configuración 1

    Crea un archivo en el directorio principal del usuario que ejecuta nodetool.

    $HOME/.cassandra/nodetool-ssl.properties

    Agrega las siguientes líneas al archivo:

    -Djavax.net.ssl.trustStore=<path-to-truststore.node1>
-Djavax.net.ssl.trustStorePassword=<truststore-password>
-Dcom.sun.management.jmxremote.registry.ssl=true

    Cualquier usuario que ejecute nodetool debe poder acceder a la ruta de acceso del almacén de confianza especificada anteriormente.

    Ejecuta nodetool con la opción --ssl.

    /opt/apigee/apigee-cassandra/bin/nodetool --ssl -u <jmx-user-name> -pw <jmx-user-password> -h localhost ring

    Opción de configuración 2

    Ejecuta nodetool como un solo comando con los parámetros adicionales que se indican a continuación.

    /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

Revierte las configuraciones de SSL

Si necesitas revertir los parámetros de configuración de SSL descritos en el procedimiento anterior, sigue estos pasos:

  1. Para detener apigee-cassandra, ingresa 
    apigee-service apigee-cassandra stop
  2. Quita la línea conf_cassandra-env_com.sun.management.jmxremote.ssl=true del archivo /opt/apigee/customer/application/cassandra.properties.
  3. Marca como comentario las siguientes líneas en /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. Para iniciar apigee-cassandra, ingresa
    5. apigee-service apigee-cassandra start
  5. Quita la variable de entorno CASS_JMX_SSL si se configuró.

    unset CASS_JMX_SSL
  6. Verifica que los comandos basados en apigee-service, como ring, stop, backup, etcétera, funcionen.
  7. Deja de usar el interruptor --ssl con nodetool

Inhabilita la autenticación de JMX para Cassandra

Para inhabilitar la autenticación de JMX para Cassandra, sigue estos pasos:

  1. Editar /opt/apigee/customer/application/cassandra.properties.
  2. Quita la siguiente línea del archivo: 
    conf_cassandra-env_com.sun.management.jmxremote.authenticate=true
  3. Ejecuta configure en Cassandra: 
    /opt/apigee/apigee-service/bin/apigee-service apigee-cassandra configure
  4. Reinicia Cassandra: 
    /opt/apigee/apigee-service/bin/apigee-service apigee-cassandra restart
  5. Repite este proceso en todos los demás nodos de Cassandra.

Usa JConsole: Supervisa las estadísticas de las tareas

Usa JConsole y la siguiente URL de servicio para supervisar los atributos de JMX (MBeans) que se ofrecen a través de JMX:

service:jmx:rmi:///jndi/rmi://IP_address:7199/jmxrmi

Donde IP_address es la IP del servidor de Cassandra.

Estadísticas de JMX de Cassandra

MBeans de JMX Atributos de JMX

ColumnFamilies/apprepo/environments

ColumnFamilies/apprepo/organizations

ColumnFamilies/apprepo/apiproxy_revisions

ColumnFamilies/apprepo/apiproxies

ColumnFamilies/audit/audits

ColumnFamilies/audit/audits_ref

PendingTasks

MemtableColumnsCount

MemtableDataSize

ReadCount

RecentReadLatencyMicros

TotalReadLatencyMicros

WriteCount

RecentWriteLatencyMicros

TotalWriteLatencyMicros

TotalDiskSpaceUsed

LiveDiskSpaceUsed

LiveSSTableCount

BloomFilterFalsePositives

RecentBloomFilterFalseRatio

BloomFilterFalseRatio

Usa nodetool para administrar los nodos del clúster

La utilidad nodetool es una interfaz de línea de comandos para Cassandra que administra los nodos del clúster. La utilidad se puede encontrar en /opt/apigee/apigee-cassandra/bin.

Se pueden realizar las siguientes llamadas en todos los nodos del clúster de Cassandra:

  1. Información general del anillo (también es posible para un solo nodo de Cassandra): Busca "Up" y "Normal" para todos los nodos. 
    nodetool [-u username -pw password] -h localhost ring

    Solo necesitas pasar tu nombre de usuario y contraseña si habilitaste la autenticación de JMX para Cassandra.

    El resultado del comando anterior se ve de la siguiente manera: 

    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. Información general sobre los nodos (llamada por nodo) 
    nodetool [-u username -pw password]  -h localhost info

    El resultado del comando anterior se ve de la siguiente manera:

    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. Estado del servidor de Thrift (API de cliente de entrega) 
    nodetool [-u username -pw password] -h localhost statusthrift

    El resultado del comando anterior se ve de la siguiente manera:

    running
  4. Estado de las operaciones de transmisión de datos: Observa el tráfico de los nodos de Cassandra: 
    nodetool [-u username -pw password] -h localhost netstats

    El resultado del comando anterior se ve de la siguiente manera:

    Mode: NORMAL
Not sending any streams.
Read Repair Statistics:
Attempted: 151612
Mismatch (Blocking): 0
Mismatch (Background): 0
Pool Name                    Active   Pending      Completed   Dropped
Commands                        n/a         0              0         0
Responses                       n/a         0              0       n/a

Para obtener más información sobre nodetool, consulta Acerca de la utilidad nodetool.

Recurso de Cassandra

Consulta la siguiente URL: http://www.datastax.com/docs/1.0/operations/monitoring.

Apache ZooKeeper

Verifica el estado de ZooKeeper

  1. Asegúrate de que el proceso de ZooKeeper se esté ejecutando. ZooKeeper escribe un archivo PID en opt/apigee/var/run/apigee-zookeeper/apigee-zookeeper.pid.
  2. Prueba los puertos de ZooKeeper para asegurarte de que puedes establecer una conexión TCP con los puertos 2181 y 3888 en cada servidor de ZooKeeper.
  3. Asegúrate de que puedes leer los valores de la base de datos de ZooKeeper. Conéctate con una biblioteca cliente de ZooKeeper (o /opt/apigee/apigee-zookeeper/bin/zkCli.sh) y lee un valor de la base de datos.
  4. Verifica el estado: 
    /opt/apigee/apigee-service/bin/apigee-service apigee-zookeeper status

Usa las palabras de cuatro letras de ZooKeeper

ZooKeeper se puede supervisar a través de un pequeño conjunto de comandos (palabras de cuatro letras) que se envían al puerto 2181 con netcat (nc) o telnet.

Para obtener más información sobre los comandos de ZooKeeper, consulta la referencia de comandos de Apache ZooKeeper.

Por ejemplo:

  • srvr: Muestra los detalles completos del servidor.
  • stat: Muestra detalles breves del servidor y los clientes conectados.

Se pueden emitir los siguientes comandos al puerto de ZooKeeper:

  1. Ejecuta el comando de cuatro letras ruok para probar si el servidor se está ejecutando en un estado sin errores. Una respuesta correcta devuelve "imok". 
    echo ruok | nc host 2181

    Se muestra lo siguiente:

    imok
  2. Ejecuta el comando de cuatro letras, stat, para enumerar las estadísticas de rendimiento del servidor y de los clientes conectados: 
    echo stat | nc host 2181

    Se muestra lo siguiente:

    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. Si netcat (nc) no está disponible, puedes usar Python como alternativa. Crea un archivo llamado zookeeper.py que contenga lo siguiente: 
    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)

    Ahora, ejecuta las siguientes líneas de Python:

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

Prueba de nivel de LDAP

Puedes supervisar OpenLDAP para ver si las solicitudes específicas se entregan correctamente. En otras palabras, verifica que una búsqueda específica devuelva el resultado correcto.

  1. Usa ldapsearch (yum install openldap-clients) para consultar la entrada del administrador del sistema. Esta entrada se usa para autenticar todas las llamadas a la 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

    Luego, se te solicitará la contraseña de administrador de LDAP:

    Enter LDAP Password:

    Después de ingresar la contraseña, verás una respuesta en el siguiente formato:

    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. Verifica si el servidor de administración aún está conectado a LDAP con el siguiente comando: 
    curl -u userEMail:password http://localhost:8080/v1/users/ADMIN

    Se muestra lo siguiente:

    {
  "emailId" : ADMIN,
  "firstName" : "admin",
  "lastName" : "admin"
}

También puedes supervisar las cachés de OpenLDAP, que ayudan a reducir la cantidad de accesos al disco y, por lo tanto, mejoran el rendimiento del sistema. Supervisar y, luego, ajustar el tamaño de la caché en el servidor de OpenLDAP puede afectar en gran medida el rendimiento del servidor de directorio. Puedes ver los archivos de registro (opt/apigee/var/log) para obtener información sobre la caché.