Capítulo práctico Service Mesh-Istio (Parte 2)

Primer artículo:

• Capítulo práctico Service Mesh-Istio (Parte 1)

---

Recopile métricas y monitoree aplicaciones

En observabilidad, los indicadores son los más capaces de reflejar las condiciones operativas del sistema desde muchos aspectos. Debido a que existen varios indicadores, podemos medir y monitorear cada dimensión del sistema a través de análisis de datos multidimensionales.

De forma predeterminada, Istio usa sus propios componentes Promethuse y Grafana para completar la recopilación y visualización de indicadores, pero las herramientas básicas como los sistemas de monitoreo suelen ser necesarias en el entorno de producción de cada empresa, por lo que si usa los propios componentes de Istio Solo repite.

Por lo tanto, integrar el sistema de monitoreo existente e Istio es la mejor solución. Entonces, esta sección demostrará la integración de la recopilación de indicadores con el sistema de monitoreo existente e Istio.

Interfaz del indicador de Istio

Primero, debemos comprender cómo expone Istio sus indicadores. Proporciona principalmente las siguientes dos interfaces de indicadores:

• /metrics： Proporciona información del indicador del estado operativo propio de Istio
• /stats/prometheus: Interfaz proporcionada por Envoy para obtener indicadores relacionados con el tráfico de la red
  

Podemos solicitar /stats/prometheusinterfaz para ver las métricas que proporciona:

$ kubectl exec -it -n demo ${sleep_pod_name} -c sleep -- curl http://httpbin.demo:15090/stats/prometheus

La /metricsinterfaz de servicio istiod expone algunos de los indicadores del plano de control, podemos obtenerlos de las siguientes formas:

$ kubectl exec -it -n demo ${sleep_pod_name} -c sleep -- curl http://istiod.istio-system:15014/metrics

Método de configuración de Prometheus

• La configuración estática tiene limitaciones relativamente grandes y no se puede adaptar bien a los cambios, por lo que generalmente se usa la configuración dinámica

La base que respalda la configuración dinámica es el mecanismo de descubrimiento de servicios de Prometheus:

• El mecanismo de descubrimiento de servicios puede garantizar que Prometheus pueda encontrar las interfaces proporcionadas por estos indicadores correspondientes a través de las interfaces expuestas por el servicio.
• kubernetes_sd_config.role Los elementos de configuración definen qué objetivos se recopilan para las métricas
  • nodo: nodo del clúster
  • servicio: servicio, a menudo utilizado para el monitoreo de caja negra
  • pod: apunte al contenedor en el pod
  • puntos finales: puntos finales
  • ingreso: puerta de enlace de ingreso
• relabel_configs El elemento de configuración define el mecanismo de filtrado para filtrar las interfaces expuestas.

Combate real

Primero construyamos un sistema de monitoreo y luego integremos con Istio. Primero implemente Prometheus, la lista de configuración específica es la siguiente:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: prometheus
  namespace: monitoring
  labels:
    app: prometheus
spec:
  selector:
    matchLabels:
      app: prometheus
  template:
    metadata:
      labels:
        app: prometheus
    spec:
      serviceAccount: appmesh-prometheus
      serviceAccountName: appmesh-prometheus
      containers:
      - image: prom/prometheus:latest
        name: prometheus
        command:
        - "/bin/prometheus"
        args:
        - "--config.file=/etc/prometheus/prometheus.yml"
        - "--storage.tsdb.path=/prometheus"
        - "--storage.tsdb.retention=24h"
        - "--web.enable-admin-api"  
        - "--web.enable-lifecycle"  
        ports:
        - containerPort: 9090
          protocol: TCP
          name: http
        volumeMounts:
        - mountPath: /etc/prometheus
          name: config-volume
        - mountPath: /prometheus/data
          name: data-volume
        resources:
          requests:
            cpu: 100m
            memory: 512Mi
          limits:
            cpu: 100m
            memory: 512Mi
      securityContext:
        runAsUser: 0
      volumes:
      - configMap:
          name: prometheus-config
        name: config-volume
      - emptyDir: {}
        name: data-volume
---
apiVersion: v1
kind: Service
metadata:
  name: prometheus
  namespace: monitoring
  labels:
    app: prometheus
spec:
  selector:
    app: prometheus
  type: NodePort
  ports:
    - name: web
      port: 9090
      targetPort: http
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: appmesh-prometheus
  namespace: monitoring
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  namespace: monitoring
  name: appmesh-prometheus
