14 Min. Lesezeit

Lernziele

Am Ende dieses Moduls werden Sie in der Lage sein:

  • Monitoring Service- und Logging Service-Pipelines mit Terraform zu provisionieren und die Metriken und Logs von TaskBoard dorthin zu senden
  • Workload-Logs von Managed Kubernetes mit Fluent Bit an den Logging Service weiterzuleiten und sie mit LogQL in Grafana zu durchsuchen
  • TaskBoard-Traces über OTLP an den Tracing Service zu senden und eine langsame Span mit ihren Logzeilen zu korrelieren
  • Infrastrukturänderungen mit der Activity Log API zu auditieren und Netzwerkpfade mit Flow Logs zu debuggen
  • Ein fehlerhaftes Deployment auf MKS schrittweise zu debuggen, von `kubectl` bis hin zur Metrik- und Logsuche

Einheit 5.1: Observability und Debugging

Einführung

TaskBoard läuft auf Managed Kubernetes, wird über CI/CD ausgeliefert und kommuniziert mit PostgreSQL, In-Memory DB, Kafka und Object Storage. Dann meldet ein Benutzer, dass die Aufgabenliste langsam ist und der Worker keine Benachrichtigungen mehr sendet. Sie benötigen schnell Antworten: Welcher Dienst ist langsam, was hat sich geändert und wohin gehen die Pakete.

Die Monitoring-, Logging- und Tracing Services speichern Metriken, Logs und Traces, die alle in einem verwalteten Grafana sichtbar sind. Sie arbeiten nach dem Push-Prinzip: Sie erstellen eine Pipeline und richten anschließend einen Agenten oder SDK darauf aus. Die Activity Log API protokolliert, wer was geändert hat, und Flow Logs erfassen Netzwerkflüsse. In dieser Einheit erstellen Sie dieses Setup für TaskBoard als Code, und im Code Lab nutzen Sie es, um einen simulierten Ausfall zu debuggen.

1. Metriken mit dem Monitoring Service

1.1 Bereitstellen einer Pipeline

resource "ionoscloud_monitoring_pipeline" "taskboard" {
  location = "de/txl"
  name     = "taskboard-metrics"
}

output "metrics_push_url" {
  value = "${ionoscloud_monitoring_pipeline.taskboard.http_endpoint}/api/v1/push"
}

output "metrics_key" {
  value     = ionoscloud_monitoring_pipeline.taskboard.key
  sensitive = true
}

output "grafana_url" {
  value = ionoscloud_monitoring_pipeline.taskboard.grafana_endpoint
}

Die Ressource akzeptiert ausschließlich Token für die Autorisierung, daher IONOS_TOKEN setzen. Die gleiche Pipeline über die REST API ist ein POST an den regionalen Host:

curl --request POST "https://monitoring.de-txl.ionos.com/pipelines" \
  --header "Authorization: Bearer $IONOS_TOKEN" \
  --header "Content-Type: application/json" \
  --data '{"metadata": {}, "properties": {"name": "taskboard-metrics"}}'

Der Pipeline-Schlüssel wird nur in der Erstellungsantwort und bei der Schlüsselrotation (POST /pipelines/{pipelineID}/key) zurückgegeben, wodurch der alte Schlüssel ungültig wird. Speichern Sie ihn sofort in Ihrem Secret Store. Ein Vertrag kann standardmäßig bis zu 10 Pipelines haben; IONOS CLOUD Support kann das Limit erhöhen. Rufen Sie GET /pipelines/{pipelineID} ab, bis metadata.state den Wert AVAILABLE hat, bevor Sie Agenten konfigurieren.

1.2 Pushen von TaskBoard-Metriken

Der Monitoring Service ist push-basiert: Prometheus, Grafana Agent, OpenTelemetry und Fluent Bit senden Metriken im Prometheus-Format an https://<HTTP_ENDPOINT>/api/v1/push über den ausgehenden Port 443. Fügen Sie für einen Prometheus-Server in der Cluster-Umgebung einen remote_write-Block zu prometheus.yml hinzu:

remote_write:
  - url: "https://<pipeline-id>-metrics.<tenant>.monitoring.de-txl.ionos.com/api/v1/push"
    headers:
      APIKEY: "<pipeline key>"

Das Agent sendet den Schlüssel im APIKEY-Header. Das Standard-Intervall für das Pushen beträgt eine Minute und kann geändert werden. OpenTelemetry Collectors können auch nativ im OTLP-Format an <httpEndpoint>/otlp/v1/metrics senden. Jeder gesendete Datenpunkt wird für die Abrechnung berücksichtigt, daher sollten Sie Serien, die Sie nicht benötigen, entfernen, bevor sie den Cluster verlassen.

1.3 Warnungen

Benutzerdefinierte Warnungen befinden sich in Grafana: Dort definieren Sie die Bedingung, den Schwellenwert und die Benachrichtigungseinstellungen für die Warnung. Für die API-Latenz von TaskBoard wird eine Warnung ausgelöst, wenn der 95. Perzentilwert des Histogramms der Anfragezeit überschritten wird, das die API exportiert:

histogram_quantile(0.95,
  sum by (le) (rate(http_request_duration_seconds_bucket{service="taskboard-api"}[5m]))
) > 0.5

Halten Sie den Ausdruck in Git neben dem Dienst. Für Server-Prüfungen ohne Agenten verwenden Sie die Telemetry API. Sie ist Prometheus-kompatibel, schreibgeschützt, verwendet Ihr Cloud API-Token und wird verfügbar, sobald Ihr Vertrag über mindestens eine Observability-Pipeline verfügt:

curl --silent --get "https://api.ionos.com/telemetry/api/v1/query" \
  --header "Authorization: Bearer $IONOS_TOKEN" \
  --data-urlencode "query=instance_cpu_utilization_average > 90"

instance_cpu_utilization_average ist ein Gauge; die anderen acht Telemetry API Metriken sind Counter, daher müssen sie in rate() eingebettet werden. Metriken tragen den Server uuid, nicht dessen Namen, daher werden Namen über die Cloud API aufgelöst.

2. Protokolle mit dem Logging Service

2.1 Bereitstellung einer Pipeline

resource "ionoscloud_logging_pipeline" "taskboard" {
  location = "de/txl"
  name     = "taskboard-logs"

  log {
    source   = "kubernetes"
    tag      = "k8s"
    protocol = "tcp"
    destinations {
      type              = "loki"
      retention_in_days = 14
    }
  }
}

output "logging_tcp_host" {
  value = split(":", ionoscloud_logging_pipeline.taskboard.tcp_address)[0]
}

output "logging_key" {
  value     = ionoscloud_logging_pipeline.taskboard.key
  sensitive = true
}

Jeder log-Block ist ein Log-Stream mit einer eindeutigen tag. Die Aufbewahrungsdauer beträgt 7, 14 oder 30 Tage pro Stream, wobei 30 Tage der Standardwert ist. Der Schlüssel folgt einer einmaligen Freigabepolitik: Er kann nicht erneut abgerufen werden, und die Erzeugung eines neuen Schlüssels mit POST /pipelines/{pipelineID}/key widerruft den vorherigen Schlüssel sofort.

Die folgende Tabelle listet die Grenzen des Logging Service auf:

Aspekt Beschreibung Grenze
HTTP Rate Limit Standard-Ratenbeschränkung für HTTP-Anfragen pro Pipeline während der Log-Aufnahme. 50 Anfragen pro Sekunde
TCP Bandbreite Standard-TCP-Bandbreitenbeschränkung pro Pipeline, ungefähr ausgedrückt als Logs pro Sekunde. ~10.000 Logs pro Sekunde
Maximale Pipelines Die maximale Anzahl an Pipelines, die pro Vertrag zulässig sind. 10 Pipelines
Log-Streams pro Pipeline Die maximale Anzahl an Log-Streams, die pro Pipeline zulässig sind. 5 Log-Streams pro Pipeline

