A pesar de todas sus ventajas, una arquitectura de microservicios también introduce nuevas complejidades. Una de ellas es la dificultad de realizar un seguimiento de las solicitudes a medida que se procesan y los datos fluyen entre todos los microservicios que componen la aplicación. Para ello, se ha creado una nueva metodología denominada rastreo distribuido (de solicitudes); por su parte, OpenTracing es una especificación y un conjunto estándar de API destinados a orientar el diseño y la implementación de herramientas de rastreo distribuido.
En la versión 18 de NGINX Plus (R18), añadimos el módulo NGINX OpenTracing a nuestro repositorio de módulos dinámicos (ya estaba disponible como módulo de terceros en GitHub desde hacía un par de años). Una gran ventaja del módulo NGINX OpenTracing es que, al instrumentar NGINX y NGINX Plus para el rastreo distribuido, se obtienen datos de rastreo de todas las aplicaciones que pasan por el proxy, sin tener que instrumentarlas individualmente.
En este blog mostramos cómo habilitar el seguimiento distribuido de solicitudes para NGINX o NGINX Plus (para abreviar, de ahora en adelante nos referiremos simplemente a NGINX Plus). Proporcionamos instrucciones para dos servicios de seguimiento distribuido (trazadores, en la terminología de OpenTracing): Jaeger y Zipkin. (Para consultar una lista de otros trazadores, consulte la documentación de OpenTracing.) Para ilustrar el tipo de información que proporcionan los trazadores, comparamos el procesamiento de solicitudes antes y después de habilitar el almacenamiento en caché de NGINX Plus.
Un sistema de rastreo tiene dos componentes básicos:
- Un agente que recopila datos de rastreo de las aplicaciones que se ejecutan en el mismo host que él. En nuestro caso, la «aplicación» es NGINX Plus y el agente se implementa como un complemento.
- Un servidor (también denominado recopilador) que acepta datos de seguimiento de uno o varios agentes y los muestra en una interfaz de usuario centralizada. Puede ejecutar el servidor en el host de NGINX Plus o en otro host, según prefiera.
Instalación de un servidor de rastreo
El primer paso consiste en instalar y configurar el servidor para el sistema de rastreo que prefiera. Proporcionamos instrucciones para Jaeger y Zipkin; adáptelas según sea necesario para otros sistemas de rastreo.
Instalación del servidor Jaeger
Recomendamos el siguiente método para instalar el servidor Jaeger. También puede descargar imágenes de Docker en la URL indicada en el paso 1.
- Vaya a la página de descarga de Jaeger y descargue el archivo binario para Linux (en el momento de redactar este documento, jaeger-1.12.0-linux-amd64.tar).
- Mueve el binario a /usr/bin/jaeger (crea primero el directorio si es necesario) y ejecútalo.
$ mkdir /usr/bin/jaeger$ mv jaeger-1.12.0-linux-amd64.tar /usr/bin/jaeger
$ cd /usr/bin/jaeger
$ tar xvzf jaeger-1.12.0-linux-amd64.tar.gz
$ sudo rm -rf jaeger-1.12.0-linux-amd64.tar.gz
$ cd jaeger-1.12.0-linux-amd64
$ ./jaeger-all-in-one- Compruebe que puede acceder a la interfaz de usuario de Jaeger desde su navegador en http://dirección-IP-del-servidor-Jaeger:16686/ (16686 es el puerto predeterminado del servidor Jaeger).
Instalación del servidor Zipkin
- Descarga y ejecuta una imagen de Docker de Zipkin (usamos el puerto 9411, que es el predeterminado).
$ docker run -d -p 9411:9411 openzipkin/zipkin- Compruebe que puede acceder a la interfaz de usuario de Zipkin desde su navegador, en http://dirección-IP-del-servidor-Zipkin:9411/.
Instalación y configuración de un complemento de rastreo
Ejecute estos comandos en el host de NGINX Plus para instalar el complemento de Jaeger o Zipkin.
Instalación del complemento de Jaeger
- Instale el complemento de Jaeger. El siguiente comando «
wget» es para sistemas Linux x86-64:
$ cd /usr/local/lib
$ wget https://github.com/jaegertracing/jaeger-client-cpp/releases/download/v0.4.2/libjaegertracing_plugin.linux_amd64.so -O /usr/local/lib/libjaegertracing_plugin.so- Las instrucciones para compilar el complemento a partir del código fuente están disponibles en GitHub.
- Cree un archivo de configuración con formato JSON para el complemento, denominado /etc/jaeger/jaeger-config.json, con el siguiente contenido. Usaremos el puerto predeterminado del servidor Jaeger, el 6831:
{ "service_name": "nginx",
"sampler": {
"type": "const",
"param": 1
},
"reporter": {
"localAgentHostPort": "Jaeger-server-IP-address:6831"
}
}- Para obtener más información sobre el objeto
sampler, consulte la documentación de Jaeger.
Instalación del complemento de Zipkin
- Instale el complemento de Zipkin. El siguiente comando «
wget» es para sistemas Linux x86-64:
$ cd /usr/local/lib$ wget -O - https://github.com/rnburn/zipkin-cpp-opentracing/releases/download/v0.5.2/linux-amd64-libzipkin_opentracing_plugin.so.gz | gunzip -c > /usr/local/lib/libzipkin_opentracing_plugin.so- Cree un archivo de configuración con formato JSON para el complemento, denominado /etc/zipkin/zipkin-config.json, con el siguiente contenido. Usaremos el puerto predeterminado del servidor Zipkin, el 9411:
{ "service_name": "nginx",
"collector_host": "Zipkin-server-IP-address",
"collector_port": 9411
}- Para obtener más información sobre los objetos de configuración, consulte el esquema JSON en GitHub.
Configuración de NGINX Plus
Siga estas instrucciones en el host de NGINX Plus.
- Instale el módulo OpenTracing de NGINX siguiendo las instrucciones de la Guía de administración de NGINX Plus.
- Añada la siguiente directiva
load_moduleen el contexto principal (de nivel superior) del archivo de configuración principal de NGINX Plus (/etc/nginx/nginx.conf):
load_module modules/ngx_http_opentracing_module.so;- Añada las siguientes directivas a la configuración de NGINX Plus. Si utiliza el esquema de configuración convencional, incluya las directivas en un archivo nuevo llamado /etc/nginx/conf.d/opentracing.conf. Compruebe también que la siguiente directiva
includeaparezca en el contextohttpde /etc/nginx/nginx.conf:
http {
include /etc/nginx/conf.d/*.conf;
}# Load a vendor tracer#opentracing_load_tracer /usr/local/libjaegertracing_plugin.so
# /etc/jaeger/jaeger-config.json;
#opentracing_load_tracer /usr/local/lib/libzipkin_opentracing_plugin.so
# /etc/zipkin/zipkin-config.json;
# Enable tracing for all requests
opentracing on;
# Set additional tags that capture the value of NGINX Plus variables
opentracing_tag bytes_sent $bytes_sent;
opentracing_tag http_user_agent $http_user_agent;
opentracing_tag request_time $request_time;
opentracing_tag upstream_addr $upstream_addr;
opentracing_tag upstream_bytes_received $upstream_bytes_received;
opentracing_tag upstream_cache_status $upstream_cache_status;
opentracing_tag upstream_connect_time $upstream_connect_time;
opentracing_tag upstream_header_time $upstream_header_time;
opentracing_tag upstream_queue_time $upstream_queue_time;
opentracing_tag upstream_response_time $upstream_response_time;
#uncomment for debugging
# log_format opentracing '$remote_addr - $remote_user [$time_local] "$request" '
# '$status $body_bytes_sent "$http_referer" '
# '"$http_user_agent" "$http_x_forwarded_for" '
# '"$host" sn="$server_name" '
# 'rt=$request_time '
# 'ua="$upstream_addr" us="$upstream_status" '
# 'ut="$upstream_response_time" ul="$upstream_response_length" '
# 'cs=$upstream_cache_status';
#access_log /var/log/nginx/opentracing.log opentracing;
server {
listen 9001;
location / {
# The operation name used for OpenTracing Spans defaults to the name of the
# 'location' block, but uncomment this directive to customize it.
#opentracing_operation_name $uri;
# Propagate the active Span context upstream, so that the trace can be
# continued by the backend.
opentracing_propagate_context;
# Make sure that your Ruby app is listening on port 4567
proxy_pass http://127.0.0.1:4567;
}
}- La directiva «
opentracing_load_tracer» habilita el complemento de rastreo. Quite el comentario de la directiva de Jaeger o Zipkin, según corresponda. - Las directivas
opentracing_tagpermiten que las variables de NGINX Plus estén disponibles como etiquetas de OpenTracing que aparecen en la interfaz de usuario del sistema de rastreo. - Para depurar la actividad de OpenTracing, quite los comentarios de las directivas
log_formatyaccess_log. Si desea sustituir el registro de acceso y el formato de registro predeterminados de NGINX por estos, quite los comentarios de las directivas y, a continuación, cambie las tres apariciones de «opentracing» por «main». Otra opción es registrar la actividad de OpenTracing únicamente para el tráfico del puerto 9001; quite los comentarios de las directivaslog_formatyaccess_logy muévalas al bloqueserver. - El bloque
serverconfigura OpenTracing para la aplicación Ruby de ejemplo descrita en la siguiente sección.
- Valide y vuelva a cargar la configuración de NGINX Plus:
$ nginx -t$ nginx -s reloadConfiguración de la aplicación Ruby de ejemplo
Una vez configurados el trazador y NGINX Plus, creamos una aplicación Ruby de ejemplo que muestra el aspecto de los datos de OpenTracing. La aplicación nos permite medir cuánto mejora el almacenamiento en caché de NGINX Plus el tiempo de respuesta. Cuando la aplicación recibe una solicitud como la siguiente solicitud HTTP GET para /, espera un tiempo aleatorio (entre 2 y 5 segundos) antes de responder.
$ curl http://NGINX-Plus-IP-address:9001/- Instale y configure tanto Ruby como Sinatra (una biblioteca de código abierto para aplicaciones web y un lenguaje específico de dominio escrito en Ruby que sirve como alternativa a otros frameworks de aplicaciones web de Ruby).
- Crea un archivo llamado app.rb con el siguiente contenido:
#!/usr/bin/ruby
require 'sinatra'
get '/*' do
out = "<h1>Ruby simple app</h1>" + "\n"
#Sleep a random time between 2s and 5s
sleeping_time = rand(4)+2
sleep(sleeping_time)
puts "slept for: #{sleeping_time}s."
out += '<p>some output text</p>' + "\n"
return out
end- Haz que app.rb sea ejecutable y ejecútalo:
$ chmod +x app.rb$ ./app.rbSeguimiento de los tiempos de respuesta sin almacenamiento en caché
Usamos Jaeger y Zipkin para mostrar cuánto tarda NGINX Plus en responder a una solicitud cuando el almacenamiento en caché no está habilitado. Enviamos cinco solicitudes para cada sistema de rastreo.
Salida de Jaeger sin almacenamiento en caché
Estas son las cinco solicitudes que se muestran en la interfaz de usuario de Jaeger (la más reciente primero):

Esta es la misma información en la consola de la aplicación Ruby:
- -> /slept for: 3s.
127.0.0.1 - - [07/Jun/2019: 10:50:46 +0000] "GET / HTTP/1.1" 200 49 3.0028
127.0.0.1 - - [07/Jun/2019: 10:50:43 UTC] "GET / HTTP/1.0" 200 49
- -> /
slept for: 2s.
127.0.0.1 - - [07/Jun/2019: 10:50:56 +0000] "GET / HTTP/1.1" 200 49 2.0018
127.0.0.1 - - [07/Jun/2019: 10:50:54 UTC] "GET / HTTP/1.0"1 200 49
- -> /
slept for: 3s.
127.0.0.1 - - [07/Jun/2019: 10:53:16 +0000] "GET / HTTP/1.1" 200 49 3.0029
127.0.0.1 - - [07/Jun/2019: 10:53:13 UTC] "GET / HTTP/1.0" 200 49
- -> /
slept for: 4s.
127.0.0.1 - - [07/Jun/2019: 10:54:03 +0000] "GET / HTTP/1.1" 200 49 4.0030
127.0.0.1 - - [07/Jun/2019: 10:53:59 UTC] "GET / HTTP/1.0" 200 49
- -> /
slept for: 3s.
127.0.0.1 - - [07/Jun/2019: 10:54:11 +0000] "GET / HTTP/1.1" 200 49 3.0012
127.0.0.1 - - [07/Jun/2019: 10:54:08 UTC] "GET / HTTP/1.0" 200 49En la interfaz de usuario de Jaeger, hacemos clic en la primera solicitud (la más reciente) para ver sus detalles, incluidos los valores de las variables de NGINX Plus que añadimos como etiquetas:

Salida de Zipkin sin almacenamiento en caché
Aquí se muestran otras cinco solicitudes en la interfaz de usuario de Zipkin:

La misma información en la consola de la aplicación Ruby:
- -> /slept for: 2s.
127.0.0.1 - - [07/Jun/2019: 10:31:18 +0000] "GET / HTTP/1.1" 200 49 2.0021
127.0.0.1 - - [07/Jun/2019: 10:31:16 UTC] "GET / HTTP/1.0" 200 49
- -> /
slept for: 3s.
127.0.0.1 - - [07/Jun/2019: 10:31:50 +0000] "GET / HTTP/1.1" 200 49 3.0029
127.0.0.1 - - [07/Jun/2019: 10:31:47 UTC] "GET / HTTP/1.0" 200 49
- -> /
slept for: 3s.
127.0.0.1 - - [07/Jun/2019: 10:32:08 +0000] "GET / HTTP/1.1" 200 49 3.0026
127.0.0.1 - - [07/Jun/2019: 10:32:05 UTC] "GET / HTTP/1.0" 200 49
- -> /
slept for: 3s.
127.0.0.1 - - [07/Jun/2019: 10:32:32 +0000] "GET / HTTP/1.1" 200 49 3.0015
127.0.0.1 - - [07/Jun/2019: 10:32:29 UTC] "GET / HTTP/1.0" 200 49
- -> /
slept for: 5s.
127.0.0.1 - - [07/Jun/2019: 10:32:52 +0000] "GET / HTTP/1.1" 200 49 5.0030
127.0.0.1 - - [07/Jun/2019: 10:32:47 UTC] "GET / HTTP/1.0" 200 49En la interfaz de usuario de Zipkin, hacemos clic en la primera solicitud para ver sus detalles, incluidos los valores de las variables de NGINX Plus que añadimos como etiquetas:

Seguimiento de los tiempos de respuesta con almacenamiento en caché
Configuración del almacenamiento en caché de NGINX Plus
Habilitamos el almacenamiento en caché añadiendo directivas en el archivo opentracing.conf que creamos en Configuración de NGINX Plus.
- En el contexto
http, añada esta directivaproxy_cache_path:
proxy_cache_path /data/nginx/cache keys_zone=one:10m;- En el bloque
server, añade las siguientes directivas:proxy_cacheyproxy_cache_validdirectives:
proxy_cache one;
proxy_cache_valid any 1m;- Valida y vuelve a cargar la configuración:
$ nginx -t$ nginx -s reloadSalida de Jaeger con almacenamiento en caché
Esta es la interfaz de usuario de Jaeger después de dos solicitudes.

La primera respuesta (identificada como «13f69db») tardó 4 segundos. NGINX Plus almacenó la respuesta en caché y, cuando se repitió la solicitud unos 15 segundos después, la respuesta tardó menos de 2 milisegundos (ms), ya que procedía de la caché de NGINX Plus.
Al examinar en detalle las dos solicitudes, se explica la diferencia en el tiempo de respuesta. En la primera solicitud, upstream_cache_status es MISS, lo que significa que los datos solicitados no estaban en la caché. La aplicación Ruby añadió un retraso de 4 segundos.

Para la segunda solicitud, upstream_cache_status es HIT. Como los datos proceden de la caché, la aplicación Ruby no puede añadir ningún retraso y el tiempo de respuesta es inferior a 2 ms. Los valores vacíos de upstream_* también indican que el servidor de origen no intervino en esta respuesta.

Salida de Zipkin con almacenamiento en caché
La visualización en la interfaz de usuario de Zipkin para dos solicitudes con el almacenamiento en caché habilitado muestra un panorama similar:

Y, de nuevo, examinar en detalle las dos solicitudes explica la diferencia en el tiempo de respuesta. La respuesta no está almacenada en caché para la primera solicitud (upstream_cache_status es MISS) y la aplicación Ruby añade (casualmente) el mismo retraso de 4 segundos que en el ejemplo de Jaeger.

La respuesta se ha almacenado en caché antes de realizar la segunda solicitud, por lo que upstream_cache_status es HIT.

Conclusión
El módulo OpenTracing de NGINX permite rastrear las solicitudes y respuestas de NGINX Plus, así como acceder a las variables de NGINX Plus mediante etiquetas de OpenTracing. También se pueden utilizar distintos sistemas de rastreo con este módulo.
Para obtener más información sobre el módulo NGINX OpenTracing, visite el NGINX OpenTracing repositorio del módulo en GitHub.
Para probar OpenTracing con NGINX Plus, inicie hoy mismo su prueba gratuita de 30 días o póngase en contacto con nosotros para hablar sobre sus casos de uso.
Sobre el autor
Artículos relacionados del blog
Únete a F5 NGINX en AppWorld 2024
Descubre las numerosas razones para asistir al evento insignia de F5, que incluirá un emocionante anuncio sobre la cartera de productos NGINX.
Rotación de certificados SSL/TLS sin reinicios en NGINX Open Source
La función de diccionario compartido permite configurar NGINX sin necesidad de reiniciarlo al renovar los certificados SSL/TLS.
Exposición de APIs en Kubernetes
La unidad 2 de Microservices March 2022 se centra en cómo exponer tus API en Kubernetes. Aquí tienes enlaces a los recursos que necesitas: la retransmisión en directo del 14 de marzo, artículos de blog y otros recursos de preparación, y el laboratorio práctico «Protege las API de Kubernetes mediante la limitación de solicitudes».
NGINX Sprint 2.0: visión clara, código renovado y nuevos compromisos con el código abierto
Hoy, en NGINX Sprint 2.0, anunciamos cómo respaldaremos nuestra visión del futuro de las aplicaciones modernas con una mayor presencia en la comunidad de código abierto, incluida la participación en el proyecto comunitario Kubernetes, nuevos proyectos de software de código abierto y la arquitectura de referencia para aplicaciones modernas.
Presentamos NGINX Plus R22
NGINX Plus R22 incorpora nuevas funcionalidades, como la compatibilidad con OCSP para verificar la revocación de certificados en TLS mutuo, el uso de varios proveedores de identidad OIDC en una configuración, el seguimiento en tiempo real de la limitación de solicitudes y conexiones en el panel de NGINX Plus y mejoras en NGINX JavaScript.
Presentamos NGINX Plus R17
NGINX Plus R17 incorpora compatibilidad con la limitación de velocidad en dos fases y con TLS 1.3, la versión más reciente del protocolo Transport Layer Security. La configuración de OpenID Connect es más sencilla y NGINX ModSecurity WAF es el doble de rápido que antes. También se ha actualizado el módulo JavaScript de NGINX.