Recolector de OpenTelemetry personalizado

Esta guía explica cómo configurar Admission Controller para enviar datos de telemetría a un recolector de OpenTelemetry ya desplegado en el clúster.

Solo debes desplegar una instancia del Recolector de OpenTelemetry en el clúster.

Instalar dependencias

Primero, comienza instalando las dependencias del Recolector de OpenTelemetry.

Necesitas comunicación encriptada entre los componentes del SUSE Security Admission Controller y el Recolector de OpenTelemetry. Puedes usar cert-manager para gestionar todos los certificados requeridos para una comunicación segura.

Las trazas del Recolector de OpenTelemetry se envían a una instancia de Jaeger.

La pila del Admission Controller envía métricas al Recolector de OpenTelemetry. Este expone las métricas como un endpoint de Prometheus. Las métricas son luego recogidas por una instancia de Prometheus y almacenadas en su base de datos. La misma instancia de Prometheus también expone una interfaz de usuario para ver y utilizar las métricas.

Los recursos que creas se definen en el espacio de nombres kubewarden, o se espera su existencia. Debido a eso, debes comenzar creando el espacio de nombres:

kubectl create namespace suse-sec-adm-controller

kubectl create secret docker-registry application-collection \
  --namespace suse-sec-adm-controller \
  --docker-server=dp.apps.rancher.io \
  --docker-username=<your-username> \
  --docker-password=<your-token>

Instalar cert-manager y OpenTelemetry

Instalas cert-manager y el operador de OpenTelemetry de esta manera:

for ns in cert-manager open-telemetry; do
  kubectl create namespace $ns
  kubectl create secret docker-registry application-collection \
    --namespace $ns \
    --docker-server=dp.apps.rancher.io \
    --docker-username=<your-username> \
    --docker-password=<your-token>
done

helm install --wait \
  --namespace cert-manager \
  --set crds.enabled=true \
  --set global.imagePullSecrets={application-collection} \
  --version 1.21.2 \
  cert-manager oci://dp.apps.rancher.io/charts/cert-manager

helm install --wait \
  --namespace open-telemetry \
  --version 0.124.1 \
  --set global.imagePullSecrets={application-collection} \
  --set manager.collectorImage.tag=0.160.0-contrib \
  my-opentelemetry-operator oci://dp.apps.rancher.io/charts/opentelemetry-operator

Configuras la comunicación entre los componentes del Admission Controller y el Recolector de OpenTelemetry usando mTLS.

Para hacer eso, necesitas crear toda la infraestructura de clave pública (PKI):

# pki.yaml file
apiVersion: cert-manager.io/v1
kind: Certificate
metadata:
  name: my-client-certificate
  namespace: suse-sec-adm-controller
spec:
  dnsNames:
  - kubewarden.suse-sec-adm-controller.svc
  - kubewarden.suse-sec-adm-controller.svc.cluster.local
  issuerRef:
  kind: Issuer
  name: my-selfsigned-issuer
  secretName: my-client-cert
---
apiVersion: cert-manager.io/v1
kind: Certificate
metadata:
  name: my-certificate
  namespace: suse-sec-adm-controller
spec:
  dnsNames:
  - my-collector-collector.suse-sec-adm-controller.svc
  - my-collector-collector.suse-sec-adm-controller.svc.cluster.local
  issuerRef:
  kind: Issuer
  name: my-selfsigned-issuer
  secretName: my-server-cert
---
apiVersion: cert-manager.io/v1
kind: Issuer
metadata:
  name: my-selfsigned-issuer
  namespace: suse-sec-adm-controller
spec:
  selfSigned: {}

Aplica el manifiesto:

kubectl apply -f pki.yaml

Instala Jaeger y Prometheus

Después de eso, instalas Jaeger para almacenar y visualizar eventos de trazado.

kubectl create namespace jaeger

kubectl create secret docker-registry application-collection \
  --namespace jaeger \
  --docker-server=dp.apps.rancher.io \
  --docker-username=<your-username> \
  --docker-password=<your-token>

helm upgrade -i --wait \
  --namespace jaeger \
  --version 2.57.0 \
  jaeger-operator oci://dp.apps.rancher.io/charts/jaeger-operator \
  --set global.imagePullSecrets={application-collection} \
  --set rbac.clusterRole=true

kubectl apply -f - <<EOF
apiVersion: jaegertracing.io/v1
kind: Jaeger
metadata:
  name: my-open-telemetry
  namespace: jaeger
spec:
  imagePullSecrets:
    - name: application-collection
EOF

Si instalaste Traefik en el inicio rápido de OpenTelemetry, expón la interfaz de usuario de consulta de Jaeger con esto Ingress:

kubectl apply -f - <<EOF +
apiVersion: networking.k8s.io/v1 +
kind: Ingress +
metadata: +
  name: my-open-telemetry-query +
  namespace: jaeger +
spec: +
  ingressClassName: traefik +
  rules: +
    - http: +
        paths: +
          - path: / +
            pathType: Prefix +
            backend: +
              service: +
                name: my-open-telemetry-query +
                port: +
                  number: 16686
EOF

Ahora instalas Prometheus para almacenar y visualizar métricas.

cat <<EOF > kube-prometheus-stack-values.yaml
prometheus:
  additionalServiceMonitors:
  - name: kubewarden
    selector:
    matchLabels:
      app.kubernetes.io/instance: suse-sec-adm-controller.my-collector
    namespaceSelector:
    matchNames:
      - suse-sec-adm-controller
    endpoints:
    - port: prometheus
    interval: 10s
EOF

kubectl create namespace prometheus

kubectl create secret docker-registry application-collection \
  --namespace prometheus \
  --docker-server=dp.apps.rancher.io \
  --docker-username=<your-username> \
  --docker-password=<your-token>

helm install --wait \
  --namespace prometheus \
  --version 92.1.0 \
  --values kube-prometheus-stack-values.yaml \
  --set global.imagePullSecrets={application-collection} \
  prometheus oci://dp.apps.rancher.io/charts/prometheus-operator

El monitor de servicio de Prometheus obtiene las métricas Admission Controller al raspar el recolector de OpenTelemetry que se ejecuta en el espacio de nombres kubewarden.

Instala el Recolector de OpenTelemetry

Ahora puedes desplegar un Recolector de OpenTelemetry personalizado en el espacio de nombres kubewarden.

# otel-collector.yaml file
apiVersion: v1
kind: ServiceAccount
metadata:
  name: my-collector
  namespace: suse-sec-adm-controller
imagePullSecrets:
  - name: application-collection
---
apiVersion: opentelemetry.io/v1beta1
kind: OpenTelemetryCollector
metadata:
  name: my-collector
  namespace: suse-sec-adm-controller
spec:
  mode: deployment # This configuration is omittable.
  serviceAccount: my-collector
  volumes:
  - name: server-certificate
    secret:
    secretName: my-server-cert
  - name: client-certificate
    secret:
    secretName: my-client-cert
  volumeMounts:
  - name: server-certificate
    mountPath: /tmp/etc/ssl/certs/my-server-cert
    readOnly: true
  - name: client-certificate
    mountPath: /tmp/etc/ssl/certs/my-client-cert
    readOnly: true
  config:
  receivers:
    otlp:
    protocols:
      grpc:
      tls:
        cert_file: /tmp/etc/ssl/certs/my-server-cert/tls.crt
        key_file: /tmp/etc/ssl/certs/my-server-cert/tls.key
        client_ca_file: /tmp/etc/ssl/certs/my-client-cert/ca.crt
  processors: {}
  exporters:
    debug:
    verbosity: normal
    prometheus:
    endpoint: ":8080"
    otlp/jaeger:
    endpoint: "my-open-telemetry-collector.jaeger.svc.cluster.local:4317"
    tls:
      insecure: true
  service:
    pipelines:
    metrics:
      receivers: [otlp]
      processors: []
      exporters: [debug, prometheus]
    traces:
      receivers: [otlp]
      processors: []
      exporters: [debug, otlp/jaeger]

Aplica el manifiesto:

kubectl apply -f otel-collector.yaml

Esa configuración utiliza un pipeline de procesamiento trivial para recibir eventos de trazado y reenviarlos a Jaeger. También recibe métricas y las expone para la recolección mediante Prometheus.

Aseguras la comunicación entre la pila Admission Controller y el Recolector de OpenTelemetry utilizando mTLS. Sin embargo, la comunicación entre el Recolector de OpenTelemetry y Jaeger no está asegurada, para reducir la complejidad del ejemplo.

Instala la pila Admission Controller

Cuando el Recolector de OpenTelemetry está en funcionamiento, puedes desplegar Admission Controller de la manera habitual.

Necesitas configurar los componentes Admission Controller para que envíen eventos y métricas al Recolector de OpenTelemetry.

# values.yaml
telemetry:
  mode: custom
  metrics: True
  tracing: True
  custom:
  endpoint: "https://my-collector-collector.suse-sec-adm-controller.svc:4317"
  insecure: false
  otelCollectorCertificateSecret: "my-server-cert"
  otelCollectorClientCertificateSecret: "my-client-cert"

El Secreto referenciado por la clave otelCollectorCertificateSecret debe tener una entrada llamada ca.crt. Eso contiene el certificado de la CA que emitió el certificado utilizado por el Recolector de OpenTelemetry.

El Secreto referenciado por la clave otelCollectorClientCertificateSecret debe tener las siguientes entradas: las claves tls.crt y tls.key. Estos son el certificado del cliente y su clave utilizados por la pila Admission Controller para autenticarse ante el Recolector de OpenTelemetry.

Deja estos valores vacíos si no utilizas cifrado o mTLS.

Instala el Admission Controllerstack:

helm install --wait \
  --namespace suse-sec-adm-controller \
  --values values.yaml \
  --set global.imagePullSecrets={application-collection} \
  --set recommendedPolicies.enabled=True \
  --set recommendedPolicies.defaultPolicyMode=monitor \
  suse-sec-adm-controller oci://dp.apps.rancher.io/charts/suse-security-admission-controller

Ahora todo está en su lugar.

Explorando la interfaz de usuario de Jaeger

Puedes ver los eventos de trazado generados por Admission Controller utilizando la interfaz web de Jaeger. Están agrupados bajo el servicio kubewarden-policy-server:

El panel de control de Jaeger

Para acceder a la interfaz de usuario de Jaeger con Traefik, reenvía el puerto del servicio Traefik:

kubectl -n traefik port-forward service/traefik 8080:80

La interfaz web es accesible en http://localhost:8080.

Si prefieres evitar Traefik, reenvía el servicio de consulta de Jaeger directamente:

kubectl -n jaeger port-forward service/my-open-telemetry-query 16686

La interfaz web es accesible en http://localhost:16686.

Explorando la interfaz de usuario de Prometheus

Puedes acceder a la interfaz de usuario de Prometheus reenviando el puerto a tu máquina local:

kubectl port-forward -n prometheus --address 0.0.0.0 svc/prometheus-operated 9090

La interfaz web ahora es accesible en http://localhost:9090.