En el post anterior se habló de lo que es un Service Mesh e instalamos Istio. Hoy toca hablar sobre Linkerd, es un Service Mesh que no cuenta con tantas cosas como Istio, ¿esto es malo?, no es malo por que lo que hace, lo hace bien. En comparación con Istio no es necesario crear los Istio ingress o gateways, solo se encarga del Service Mesh. Linkerd tiene mejor performance que Istio (según la documentación de Linkerd claro está). Como Linkerd es más pequeño puedes tener un ahorro en el costo de tu cluster de Kubernetes en tu proveedor de la nube. Al igual que Istio cuenta con mTLS entre los microservicios cuando se inyecta el sidecar (proxy) de Linkerd, esta de más decir que esto te agregará un poco de latencia en tu aplicación. Acá esta el video para que vayas conmigo haciendo el tutorial:
## Instalación Al igual que Istio debemos instalar un cliente: ```bash curl --proto '=https' --tlsv1.2 -sSfL https://run.linkerd.io/install-edge | sh ``` Y mover el cliente a una ruta de tu Path para que funcione y listo. Puedes ejecutar el siguiente comando para probar que esté funcionando: ```bash linkerd version ```
Como solo hemos instalado el client veras un error en el server (control plane), esto es normal y más adelante lo solucionamos. Ahora debemos comprobar que nuestro cluster de kubernetes cumple con la configuración de Linkerd. ```bash linkerd check --pre ``` El último paso de la instalación es instalar el CRD de Linkerd en nuestro cluster: ```bash linkerd install --crds | kubectl apply -f - linkerd install | kubectl apply -f - ``` Para la validación de la instalación puedes ejecutar el siguiente comando: ```bash linkerd check ``` o puedes verificar que ya está en estado RUNNING todo lo que se encuentra en el namespace linkerd: ```bash kubectl get all -n linkerd ``` ## Configuración de Linkerd Para que tu aplicación funcione con Linkerd hay que inyectarle el sidecar de Linkerd. Para hacer esto podemos hacerlo de 3 formas: 1. Agregando a la aplicación (manifest) la annotations: ```yaml annotations: linkerd.io/inject: enabled ``` 2. Agregando al namespace el annotations linkerd.io/injec: enabled ```bash kubectl annotate namespace linkerd.io/inject=enabled ``` 3. Haciendo un deploy de una aplicación e inyectarle Linkerd: ```bash cat deployment.yml | linkerd inject - | kubectl apply -f - ``` ## Instalando la aplicación de prueba Vamos a probar el service mes Linkerd usando la misma aplicación que instalamos con Istio. - Creamos un namespace para nuestra aplicación de ejemplo: ```bash kubectl create namespace bookinfo ``` - Aplicamos el annotations en el namespace: ```bash kubectl annotate namespace bookinfo linkerd.io/inject=enabled ``` - Instalamos la aplicación: ```bash kubectl -n bookinfo apply -f https://raw.githubusercontent.com/istio/istio/release-1.23/samples/bookinfo/platform/kube/bookinfo.yaml ``` Vamos a crear un LoadBalancer para la aplicación o si quieres puedes hacer un port-forward: **loadbalancer-bookinfo.yaml** ```yaml --- apiVersion: v1 kind: Service metadata: name: loadbalancer-productpage spec: selector: app: productpage ports: - port: 80 targetPort: 9080 type: LoadBalancer --- ``` port-fordward ```bash kubectl -n bookinfo port-forward svc/productpage 9080:9080 ``` Verificamos que Linkerd se haya inyectado en cada pod, es decir, que cada pod cuente con dos contenedores: ```bash kubectl get pods -n bookinfo ```
o podemos ejecutar el siguiente comando: ```bash linkerd -n bookinfo check --proxy ``` ## Viz Dashboard y extensiones Linkerd cuenta con su propio dashboard y en esta parte vamos a ver como instalarlo y realizar configuraciones de Prometheus y Grafana ya existentes en nuestro cluster (tal como hicimos en el tutorial de Istio). Para instalar el dashboard que te incluye Prometheus y Grafana, ejecuta el siguiente comando: ```bash linkerd viz install | kubectl apply -f - ``` En mi escenario yo ya cuento con Prometheus y Grafana instalados, por lo que tengo que tengo que pasarle ciertos parámetros a Viz, para que haga uso de lo que ya tengo instalado. ### Prometheus Con la siguiente configuración podremos exportar las métricas del control plane y del proxy de Linkerd hacia Prometheus, tal cual hicimos en nuestro tutorial de Istio. De igual forma puedes editar el configmap o puedes aplicar en un nuevo manifest agregando lo siguiente: Debes modificar los valores que están dentro de {{.Values.linkerdNamespace}} y {{.Values.namespace}}. ```yaml - job_name: "linkerd-controller" kubernetes_sd_configs: - role: pod namespaces: names: - "linkerd" - "linkerd-viz" relabel_configs: - source_labels: - __meta_kubernetes_pod_container_port_name action: keep regex: admin-http - source_labels: [__meta_kubernetes_pod_container_name] action: replace target_label: component - job_name: "linkerd-service-mirror" kubernetes_sd_configs: - role: pod relabel_configs: - source_labels: - __meta_kubernetes_pod_label_linkerd_io_control_plane_component - __meta_kubernetes_pod_container_port_name action: keep regex: linkerd-service-mirror;admin-http$ - source_labels: [__meta_kubernetes_pod_container_name] action: replace target_label: component - job_name: "linkerd-proxy" kubernetes_sd_configs: - role: pod relabel_configs: - source_labels: - __meta_kubernetes_pod_container_name - __meta_kubernetes_pod_container_port_name - __meta_kubernetes_pod_label_linkerd_io_control_plane_ns action: keep regex: ^linkerd-proxy;linkerd-admin;linkerd$ - source_labels: [__meta_kubernetes_namespace] action: replace target_label: namespace - source_labels: [__meta_kubernetes_pod_name] action: replace target_label: pod # special case k8s' "job" label, to not interfere with prometheus' "job" # label # __meta_kubernetes_pod_label_linkerd_io_proxy_job=foo => # k8s_job=foo - source_labels: [__meta_kubernetes_pod_label_linkerd_io_proxy_job] action: replace target_label: k8s_job # drop __meta_kubernetes_pod_label_linkerd_io_proxy_job - action: labeldrop regex: __meta_kubernetes_pod_label_linkerd_io_proxy_job # __meta_kubernetes_pod_label_linkerd_io_proxy_deployment=foo => # deployment=foo - action: labelmap regex: __meta_kubernetes_pod_label_linkerd_io_proxy_(.+) # drop all labels that we just made copies of in the previous labelmap - action: labeldrop regex: __meta_kubernetes_pod_label_linkerd_io_proxy_(.+) # __meta_kubernetes_pod_label_linkerd_io_foo=bar => # foo=bar - action: labelmap regex: __meta_kubernetes_pod_label_linkerd_io_(.+) # Copy all pod labels to tmp labels - action: labelmap regex: __meta_kubernetes_pod_label_(.+) replacement: __tmp_pod_label_$1 # Take `linkerd_io_` prefixed labels and copy them without the prefix - action: labelmap regex: __tmp_pod_label_linkerd_io_(.+) replacement: __tmp_pod_label_$1 # Drop the `linkerd_io_` originals - action: labeldrop regex: __tmp_pod_label_linkerd_io_(.+) # Copy tmp labels into real labels - action: labelmap regex: __tmp_pod_label_(.+) ``` Ahora vamos a crear un archivo llamado prometheus-values.yaml y vamos a copiar lo siguiente para decirle a viz que haga uso de nuestro Prometheus: ```yaml prometheusUrl: http://prometheus-service.monitoring.svc.cluster.local:8082/ prometheus: enabled: false ``` La primera línea es la url de Prometheus. La segunda es para decirle a Viz que no haga uso del Prometheus que instala (vamos, que haga uso de Prometheus que ya tenemos instalado). ### Linkerd Jaeger Para instalar Jaegar es muy sencillo: ```bash linkerd jaeger install | kubectl apply -f - ``` Verificamos que todo se haya instalado correctamente: ```bash linkerd jaeger check ``` **Nota:** Recuerda que para que jaeger muestre las trazas la aplicación debe tener implementado tracing, en esta aplicación que estamos usando de prueba no tiene habilitado/programado el tracing: Si se lo quieres habilitar lo puedes hacer con el siguiente comando: ```bash kubectl -n bookinfo set env --all deploy OC_AGENT_HOST=collector.linkerd-jaeger:55678 ``` Lo que hace este comando es que agrega una variable de entorno que habilita la aplicación a propagar y emitir trazas. ### Grafana Para Grafana es más fácil, por que solo tenemos que pasarle un parámetro a Viz. Los dashboards recomendados son: - 14260, 11868, 14262, 14261, 14263 ```bash linkerd viz install --set grafana.url=http://grafana.ahioros.homelab.local | kubectl apply -f - ``` **NOTA:** en caso que estés usando un proveedor externo de Grafana debes usar el siguiente parámetro: ```bash linkerd viz install --set grafana.externalUrl=https://dirección-grafana.net/ | kubectl apply -f - ``` ### Comando completo En nuestro caso tenemos que pasarle también el archivo prometheus-values.yaml por lo que el comando quedaría así: ```bash linkerd viz install --set grafana.externalUrl=http://grafana.ahioros.homelab.local -f prometheus-values.yaml | kubectl apply -f - ``` Para obtener la funcionalidad de que aparezca el ícono de jaeger en el dashboard después de instalarlo debemos hacer lo siguiente: linkerd viz install --set jaegerUrl=jaeger.linkerd-jaeger:16686 | kubectl apply -f - Validamos nuevamente que todo se haya instalado correctamente: ```bash linkerd check ``` Y si unimos todos los comandos de prometheus, grafana, jaeger tenemos: ```bash linkerd viz install --set grafana.externalUrl=http://grafana.ahioros.homelab.local -f prometheus-values.yaml --set jaegerUrl=jaeger.linkerd-jaeger:16686 | kubectl apply -f - ``` ### Linkerd Dashboard Para ver el dashboard ejecutamos el siguiente comando (esto te abrirá una ventana en tu navegador): ```bash linkerd viz dashboard ```
**Nota:** También puedes crearte un port-forward, LoadBalancer, Ingress, para ver el dashboard. Al igual que con Istio la comunicación entre los microservicios es cifrada, te puedes dar cuenta aquí:
O entrando a algún Deployment y verás en la columna superior derecha que dice **meshed** ## Desinstalación de Linkerd - Eliminamos la aplicación: ```bash kubectl delete ns bookinfo ``` - Eliminar las extensiones: ```bash linkerd viz uninstall | kubectl delete -f - ``` - Eliminamos jaeger: ```bash linkerd jaeger uninstall | kubectl delete -f - ``` - Eliminar el control plane, CRDs, namespace, etc: ```bash linkerd uninstall | kubectl delete -f - ``` Listo espero te haya funcionado si tienes dudas o comentarios no dudes en contactarme o dejarme tu comentario, saludos.