Cómo implementar el seguimiento distribuido con Jaeger en Kubernetes

El autor seleccionó el Fondo de Ayuda COVID-19 para recibir una donación como parte del programa Write for DOnations.

Introducción

Kubernetes y las arquitecturas de microservicios que permite crear sistemas muy eficientes y escalables. Pero los problemas surgen cuando uno de estos microservicios desarrolla problemas de rendimiento. Normalmente, lo primero que notamos es que los tiempos de respuesta de nuestros servicios orientados al cliente son cada vez más largos. El problema puede estar en uno de los servicios de backend o quizás en una base de datos que está más allá de su capacidad óptima. Para descubrir la raíz de nuestro problema, necesitamos implementar un seguimiento distribuido.

Jaeger es una solución de rastreo distribuido y un graduado del proyecto de incubación de la Cloud Native Computing Foundation. Cuenta con una interfaz de usuario agradable para visualizar los rastreos, sidecars de Jaeger para recopilar los rastreos y varios otros componentes. Los sistemas de rastreo distribuido como Jaeger nos permiten rastrear el ciclo de vida de cada evento generado por el cliente y ver cómo cada servicio procesa ese evento.

En este tutorial, implementaremos una aplicación distribuida muy pequeña en un clúster de Kubernetes y simularemos un retraso en el rendimiento mediante una función de suspensión en nuestro código. Para encontrar la causa raíz de este problema y rastrear cada evento, usaremos Jaeger. Con el rastreo habilitado, veremos cuán eficaz es para observar el comportamiento de los servicios y detectar problemas.

Si está buscando un servicio de alojamiento de Kubernetes administrado, consulte nuestro servicio de Kubernetes simple y administrado diseñado para el crecimiento.

Prerrequisitos

Antes de comenzar, necesitará las siguientes herramientas y cuentas:

• Un clúster de Kubernetes 1.15+ con la configuración de conexión establecida como kubectlpredeterminada. Para crear un clúster de Kubernetes en DigitalOcean, lea nuestra Guía de inicio rápido de Kubernetes. Para conectarse al clúster, lea Cómo conectarse a un clúster de Kubernetes de DigitalOcean.
• Docker instalado. Sigue nuestro tutorial sobre cómo instalar y usar Docker para obtener instrucciones. El sitio web de Docker ofrece instrucciones de instalación para otros sistemas operativos como macOS y Windows.
• Una cuenta en Docker Hub para almacenar su imagen de Docker.
• La kubectlherramienta de línea de comandos instalada en su máquina local y configurada para conectarse a su clúster. Puede leer más sobre la instalación kubectlen la documentación oficial o seguir este tutorial sobre cómo comenzar a usar Kubernetes: una kubectlhoja de referencia.
• La curlutilidad de línea de comandos instalada en su equipo local. Puede instalarla curlutilizando el administrador de paquetes integrado en su sistema operativo.

Paso 1: creación de la aplicación de muestra

Para probar las capacidades de rastreo de Jaeger, crearemos e implementaremos una aplicación de muestra, sammy-jaegerque utiliza dos servicios: uno para el frontend y otro para el backend. Desarrollaremos ambos usando Python y el microframework Flask.

Nuestra aplicación será un contador de visitas cuyo valor aumenta cada vez que llamamos al frontend. Para simular problemas de rendimiento, codificaremos una función de suspensión aleatoria que se ejecuta cada vez que el frontend envía una GETsolicitud al backend. En este paso, crearemos e implementaremos esa aplicación. En los siguientes pasos, implementaremos la aplicación en Kubernetes, instalaremos Jaeger y luego la usaremos para rastrear nuestro problema de servicio.

Primero, creemos una estructura de directorio de proyecto y naveguemos dentro de ella:

mkdir -p ./sammy-jaeger/frontend ./sammy-jaeger/backend  cd ./sammy-jaeger

Ahora tenemos un directorio raíz, sammy-jaegery dos subdirectorios:

output.├── backend└── frontend

También cambiamos al directorio raíz, /sammy-jaeger. Ejecutaremos todos los comandos restantes desde aquí.

Comencemos a construir la aplicación frontend.

Construyendo la aplicación frontend