rules:
  - apiGroups:
      - ""
    resources:
      - nodes
      - nodes/proxy
      - nodes/metrics
      - services
      - endpoints
      - pods
      - ingresses
      - configmaps
    verbs:
      - get
      - list
      - watch
  - apiGroups:
      - "extensions"
      - "networking.k8s.io"
    resources:
      - ingresses/status
      - ingresses
    verbs:
      - get
      - list
      - watch
  - nonResourceURLs:
      - "/metrics"
    verbs:
      - get
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: appmesh-prometheus
subjects:
  - kind: ServiceAccount
    name: appmesh-prometheus
    namespace: monitoring
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: appmesh-prometheus

Cree un ConfigMap de Prometheus:

apiVersion: v1
kind: ConfigMap
metadata:
  name: prometheus-config
  namespace: monitoring
data:
  prometheus.yml: |
    global:
      scrape_interval: 15s
      scrape_timeout: 15s
    scrape_configs:
    - job_name: 'prometheus'
      static_configs:
      - targets: ['localhost:9090']

Luego implemente Grafana, la lista de configuración es la siguiente:

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: grafana
  name: grafana
  namespace: monitoring
spec:
  replicas: 1
  selector:
    matchLabels:
      app: grafana
  template:
    metadata:
      labels:
        app: grafana
    spec:
      containers:
      - name: grafana
        image: grafana/grafana:latest
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 3000
          name: grafana
        env:
        - name: GRAFANA_PORT
          value: "3000"
        - name: GF_AUTH_BASIC_ENABLED
          value: "false"
        - name: GF_AUTH_ANONYMOUS_ENABLED
          value: "true"
        - name: GF_AUTH_ANONYMOUS_ORG_ROLE
          value: Admin
        resources:
          limits:
            cpu: 100m
            memory: 256Mi
          requests:
            cpu: 100m
            memory: 256Mi
        volumeMounts:
          - mountPath: /var/lib/grafana
            name: grafana-storage
      volumes:
        - name: grafana-storage
          emptyDir: {}
---
apiVersion: v1
kind: Service
metadata:
  name: grafana
  namespace: monitoring
  labels:
    app: grafana
spec:
  selector:
    app: grafana
  type: NodePort
  ports:
    - name: http
      port: 3000
      targetPort: 3000
      nodePort: 32000
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: grafana
  namespace: monitoring

Confirme que todo comenzó normalmente:

[root@m1 ~]# kubectl get all -n monitoring 
NAME                             READY   STATUS    RESTARTS   AGE
pod/grafana-86f5dc96d-6hsmz      1/1     Running   0          20m
pod/prometheus-9dd6bd8bb-wcdrw   1/1     Running   0          2m30s

NAME                 TYPE       CLUSTER-IP       EXTERNAL-IP   PORT(S)          AGE
service/grafana      NodePort   10.101.215.111   <none>        3000:32000/TCP   20m
service/prometheus   NodePort   10.101.113.122   <none>        9090:31053/TCP   13m

NAME                         READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/grafana      1/1     1            1           20m
deployment.apps/prometheus   1/1     1            1           13m

NAME                                   DESIRED   CURRENT   READY   AGE
replicaset.apps/grafana-86f5dc96d      1         1         1       20m
replicaset.apps/prometheus-9dd6bd8bb   1         1         1       13m
[root@m1 ~]# 

Compruebe en qué nodo de trabajo están programados prometheus y grafana:

[root@m1 ~]# kubectl get po -l app=grafana -n monitoring -o jsonpath='{.items[0].status.hostIP}'
192.168.243.139
[root@m1 ~]# kubectl get po -l app=prometheus -n monitoring -o jsonpath='{.items[0].status.hostIP}'
192.168.243.139

Utilice un navegador para visitar prometheus y compruebe si su contenido de configuración cumple con las expectativas, es decir, si puede corresponder al contenido del ConfigMap:

En la figura anterior, podemos ver que el prometheus actual es de configuración estática. A continuación, debemos cambiarlo a configuración dinámica y modificar su contenido de ConfigMap de la siguiente manera:

apiVersion: v1
kind: ConfigMap
metadata:
  name: prometheus-config
  namespace: monitoring