Durch Ratenbeschränkung verworfene Datensätze werden nicht gespeichert.

2.2 Weiterleitung von Cluster-Logs aus MKS

Kubernetes API-Audit-Logs werden in den Object Storage-Bucket gesendet, den Sie auf dem Cluster konfigurieren (Einheit 3.2). Um Pod-Logs in den Logging Service zu übergeben, führen Sie einen Agenten im Cluster aus, in der Regel Fluent Bit als DaemonSet:

[OUTPUT]
    Name        forward
    Match       kube.*
    Host        ${LOGGING_TCP_HOST}
    Port        9000
    Tag         k8s
    tls         on
    Shared_Key  ${LOGGING_KEY}

Der TCP-Stream erfordert Port 9000 mit TLS, und Shared_Key enthält den Pipeline-Schlüssel. HTTP-Streams akzeptieren ausschließlich JSON, wobei der Schlüssel im APIKEY-Header übergeben wird.

2.3 Durchsuchen von Logs

Der Logging Service speichert Logs in Loki, und Sie durchsuchen sie mit LogQL in Grafana Explore. Abfragen werden nicht in der Abrechnung berücksichtigt.

{tag_name="k8s"} |= "taskboard-api" | json | level="error"
{tag_name="k8s"} |= "taskboard-worker" |= "KafkaError"

Das Tag des Streams wird zum tag_name-Label. Weitere Labels hängen von der Protokollierungsquelle und Ihren benutzerdefinierten Labels ab. Prüfen Sie daher vor dem Speichern einer Abfrage in einem Dashboard den Label-Browser in Explore.

3. Traces mit dem Tracing Service

3.1 Erstellen einer OTLP-Pipeline

curl --request POST "https://tracing.de-txl.ionos.com/pipelines" \
  --header "Authorization: Bearer $IONOS_TOKEN" \
  --header "Content-Type: application/json" \
  --data '{"metadata": {}, "properties": {"name": "taskboard-traces", "protocol": "otlp-http"}}'

protocol ist otlp-http oder otlp-grpc. Sobald die Pipeline AVAILABLE ist, enthält metadata.otlpEndpoint den Ingestion-Host; es handelt sich um einen eindeutigen Hostnamen pro Pipeline, nicht um den tracing.<region>.ionos.com-Verwaltungshost. OTLP/HTTP-Exporter fügen /v1/traces hinzu und senden den Schlüssel im apikey-Header; OTLP/gRPC-Exporter senden ihn als apikey-Metadaten auf Port 443.

3.2 Instrumentierung der TaskBoard API

Der Exporter liest OTEL_EXPORTER_OTLP_TRACES_ENDPOINT="https://<tracing-ingestion-endpoint>/v1/traces", OTEL_EXPORTER_OTLP_PROTOCOL="http/protobuf" und OTEL_EXPORTER_OTLP_HEADERS="apikey=<API_KEY>" aus der Umgebung:

import json

from opentelemetry import trace
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor

provider = TracerProvider(resource=Resource.create({"service.name": "taskboard-api"}))
provider.add_span_processor(BatchSpanProcessor(OTLPSpanExporter()))
trace.set_tracer_provider(provider)
tracer = trace.get_tracer("taskboard")

def log_json(level, msg):
    ctx = trace.get_current_span().get_span_context()
    print(json.dumps({"level": level, "msg": msg, "trace_id": format(ctx.trace_id, "032x")}))

with tracer.start_as_current_span("list_tasks"):
    log_json("info", "cache miss, reading tasks from PostgreSQL")