Usando su editor de texto preferido, cree y abra un nuevo archivo frontend.pyllamado ./frontend:

nano ./frontend/frontend.py

Agregue el siguiente código. Esto importará Flask, creará nuestras funciones de contador y definirá una ruta para las solicitudes HTTP:

./frontend/frontend.py

import osimport requestsfrom flask import Flaskapp = Flask(__name__)def get_counter(counter_endpoint):    counter_response = requests.get(counter_endpoint)    return counter_response.textdef increase_counter(counter_endpoint):    counter_response = requests.post(counter_endpoint)    return counter_response.text@app.route('/')def hello_world():    counter_service = os.environ.get('COUNTER_ENDPOINT', default="https://localhost:5000")    counter_endpoint = f'{counter_service}/api/counter'    counter = get_counter(counter_endpoint)    increase_counter(counter_endpoint)    return f"""Hello, World!You're visitor number {counter} in here!nn"""

Estamos importando tres módulos. El osmódulo se comunicará con nuestro sistema operativo. El requestsmódulo es una biblioteca para enviar solicitudes HTTP. Flask es un microframework que alojará nuestra aplicación.

Luego definimos nuestras funciones get_counter()y increase_counter(), que aceptan el parámetro counter_endpoint. get_counter()llamará al backend usando el GETmétodo para encontrar el estado actual del contador. increase_counter()llamará al backend con el POSTmétodo para incrementar el contador.

Luego definimos nuestra ruta /, que llamará a otra función llamada hello_world(). Esta función recuperará una URL y un puerto para nuestro pod de backend, lo asignará a una variable y luego pasará esa variable a nuestras primeras dos funciones, get_counter()y increase_counter(), que enviarán las solicitudes GETy POSTal backend. Luego, el backend hará una pausa durante un período de tiempo aleatorio (nuestro retraso simulado) antes de incrementar el número del contador actual y luego devolver ese número. Por último, hello_world()tomará este valor e imprimirá una cadena "Hello World!" en nuestra consola que incluye nuestro nuevo recuento de visitantes.

Es posible que hayas notado que no creamos un entorno de Python ni lo instalamos pipen nuestra máquina local. Completaremos estos pasos cuando contengamos nuestra aplicación con Docker.

Guardar y cerrar frontend.py.

Ahora crearemos un Dockerfile para la aplicación frontend. Este Dockerfile incluirá todos los comandos necesarios para crear nuestro entorno contenedorizado.

Crea y abre un nuevo Dockerfileen ./frontend:

nano ./frontend/Dockerfile

Añade el siguiente contenido:

./frontend/archivo Docker

FROM alpine:3.8RUN apk add --no-cache py3-pip python3      pip3 install flask requestsCOPY . /usr/src/frontendENV FLASK_APP frontend.pyWORKDIR /usr/src/frontendCMD flask run --host=0.0.0.0 --port=8000

En este ejemplo Dockerfile, le indicamos a nuestra imagen que se compile a partir de la imagen base de Alpine Linux. Luego, instalamos Python3, pipy varias dependencias adicionales. A continuación, copiamos el código fuente de la aplicación, configuramos una variable de entorno que apunta al código principal de la aplicación, configuramos el directorio de trabajo y escribimos un comando para ejecutar Flask cada vez que creamos un contenedor a partir de la imagen.

Guarde y cierre el archivo.

Ahora construyamos la imagen de Docker para nuestra aplicación frontend y enviémosla a un repositorio en Docker Hub.

Primero, verifique que haya iniciado sesión en Docker Hub:

docker login --username=your_username --password=your_password

Construye la imagen:

docker build -t your_username/do-visit-counter-frontend:v1 ./frontend

Ahora envíe la imagen a Docker Hub:

docker push your_username/do-visit-counter-frontend:v1

Nuestra aplicación frontend ya está compilada y disponible en Docker Hub. Sin embargo, antes de implementarla en Kubernetes, vamos a codificar y compilar nuestra aplicación backend.

Construyendo la aplicación backend

La aplicación backend requiere los mismos pasos que la aplicación frontend.

Primero, crea y abre un archivo llamado backend.pyen ./backend:

nano ./backend/backend.py

Agregue el siguiente contenido, que definirá dos funciones y otra ruta:

./backend/backend.py

from random import randintfrom time import sleepfrom flask import requestfrom flask import Flaskapp = Flask(__name__)counter_value = 1def get_counter():    return str(counter_value)def increase_counter():    global counter_value    int(counter_value)    sleep(randint(1,10))    counter_value += 1    return str(counter_value)@app.route('/api/counter', methods=['GET', 'POST'])def counter():    if request.method == 'GET':        return get_counter()    elif request.method == 'POST':        return increase_counter()

Estamos importando varios módulos, incluidos randomy sleep. Luego, configuramos nuestro valor de contador en 1y definimos dos funciones. La primera, get_counter, devuelve el valor de contador actual, que se almacena como counter_value. La segunda función, increase_counter, realiza dos acciones. Incrementa nuestro valor de contador en 1y usa el sleepmódulo para retrasar la finalización de la función por una cantidad de tiempo aleatoria.

El backend también tiene una ruta ( /api/counter) que acepta dos métodos: POSTy GET. Cuando llamamos a esta ruta usando el GETmétodo, llama get_counter()y devuelve nuestro valor de contador. Cuando llamamos a esta ruta usando el POSTmétodo, llama increase_counter()y aumenta el valor del contador mientras espera una cantidad de tiempo aleatoria.

Guarde y cierre el archivo.

Nuestra aplicación backend también requerirá su propia versión Dockerfile, que es casi idéntica a la versión del frontend.

Crea y abre un segundo Dockerfileen ./backend:

nano ./backend/Dockerfile

Agregue el siguiente contenido. La única diferencia importante aquí, además de las rutas de archivo, será el puerto:

./backend/Archivo Docker

FROM alpine:3.8RUN apk add --no-cache py3-pip python3      pip3 install flaskCOPY . /usr/src/backendENV FLASK_APP backend.pyWORKDIR /usr/src/backendCMD flask run --host=0.0.0.0 --port=5000

Guarde y cierre el archivo.

Ahora construye la imagen:

docker build -t your_username/do-visit-counter-backend:v1 ./backend

Envíalo a Docker Hub:

docker push your_username/do-visit-counter-backend:v1

Con nuestra aplicación disponible en Docker Hub, ahora estamos listos para implementarla en nuestro clúster y probarla en el siguiente paso.

Paso 2: Implementación y prueba de la aplicación

Escribir nuestro código y publicar nuestros contenedores fue nuestro primer paso importante. Ahora necesitamos implementar en Kubernetes y probar la aplicación básica. Después de eso, podemos agregar Jaeger y explorar el potencial del rastreo distribuido.

Comencemos con la implementación y las pruebas.

En este punto, nuestro árbol de directorios se ve así:

.├── backend│ ├── Dockerfile│ └── backend.py└── frontend    ├── Dockerfile    └── frontend.py

Para implementar esta aplicación en nuestro clúster, también necesitaremos dos manifiestos de Kubernetes; uno para cada mitad de la aplicación.

Crea y abre un nuevo archivo de manifiesto en ./frontend:

nano ./frontend/deploy_frontend.yaml

Agregue el siguiente contenido. Este manifiesto especificará cómo Kubernetes crea nuestra implementación (recuerde reemplazar la sección resaltada con su nombre de usuario de Docker Hub):

./frontend/deploy_frontend.yaml

apiVersion: apps/v1kind: Deploymentmetadata:  name: do-visit-counter-frontend  labels:    name: do-visit-counter-frontendspec:  replicas: 1  selector:    matchLabels:      app: do-visit-counter-frontend  template:    metadata:      labels:        app: do-visit-counter-frontend    spec:      containers:        - name: do-visit-counter-frontend          image: your_dockerhub_username/do-visit-counter-frontend:v1          imagePullPolicy: Always          env:            - name: COUNTER_ENDPOINT              value: "http://do-visit-counter-backend.default.svc.cluster.local:5000"          ports:            - name: frontend-port              containerPort: 8000              protocol: TCP