data:
  prometheus.yml: |-
    global:
      scrape_interval: 15s
      scrape_timeout: 15s
    scrape_configs:
    - job_name: 'prometheus'
      static_configs:
      - targets: ['localhost:9090']

    # 以下是整合Istio的配置
    - job_name: envoy-stats
      honor_timestamps: true
      metrics_path: /stats/prometheus
      scheme: http
      kubernetes_sd_configs:
      - role: pod
      relabel_configs:
      - source_labels: [__meta_kubernetes_pod_container_port_name]
        separator: ;
        regex: .*-envoy-prom
        replacement: $1
        action: keep
      - source_labels: [__address__, __meta_kubernetes_pod_annotation_prometheus_io_port]
        separator: ;
        regex: ([^:]+)(?::\d+)?;(\d+)
        target_label: __address__
        replacement: $1:15090
        action: replace
      - separator: ;
        regex: __meta_kubernetes_pod_label_(.+)
        replacement: $1
        action: labeldrop
      - source_labels: [__meta_kubernetes_namespace]
        separator: ;
        regex: (.*)
        target_label: namespace
        replacement: $1
        action: replace
      - source_labels: [__meta_kubernetes_pod_name]
        separator: ;
        regex: (.*)
        target_label: pod_name
        replacement: $1
        action: replace  

• Sugerencias: El contenido de configuración de ConfigMap aquí se copia del archivo de configuración de Prometheus proporcionado oficialmente por Istio, y la configuración puede ser diferente para cada versión. El camino es:$ISTIO_HOME/samples/addons/prometheus.yaml

Luego reconstruya prometheus a través del comando patch:

[root@m1 ~]# kubectl patch deployment prometheus -n monitoring -p "{\"spec\":{\"template\":{\"metadata\":{\"labels\":{\"date\":\"`date +'%s'`\"}}}}}"
deployment.apps/prometheus patched
[root@m1 ~]# 

Compruebe si la configuración ha surtido efecto:

En este punto, las métricas de Istio se pueden consultar en prometheus:

Para Grafana, solo necesita exportar el Panel de control integrado de Istio y luego importarlo a otro Grafana. Es relativamente simple y no se demostrará.

---

Conjunto de registros ELK Stack integrado

En un sistema distribuido, los logs generados por la aplicación se distribuirán en cada nodo, lo que es muy desfavorable para su visualización y gestión. Por lo tanto, generalmente se usa una arquitectura de registro centralizada para agregar datos de registro en una plataforma de registro para una administración unificada, y la plataforma de registro más conocida es ELK Stack.

Arquitectura de registro centralizada

La función principal:

• recoger
• tratar con
• Presumir

Arquitectura de registro ELK Stack

• ElasticSearch: responsable del almacenamiento y la búsqueda de datos
• Logstash: responsable de la canalización de recopilación de datos, proporcionando funciones de filtrado y preprocesamiento
• Kibana: utilizado para trazar datos
• LibBeats: recopilador de datos ligero

Formulario de implementación de ELK

Combate real

A continuación, instalamos la suite ELK para recopilar los datos de registro de Istio Envoy. Primero cree un espacio de nombres en el clúster:

[root@m1 ~]# kubectl create ns elk
namespace/elk created
[root@m1 ~]# 

Luego, use la siguiente lista de verificación de configuración para implementar Elastic Search y Kibana:

kind: List
apiVersion: v1
items:
- apiVersion: apps/v1
  kind: Deployment
  metadata:
    name: kibana
  spec:
    selector:
      matchLabels:
        app: kibana
    replicas: 1
    template:
      metadata:
        name: kibana
        labels:
          app: kibana
      spec:
        containers:
        - image: docker.elastic.co/kibana/kibana:6.4.0
          name: kibana
          env:
          - name: ELASTICSEARCH_URL
            value: "http://elasticsearch:9200"
          ports:
          - name: http
            containerPort: 5601
- apiVersion: v1
  kind: Service
  metadata:
    name: kibana
  spec:
    type: NodePort
    ports:
    - name: http
      port: 5601
      targetPort: 5601 
      nodePort: 32001
    selector:
      app: kibana            
