Este documento describe las técnicas de supervisión de componentes soportados por una red local e implementación de Apigee Edge para la nube privada.
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 | |||||||
Componente | 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 | |||||||
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, ya que se describe en Cómo habilitar JMX. ** El servicio |
Puertos de supervisión y archivos de configuración
Cada componente es compatible con las llamadas de supervisión de Java Management Extensions (JMX) y la API de Management en puertos diferentes. El la siguiente tabla incluye los puertos de JMX y de la API de Management para cada tipo de servidor y de configuración de Terraform:
Componente | Puerto JMX | Puerto de la API de Management | 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.
Habilitar JMX
Para habilitar JMX sin autenticación ni comunicación basada en SSL, realiza los pasos que se indican a continuación. Nota: En los sistemas de producción, se deben habilitar tanto la autenticación encriptada como SSL para seguridad.
- Edita el archivo de configuración apropiado (consulta
Referencia del archivo de configuración). Crea el archivo de configuración si no existe.
conf_system_jmxremote_enable=true
- Guarda el archivo de configuración y asegúrate de que este es propiedad de
apigee:apigee
. - 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 la nube privada admite autenticación basada en contraseña mediante el uso de detalles almacenados en archivos. Puedes almacenar las contraseñas como un hash para mayor seguridad.
- Para habilitar la autenticación JMX en un componente Edge*, edita el archivo de configuración correspondiente
(consulta
Referencia del archivo de configuración). Crea el archivo de configuración si no existe:
Guarda el archivo de configuración y asegúrate de que es propiedad deconf_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
apigee:apigee
. - Crea un hash SHA256 de la contraseña:
echo -n '
' | openssl dgst -sha256 - Crea un archivo
jmxremote.password
con credenciales de usuario de JMX:- Copia los siguientes archivos de tu directorio
$JAVA_HOME
a el directorio/opt/apigee/customer/application/<component>/
:cp ${JAVA_HOME}/lib/management/jmxremote.password.template $APIGEE_ROOT/customer/application/management-server/jmxremote.password
- Edita el archivo y agrega tu nombre de usuario y contraseña de JMX con la siguiente sintaxis:
USERNAME <HASH-PASSWORD>
- Asegúrate de que el archivo sea propiedad de
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
- Copia los siguientes archivos de tu directorio
- Crea un archivo
jmxremote.access
con permisos de usuario de JMX:- Copia los siguientes archivos de tu directorio $JAVA_HOME en
el directorio
/opt/apigee/customer/application/<component>/
cp ${JAVA_HOME}/lib/management/jmxremote.access$APIGEE_ROOT/customer/application/management-server/jmxremote.password/jmxremote.access
- Edita el archivo y agrega tu nombre de usuario de JMX seguido de un permiso (READONLY/READWRITE)
USERNAME READONLY
- Asegúrate de que el archivo sea propiedad de
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
- Copia los siguientes archivos de tu directorio $JAVA_HOME en
el directorio
- Reinicia el componente de Edge adecuado:
apigee-service edge-management-server restart
Para inhabilitar la autenticación JMX, quita la propiedad
conf_system_jmxremote_authenticate
o cambia el valor a false
.
reiniciar el componente de Edge adecuado.
SSL en JMX
Para habilitar JMX basado en SSL en un componente Edge*:
- Edita el archivo de configuración adecuado
(consulta
Referencia del archivo de configuración). Crea el archivo de configuración si no existe:
Guarda el archivo de configuración y asegúrate de que es propiedad deconf_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>
apigee:apigee
. - Prepara un almacén de claves que contenga la clave del servidor y colócalo en la ruta de acceso proporcionada en el
configuración
conf_system_javax_net_ssl_keystore
anterior. Asegúrate de que el archivo del almacén de claves es legible porapigee:apigee
. - Reinicia el componente de Edge adecuado:
apigee-service edge-management-server restart
Para inhabilitar el JMX basado en SSL, quita la propiedad conf_system_jmxremote_ssl
.
o cambia el valor a false
. Reinicia el componente de Edge adecuado.
Supervisión a través de Jconsole
Las instrucciones de supervisión a través de jconsole siguen siendo las mismas que las descritas en https://docs.apigee.com/private-cloud/v4.52.01/how-monitor#jconsole.
Se puede agregar una línea que diga “jconsole deberá iniciarse con un almacén de confianza y una contraseña de almacén de confianza si SSL está habilitado para JMX”. Referencia: https://docs.oracle.com/javase/8/docs/technotes/guides/management/jconsole.htmlSupervisar 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
Debes iniciar JConsole con un almacén y una contraseña de almacén de confianza si SSL está habilitado para JMX. 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 |
|
Referencia del archivo de configuración
En las siguientes secciones, se describen los cambios que quizás debas realizar en la configuración de los componentes de Edge de configuración para las configuraciones relacionadas con JMX. Consulta Supervisión de puertos y archivos de configuración para obtener más información información.
la configuración de JMX que se agregará al archivo de configuración del componente adecuado
- Habilitar el agente de JMX en el componente perimetral Falso de forma predeterminada.
conf_system_jmxremote_enable=true
Configuraciones de autenticación basada en contraseña
- Habilitar la autenticación basada en contraseña Falso de forma predeterminada.
conf_system_jmxremote_authenticate=true
- Ruta de acceso al archivo. Solo el usuario de Apigee debe ser propiedad de un usuario de Apigee.
conf_system_jmxremote_access_file=/opt/apigee/customer/application/management-server/jmxremote.access
- Ruta al archivo de contraseña. Solo el usuario de Apigee debe ser propiedad de un usuario de Apigee.
conf_system_jmxremote_password_file=/opt/apigee/customer/application/management-server/jmxremote.password
- Habilita el almacenamiento de contraseñas en formato encriptado. Falso de forma predeterminada.
conf_system_jmxremote_encrypted_auth=true
Configuraciones para JMX basado en SSL
- Habilita SSL para la comunicación JMX. Falso de forma predeterminada.
conf_system_jmxremote_ssl=true
- Ruta de acceso al almacén de claves. Solo el usuario de Apigee debe ser propiedad de un usuario de Apigee.
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
Configuraciones opcionales de JMX
Los valores que se indican son predeterminados y se pueden cambiar.
- JMX. Los valores predeterminados se indican en la siguiente tabla.
conf_system_jmxremote_port=
- Puerto RMI JMX. De forma predeterminada, el proceso de Java elegirá un puerto aleatorio.
conf_system_jmxremote_rmi_port=
- El nombre de host para stubs remotos. Dirección IP predeterminada de localhost.
conf_system_java_rmi_server_hostname=
- Protege el registro JMX con SSL. El valor predeterminado es falso. Solo se aplica si se habilita SSL.
conf_system_jmxremote_registry_ssl=false
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:
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
"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 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:passwordcurl 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:
- 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
- Servidor de administración:
- Realiza una llamada al servidor para comprobar si está funcionando correctamente.
- 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:
- 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
- Servidor de administración:
- Si el servicio no se está ejecutando, inícialo:
/opt/apigee/apigee-service/bin/apigee-service service_name start
- 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:
- Debes instalar la secuencia de comandos check_postgres.pl en cada nodo de Postgres.
- 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
- 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:
- 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'
- 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
- 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
- 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%'
- 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:
- 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 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:
- Crea y edita el archivo
cassandra.properties
:- Edita el archivo
/opt/apigee/customer/application/cassandra.properties
. Si el botón no existe, créalo. - 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
- Guarda el archivo
cassandra.properties
. - 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.
- Edita el archivo
- Crea y edita
jmx_auth.sh
:- Crea un archivo en la siguiente ubicación si no existe:
/opt/apigee/customer/application/jmx_auth.sh
- Agrega las siguientes propiedades al archivo:
export CASS_JMX_USERNAME=JMX_USERNAME export CASS_JMX_PASSWORD=JMX_PASSWORD
- Guarda el archivo
jmx_auth.sh
. - Busca el archivo:
source /opt/apigee/customer/application/jmx_auth.sh
- Crea un archivo en la siguiente ubicación si no existe:
- Copia y edita el archivo
jmxremote.password
:- 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
- 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.
- Asegúrate de que el archivo sea propiedad de “apigee” y que el modo de archivo es 400:
chown apigee:apigee /opt/apigee/customer/application/apigee-cassandra/jmxremote.password
chmod 400 /opt/apigee/customer/application/apigee-cassandra/jmxremote.password
- Copia el siguiente archivo de tu directorio
- Copia y edita el archivo
jmxremote.access
:- 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
- Edita el archivo
jmxremote.access
y agrega la siguiente función:JMX_USERNAME readwrite
- Asegúrate de que el archivo sea propiedad de “apigee” y que el modo de archivo es 400:
chown apigee:apigee /opt/apigee/customer/application/apigee-cassandra/jmxremote.access
chmod 400 /opt/apigee/customer/application/apigee-cassandra/jmxremote.access
- Copia el siguiente archivo de tu directorio
- Ejecuta
configure
en Cassandra:/opt/apigee/apigee-service/bin/apigee-service apigee-cassandra configure
- Reinicia Cassandra:
/opt/apigee/apigee-service/bin/apigee-service apigee-cassandra restart
- 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:
- Abre el archivo
source/conf/casssandra-env.sh
. - Crea y edita el archivo
cassandra.properties
:- Edita el archivo
/opt/apigee/customer/application/cassandra.properties
. Si el archivo no existe, créalo. - Agrega lo siguiente al archivo.
conf_cassandra_env_com.sun.management.jmxremote.encrypted.authenticate=true
- Guarda el archivo cassandra.properties.
- Cambia el propietario del archivo a apigee:apigee, como se muestra en el siguiente ejemplo:
chown apigee:apigee /opt/apigee/customer/application/cassandra.properties
- Edita el archivo
- En la línea de comandos, genera los hash SHA1 de las contraseñas deseadas ingresando
echo -n 'Secret' | openssl dgst -sha1
- Configura las contraseñas con el nombre de usuario en
$APIGEE_ROOT/customer/application/apigee-cassandra/jmxremote.password
(creado en en la sección anterior). - Ejecuta la configuración en Cassandra:
/opt/apigee/apigee-service/bin/apigee-service apigee-cassandra configure
- Reinicia Cassandra:
/opt/apigee/apigee-service/bin/apigee-service apigee-cassandra restart
- Repite este proceso en todos los demás nodos de Cassandra.
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:
- Habilita JMX. Habilita la encriptación de contraseñas si es necesario.
- 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
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:
- Coloca el archivo del almacén de claves en
/opt/apigee/customer/application/apigee-cassandra/
. - Asegúrate de que el usuario de Apigee solo pueda leer el archivo de almacén de claves ingresando
chown apigee:apigee /opt/apigee/customer/application/apigee-cassandra/keystore.node1
chmod 400 /opt/apigee/customer/application/apigee-cassandra/keystore.node1
- Configura Cassandra para JMX con SSL mediante los siguientes pasos:
- Detenga el nodo de Cassandra ingresando
apigee-service apigee-cassandra stop
- Habilitar SSL en Cassandra
abriendo 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
- Cambia el propietario del archivo a apigee:apigee, como se muestra en el siguiente ejemplo:
chown apigee:apigee /opt/apigee/customer/application/cassandra.properties
- Ejecuta la configuración en Cassandra:
/opt/apigee/apigee-service/bin/apigee-service apigee-cassandra configure
- Reinicia Cassandra:
/opt/apigee/apigee-service/bin/apigee-service apigee-cassandra restart
- Repite este proceso en todos los demás nodos de Cassandra.
- Inicia el nodo de Cassandra ingresando
apigee-service apigee-cassandra start
- Detenga el nodo de Cassandra ingresando
- Configura los comandos de Cassandra de
apigee-service
. Debes configurar ciertas variables de entorno mientras ejecutasapigee-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)
- Opción 2 (argumentos SSL almacenados en variables de entorno)
- Opción 3 (argumentos SSL pasados directamente a
apigee-service
)
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
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:
- Para detener
apigee-cassandra
ingresaapigee-service apigee-cassandra stop
- Quita la línea
conf_cassandra-env_com.sun.management.jmxremote.ssl=true
de el archivo/opt/apigee/customer/application/cassandra.properties
. - 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”
- Para iniciar
apigee-cassandra
, ingresa - Quita la variable de entorno
CASS_JMX_SSL
si se configuró.unset CASS_JMX_SSL
- Comprueba que los comandos basados en
apigee-service
, comoring
,stop
,backup
, etc., funcionan. - Deja de usar el switch
--ssl
con nodetool
apigee-service apigee-cassandra start
Inhabilitar la autenticación JMX para Cassandra
Sigue estos pasos para inhabilitar la autenticación JMX para Cassandra:
- Editar
/opt/apigee/customer/application/cassandra.properties
. - Quita la siguiente línea del archivo:
conf_cassandra-env_com.sun.management.jmxremote.authenticate=true
- Ejecuta la configuración en Cassandra:
/opt/apigee/apigee-service/bin/apigee-service apigee-cassandra configure
- Reinicia Cassandra:
/opt/apigee/apigee-service/bin/apigee-service apigee-cassandra restart
- 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
MB 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:
- 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
- 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
- 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
- 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.
Supervisa el agente Qpid de Apache Qpid-J
Puedes supervisar Qpid Agent-J desde la consola de administración de Qpid. En esta sección, se explica cómo acceder a la consola y usarla para realizar funciones básicas de supervisión Para obtener información información sobre el uso de la consola de administración, consulta Consola de administración web en la documentación de Apache Qpid.
Accede a la consola de administración
El puerto predeterminado de la consola de administración es 8090. Para acceder a la consola en este puerto predeterminado, Dirige tu navegador web hacia:
http://QPID_NODE_IP:8090
Para acceder a la consola, usa las credenciales predeterminadas establecidas por Apigee o las que se establecen en la sección Archivo de configuración de Edge. Para obtener más información, consulta Referencia del archivo de configuración de Edge.
Supervisa colas y mensajes
En el panel de navegación izquierdo, dirígete a Java-Broker > hosts virtuales > filas. Seleccionar una cola para ver sus detalles en la parte principal de la IU. En la vista de detalles, puedes ver Atributos y estadísticas de la cola, incluida la información sobre los mensajes entregados, en cola, las tasas de mensajes, etc.
Cómo ver y descargar archivos de registro
En el panel de navegación izquierdo, dirígete a Java-Broker > registradores de corredores > Archivo de registro. En la de detalles de la IU principal, puedes ver los detalles del archivo de registro y descargarlos.
Usa la API de administración de Qpid
Puedes usar la API de REST de Agent-J de Apache Qpid para automatizar las tareas de administración y supervisar el agente. Para obtener más información, consulta la Documentación de la API de REST del agente de Apache Qpid
También puedes usar las herramientas de línea de comandos para supervisar el agente. Por ejemplo:
curl "QPID_NODE_IP":"8090"/api/latest/broker -u "USERNAME":"PASSWORD"
Habilitar la supervisión con SSL para Qpid
Para proporcionar seguridad adicional en la supervisión y la administración, habilita SSL en el portal de administración de Qpid y las APIs de administración de Qpid. Sigue los lineamientos que se indican a continuación para proporcionar una clave y un certificado.
Qpid proporciona una opción para un almacén de claves de archivos habilitado en Apigee. Este tipo acepta el formato de almacén de claves JKS estándar que comprenden las herramientas Java y Java, como keytool.
Preparación del almacén de claves
Debes proporcionar el archivo de certificado directamente para que lo usen los clientes de Qpidd, además de usar keytool.
Para generar almacenes de claves, consulta la documentación de Java Keytool.
Después de verificar los requisitos
- Coloca los archivos de almacén de claves y certificado en
/opt/apigee/customer/application/apigee-qpidd
. - Asegúrate de que solo el usuario de Apigee pueda leer el archivo del almacén de claves:
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
Habilitar SSL en Qpid
Realiza los pasos que se indican a continuación en un nodo Qpid a la vez:
Abre el archivo /opt/apigee/customer/application/qpidd.properties
y agrega las siguientes líneas:
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
- Cambia el propietario del archivo a apigee:apigee:
chown apigee:apigee /opt/apigee/customer/application/qpidd.properties
- Configurar Qpidd:
apigee-service apigee-qpidd configure
- Reiniciar Qpidd:
apigee-service apigee-qpidd restart
- Verifica el estado con wait_for_ready:
apigee-service apigee-qpidd wait_for_ready
Revertir la configuración de SSL
Quita o marca como comentario las propiedades del archivo /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
- Configurar Qpidd:
apigee-service apigee-qpidd configure
- Reiniciar Qpidd:
apigee-service apigee-qpidd restart
- Verifica el estado con wait_for_ready:
apigee-service apigee-qpidd wait_for_ready
Apache ZooKeeper
Cómo verificar el estado de ZooKeeper
- 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
- 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.
- 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. - 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:
- 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
- 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
- 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.
- 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
- 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é.