Hemos especificado que Kubernetes cree una implementación, la nombre do-visit-counter-frontendy que implemente una réplica utilizando nuestra imagen de interfaz en Docker Hub. También hemos configurado una variable de entorno llamada COUNTER_ENDPOINTpara vincular las dos mitades de nuestra aplicación.

Guarde y cierre el archivo.

Ahora crea el manifiesto para nuestra aplicación backend en ./backend:

nano ./backend/deploy_backend.yaml

Agregue el siguiente contenido, reemplazando nuevamente la sección resaltada con su nombre de usuario de Docker Hub:

./backend/deploy_backend.yaml

apiVersion: apps/v1kind: Deploymentmetadata:  name: do-visit-counter-backend  labels:    name: do-visit-counter-backendspec:  replicas: 1  selector:    matchLabels:      app: do-visit-counter-backend  template:    metadata:      labels:        app: do-visit-counter-backend    spec:      containers:        - name: do-visit-counter-backend          image: your_dockerhub_username/do-visit-counter-backend:v1          imagePullPolicy: Always          ports:            - name: backend-port              containerPort: 5000              protocol: TCP---apiVersion: v1kind: Servicemetadata:    name: do-visit-counter-backendspec:    selector:        app: do-visit-counter-backend    ports:        - protocol: TCP          port: 5000          targetPort: 5000

En este manifiesto, se define una implementación y un servicio para nuestro backend. La implementación describe cómo y qué ejecutará el contenedor. Tenga en cuenta que nuestro puerto ha cambiado de 8000estar en el frontend a 5000estar en el backend. El servicio permite conexiones entre clústeres desde el frontend hasta el backend.

Guarde y cierre el archivo.

Ahora implementemos nuestro contador en el clúster usando kubectl. Comencemos con el frontend:

kubectl apply -f ./frontend/deploy_frontend.yaml

Y luego implementa el backend:

kubectl apply -f ./backend/deploy_backend.yaml

Para verificar que todo funciona, llame a kubectl get pods:

kubectl get pods

Verás un resultado como este:

OutputNAME                                         READY   STATUS    RESTARTS   AGEdo-visit-counter-backend-79f6964-prqpb       1/1     Running   0          3mdo-visit-counter-frontend-6985bdc8fd-92clz   1/1     Running   0          3m

Queremos todos los pods del READYestado. Si aún no están listos, espere unos minutos y vuelva a ejecutar el comando anterior.

Por último, queremos utilizar nuestra aplicación. Para ello, reenviaremos puertos desde el clúster y luego nos comunicaremos con el frontend mediante el curlcomando. Asegúrese de abrir una segunda ventana de terminal porque el reenvío de puertos bloqueará una ventana.

Utilice kubectlpara reenviar el puerto:

kubectl port-forward $(kubectl get pods -l=app="do-visit-counter-frontend" -o name) 8000:8000

Ahora, en una segunda ventana de terminal, envíe tres solicitudes a su aplicación frontend:

for i in 1 2 3; do curl localhost:8000; done

Cada curlllamada incrementará el número de visitas. Verá un resultado como este:

OutputHello, World!You're visitor number 1 in here!Hello, World!You're visitor number 2 in here!Hello, World!You're visitor number 3 in here!

Nuestro contador de visitas funciona correctamente, pero es probable que hayas notado un retraso entre cada respuesta. Esto es el resultado de nuestra función de suspensión, que simula un retraso en el rendimiento.

Con nuestra aplicación distribuida lista, es hora de instalar Jaeger y rastrear estos eventos.

Paso 3: Implementación de Jaeger

La especialidad de Jaeger es recopilar rastros y visualizarlos. En este paso, implementaremos Jaeger en nuestro clúster para que pueda detectar nuestros retrasos en el rendimiento.

La documentación oficial de Jaeger incluye comandos para instalar el operador Jaeger. También incluye cuatro manifiestos adicionales que debes implementar para que la herramienta funcione. Hagámoslo ahora:

En primer lugar, cree la definición de recurso personalizada que requiere el operador de Jaeger. Usaremos las plantillas recomendadas disponibles en la documentación oficial de Jaeger:

kubectl create -f https://raw.githubusercontent.com/jaegertracing/jaeger-operator/master/deploy/crds/jaegertracing.io_jaegers_crd.yaml

A continuación, cree una cuenta de servicio, un rol y un enlace de rol para el control de acceso basado en roles:

kubectl create -f https://raw.githubusercontent.com/jaegertracing/jaeger-operator/master/deploy/service_account.yaml
kubectl create -f https://raw.githubusercontent.com/jaegertracing/jaeger-operator/master/deploy/role.yaml
kubectl create -f https://raw.githubusercontent.com/jaegertracing/jaeger-operator/master/deploy/role_binding.yaml

Por último, implementa el operador Jaeger:

kubectl create -f https://raw.githubusercontent.com/jaegertracing/jaeger-operator/master/deploy/operator.yaml

El operador en sí no significa que tengamos a Jaeger funcionando. Aquí es donde entran en juego las definiciones de recursos personalizados. Necesitamos crear un recurso que describa la instancia de Jaeger que queremos que administre el operador. Una vez más, seguiremos los pasos que se indican en la documentación oficial de Jaeger:

Utilice un heredoc para crear este recurso desde la línea de comando:

kubectl apply -f - EOF
apiVersion: jaegertracing.io/v1
kind: Jaeger
metadata:
  name: simplest
EOF

Presione ENTERpara crear el recurso.

Ahora revisa tus implementaciones nuevamente:

kubectl get pods

Verá una salida con su operador Jaeger y la simplestimplementación:

OutputNAME                                                   READY   STATUS    RESTARTS   AGEdo-visit-counter-backend-79f6964-prqpb                 1/1     Running   0          3mdo-visit-counter-frontend-6985bdc8fd-92clz             1/1     Running   0          3mjaeger-operator-547567dddb-rxsd2                       1/1     Running   0          73ssimplest-759cb7d586-q6x28                              1/1     Running   0          42s

Para validar que Jaeger está funcionando correctamente, reenvíemos su puerto y veamos si podemos acceder a la interfaz de usuario:

kubectl port-forward $(kubectl get pods -l=app="jaeger" -o name) 16686:16686

Abra un navegador y navegue hasta http://localhost:16686. Se cargará la interfaz de usuario de Jaeger.

Tanto nuestra aplicación como Jaeger funcionan. En el siguiente paso, agregaremos instrumentación para permitir que Jaeger recopile datos y detecte nuestro retraso en el rendimiento.

Paso 4: Agregar instrumentación

Si bien Jaeger automatiza muchas tareas cuando se utiliza con Kubernetes, aún necesitamos agregar instrumentación manualmente a nuestra aplicación. Afortunadamente, tenemos el módulo Flask-OpenTracing para manejar esa tarea.

OpenTracing es uno de los estándares de rastreo distribuido. Fue propuesto por los autores de Jaeger con el objetivo de que también admita otras herramientas de rastreo. Es independiente del proveedor y admite muchos lenguajes de programación y marcos populares.

Como es el caso con todas las implementaciones de OpenTracing, necesitamos modificar nuestras aplicaciones originales agregando la configuración de Jaeger y adjuntando los decoradores de seguimiento a los puntos finales que queremos rastrear.

Agreguemos Flask-OpenTracing a nuestro código frontend.

Reabrir .frontend.py:

nano ./frontend/frontend.py

Ahora agregue el siguiente código resaltado, que integrará OpenTracing:

./frontend/frontend.py

import osimport requestsfrom flask import Flaskfrom jaeger_client import Configfrom flask_opentracing import FlaskTracingapp = Flask(__name__)config = Config(    config={        'sampler':        {'type': 'const',         'param': 1},                        'logging': True,                        'reporter_batch_size': 1,},                         service_name="service")jaeger_tracer = config.initialize_tracer()tracing = FlaskTracing(jaeger_tracer, True, app)def get_counter(counter_endpoint):    counter_response = requests.get(counter_endpoint)    return counter_response.textdef increase_counter(counter_endpoint):    counter_response = requests.post(counter_endpoint)    return counter_response.text@app.route('/')def hello_world():    counter_service = os.environ.get('COUNTER_ENDPOINT', default="https://localhost:5000")    counter_endpoint = f'{counter_service}/api/counter'    counter = get_counter(counter_endpoint)    increase_counter(counter_endpoint)    return f"""Hello, World!You're visitor number {counter} in here!nn"""

Guarde y cierre el archivo. Puede obtener más información sobre las configuraciones de Flask OpenTracing en su página de GitHub.

Ahora abre el código de tu aplicación backend:

nano ./backend/backend.py

Añade el código resaltado. Es el mismo código que pusimos en frontend.py:

./backend/backend.py

from random import randintfrom time import sleepfrom flask import Flaskfrom flask import requestfrom jaeger_client import Configfrom flask_opentracing import FlaskTracingapp = Flask(__name__)config = Config(    config={        'sampler':        {'type': 'const',         'param': 1},                        'logging': True,                        'reporter_batch_size': 1,},                         service_name="service")jaeger_tracer = config.initialize_tracer()tracing = FlaskTracing(jaeger_tracer, True, app)counter_value = 1def get_counter():    return str(counter_value)def increase_counter():    global counter_value    int(counter_value)    sleep(randint(1,10))    counter_value += 1    return str(counter_value)@app.route('/api/counter', methods=['GET', 'POST'])def counter():    if request.method == 'GET':        return get_counter()    elif request.method == 'POST':        return increase_counter()

Guarde y cierre el archivo.

Como estamos agregando bibliotecas adicionales, también tenemos que modificar las nuestras Dockerfilespara ambos servicios.

Abra Dockerfileel frontend:

nano ./frontend/Dockerfile

Añade el código resaltado:

./frontend/archivo Docker

FROM alpine:3.8RUN apk add --no-cache py3-pip python3      pip3 install flask requests Flask-Opentracing jaeger-clientCOPY . /usr/src/frontendENV FLASK_APP frontend.pyWORKDIR /usr/src/frontendCMD flask run --host=0.0.0.0 --port=8000

Guarde y cierre el archivo.

Ahora abre el backend Dockerfile:

nano ./backend/Dockerfile

Añade el código resaltado:

./backend/Archivo Docker

FROM alpine:3.8RUN apk add --no-cache py3-pip python3      pip3 install flask Flask-Opentracing jaeger-clientCOPY . /usr/src/backendENV FLASK_APP backend.pyWORKDIR /usr/src/backendCMD flask run --host=0.0.0.0 --port=5000

Con estos cambios, queremos reconstruir y lanzar las nuevas versiones de nuestros contenedores.

Cree y envíe la aplicación frontend. Tenga en cuenta la v2etiqueta al final:

docker build -t your_username/do-visit-counter-frontend:v2 ./frontend
docker push your_username/do-visit-counter-frontend:v2

Ahora construya y envíe la aplicación backend:

docker build -t your_username/do-visit-counter-backend:v2 ./backend
docker push your_username/do-visit-counter-backend:v2

Nuestro sistema de rastreo distribuido requiere una última pieza: queremos inyectar sidecars de Jaeger en nuestros pods de aplicación para escuchar los rastros del pod y reenviarlos al servidor de Jaeger. Para eso, necesitamos agregar una anotación a nuestros manifiestos.

Abra el manifiesto para el frontend:

nano ./frontend/deploy_frontend.yaml

Agrega el código resaltado. Ten en cuenta que también estamos reemplazando nuestra imagen con la v2versión. Asegúrate de revisar esa línea y agregar tu nombre de usuario de Docker Hub:

./frontend/deploy_frontend.yaml

apiVersion: apps/v1kind: Deploymentmetadata:  name: do-visit-counter-frontend  labels:    name: do-visit-counter-frontend  annotations:    "sidecar.jaegertracing.io/inject": "true"spec:  replicas: 1  selector:    matchLabels:      app: do-visit-counter-frontend  template:    metadata:      labels:        app: do-visit-counter-frontend    spec:      containers:        - name: do-visit-counter-frontend             image: your_dockerhub_username/do-visit-counter-frontend:v2          imagePullPolicy: Always          env:            - name: COUNTER_ENDPOINT              value: "http://do-visit-counter-backend.default.svc.cluster.local:5000"          ports:            - name: frontend-port              containerPort: 8000              protocol: TCP

Esta anotación inyectará un sidecar Jaeger en nuestro pod.

Guarde y cierre el archivo.

Ahora abra el manifiesto para el backend:

nano ./backend/deploy_backend.yaml

Repita el proceso, agregando las líneas resaltadas para inyectar el sidecar de Jaeger y actualizando su etiqueta de imagen:

./backend/deploy_backend.yaml

apiVersion: apps/v1kind: Deploymentmetadata:  name: do-visit-counter-backend  labels:    name: do-visit-counter-backend  annotations:    "sidecar.jaegertracing.io/inject": "true"spec:  replicas: 1  selector:    matchLabels:      app: do-visit-counter-backend  template:    metadata:      labels:        app: do-visit-counter-backend    spec:      containers:        - name: do-visit-counter-backend             image: your_dockerhub_username/do-visit-counter-backend:v2          imagePullPolicy: Always          ports:            - name: backend-port              containerPort: 5000              protocol: TCP---apiVersion: v1kind: Servicemetadata:    name: do-visit-counter-backendspec:    selector:        app: do-visit-counter-backend    ports:        - protocol: TCP          port: 5000          targetPort: 5000

Con nuestros nuevos manifiestos en su lugar, necesitamos aplicarlos al clúster y esperar a que se creen los pods.

Eliminemos nuestros recursos antiguos:

kubectl delete -f ./frontend/deploy_frontend.yaml
kubectl delete -f ./backend/deploy_backend.yaml

Y luego reemplázalos:

kubectl apply -f ./frontend/deploy_frontend.yaml
kubectl apply -f ./backend/deploy_backend.yaml

Esta vez los pods para nuestras aplicaciones constarán de dos contenedores: uno para la aplicación y un segundo para el sidecar de Jaeger.

Utilice kubectlpara comprobar esto:

kubectl get pods

Nuestros pods de aplicación ahora aparecen 2/2en la READYcolumna:

OutputNAME                                                   READY   STATUS    RESTARTS   AGEjaeger-operator-547567dddb-rxsd2                       1/1     Running   0          23msimplest-759cb7d586-q6x28                              1/1     Running   0          22mdo-visit-counter-backend-694c7db576-jcsmv              2/2     Running   0          73sdo-visit-counter-frontend-6d7d47f955-lwdnf             2/2     Running   0          42s

Con nuestros sidecars e instrumentación en su lugar, ahora podemos volver a ejecutar nuestro programa e investigar los rastros en la interfaz de usuario de Jaeger.

Paso 5: Investigar rastros en Jaeger

Ahora podemos aprovechar los beneficios del seguimiento. El objetivo aquí es ver qué llamada podría ser un problema de rendimiento al observar la interfaz de usuario de Jaeger. Por supuesto, si queremos ver algunos rastros en la interfaz de usuario, primero tenemos que generar algunos datos mediante nuestra aplicación.

Vamos a configurar esto abriendo una segunda y una tercera ventana de terminal. Usaremos dos ventanas para redireccionar los puertos de Jaeger y nuestra aplicación, y la tercera para enviar solicitudes HTTP al frontend desde nuestra máquina a través de curl.

En la primera ventana, reenvíe el puerto para el servicio frontend:

kubectl port-forward $(kubectl get pods -l=app="do-visit-counter-frontend" -o name) 8000:8000

En la segunda ventana, reenvíe el puerto para Jaeger:

					

												


							
															

									SUSCRÍBETE A NUESTRO BOLETÍN 								
							
															

									No te pierdas de nuestro contenido ni de ninguna de nuestras guías para que puedas avanzar en los juegos que más te gustan.								
							
						
						
						
					
				
			

		

			Correo Electronico
			

		
			

		
			

		
							

					Al suscribirte, aceptas nuestra política de privacidad y nuestros términos de servicio.				
						

			
			


Tal vez te puede interesar:

Cómo agregar efectos de sonido a tus aplicaciones React
Cómo utilizar el modo independiente de Certbot para recuperar certificados SSL de Let's Encrypt en Debian 10
Cómo instalar el servidor web Apache en Debian 10
Obtención de datos de ubicación con Ionic 4 y Capacitor