Coletor OpenTelemetry Personalizado

Este guia explica como configurar o Admission Controller para enviar dados de telemetria para um coletor OpenTelemetry já implantado no cluster.

Você deve implantar apenas uma instância do Coletor OpenTelemetry no cluster.

Instalar dependências

Primeiro, comece instalando as dependências do Coletor OpenTelemetry.

Você precisa de comunicação criptografada entre os componentes do SUSE Security Admission Controller e o coletor. Você pode usar cert-manager para gerenciar todos os certificados necessários para comunicação segura.

Os traços do Coletor OpenTelemetry são enviados para uma instância do Jaeger.

A pilha do Admission Controller envia métricas para o Coletor OpenTelemetry. Este expõe as métricas como um endpoint Prometheus. As métricas são então coletadas por uma instância do Prometheus e armazenadas em seu banco de dados. A mesma instância do Prometheus também expõe uma interface para visualizar e usar as métricas.

Os recursos que você cria são definidos no Namespace kubewarden e pressupõem a sua existência. Devido a isso, você deve começar criando o Namespace:

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 e OpenTelemetry

Você instala o cert-manager e o operador OpenTelemetry desta forma:

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

Você configura a comunicação entre os componentes Admission Controller e o Coletor OpenTelemetry usando mTLS.

Para fazer isso, você precisa criar toda a Infraestrutura de Chave 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: {}

Aplique o manifesto:

kubectl apply -f pki.yaml

Instale o Jaeger e o Prometheus

Depois disso, você instala Jaeger para armazenar e visualizar eventos de rastreamento.

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

Se você instalou o Traefik no início rápido do OpenTelemetry, exponha a interface de consulta do Jaeger com este 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

Agora você instala Prometheus para armazenar e 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

O monitor de serviço do Prometheus obtém as métricas Admission Controller raspando o coletor OpenTelemetry em execução no kubewarden Namespace.

Instale o Coletor OpenTelemetry

Agora você pode implantar um Coletor OpenTelemetry personalizado no kubewarden Namespace.

# 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]

Aplique o manifesto:

kubectl apply -f otel-collector.yaml

Essa configuração usa um pipeline de processamento trivial para receber eventos de rastreamento e encaminhá-los para o Jaeger. Ele também recebe métricas e as expõe para coleta pelo Prometheus.

Você protege a comunicação entre a pilha Admission Controller e o Coletor OpenTelemetry usando mTLS. No entanto, a comunicação entre o Coletor OpenTelemetry e o Jaeger não está segura, para reduzir a complexidade do exemplo.

Instale a pilha Admission Controller

Quando o Coletor OpenTelemetry estiver em execução, você pode implantar Admission Controller da maneira usual.

Você precisa configurar os componentes Admission Controller para que eles enviem eventos e métricas para o OpenTelemetry Collector.

# 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"

O Secret referenciado pela chave otelCollectorCertificateSecret deve ter uma entrada chamada ca.crt. Isso contém o certificado da CA que emitiu o certificado usado pelo OpenTelemetry Collector.

O Secret referenciado pela chave otelCollectorClientCertificateSecret deve ter as seguintes entradas: as chaves tls.crt e tls.key. Esses são o certificado do cliente e sua chave usados pela pilha Admission Controller para se autenticar contra o OpenTelemetry Collector.

Deixe esses valores vazios se você não usar criptografia ou mTLS.

Instale a pilha Admission Controller:

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

Agora tudo está em ordem.

Explorando a interface do Jaeger

Você pode ver os eventos de rastreamento gerados por Admission Controller usando a interface web do Jaeger. Eles estão agrupados sob o serviço kubewarden-policy-server:

O painel do Jaeger

Para acessar a interface do Jaeger com o Traefik, faça o port-forward do serviço Traefik:

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

A interface web é acessível em http://localhost:8080.

Se você preferir contornar o Traefik, faça o port-forward do serviço de consulta do Jaeger diretamente:

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

A interface web é acessível em http://localhost:16686.

Explorando a interface do Prometheus

Você pode acessar a interface do Prometheus fazendo o port-forward para sua máquina local:

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

A interface web agora é acessível em http://localhost:9090.