Setzen Sie den Wert des Headers in ein Kubernetes Secret. Das trace_id in jeder JSON-Logzeile ermöglicht die Korrelation zwischen Trace und Log: Im selben Grafana-Workspace können Sie von einem Span zu den zugehörigen Loki-Logs und den verwandten Mimir-Metriken navigieren.

Ein einzelner Trace darf nicht mehr als 5 MB an zusammengefassten Span-Daten enthalten. Die Aufnahme ist auf 15 MB/s dauerhaft und 20 MB als Burst begrenzt; überschüssiger Verkehr erhält HTTP 429 (OTLP/HTTP) oder RESOURCE_EXHAUSTED (OTLP/gRPC). Traces werden 30 Tage aufbewahrt. Konfigurieren Sie Sampling, um das Volumen zu reduzieren, das Sie senden.

4. Änderungen und Netzwerkflüsse auditieren

4.1 Die Activity Log API

Die Activity Log API ist nur lesbar (nur GET) unter https://api.ionos.com/activitylog/v1, akzeptiert Basic Auth oder ein Bearer-Token und gibt JSON mit den Einträgen unter hits zurück:

import os
import requests

BASE = "https://api.ionos.com/activitylog/v1"
HEADERS = {"Authorization": f"Bearer {os.environ['IONOS_TOKEN']}",
           "Content-Type": "application/json"}

def activity(contract, date_start, date_end, page=500):
    offset = 0
    while True:
        params = {"dateStart": date_start, "dateEnd": date_end, "offset": offset, "limit": page}
        r = requests.get(f"{BASE}/contracts/{contract}", headers=HEADERS, params=params, timeout=30)
        r.raise_for_status()
        hits = r.json()["hits"]["hits"]
        for hit in hits:
            yield hit["_source"]
        if len(hits) < page:
            return
        offset += page

for e in activity(31721060, "2026-11-02T00:00:00Z", "2026-11-03T00:00:00Z"):
    actions = [a for res in e["event"]["resources"] for a in res["action"]]
    print(e["meta"]["time"], e["principal"]["identity"]["username"], e["event"]["type"], actions)

dateStart ist inklusiv und dateEnd exklusiv; limit akzeptiert bis zu 10000. GET /contracts listet die Verträge auf, auf die Ihre Zugangsdaten zugreifen können. Standardmäßig können nur der Vertragsinhaber und Administratoren die API aufrufen; andere Benutzer benötigen eine Gruppe mit dem Berechtigungssatz „Access Activity Log“. Einträge werden 35 Tage aufbewahrt. Exportieren Sie sie in Object Storage oder in den Logging Service, wenn Sie eine längere Historie benötigen. Das Activity Log deckt IaaS-Produkte ab, nicht jedoch PaaS-Produkte.

4.2 Flow Logs für Verbindungsprobleme

resource "ionoscloud_nic" "worker" {
  datacenter_id = ionoscloud_datacenter.taskboard.id
  server_id     = ionoscloud_vcpu_server.worker.id
  lan           = ionoscloud_lan.app.id
  dhcp          = true

  flowlog {
    name      = "worker-rejected"
    action    = "REJECTED"
    direction = "BIDIRECTIONAL"
    bucket    = "taskboard-flowlogs-7f3a"
  }
}

Flow Logs werden auf VM-Netzwerkschnittstellen, dem Managed Network Load Balancer, dem Managed Application Load Balancer und dem Managed NAT Gateway unterstützt, jeweils mit einem Flow Log pro Ressource. Der Bucket muss bereits existieren und dem Benutzer gehören. action, direction und bucket sind unveränderlich; das Entfernen des flowlog-Blocks erzwingt die Neuanlage der NIC. Datensätze treffen alle 10 Minuten als .log.gz-Objekte ein, und für Intervalle ohne Flows wird keine Datei geschrieben:

2 12345678 7ffd6527-ce80-4e57-a949-f9a45824ebe2 172.17.1.100 172.17.1.101 59113 20756 6 17 1325 1587983051 1587983052 REJECT OK

Die Felder lauten version account-id interface-id srcaddr dstaddr srcport dstport protocol packets bytes start end action log-status. Ein REJECT auf dem Zielport von PostgreSQL oder Kafka verweist auf eine Firewall- oder NSG-Regel, nicht auf die Anwendung. Richten Sie eine Lifecycle Policy für den Bucket ein, da die Flow Logs bestehen bleiben, bis Sie sie löschen.

5. Der Kubernetes-Debugging-Workflow

5.1 Vom Pod zur Plattform

Arbeiten Sie von der engsten Ansicht aus nach außen:

kubectl -n taskboard get pods -o wide                        # 1. status, restarts, node
kubectl -n taskboard describe pod <pod>                      # 2. probe failures, pull errors
kubectl -n taskboard get events --sort-by=.lastTimestamp     # 3. scheduling, evictions
kubectl -n taskboard logs deploy/taskboard-api --previous    # 4. the crashed container's output

Erweitern Sie anschließend den Blick auf die Plattform: (5) die Latenz- und Fehlerquoten-Panel aus dem Monitoring Service, (6) eine LogQL-Suche über alle Pods und die Worker-VM, (7) der Trace einer langsamen Anfrage und (8) das Activity Log für Änderungen im gleichen Zeitfenster. Kubernetes speichert Ereignisse nur für eine begrenzte Zeit, daher die Ausgabe von kubectl get events während des Vorfalls speichern.

5.2 Health Checks

livenessProbe:
  httpGet: { path: /api/health/live, port: 8000 }
  periodSeconds: 10
  failureThreshold: 3
readinessProbe:
  httpGet: { path: /api/health/ready, port: 8000 }
  periodSeconds: 5

Liveness startet einen festgefahrenen Container neu; Readiness entfernt einen Pod aus seinem Service, während Abhängigkeiten wie PostgreSQL nicht erreichbar sind. Am ALB weisen Sie das http_health_check der Target Group aus den Einheiten 2.3 und 3.2 auf denselben Readiness-Pfad. Sein health_check-Block setzt check_interval und check_timeout in Millisekunden; das Standardintervall beträgt 2000.

Schnellkarte zur API-Referenz

Wichtige API-Endpunkte für das Thema dieser Einheit:

Methode Endpunkt Beschreibung
POST https://monitoring.<region>.ionos.com/pipelines Monitoring Service-Pipeline erstellen
POST https://logging.<region>.ionos.com/pipelines/{pipelineID}/key Schlüssel einer Logging Service-Pipeline rotieren
POST https://tracing.<region>.ionos.com/pipelines Tracing Service-Pipeline erstellen
GET https://api.ionos.com/telemetry/api/v1/query Servermetriken mit PromQL abfragen
GET https://api.ionos.com/activitylog/v1/contracts/{contractNumber} Activity Log-Einträge lesen

Basis-URL: regional pro Service, wie oben aufgeführt Authentifizierung: Authorization: Bearer <token>

Code Lab

Ziel: Metrik- und Log-Pipelines für TaskBoard bereitstellen, MKS-Logs mit Fluent Bit weiterleiten und anschließend einen simulierten Ausfall mit kubectl, LogQL und dem Activity Log debuggen.

Voraussetzungen:

  • IONOS CLOUD Konto mit einem API-Token in IONOS_TOKEN
  • Der MKS-Cluster und die TaskBoard-Deployments aus Einheit 3.2
  • Terraform, kubectl, Helm und Python 3 mit requests

Schritt 1: Die Pipelines bereitstellen

Fügen Sie die Ressourcen und Ausgaben aus den Abschnitten 1.1 und 2.1 hinzu.

terraform apply -target=ionoscloud_monitoring_pipeline.taskboard -target=ionoscloud_logging_pipeline.taskboard
terraform output grafana_url

Erwartete Ausgabe:

ionoscloud_monitoring_pipeline.taskboard: Creation complete after ...
ionoscloud_logging_pipeline.taskboard: Creation complete after ...
"https://grafana.<...>.ionos.com"

Schritt 2: Die Protokollierungsanmelddaten im Cluster speichern

kubectl create namespace logging
kubectl -n logging create secret generic logging-pipeline \
  --from-literal=LOGGING_TCP_HOST="$(terraform output -raw logging_tcp_host)" \
  --from-literal=LOGGING_KEY="$(terraform output -raw logging_key)"

Erwartete Ausgabe:

namespace/logging created
secret/logging-pipeline created

Schritt 3: Fluent Bit bereitstellen

Speichern Sie fluent-bit-values.yaml mit envFrom: [{secretRef: {name: logging-pipeline}}] und dem Abschnitt [OUTPUT] aus Abschnitt 2.2 unter config.outputs.

helm repo add fluent https://fluent.github.io/helm-charts
helm install fluent-bit fluent/fluent-bit -n logging -f fluent-bit-values.yaml
kubectl -n logging get pods

Erwartete Ausgabe:

NAME               READY   STATUS    RESTARTS   AGE
fluent-bit-<id>    1/1     Running   0          30s

Schritt 4: TaskBoard-Protokolle in Grafana finden

Öffnen Sie die Grafana-URL, melden Sie sich mit Ihren IONOS CLOUD-Anmeldedaten an, wählen Sie „Explore" und führen Sie Folgendes aus:

{tag_name="k8s"} |= "taskboard-api"

Erwartete Ausgabe:

<timestamp>  {"level": "info", "msg": "GET /api/health 200", ...}

Schritt 5: Eine Störung simulieren und die Ursache ermitteln

kubectl -n taskboard set env deploy/taskboard-api DATABASE_URL="postgresql://wrong-host:5432/taskboard"
kubectl -n taskboard describe pod <new-pod> | grep Readiness

Suchen Sie dann in Grafana Explore nach {tag_name="k8s"} |= "taskboard-api" |= "wrong-host". Erwartete Ausgabe:

Readiness probe failed: HTTP probe failed with statuscode: 503
{"level": "error", "msg": "could not translate host name \"wrong-host\" ..."}

Schritt 6: Infrastrukturänderungen ausschließen und wiederherstellen

Führen Sie das Skript aus Abschnitt 4.1 für heute aus. Eine kubectl-Änderung ist kein Cloud API-Aufruf, daher nur nach unerwarteten Infrastruktur-Einträgen suchen; anschließend zurückrollen.

python activity.py
kubectl -n taskboard rollout undo deploy/taskboard-api
kubectl -n taskboard rollout status deploy/taskboard-api

Erwartete Ausgabe:

<time> <user> <event type> [<actions>]
deployment "taskboard-api" successfully rolled out

Validierungscheckliste:

  • [ ] Beide Pipelines existieren und ihre Schlüssel befinden sich ausschließlich im Terraform-Zustand und im Kubernetes-Secret
  • [ ] Die Pod-Protokolle von TaskBoard sind in Grafana mit LogQL durchsuchbar
  • [ ] Der fehlerhafte Rollout zeigt fehlgeschlagene Readiness-Probes und den Fehler in den Protokollen
  • [ ] rollout undo stellt eine bereite API wieder her

Aufräumarbeiten:

helm uninstall fluent-bit -n logging
kubectl delete namespace logging
terraform destroy -target=ionoscloud_logging_pipeline.taskboard -target=ionoscloud_monitoring_pipeline.taskboard

Häufige Fehler

Fehler von Entwicklerinnen und Entwicklern, die bei dem Thema dieser Einheit zu vermeiden sind:

  1. Warten auf Cluster-Protokolle, die nie eintreffen

    • Problem: Die Logging Service-Pipeline ist AVAILABLE, aber Grafana zeigt keine Kubernetes-Protokolle oder -Ereignisse an.
    • Ursache: Control-Plane-Ereignisse fließen nicht über den Logging Service, Audit-Protokolle werden in den Object Storage-Bucket des Clusters geschrieben, und Pod-Protokolle benötigen einen Agenten, den Sie bereitstellen.
    • Lösung: Führen Sie Fluent Bit (oder einen OTLP-Exporter) im Cluster mit dem TCP-Host der Pipeline, Port 9000, tls on und Shared_Key aus (Abschnitt 2.2).
  2. Verlust des Pipeline-Schlüssels

    • Problem: Ein neuer Agent benötigt den Schlüssel, aber GET /pipelines/{pipelineID} gibt ihn nicht zurück.
    • Ursache: Monitoring- und Logging-Schlüssel werden nur einmal angezeigt; bei einer Rotation wird der alte Schlüssel sofort widerrufen.
    • Lösung: Markieren Sie die Terraform-Ausgabe sensitive, speichern Sie den Schlüssel in Ihrem Secret Store und aktualisieren Sie bei einer Rotation alle Agenten in derselben Änderung.
  3. Flow-Log-Änderungen, die eine NIC neu erstellen

    • Problem: Eine Änderung von action oder das Entfernen des flowlog-Blocks plant die Ersetzung der NIC der Worker.
    • Ursache: Flow-Log-Einstellungen sind unveränderlich, und das Löschen eines Flow Logs erzwingt die Neuerstellung der NIC.
    • Lösung: Bestimmen Sie die Erfassungseinstellungen einmalig, ändern Sie nur name an Ort und Stelle und planen Sie das Entfernen von Flow Logs als NIC-Ersetzung in einem Wartungsfenster.

Zusammenfassung

Sie können TaskBoard nun Observability as Code bereitstellen: Terraform erstellt die Pipelines, Prometheus und Fluent Bit übermitteln Daten an diese, und OpenTelemetry-Traces werden über die Trace ID mit Logzeilen verknüpft. Wenn etwas fehlerhaft ist, arbeiten Sie von kubectl aus nach außen hin zu Metriken, Logs, Traces, dem Activity Log und Flow Logs.

Wichtige Punkte:

  • Jeder Observability-Dienst ist push-basiert: Erstellen Sie eine Pipeline und weisen Sie dann einen Agenten oder eine SDK ihrem Endpunkt mit dem Pipeline-Schlüssel zu
  • Pipeline-Schlüssel werden nur einmal angezeigt; die Rotation eines Schlüssels widerruft den alten
  • Audit-Logs des MKS API-Servers werden in einen von Ihnen benannten Object Storage-Bucket gesendet; Pod-Logs werden mit einem von Ihnen bereitgestellten Agenten übertragen
  • Die Activity Log API ist schreibgeschützt, speichert 35 Tage und deckt IaaS-Produkte ab
  • Flow-Log-Einstellungen sind unveränderlich; Datensätze werden alle 10 Minuten in Ihrem eigenen Object Storage-Bucket abgelegt

Wichtige Begriffe:

  • Pipeline: Eine Instanz des Monitoring-, Logging- oder Tracing Service mit eigenem Ingestion-Endpunkt und Schlüssel
  • Remote write: Das Prometheus-Protokoll zum Übermitteln von Stichproben an /api/v1/push
  • LogQL: Die Loki-Abfragesprache, die Sie in Grafana Explore zur Suche in Logs verwenden
  • OTLP: Das OpenTelemetry Protocol, das über HTTP oder gRPC zur Übermittlung von Traces verwendet wird
  • Flow-Log-Datensatz: Eine durch Leerzeichen getrennte Zeile, die einen Netzwerkfluss, seine Byteanzahl und seine ACCEPT- oder REJECT-Aktion beschreibt

Nächste Schritte

Weiter lernen: Einheit 5.2: Sicherheitsautomatisierung

Verwandte Themen: