Cómo instalar y usar Linkerd con Kubernetes

El autor seleccionó el Tech Education Fund para que recibiese una donación como parte del programa Write for DOnations.

Introducción

Una malla de servicios es una capa de infraestructura dedicada que ayuda a los administradores a gestionar la comunicación de servicio a servicio. Al ofrecer muchas herramientas potentes, estas mallas de servicios pueden hacer que su sistema sea más seguro, confiable y, también, más visible.

Una malla de servicios como Linkerd, por ejemplo, puede cifrar automáticamente conexiones; gestionar reintentos de solicitudes y tiempos de espera; proporcionar información de telemetría, como tasas de éxito y latencias; y más.

En este tutorial, instalará la malla de servicios Linkerd en su clúster de Kubernetes, implementará una aplicación de ejemplo y, luego, explorará el panel de Linkerd. Después de familiarizarse con cierta información de este panel, configurará Linkerd para aplicar políticas de timeout y retry para un pod de Kubernetes en particular.

De forma alternativa, considere la opción de instalación de Linkerd/Kubernetes en un solo clic de DigitalOcean.

Requisitos previos

• Un clúster de Kubernetes 1.12+. En este tutorial, se usará un clúster de Kubernetes de DigitalOcean con tres nodos para la configuración, pero puede crear un clúster usando otro método.

• La herramienta de línea de comandos kubectl instalada en un servidor de desarrollo y configurada para conectarse a su clúster. Puede encontrar más información sobre la instalación de kubectl en su documentación oficial.

Paso 1: Implementar la aplicación

Para ver Linkerd en acción, debe tener una aplicación en ejecución en su clúster. En este paso, implementará una aplicación denominada emojivoto, que el equipo de Linkerd creó para este propósito.

En este repositorio, puede ver el código de los cuatro servicios que componen la aplicación, así como el archivo de manifiesto que usará para implementar estos servicios en su clúster de Kubernetes.

Primero, guarde este archivo de manifiesto de forma local:

curl https://run.linkerd.io/emojivoto.yml --output manifest.yaml

Utiliza curl para obtener el archivo y, luego, pasa la opción --output para indicarle dónde desea guardar el archivo. En este caso, está creando un archivo denominado manifest.yaml.

Para comprender mejor lo que hace este archivo, inspeccione su contenido con cat o ábralo con su editor favorito:

cat manifest.yaml | less

Presione la barra espaciadora para desplazarse por las directivas. Verá que manifest.yaml crea un espacio de nombres de Kubernetes denominado emojivoto, donde se ejecutará todo lo relacionado con esta aplicación, y algunos Deployments y Services de Kubernetes.

A continuación, aplique este manifiesto en su clúster de Kubernetes:

kubectl apply -f manifest.yaml

Una vez más, está usando kubectl apply con el indicador -f para asignar un archivo que quiere aplicar.

Este comando generará una lista de todos los recursos que se crearon:

Output
namespace/emojivoto created
serviceaccount/emoji created
serviceaccount/voting created
serviceaccount/web created
service/emoji-svc created
service/voting-svc created
service/web-svc created
deployment.apps/emoji created
deployment.apps/vote-bot created
deployment.apps/voting created
deployment.apps/web created

Ahora, compruebe que los servicios se estén ejecutando:

kubectl -n emojivoto get pods

Utiliza kubectl para enumerar todos los pods que tiene en ejecución en su clúster y, luego, pasa el indicador -n para indicar los espacios de nombres que quiere usar. Pasa el espacio de nombre emojivoto porque allí es donde está ejecutando todos estos servicios.

Estará listo cuando vea todos los pods con estado Running (En ejecución):

Output
NAME                        READY   STATUS    RESTARTS   AGE
emoji-566954596f-cw75b      1/1     Running   0          24s
vote-bot-85c5f5699f-7dw5c   1/1     Running   0          24s
voting-756995b6fc-czf8z     1/1     Running   0          24s
web-7f7b69d467-2546n        1/1     Running   0          23s

Por último, para ver la aplicación en ejecución en su navegador, usará la función integrada kubectl para reenviar solicitudes locales a su clúster remoto:

kubectl -n emojivoto port-forward svc/web-svc 8080:80

Aquí, nuevamente, está usando kubectl en los espacios de nombres emojivoto, pero, ahora, está invocando el subcomando port-forward y le está indicando que reenvíe todas las solicitudes locales del puerto 8080 al servicio de Kubernetes web-svc, en el puerto 80. Esta es, simplemente, una forma conveniente de acceder a su aplicación sin necesidad de tener un equilibrador de carga adecuado establecido.

Ahora, diríjase a http://localhost:8080 para ver la aplicación emojivoto.

Presione CTRL + C en su terminal. Ahora que tiene una aplicación en ejecución en su clúster, está listo para instalar Linkerd y ver cómo funciona.

Paso 2: Instalar Linkerd

Ahora que tiene una aplicación en ejecución, instalaremos Linkerd. Para instalarlo en su clúster de Kubernetes, primero, necesita la CLI de Linkerd. Utilizará esta interfaz de línea de comandos para interactuar con Linkerd desde su máquina local. Luego, puede instalar Linkerd en su clúster.

Primero, instalaremos la CLI con la secuencia de comandos proporcionada por el equipo Linkerd:

curl https://run.linkerd.io/install | sh

Aquí, utiliza curl para descargar la secuencia de comandos de instalación y, luego, canaliza el resultado a sh, que la ejecuta de forma automática. De forma alternativa, puede descargar la CLI directamente de la página de lanzamientos de Linkerd.

Si utiliza la secuencia de comandos, esta instalará Linkerd en ~/.linkerd2/bin. Ahora, confirme que la CLI esté funcionando correctamente:

~/.linkerd2/bin/linkerd version

El comando generará algo similar a esto:

Output
Client version: stable-2.7.1
Server version: unavailable

Luego, para facilitar la ejecución de CLI, añada este directorio a su $PATH:

export PATH=$PATH:$HOME/.linkerd2/bin

Ahora, puede ejecutar los comandos, como el anterior, de forma más directa:

linkerd version

Por último, instalaremos Linkerd en su clúster de Kubernetes. El comando linkerd install se utiliza para generar todos los manifiestos yaml necesarios para ejecutar Linkerd, pero no los aplica a su clúster. Ejecute este comando para inspeccionar su resultado:

linkerd install

Verá un resultado largo que enumera todos los manifiestos yaml de los recursos que Linkerd necesita para ejecutarse. Para aplicar estos manifiestos a su clúster, ejecute lo siguiente:

linkerd install | kubectl apply -f -

La ejecución de linkerd install generará todos los manifiestos que vio anteriormente. Luego, | canaliza el resultado directamente a kubectl apply para que los aplique.

Cuando ejecute este comando, kubectl apply generará una lista de todos los recursos que se crearon.

Para confirmar que todo se esté ejecutando en su clúster, ejecute linkerd check:

linkerd check

Con esto, se ejecutarán varias verificaciones de su clúster para confirmar que todos los componentes necesarios se estén ejecutando:

Output
kubernetes-api
--------------
√ can initialize the client
√ can query the Kubernetes API

[...]

control-plane-version
---------------------
√ control plane is up-to-date
√ control plane and cli versions match

Status check results are √

Por último, ejecute este comando para abrir el panel de Linkerd integrado en su navegador (recuerde que deberá proporcionar el indicador --address 0.0.0.0 si no está ejecutando el comando desde su máquina local):

linkerd dashboard

Puede obtener la mayoría de la información que ve en el panel usando la CLI de Linkerd. Por ejemplo, ejecute este comando para ver implementaciones con estadísticas de alto nivel:

linkerd stat deployments -n linkerd

Aquí, está indicando que quiere las estadísticas de las implementaciones que se están ejecutando en el espacio de nombres linkerd. Estos son los componentes propios de Linkerd y, curiosamente, se puede usar el mismo Linkerd para monitorearlos. Puede ver estadísticas como las solicitudes por segundo (RPS), la tasa de éxito, la latencia y más. También puede ver la columna Meshed, que indica la cantidad de pods que insertó Linkerd:

Output
NAME                     MESHED   SUCCESS      RPS   LATENCY_P50   LATENCY_P95   LATENCY_P99   TCP_CONN
linkerd-controller          1/1   100.00%   0.4rps           1ms          87ms          98ms          5
linkerd-destination         1/1   100.00%   0.3rps           1ms           2ms           2ms         13
linkerd-grafana             1/1   100.00%   0.3rps           2ms           3ms           3ms          2
linkerd-identity            1/1   100.00%   0.3rps           1ms           2ms           2ms         10
linkerd-prometheus          1/1   100.00%   0.7rps          35ms         155ms         191ms          9
linkerd-proxy-injector      1/1   100.00%   0.3rps           2ms           3ms           3ms          2
linkerd-sp-validator        1/1   100.00%   0.3rps           1ms           5ms           5ms          2
linkerd-tap                 1/1   100.00%   0.3rps           1ms           4ms           4ms          6
linkerd-web                 1/1   100.00%   0.3rps           1ms           2ms           2ms          2

Ahora, pruebe este comando en su espacio de nombres emojivoto:

linkerd stat deployments -n emojivoto

Si bien puede ver los cuatro servicios, ninguna de las estadísticas que vio está disponible para estas implementaciones, y puede observar que el valor de la columna “Meshed” es 0/1:

Output
NAME       MESHED   SUCCESS   RPS   LATENCY_P50   LATENCY_P95   LATENCY_P99   TCP_CONN
emoji         0/1         -     -             -             -             -          -
vote-bot      0/1         -     -             -             -             -          -
voting        0/1         -     -             -             -             -          -
web           0/1         -     -             -             -             -          -

Este resultado indica que todavía no insertó Linkerd en la aplicación. Ese será su siguiente paso.

Paso 3: Insertar Linkerd en su aplicación

Ahora que tiene Linkerd activo en su clúster, está listo para insertarlo en su aplicación emojivoto.

Linkerd funciona ejecutando un contenedor sidecar en sus pods de Kubernetes. Es decir, insertará un contenedor proxy linkerd en cada pod que tenga en ejecución. Cada solicitud que sus pods envíen o reciban, luego, pasará por este proxy muy ligero que recopila métricas (como la tasa de éxito, las solicitudes por segundo y la latencia) y aplica políticas (como tiempos de espera y reintentos).

Puede insertar el proxy de Linkerd de forma manual con este comando:

kubectl get deployments -n emojivoto -o yaml | linkerd inject - | kubectl apply -f -

En este comando, primero, utiliza kubectl get para obtener todas las deployments de Kubernetes que tiene activas en el espacio de nombres emojivoto y, luego, especifica que quiere el resultado en formato yaml. Luego, envía ese resultado al comando linkerd inject. Este comando lee el archivo yaml con los manifiestos que tiene en ejecución y lo modifica para que incluya el proxy linkerd en cada deployment.

Por último, recibe este manifiesto modificado y lo aplica a su clúster con kubectl apply.

Después de ejecutar este comando, verá un mensaje que indica que los cuatro servicios para emojivoto (emoji, vote-bot, voting y web) se insertaron correctamente.

Si consulta las stats de emojivoto, verá que, ahora, todas sus deployments están interconectadas, y, después de unos segundos, empezará a ver las mismas estadísticas que vio para el espacio de nombres linkerd:

linkerd stat deployments -n emojivoto

Aquí, puede ver las estadísticas de los cuatro servicios que componen la aplicación emojivoto, con sus solicitudes por segundo, su tasa de éxito y latencia respectivas, sin necesidad de escribir ni cambiar ningún código de la aplicación.

Output
NAME       MESHED   SUCCESS      RPS   LATENCY_P50   LATENCY_P95   LATENCY_P99   TCP_CONN
emoji         1/1   100.00%   1.9rps           1ms           2ms           2ms          2
vote-bot      1/1         -        -             -             -             -          -
voting        1/1    85.96%   0.9rps           1ms           1ms           1ms          2
web           1/1    93.04%   1.9rps           8ms          27ms          29ms          2

No se muestra ninguna estadística del servicio vote-bot porque es solo un bot que envía solicitudes a otros servicios y, por lo tanto, no recibe nada de tráfico, que, en sí, es información valiosa.

Ahora, veamos cómo puede proporcionar a Linkerd más información sobre sus servicios para personalizar su comportamiento.

Paso 4: Definir un perfil de servicio

Ahora que insertó Linkerd en su aplicación, puede comenzar a obtener información valiosa sobre el comportamiento de cada uno de sus servicios. Observe que lo hizo sin necesidad de escribir ninguna configuración personalizada ni de cambiar el código de su aplicación. Sin embargo, si proporciona a Linkerd un poco más de información puede aplicar numerosas políticas, como tiempos de espera y reintentos. También puede proporcionar métricas por ruta.

Esta información se proporciona mediante un perfil de servicio, que es un recurso de Linkerd personalizado en el que puede describir las rutas de sus aplicaciones y cómo se comporta cada una de ellas.

Puede ver el aspecto del manifiesto de un perfil de servicio en este ejemplo:

apiVersion: linkerd.io/v1alpha2
kind: ServiceProfile
metadata:
  name: my-service.my-namespace.svc.cluster.local
spec:
  routes:
  - name: My Route Name
    isRetryable: true # Define it's safe to retry this route
    timeout: 100ms # Define a timeout for this route
    condition:
      method: GET
      pathRegex: /my/route/path

El perfil de servicio describe una lista de rutas y, luego, define el comportamiento que tendrán las solicitudes que coinciden con la condition especificada. En este ejemplo, indica que cada solicitud GET que se envíe a /my/route/path tendrá un tiempo de espera de 100 ms y, si presenta un error, se podrá reintentar.

Ahora, crearemos un perfil de servicio para uno de sus servicios. Tomando voting-svc como ejemplo, primero, utilice la CLI de Linkerd para verificar las rutas que definió para este servicio:

linkerd routes svc/voting-svc -n emojivoto

Aquí, utiliza el comando linkerd routes para enumerar todas las rutas del servicio voting-svc en el espacio de nombres emojiovoto:

Output
ROUTE          SERVICE   SUCCESS      RPS   LATENCY_P50   LATENCY_P95   LATENCY_P99
[DEFAULT]   voting-svc    83.05%   1.0rps           1ms           1ms           2ms

Verá una sola ruta: [DEFAULT]. Aquí es donde se agrupan todas las solicitudes hasta que defina su perfil de servicio.

Ahora, abra nano o su editor favorito para crear un archivo service-profile.yaml:

nano service-profile.yaml

Añada la siguiente definición de perfil de servicio a este archivo:

apiVersion: linkerd.io/v1alpha2
kind: ServiceProfile
metadata:
  name: voting-svc.emojivoto.svc.cluster.local
  namespace: emojivoto
spec:
  routes:
  - name: VoteDoughnut
    isRetryable: true
    timeout: 100ms
    condition:
      method: POST
      pathRegex: /emojivoto.v1.VotingService/VoteDoughnut

Ahora, guarde el archivo y cierre su editor.

Aquí, declara un perfil de servicio para el servicio voting-svc en el espacio de nombres emojivoto. Definió una ruta, denominada VoteDoughnut, que hará coincidir toda solicitud POST con la ruta /emojivoto.v1.VotingService/VoteDoughnut.  Si una solicitud que coincida con estos criterios requiere más de 100 ms, Linkerd la cancelará, y el cliente recibirá una respuesta 504. También le indica a Linkerd que, si la solicitud presenta un error, se puede volver a intentar.

Ahora, aplique este archivo a su clúster:

kubectl apply -f service-profile.yaml

Después de algunos segundos, vuelva a revisar las rutas de este servicio:

linkerd routes svc/voting-svc -n emojivoto

Ahora, verá la ruta de VoteDoughnut que acaba de definir:

Output
ROUTE             SERVICE   SUCCESS      RPS   LATENCY_P50   LATENCY_P95   LATENCY_P99
VoteDoughnut   voting-svc     0.00%   0.2rps           1ms           1ms           1ms
[DEFAULT]      voting-svc   100.00%   0.8rps           1ms           4ms           4ms

Puede ver varias métricas personalizadas, como la tasa de éxito, las solicitudes por segundo y latencia, de esta ruta específica. Observe que el punto final VoteDoughnut se configuró intencionalmente para que siempre devuelva un error, y tiene una tasa de éxito del 0 %, mientras que la de la ruta [DEFAULT] es del 100 %.

Ahora, después de proporcionar a Linkerd un poco más de información sobre su servicio, cuenta con métricas personalizadas por ruta y tiene dos políticas implementadas: tiempos de espera y reintentos.

Conclusión

En este artículo, instaló Linkerd en su clúster de Kubernetes y lo utilizó para monitorear una aplicación de ejemplo. Obtuvo información de telemetría útil, como la tasa de éxito, el rendimiento y latencia. También configuró un perfil de servicio de Linkerd para recopilar métricas por ruta e implementar dos políticas en la aplicación emojivoto.

Si desea obtener más información sobre Linkerd, puede consultar su excelente página de documentación, en la que se indica cómo proteger sus servicios, configurar seguimiento distribuido, automatizar versiones controladas (canary) y mucho más.

En este punto, también podría considerar probar Istio, que es otra malla de servicios con un conjunto diferente de funciones, ventajas y desventajas.