- apiVersion: apps/v1
  kind: Deployment
  metadata:
    name: elasticsearch
  spec:
    selector:
      matchLabels:
        app: elasticsearch
    replicas: 1
    template:
      metadata:
        name: elasticsearch
        labels:
          app: elasticsearch
      spec:
        initContainers:
        - name: init-sysctl
          image: busybox
          command:
          - sysctl
          - -w
          - vm.max_map_count=262144
          securityContext:
            privileged: true
        containers:
        - image: docker.elastic.co/elasticsearch/elasticsearch:6.4.0
          name: elasticsearch
          env:
          - name: network.host
            value: "_site_"
          - name: node.name
            value: "${HOSTNAME}"
          - name: discovery.zen.ping.unicast.hosts
            value: "${ELASTICSEARCH_NODEPORT_SERVICE_HOST}"
          - name: cluster.name
            value: "test-single"
          - name: ES_JAVA_OPTS
            value: "-Xms128m -Xmx128m"
          volumeMounts:
          - name: es-data
            mountPath: /usr/share/elasticsearch/data
        volumes:
          - name: es-data
            emptyDir: {}
- apiVersion: v1
  kind: Service
  metadata: 
    name: elasticsearch-nodeport
  spec:
    type: NodePort
    ports:
    - name: http
      port: 9200
      targetPort: 9200
      nodePort: 32002
    - name: tcp
      port: 9300
      targetPort: 9300
      nodePort: 32003
    selector:
      app: elasticsearch
- apiVersion: v1
  kind: Service
  metadata:
    name: elasticsearch
  spec:
    clusterIP: None
    ports:
    - name: http
      port: 9200
    - name: tcp
      port: 9300
    selector:
      app: elasticsearch

Especifique el espacio de nombres para la implementación:

[root@m1 ~]# kubectl apply -f elk/deploy.yaml -n elk 
deployment.apps/kibana created
service/kibana created
deployment.apps/elasticsearch created
service/elasticsearch-nodeport created
service/elasticsearch created
[root@m1 ~]# 

Lo anterior solo implementa elasticsearch y kibana, pero si queremos recopilar registros de Envoy, también necesitamos implementar Logstash o FileBeats. Aquí, FileBeats se usa como ejemplo. La lista de configuración es la siguiente:

kind: List
apiVersion: v1
items:
- apiVersion: v1
  kind: ConfigMap
  metadata:
    name: filebeat-config
    labels:
      k8s-app: filebeat
      kubernetes.io/cluster-service: "true"
      app: filebeat-config
  data:
    filebeat.yml: |
      processors:
        - add_cloud_metadata:
      filebeat.modules:
      - module: system
      filebeat.inputs:
      - type: log
        paths:
          - /var/log/containers/*.log
        symlinks: true
      output.elasticsearch:
        hosts: ['elasticsearch:9200']
      logging.level: info        
- apiVersion: apps/v1
  kind: Deployment 
  metadata:
    name: filebeat
    labels:
      k8s-app: filebeat
      kubernetes.io/cluster-service: "true"
  spec:
    selector:
      matchLabels:
        app: filebeat
    replicas: 1
    template:
      metadata:
        name: filebeat
        labels:
          app: filebeat
          k8s-app: filebeat
          kubernetes.io/cluster-service: "true"
      spec:
        containers:
        - image: docker.elastic.co/beats/filebeat:6.4.0
          name: filebeat
          args: [
            "-c", "/home/filebeat-config/filebeat.yml",
            "-e",
          ]
          securityContext:
            runAsUser: 0
          volumeMounts:
          - name: filebeat-storage
            mountPath: /var/log/containers
          - name: varlogpods
            mountPath: /var/log/pods
          - name: varlibdockercontainers
            mountPath: /var/lib/docker/containers
          - name: "filebeat-volume"
            mountPath: "/home/filebeat-config"
        volumes:
          - name: filebeat-storage
            hostPath:
              path: /var/log/containers
          - name: varlogpods
            hostPath:
              path: /var/log/pods
          - name: varlibdockercontainers
            hostPath:
              path: /var/lib/docker/containers
          - name: filebeat-volume
            configMap:
              name: filebeat-config
- apiVersion: rbac.authorization.k8s.io/v1
  kind: ClusterRoleBinding
  metadata:
    name: filebeat
  subjects:
  - kind: ServiceAccount
    name: filebeat
    namespace: elk
  roleRef:
    kind: ClusterRole
    name: filebeat
    apiGroup: rbac.authorization.k8s.io
- apiVersion: rbac.authorization.k8s.io/v1
  kind: ClusterRole
  metadata:
    name: filebeat
    labels:
      k8s-app: filebeat
  rules:
  - apiGroups: [""] # "" indicates the core API group
    resources:
    - namespaces
    - pods
    verbs:
    - get
    - watch
    - list
- apiVersion: v1
  kind: ServiceAccount
  metadata:
    name: filebeat
    namespace: elk
    labels:
      k8s-app: filebeat

Confirme que todos los componentes se hayan implementado correctamente:

[root@m1 ~]# kubectl get all -n elk 
NAME                                 READY   STATUS    RESTARTS   AGE
pod/elasticsearch-697c88cd76-xvn4j   1/1     Running   0          4m53s
pod/filebeat-8646b847b7-f58zg        1/1     Running   0          32s
pod/kibana-fc98677d7-9z5dl           1/1     Running   0          8m14s

NAME                             TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)                         AGE
service/elasticsearch            ClusterIP   None            <none>        9200/TCP,9300/TCP               8m14s
service/elasticsearch-nodeport   NodePort    10.96.106.229   <none>        9200:32002/TCP,9300:32003/TCP   8m14s
service/kibana                   NodePort    10.105.91.140   <none>        5601:32001/TCP                  8m14s

NAME                            READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/elasticsearch   1/1     1            1           8m14s
deployment.apps/filebeat        1/1     1            1           32s
deployment.apps/kibana          1/1     1            1           8m14s

NAME                                       DESIRED   CURRENT   READY   AGE
replicaset.apps/elasticsearch-697c88cd76   1         1         1       4m53s
replicaset.apps/filebeat-8646b847b7        1         1         1       32s
replicaset.apps/kibana-fc98677d7           1         1         1       8m14s
[root@m1 ~]# 

Vaya a Kibana para crear un patrón de índice simple:

Creado:

Luego, puede ver los datos de registro recopilados por FileBeat y almacenados en Elastic Search en la página Descubrir:

---

Herramienta de seguimiento distribuida integrada

Seguimiento distribuido de Istio

• El rastreo distribuido de Istio se implementa en base a Envoy
• La aplicación es responsable de transmitir la información del encabezado de seguimiento (encabezado de seguimiento b3), por lo que no es completamente transparente para la aplicación y la aplicación debe pasar el encabezado por sí misma
• b3 Este encabezado de información fue propuesto por primera vez por openzipkin: https://github.com/openzipkin/b3-propagation
• Tasa de muestreo de soporte

El proceso de rastreo distribuido basado en Envoy es el siguiente:

• Primero, genere RequestId para las solicitudes que fluyen a través del proxy Envoy y TraceHeader, que es el encabezado de información
• Genere el TraceSpan correspondiente en función de los metadatos de la solicitud y la respuesta, y luego envíe el Span al backend de Trace
• Finalmente, el encabezado Trace se reenvía al nodo de la aplicación del agente.

Implementar Jaeger

A continuación, usamos Operator para instalar Jaeger y demostrar cómo se integra Istio con el sistema de seguimiento distribuido existente. Echemos un breve vistazo a Operador:

• Kit de herramientas para implementar y administrar aplicaciones de Kubernetes
• Implementar en un clúster, usar la API de Kubernetes para administrar aplicaciones
• Marco del operador
  • SDK del operador
  • Administrador del ciclo de vida del operador
    

Primero clone el repositorio de jaeger-operator:

[root@m1 ~]# cd /usr/local/src
[root@m1 /usr/local/src]# git clone https://github.com/jaegertracing/jaeger-operator.git

Modifique el archivo de configuración, WATCH_NAMESPACEse valueestablece en nulo, para que pueda rastrear la solicitud en todos los espacios de nombres:

[root@m1 /usr/local/src]# vim jaeger-operator/deploy/operator.yaml
...
        env:
        - name: WATCH_NAMESPACE
          value:
...

Cree el crd de jaeger:

[root@m1 /usr/local/src]# kubectl apply -f jaeger-operator/deploy/crds/jaegertracing.io_jaegers_crd.yaml 
customresourcedefinition.apiextensions.k8s.io/jaegers.jaegertracing.io created
[root@m1 /usr/local/src]# 

Luego cree un espacio de nombres y cree otros recursos de jaeger bajo este espacio de nombres:

$ kubectl create ns observability
$ kubectl apply -f jaeger-operator/deploy/role.yaml -n observability 
$ kubectl apply -f jaeger-operator/deploy/role_binding.yaml -n observability 
$ kubectl apply -f jaeger-operator/deploy/service_account.yaml -n observability 
$ kubectl apply -f jaeger-operator/deploy/cluster_role.yaml -n observability
$ kubectl apply -f jaeger-operator/deploy/cluster_role_binding.yaml -n observability
$ kubectl apply -f jaeger-operator/deploy/operator.yaml -n observability 

Confirme que el operador haya comenzado normalmente:

[root@m1 /usr/local/src]# kubectl get all -n observability 
NAME                                   READY   STATUS    RESTARTS   AGE
pod/jaeger-operator-7f76698d98-x9wkh   1/1     Running   0          105s

NAME                              TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)             AGE
service/jaeger-operator-metrics   ClusterIP   10.100.189.227   <none>        8383/TCP,8686/TCP   11s

NAME                              READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/jaeger-operator   1/1     1            1           105s

NAME                                         DESIRED   CURRENT   READY   AGE
replicaset.apps/jaeger-operator-7f76698d98   1         1         1       105s
[root@m1 /usr/local/src]# 

Instale jaegers, un recurso personalizado, y el operador lo implementará automáticamente a través del recurso personalizado:

[root@m1 /usr/local/src]# kubectl apply -f jaeger-operator/examples/simplest.yaml -n observability 
jaeger.jaegertracing.io/simplest created
[root@m1 /usr/local/src]# kubectl get jaegers -n observability 
NAME       STATUS    VERSION   STRATEGY   STORAGE   AGE
simplest   Running   1.21.0    allinone   memory    3m8s
[root@m1 /usr/local/src]# 

Jaeger integra Istio

Una vez implementado Jaeger, el siguiente paso es integrarlo con Istio. La integración es muy sencilla, solo es necesario istioctlconfigurar algunas herramientas de variables de configuración, el comando es el siguiente:

[root@m1 ~]# istioctl install --set profile=demo -y \
--set values.global.tracer.zipkin.address=simplest-collector.observability:9411 \
--set values.pilot.traceSampling=100

• Sugerencias: Elprofile valor debe establecerse en el valor establecido cuando se instala Istio; de lo contrario, Istio se reinstalará de acuerdo con el valor predeterminado

Después de que Jaeger integra Istio, queda el último paso: tenemos que inyectar el agente de Jaeger en nuestra aplicación por inyección. Jaeger Operator admite la inyección automática, solo necesitamos agregar una marca de inyección en Anotación.

Anteriormente mencionamos que el rastreo de Istio no es completamente transparente para la aplicación. Necesitamos procesar el encabezado del rastreo en la aplicación nosotros mismos. Entonces, para la comodidad de las pruebas, usaremos la aplicación oficial de Bookinfo como demostración. Implementar Bookinfo:

[root@m1 ~]# kubectl apply -f /usr/local/istio-1.8.1/samples/bookinfo/platform/kube/bookinfo.yaml
[root@m1 ~]# kubectl apply -f /usr/local/istio-1.8.1/samples/bookinfo/networking/bookinfo-gateway.yaml

Jaeger admite espacios de nombres para inyección o implementación, implementación para el producto de este ejemplo, solo necesitamos agregar una línea en su anotación sidecar.jaegertracing.io/inject: "true"para:

[root@m1 ~]# kubectl edit deployments.apps/productpage-v1
apiVersion: apps/v1
kind: Deployment
metadata:
  annotations:
    sidecar.jaegertracing.io/inject: "true"

    ...

Luego use el comando patch para reconstruir la página del producto:

[root@m1 ~]# kubectl patch deployment productpage-v1 -p "{\"spec\":{\"template\":{\"metadata\":{\"labels\":{\"date\":\"`date +'%s'`\"}}}}}"
deployment.apps/productpage-v1 patched
[root@m1 ~]# 

En este punto, puede ver que la cantidad de contenedores en el pod de la página del producto ha aumentado a tres, lo que indica que Jaeger le ha inyectado el agente:

[root@m1 ~]# kubectl get pods
NAME                              READY   STATUS    RESTARTS   AGE
productpage-v1-5c75dcd69f-g9sjh   3/3     Running   0          96s
...

Utilice el siguiente comando para abrir el puerto de acceso a la interfaz de usuario web de Jaeger:

[root@m1 ~]# kubectl port-forward svc/simplest-query -n observability 16686:16686 --address 192.168.243.138
Forwarding from 192.168.243.138:16686 -> 16686

Puede ver en la página que Jaeger puede detectar el servicio de la página del producto:

---

Herramientas y métodos de depuración: ¿Cuáles son las herramientas y métodos para depurar cuadrículas?

Los métodos de depuración comunes de Istio incluyen principalmente lo siguiente:

• línea de comando istioctl
• Herramienta de autocomprobación para el plano de control controlZ
• Interfaz de administración de Envoy
• Interfaz de depuración piloto

línea de comando istioctl

Podemos usar los --helpparámetros para ver la istioctlinformación de ayuda del comando:

$ istioctl --help

Relacionados con la instalación y el despliegue

• istioctl verify-install: Se puede utilizar para verificar si el entorno actual del clúster k8s puede implementar Istio
• istioctl install [flags]: Se utiliza para instalar el entorno de Istio en el clúster actual
• istioctl profile [list / diff / dump]: Operando el perfil de Istio
• istioctl kube-inject: Se utiliza para inyectar el sidecar Envoy en el Pod
• istioctl dashboard [command]: Inicia la interfaz de usuario web de Istio Dashboard especificada
  • controlz / envoy / Grafana / jaeger / kiali / Prometheus / zipkin

Comprobación del estado de la configuración de la red

• istioctl ps <pod-name>: Ver el estado de sincronización de la configuración de la red. Hay varios estados:
  • SYNCED: la configuración está sincronizada
  • NO ENVIADO: No se emite la configuración
  • STALE: La configuración se entregó, pero el Pod no respondió para actuar
• istioctl pc [cluster/route/…] <pod-name.namespace>: Obtiene los detalles de configuración de la cuadrícula del recurso especificado

Ver información de configuración de cuadrícula relacionada con el pod

istioctl x（ experimental ）describe pod <pod-name>：

• Verifica que esté dentro de la cuadrícula
• Verificar VirtualService
• Verificar la regla de destino
• Verificar enrutamiento
• ...

Ejemplo:

[root@m1 ~]# istioctl x describe pod productpage-v1-65576bb7bf-4bwwr
Pod: productpage-v1-65576bb7bf-4bwwr
   Pod Ports: 9080 (productpage), 15090 (istio-proxy)
--------------------
Service: productpage
   Port: http 9080/HTTP targets pod port 9080

Exposed on Ingress Gateway http://192.168.243.140
VirtualService: bookinfo
   /productpage, /static*, /login, /logout, /api/v1/products*
[root@m1 ~]# 

Diagnóstico de configuración de red

• istioctl analyze [–n <namespace> / --all-namespaces]: Verifique la configuración de la cuadrícula en el espacio de nombres especificado, si hay un problema, se le solicitará un mensaje de advertencia o error correspondiente
• istioctl analyze a.yaml b.yaml my-app-config/: Busque un solo archivo de configuración o todos los archivos de configuración en un directorio
• istioctl analyze --use-kube=false a.yaml: Verifique el archivo de configuración especificado ignorando la plataforma de implementación

herramienta de autocomprobación visual controlZ

controlZ es una herramienta de autocomprobación visual del plano de control, cuyas principales funciones son las siguientes:

• Ajustar el nivel de salida del registro
• Ver uso de memoria
• Ver variables de entorno
• Ver información del proceso

El uso es el siguiente:

istioctl d controlz <istiod-podname> -n istio-system

Interfaz API de administración de Envoy

La API de administración de Envoy puede ver y operar el plano de datos. Sus funciones principales son las siguientes:

• Ajuste del nivel de registro
• Análisis de datos de desempeño
• Configuración y otra información
• Vista del indicador

Utilice el siguiente comando para abrir la API de administración de Envoy del pod especificado:

istioctl d envoy <pod-name>.[namespace] --address ${ip}

O abre su puerto por:

kubectl port-forward <pod-name> 15000:15000 ${ip}

Su página es la siguiente:

Interfaz de depuración piloto

Las principales funciones de la interfaz de depuración de Pilot son las siguientes:

• xDS e información de configuración
• Análisis de problemas de desempeño
• Configurar la sincronización

Utilice el siguiente comando para abrir su puerto:

kubectl port-forward service/istiod -n istio-system 15014:15014 --address ${ip}

Su página es la siguiente: