Cómo supervisar

Este documento describe las técnicas de supervisión de componentes soportados por una red local la implementación de Apigee Edge.

Descripción general

Edge admite varias formas de obtener detalles sobre los servicios y de verificar estados. En la siguiente tabla, se indican los tipos de verificaciones que puedes realizar en cada opción apta servicio:

API de Management
Servicio Uso de memoria [JMX*] Verificación de servicios 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
Postgres
Qpid
Router
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, ya que se describe en Cómo habilitar JMX.

** El servicio apigee-monit verifica si un componente está activo y, luego, intentará reiniciarla si no lo es. Para obtener más información, consulta Autorreparación con apigee-monit.

Puertos de supervisión de la API de Management y JMX

Cada componente admite llamadas de supervisión a JMX y a la API de Management en diferentes puertos. El La siguiente tabla incluye los puertos de JMX y de la API de Management para cada tipo de servidor:

Componente Puerto JMX Puerto de la API de Management
Servidor de administración 1099 8080
Router 1100 8081
Message Processor 1101 8082
Qpid 1102 8083
Postgres 1103 8084

Usa JMX para supervisar

Los procesos de supervisión para el servidor de administración, el procesador de mensajes, Qpid y Postgres usar JMX. Sin embargo, JMX está habilitado de forma predeterminada solo para Cassandra y está inhabilitado para todos otros componentes de Edge. Por lo tanto, debes habilitar JMX individualmente para cada componente antes de para supervisarlos.

La autenticación JMX no está habilitada de forma predeterminada. Puedes habilitar la autenticación JMX para todas o los componentes de la solución. Para Cassandra, usa las instrucciones de Habilita la autenticación JMX para Cassandra.

Habilitar JMX

De forma predeterminada, JMX solo está habilitado para Cassandra y está inhabilitado para todos los demás dispositivos perimetrales. o los componentes de la solución. En esta sección, se describe cómo habilitar JMX para los demás componentes de Edge.

Para habilitar JMX, haz lo siguiente:

  1. Editar el archivo de configuración del componente Este archivo se encuentra en opt/apigee/edge-component_name/bin/start En producción estos archivos de configuración estarán en máquinas distintas.

    Elige entre las siguientes ubicaciones de archivos en cada servidor:

    • Servidor de administración: /opt/apigee/edge-management-server/bin/start
    • Procesador de mensajes: /opt/apigee/edge-message-processor/bin/start
    • Postgres: /opt/apigee/edge-postgres-server/bin/start
    • QPID: /opt/apigee/edge-qpid-server/bin/start
    • Router: /opt/apigee/edge-router/bin/start

    Por ejemplo, el archivo de configuración del servidor de administración en su servidor se encuentra en /opt/apigee/edge-management-server/bin/start

  2. Agrega las siguientes opciones de com.sun.management.jmxremote a exec. línea que inicia el componente: 
    -Dcom.sun.management.jmxremote \
  -Dcom.sun.management.jmxremote.port=port_number \
  -Dcom.sun.management.jmxremote.local.only=false \
  -Dcom.sun.management.jmxremote.authenticate=false \
  -Dcom.sun.management.jmxremote.ssl=false

    Donde port_number es el puerto JMX para el servicio. Para obtener el JMX de tu servicio consulta Puertos de supervisión de la API de Management y JMX.

    Por ejemplo, para habilitar JMX en el servidor de administración, agrega lo siguiente a la sección Archivo de configuración del servidor:

    exec $JAVA -classpath "$classpath" -Xms$min_mem -Xmx$max_mem $xx_opts \
  -Djava.security.auth.login.config=$conf_path/jaas.config \
  -Dinstallation.dir=$install_dir $sys_props -Dconf.dir=$conf_path \
  -Ddata.dir=$data_dir \
  -Dcom.sun.management.jmxremote \
  -Dcom.sun.management.jmxremote.port=1099 \
  -Dcom.sun.management.jmxremote.local.only=false \
  -Dcom.sun.management.jmxremote.authenticate=false \
  -Dcom.sun.management.jmxremote.ssl=false \
   $* $debug_options com.apigee.kernel.MicroKernel

    En este ejemplo, se especifica el puerto 1099 para el servidor de administración. Como se mencionó anteriormente, cada servicio tiene su propio número de puerto.

    La línea editada en el archivo de configuración se ve de la siguiente manera:

    exec $JAVA -classpath "$classpath" -Xms$min_mem -Xmx$max_mem $xx_opts -Djava.security.auth.login.config=$conf_path/jaas.config -Dinstallation.dir=$install_dir $sys_props -Dconf.dir=$conf_path -Ddata.dir=$data_dir -Dcom.sun.management.jmxremote -Dcom.sun.management.jmxremote.port=1099 -Dcom.sun.management.jmxremote.local.only=false -Dcom.sun.management.jmxremote.authenticate=false -Dcom.sun.management.jmxremote.ssl=false $* $debug_options com.apigee.kernel.MicroKernel
  3. Guarda el archivo de configuración.
  4. Reinicia el componente con el comando restart.

    Por ejemplo, ejecuta el siguiente comando para reiniciar el servidor de administración:

    /opt/apigee/apigee-service/bin/apigee-service edge-management-server restart

La autenticación para JMX no está habilitada de forma predeterminada. Puedes habilitar la autenticación JMX para todas como se describe en Habilitar la autenticación JMX. Para habilitar JMX autenticación para Cassandra, consulta Habilita la autenticación JMX para Cassandra.

Habilitar la autenticación JMX

La autenticación JMX no está habilitada de forma predeterminada. Puedes habilitar la autenticación JMX para todas o los componentes de la solución. Para Cassandra, usa las instrucciones de Habilitar la autenticación JMX para Cassandra

Para habilitar la autenticación JMX, ejecuta la siguiente acción change_jmx_auth en todos nodos:

/opt/apigee/apigee-service/bin/apigee-service component_name change_jmx_auth [options|-f config_file]

Aquí:

  • component es una de las siguientes opciones:
    • edge-management-server
    • edge-message-processor
    • edge-postgres-server
    • edge-qpid-server
    • edge-router
  • options especifica lo siguiente:
    • -u username
    • -p password
    • -e [y|n] (habilitar o inhabilitar)
  • config_file especifica la ubicación de un archivo de configuración en el que defines lo siguiente:
    • JMX_USERNAME=username
    • JMX_ENABLED=y|n
    • JMX_PASSWORD=password (si no se establece o no se pasa con -p, se te solicitará)

Puede usar las opciones de la línea de comandos o el archivo de configuración para definir el nombre de usuario y habilita o inhabilita el estado. No debes especificar un conjunto de opciones y una configuración .

El siguiente ejemplo habilita la autenticación JMX para el servidor de administración a través del comando opciones de línea:

/opt/apigee/apigee-service/bin/apigee-service edge-management-server
    change_jmx_auth -u foo -p bar -e y

En el siguiente ejemplo, se usa un archivo de configuración en lugar de opciones de línea de comandos:

/opt/apigee/apigee-service/bin/apigee-service edge-management-server
    change_jmx_auth -f /tmp/my-config-file

Si ejecutas Edge en varios nodos, ejecuta el comando en todos los nodos y especifica nombre de usuario y contraseña.

Para inhabilitar la autenticación JMX en la línea de comandos, usa la tecla “-e n” de la siguiente manera: ejemplo muestra:

/opt/apigee/apigee-service/bin/apigee-service edge-management-server
    change_jmx_auth -e n

Supervisar con JConsole

Usa JConsole (una herramienta que cumple con JMX) para administrar y supervisar la verificación de estado y las estadísticas de procesos. Con JConsole, puedes consumir estadísticas de JMX expuestas por tus servidores y mostrarlas en una con una interfaz gráfica de usuario. Para obtener más información, 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

Aquí:

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

Por ejemplo, para supervisar el servidor de administración, ejecuta 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 este ejemplo especifica el puerto 1099, que es el puerto JMX del servidor de administración. Para otro consulta Puertos de supervisión de la API de Management y JMX.

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

MB de JMX Atributos de JMX

Memoria

HeapMemoryUsage

NonHeapMemoryUsage

Uso

Supervisa con la API de Management

Edge incluye varias APIs que puedes usar para realizar verificaciones de servicios en tus servidores y también para verificar a los usuarios, las organizaciones y las implementaciones. En esta sección, se describen estas APIs.

Realiza verificaciones del servicio

La API de Management proporciona varios endpoints para supervisar y diagnosticar problemas con tu de Google Cloud. Estos extremos incluyen lo siguiente:

Extremo Descripción
/servers/self/up

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

Si el servicio se está ejecutando, este extremo muestra 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, incluida la siguiente:

  • Propiedades de configuración
  • Hora de inicio y hora de actividad
  • Información sobre compilaciones, RPM y UUID
  • Nombre de host interno y externo, y dirección IP
  • Región y Pod
  • La propiedad <isUp>, que indica si se está ejecutando el servicio

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

Aquí:

  • host es la dirección IP del servidor que deseas verificar. Si accediste a tu cuenta el servidor, puedes usar “localhost”; De lo contrario, especifica también la dirección IP del servidor nombre de usuario y contraseña.
  • port_number es el puerto de la API de Management para el servidor que deseas verificar. Este es y un puerto diferente para cada tipo de componente. Por ejemplo, el servidor de administración El puerto de la API de Management es 8080. Si deseas obtener una lista de los números de puerto de la API de Management que se deben usar, consulta Puertos de supervisión de la API de Management y JMX

Para cambiar el formato de la respuesta, puedes especificar el encabezado Accept como &quot;application/json&quot; 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 acerca del 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"

Supervisar el estado del usuario, la organización y la implementación

Puedes usar la API de Management para supervisar el estado del usuario, la organización y la implementación de tu proxies en servidores de administración y en procesadores de mensajes emitiendo 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

Donde port_number es 8080 para el servidor de administración, o bien 8082 para el mensaje Procesador.

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

El servidor debería mostrar el estado “deployed” estado de todas las llamadas. Si estos errores fallan, haz lo siguiente:

  1. Revisa los registros del servidor en busca de errores. Los registros se encuentran en la siguiente ubicación:
    • Servidor de administración: opt/apigee/var/log/edge-management-server
    • Procesador de mensajes: opt/apigee/var/log/edge-message-processor
  2. Realiza una llamada al servidor para comprobar si está funcionando 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 los problemas de los servicios perimetrales con el comando apigee-service cuando estés debe haber accedido 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
    • Procesador de mensajes: 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, comprueba que funcione, ya sea con Comando apigee-service status que usaste antes o mediante la API de Management que se describe en Cómo supervisar 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 Management para el servicio.

    En este ejemplo, se supone que accediste al servidor y puedes usar “localhost” como nombre de host. Para verificar el estado de forma remota con la API de Management, debes especificar la IP del servidor e incluya el nombre de usuario y la contraseña del administrador del sistema en su API llamada.

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 el entorno que están integrados en el servidor de Postgres Para ello, ejecuta el siguiente comando curl:

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

El sistema debe mostrar el nombre de la organización y el entorno.

Verifica el estado de las estadísticas

Puedes verificar el estado de los servidores de estadísticas de Postgres y Qpid mediante la siguiente emisión Comando curl:

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

El sistema debe mostrar un estado de éxito para todos los servidores de análisis, como en el siguiente ejemplo. muestra:

{
  "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 técnicas que puedes usar específicamente para supervisar el estado en la base de datos.

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:

  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 Perl que implementa temporizadores de alta resolución, de alarma, de suspensión, de intervalo y gettimeofday. 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 Nagios compatibles. 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 permitida conexiones: 
    check_postgres.pl -H 10.176.218.202 -db apigee -u apigee -dbpass postgres -action backends
  3. Comprueba si la base de datos se está ejecutando y si está 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 integrados 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 bases de datos

Puedes verificar que se creen las tablas adecuadas en la base de datos de PostgreSQL. Accede a PostgreSQL base de datos 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 API en la máquina de Postgres invocando el siguiente curl :

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

Este comando muestra el estado ACTIVE cuando el proceso de postgres está activo. Si el botón El proceso de Postgres no está en funcionamiento y muestra 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 JMX a Cassandra no requiere un contraseña.

Habilitar la autenticación JMX para Cassandra

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

Sigue estos pasos para habilitar la autenticación JMX para Cassandra:

  1. Crea y edita el archivo cassandra.properties:
    1. Edita el archivo /opt/apigee/customer/application/cassandra.properties. Si el botón 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}/data/apigee-cassandra/jmxremote.password
conf_cassandra-env_com.sun.management.jmxremote.access.file=${APIGEE_ROOT}/data/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

    Si quieres obtener más información sobre el uso de archivos de propiedades para establecer 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. Busca 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/data/apigee-cassandra/ 
      cp ${JAVA_HOME}/lib/management/jmxremote.password.template $APIGEE_ROOT/data/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 de JMX y que configuraste anteriormente.

    3. Asegúrate de que el archivo sea propiedad de “apigee” y que el modo de archivo es 400: 
      chown apigee:apigee /opt/apigee/data/apigee-cassandra/jmxremote.password
chmod 400 /opt/apigee/data/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/data/apigee-cassandra/ 
      cp ${JAVA_HOME}/lib/management/jmxremote.access $APIGEE_ROOT/data/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 que el modo de archivo es 400: 
      chown apigee:apigee /opt/apigee/data/apigee-cassandra/jmxremote.access
chmod 400 /opt/apigee/data/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.

Habilitar la encriptación de contraseñas JMX

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

  1. Abre el archivo source/conf/casssandra-env.sh.
  2. Quita los comentarios de las siguientes líneas en el archivo:
    • JVM_OPTS="$JVM_OPTS -Djava.security.auth.login.config={T}conf_cassandra-env_java.security.auth.login.config{/T}"
    • JVM_OPTS="$JVM_OPTS -Dcom.sun.management.jmxremote.login.config=ApigeeSecureFileLoginModule"
  3. En la línea de comandos, genera los hash SHA1 de las contraseñas deseadas ingresando echo -n 'Secret' | openssl dgst -sha1
  4. Configura las contraseñas junto con el nombre de usuario en jmxremote.password.
  5. Vuelve a cambiar el archivo cassandra-env.sh a solo lectura después de la actualización.

Habilitar 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 JMX basadas en SSL. También debes configurar nodetool (y cualquier otra herramienta que comunicarse con Cassandra a través de JMX) para SSL.

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

Si quieres 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 JMX para Cassandra. como se describió anteriormente. Asegúrate de que nodetool funcione con el conjunto de datos nombre de usuario y contraseña. 
    /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 confianza.

    • El almacén de claves debe contener una clave y un certificado, y se usa para configurar el servidor de Cassandra. Si es un 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 de la clave y del almacén de claves deben ser iguales. (valor predeterminado cuando se genera la clave con keytool).

    • El almacén de confianza solo debe contener el certificado, y lo usan los clientes (clientes (basados en servicios de Apigee) comandos o nodetool) para conectarte 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/data/apigee-cassandra.
    2. Asegúrate de que el usuario de Apigee solo pueda leer el archivo de almacén de claves ingresando 
      chown apigee:apigee /opt/apigee/data/apigee-cassandra/keystore.node1
chmod 400 /opt/apigee/data/apigee-cassandra/keystore.node1
  4. Configura Cassandra para JMX con SSL mediante los siguientes pasos:
    1. Detenga el nodo de Cassandra ingresando 
      apigee-service apigee-cassandra stop
    2. Habilitar SSL en Cassandra abriendo el archivo /opt/apigee/customer/application/cassandra.properties y agrega la siguiente línea: 
      conf_cassandra-env_com.sun.management.jmxremote.ssl=true

      El archivo debe ser propiedad de apigee:apigee.

    3. Habilita la configuración relacionada con SSL en Cassandra de la siguiente manera. Abrir el archivo /opt/apigee/apigee-cassandra/source/conf/cassandra-env.sh y quita los comentarios de las siguientes líneas, cambiando la ruta de acceso /opt/apigee/data/apigee-cassandra/keystore.node1 y la contraseña del almacén de claves según sea necesario. 
      JVM_OPTS="$JVM_OPTS -Djavax.net.ssl.keyStore=/opt/apigee/data/apigee-cassandra/keystore.node1"
JVM_OPTS="$JVM_OPTS -Djavax.net.ssl.keyStorePassword=keystore-password"
JVM_OPTS="$JVM_OPTS -Dcom.sun.management.jmxremote.registry.ssl=true"
       Asegúrate de que el archivo sea propiedad de apigee:apigee.
    4. Inicia el nodo de Cassandra ingresando 
      apigee-service apigee-cassandra start
  5. Configura los comandos de Cassandra de apigee-service. Debes configurar ciertas variables de entorno mientras ejecutas 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 JMX y SSL. Elige una opción en función de la usabilidad y tus prácticas de seguridad.

    Opción 1 (argumentos 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 de trustore.

    Ejecuta el siguiente comando apigee-service. Si se ejecuta sin errores, tu configuración es correcta.

    apigee-service apigee-cassandra ring

    Opción 2 (argumentos 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, tu configuración es correcta. 

    apigee-service apigee-cassandra ring

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

    Ejecuta cualquier comando apigee-service como el que se muestra a continuación. No necesitas 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 los parámetros JMX. Existen dos maneras puedes configurar nodetool para que se ejecute con JMX habilitado para SSL, tal como se describe en opciones de configuración disponibles a continuación:

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

    Para obtener más información sobre los parámetros 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 un comando debe poder acceder a la ruta del almacén de confianza especificada anteriormente nodetool.

    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

Revertir configuraciones de SSL

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

  1. Para detener apigee-cassandraingresa 
    apigee-service apigee-cassandra stop
  2. Quita la línea conf_cassandra-env_com.sun.management.jmxremote.ssl=true de el archivo /opt/apigee/customer/application/cassandra.properties.
  3. Comenta 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. Comprueba que los comandos basados en apigee-service, como ring, stop, backup, etc., funcionan.
  7. Deja de usar el switch --ssl con nodetool

Inhabilitar la autenticación JMX para Cassandra

Sigue estos pasos para inhabilitar la autenticación JMX para Cassandra:

  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 la configuración 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 Cassandra JMX

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. Puedes encontrar la utilidad 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 tono (también posible para un nodo de Cassandra único): Busca el “Arriba” y "Normal" para todos los nodos. 
    nodetool [-u username -pw password] -h localhost ring

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

    El resultado del comando anterior se ve como se muestra a continuación: 

    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 ahorro (API del 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

Cómo verificar 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 a los puertos 2181 y 3888 en cada servidor de ZooKeeper.
  3. Asegúrate de que puedes leer valores de la base de datos de ZooKeeper. Conéctate con ZooKeeper biblioteca cliente (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

Usar palabras de ZooKeeper de cuatro letras

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

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

Por ejemplo:

  • srvr: Muestra una lista de los detalles completos del servidor.
  • stat: Enumera breves detalles 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. R la respuesta correcta muestra “imok”. 
    echo ruok | nc host 2181

    Se muestra lo siguiente:

    imok
  2. Ejecuta el comando de cuatro letras stat para ver el rendimiento del servidor y los datos conectados. estadísticas de los clientes: 
    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 llamada zookeeper.py, que contiene 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 el OpenLDAP para ver si las solicitudes específicas se entregan correctamente. En otras palabras, busca una búsqueda específica que devuelva el resultado correcto.

  1. Usa ldapsearch (yum install openldap-clients) para buscar la entrada del administrador del sistema. Esta entrada se utiliza 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

    A continuación, se te solicita la contraseña del administrador de LDAP:

    Enter LDAP Password:

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

    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 sigue 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 a los discos. y así mejorar el rendimiento del sistema. Supervisar y ajustar el tamaño de la caché El servidor OpenLDAP puede tener un gran impacto en el rendimiento del servidor de directorio. Puedes ver el registro archivos (opt/apigee/var/log) para obtener información sobre la caché.