Versionsinformationen finden Sie in den Versionshinweisen zu Distributed Cloud Connected.

Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Logs und Messwerte

Auf dieser Seite wird erläutert, wie Google Distributed Cloud Connected verschiedene Arten von Informationen zum Betrieb protokolliert und wie Sie diese Informationen aufrufen können. Für die Erfassung einiger Arten von Logs und Messwerten fallen zusätzliche Kosten an. Weitere Informationen finden Sie unter Abrechnung für Logs und Messwerte.

Logging und Monitoring konfigurieren

Bevor Sie mit dem Erfassen von Logs und Messwerten beginnen können, müssen Sie Folgendes tun:

Aktivieren Sie die Logging-APIs mit den folgenden Befehlen:

gcloud services enable opsconfigmonitoring.googleapis.com --project PROJECT_ID
gcloud services enable logging.googleapis.com --project PROJECT_ID
gcloud services enable monitoring.googleapis.com --project PROJECT_ID

Ersetzen Sie PROJECT_ID durch die ID des Ziel Google Cloud projekts.

Erteilen Sie die erforderlichen Rollen zum Schreiben von Logs und Messwerten:

gcloud projects add-iam-policy-binding PROJECT_ID \
    --role roles/opsconfigmonitoring.resourceMetadata.writer \
    --member "serviceAccount:PROJECT_ID.svc.id.goog[kube-system/metadata-agent]"

gcloud projects add-iam-policy-binding PROJECT_ID \
    --role roles/logging.logWriter \
     --member "serviceAccount:PROJECT_ID.svc.id.goog[kube-system/stackdriver-log-forwarder]"

gcloud projects add-iam-policy-binding PROJECT_ID \
    --role roles/monitoring.metricWriter \
    --member "serviceAccount:PROJECT_ID.svc.id.goog[kube-system/gke-metrics-agent]"

Ersetzen Sie PROJECT_ID durch die ID des Ziel Google Cloud projekts.

Logs

In diesem Abschnitt werden die Cloud Logging-Ressourcentypen aufgeführt, die von Distributed Cloud unterstützt werden. Verwenden Sie den Log-Explorer in der Google Cloud Console, um Distributed Cloud Logs aufzurufen. Das Distributed Cloud-Logging ist immer aktiviert.

Die protokollierten Ressourcentypen von Distributed Cloud Connected sind die folgenden Standard-Kubernetes-Ressourcen:

k8s_container
k8s_node

Sie können auch Distributed Cloud Connected-Logs mit der Cloud Logging API erfassen und abrufen. Informationen zum Konfigurieren dieses Logging-Mechanismus finden Sie in der Dokumentation zu den Cloud Logging-Clientbibliotheken.

Messwerte

In diesem Abschnitt werden die Cloud Monitoring-Messwerte aufgeführt, die von Distributed Cloud unterstützt werden. Verwenden Sie den Metrics Explorer in der Google Cloud Console, um Distributed Cloud-Messwerte aufzurufen.

Cluster-Messwerte von Distributed Cloud Connected

Für Distributed Cloud Connected-Cluster stellt Distributed Cloud Connected die folgenden Arten von Messwerten bereit, die von Distributed Cloud Connected-Knoten generiert werden:

Ressourcenmesswerte enthalten Informationen zur Leistung von Distributed Cloud Connected-Knoten und -Pods, z. B. zur CPU-Last und zur Arbeitsspeichernutzung.
Systemanwendungsmesswerte enthalten Informationen zu Distributed Cloud Connected-Systemarbeitslasten wie coredns.

Eine Liste dieser Messwerte finden Sie unter Google Distributed Cloud und Google Distributed Cloud-Messwerte.

Distributed Cloud Connected stellt keine Messwerte bereit, die von den Kubernetes-Steuerungsebenen generiert werden, die mit Distributed Cloud Connected-Clustern verknüpft sind.

Hardwaremesswerte von Distributed Cloud Connected

Distributed Cloud Connected stellt Messwerte für Distributed Cloud Connected-Hardware mithilfe der folgenden Ressourcentypen bereit:

edgecontainer.googleapis.com/Machine
edgecontainer.googleapis.com/Rack

Ressourcenmesswerte für `Machine`

Distributed Cloud Connected schreibt die folgenden Cloud Monitoring API-Messwerte für die Ressource edgecontainer.googleapis.com/Machine:

Messwert	Beschreibung
`/machine/cpu/total_cores` Art: `GAUGE` Typ: `INT`	Gesamtzahl der physischen Prozessorkerne auf der Maschine.
`/machine/cpu/usage_time` Art: `CUMULATIVE` Typ: `DOUBLE` Einheit: `Seconds`	Kumulative CPU-Nutzungszeit für alle Kerne auf der Maschine. Der Typ kann `workload` (Kundenarbeitslasten) oder `system` (alles andere) sein.
`/machine/cpu/utilization` Art: `GAUGE` Typ: `DOUBLE`	Prozentsatz der CPU-Auslastung auf der Maschine. Der Bereich liegt zwischen 0 und 1. Der Typ kann `workload` (Kundenarbeitslasten) oder `system` (alles andere) sein.
`/machine/memory/total_bytes` Art: `GAUGE` Typ: `INT64`	Byte-Anzahl des gesamten Arbeitsspeichers auf der Maschine.
`/machine/memory/used_bytes` Art: `GAUGE` Typ: `INT64`	Byte-Anzahl des verwendeten Arbeitsspeichers auf der Maschine. `memory_type` ist entweder `evictable` (vom Kernel freigebbar) oder `non-evictable` (nicht freigebbar).
`/machine/memory/utilization` Art: `GAUGE` Typ: `DOUBLE`	Prozentsatz der Arbeitsspeicherauslastung auf der Maschine. Der Bereich liegt zwischen 0 und 1. `memory_type` ist entweder `evictable` (vom Kernel freigebbar) oder `non-evictable` (nicht freigebbar).
`/machine/network/up` Art: `GAUGE` Typ: `BOOL`	Gibt an, ob die Netzwerkschnittstelle aktiv ist. Enthält primäre Karten, sekundäre Karten und Ports.
`/machine/network/link_speed` Art: `GAUGE` Typ: `DOUBLE` Einheit: Byte pro Sekunde	Verbindungsgeschwindigkeit der primären Netzwerkkarte.
`/machine/network/received_bytes_count` Art: `CUMULATIVE` Typ: `DOUBLE`	Anzahl der empfangenen Byte für die primäre Netzwerkkarte.
`/machine/network/sent_bytes_count` Art: `CUMULATIVE` Typ: `DOUBLE`	Anzahl der gesendeten Byte für die primäre Netzwerkkarte.
`/machine/network/connectivity` Art: `GAUGE` Typ: `BOOL`	Gibt an, ob die primäre Netzwerkkarte eine Internetverbindung hat.
`/machine/disk/total_bytes` Art: `GAUGE` Typ: `INT64`	Byte-Anzahl des gesamten Speicherplatzes auf der Maschine.
`/machine/disk/used_bytes` Art: `GAUGE` Typ: `INT64`	Byte-Anzahl des verwendeten Speicherplatzes auf der Maschine.
`/machine/disk/utilization` Art: `GAUGE` Typ: `DOUBLE`	Prozentsatz der Speicherplatznutzung auf der Maschine. Der Bereich liegt zwischen 0 und 1.
`/machine/restart_count` Art: `CUMULATIVE` Typ: `INT`	Anzahl der Neustarts der Maschine.
`/machine/uptime` Art: `GAUGE` Typ: `INT` Einheit: `Seconds`	Betriebszeit der Maschine seit dem letzten Neustart.
`/machine/connected` Art: `GAUGE` Typ: `INT64`	Gibt an, ob die Maschine mit verbunden ist Google Cloud.

Ressourcenmesswerte für `Rack`

Distributed Cloud Connected schreibt die folgenden Cloud Monitoring API-Messwerte für die Ressource edgecontainer.googleapis.com/Rack:

Messwert	Beschreibung
`/router/bgp_up` Art: `GAUGE` Typ: `BOOL`	Gibt an, ob die BGP-Peering-Sitzung auf dem Router aktiv und fehlerfrei ist. `router_id` gibt den jeweiligen Router an (bis zu 2 pro Rack).
`/router/connected` Art: `GAUGE` Typ: `BOOL`	Gibt an, ob der BGP-Router mit verbunden ist Google Cloud. `router_id` gibt den jeweiligen Router an (bis zu 2 pro Rack).

Benutzerdefinierte Anwendungslogs und -messwerte exportieren

Distributed Cloud Connected exportiert automatisch Logs für Anwendungen, die auf Distributed Cloud Connected-Arbeitslasten ausgeführt werden. Wenn Sie Messwerte für eine Anwendung exportieren möchten, die auf Distributed Cloud Connected-Arbeitslasten ausgeführt wird, müssen Sie sie wie im nächsten Abschnitt beschrieben annotieren.

Arbeitslast annotieren, um den Export von Messwerten zu aktivieren

Fügen Sie dem Dienst- oder Bereitstellungsmanifest der Anwendung die folgenden Annotationen hinzu, um das Erfassen benutzerdefinierter Messwerte aus einer Anwendung zu aktivieren:

prometheus.io/scrape: "true"
prometheus.io/path: "ENDPOINT_PATH". Ersetzen Sie ENDPOINT_PATH durch den vollständigen Pfad zum Messwertendpunkt der Zielanwendung.
prometheus.io/port: "PORT_NUMBER": der Port, auf dem der Messwertendpunkt der Anwendung auf Verbindungen wartet.

Beispielanwendung ausführen

In diesem Abschnitt erstellen Sie eine Anwendung, die benutzerdefinierte Logs schreibt und einen benutzerdefinierten Messwertendpunkt bereitstellt.

Speichern Sie die folgenden Dienst- und Bereitstellungsmanifeste in einer Datei mit dem Namen my-app.yaml. Der Dienst hat die Annotation prometheus.io/scrape: "true":

kind: Service
apiVersion: v1
metadata:
  name: "monitoring-example"
  namespace: "default"
  annotations:
    prometheus.io/scrape: "true"
spec:
  selector:
    app: "monitoring-example"
  ports:
    - name: http
      port: 9090
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: "monitoring-example"
  namespace: "default"
  labels:
    app: "monitoring-example"
spec:
  replicas: 1
  selector:
    matchLabels:
      app: "monitoring-example"
  template:
    metadata:
      labels:
        app: "monitoring-example"
    spec:
      containers:
      - image: gcr.io/google-samples/prometheus-dummy-exporter:latest
        name: prometheus-example-exporter
        imagePullPolicy: Always
        command:
        - /bin/sh
        - -c
        - ./prometheus-dummy-exporter --metric-name=example_monitoring_up --metric-value=1 --port=9090
        resources:
          requests:
            cpu: 100m

Erstellen Sie das Deployment und den Dienst:

kubectl --kubeconfig apply -f my-app.yaml

Anwendungslogs aufrufen.

Console

Rufen Sie in der Console von Google Cloud die Seite Log-Explorer auf.
Zum Log-Explorer
Klicken Sie auf Ressource.
Wählen Sie in der Liste Alle Ressourcentypen die Option Kubernetes Container aus.
Wählen Sie unter Clustername den Namen Ihres Nutzerclusters aus.
Wählen Sie unter Namespace-Name die Option default aus.
Klicken Sie auf Hinzufügen und dann auf Abfrage ausführen.

Im Abschnitt Abfrageergebnisse sehen Sie die Logeinträge des Deployments monitoring-example. Beispiel:

{
  "textPayload": "2020/11/14 01:24:24 Starting to listen on :9090\n",
  "insertId": "1oa4vhg3qfxidt",
  "resource": {
    "type": "k8s_container",
    "labels": {
      "pod_name": "monitoring-example-7685d96496-xqfsf",
      "cluster_name": ...,
      "namespace_name": "default",
      "project_id": ...,
      "location": "us-west1",
      "container_name": "prometheus-example-exporter"
    }
  },
  "timestamp": "2020-11-14T01:24:24.358600252Z",
  "labels": {
    "k8s-pod/pod-template-hash": "7685d96496",
    "k8s-pod/app": "monitoring-example"
  },
  "logName": "projects/.../logs/stdout",
  "receiveTimestamp": "2020-11-14T01:24:39.562864735Z"
}

gcloud

Verwenden Sie den Befehl gcloud logging read:

gcloud logging read 'resource.labels.project_id="PROJECT_ID" AND \
    resource.type="k8s_container" AND resource.labels.namespace_name="default"'

Ersetzen Sie PROJECT_ID durch die ID Ihres Projekts.

In der Ausgabe sehen Sie die Logeinträge des Deployments monitoring-example. Beispiel:

insertId: 1oa4vhg3qfxidt
labels:
  k8s-pod/app: monitoring-example
  k8s- pod/pod-template-hash: 7685d96496
logName: projects/.../logs/stdout
receiveTimestamp: '2020-11-14T01:24:39.562864735Z'
resource:
  labels:
    cluster_name: ...
    container_name: prometheus-example-exporter
    location: us-west1
    namespace_name: default
    pod_name: monitoring-example-7685d96496-xqfsf
    project_id: ...
  type: k8s_container
textPayload: |
  2020/11/14 01:24:24 Starting to listen on :9090
timestamp: '2020-11-14T01:24:24.358600252Z'

Anwendungsmesswerte ansehen

Ihre Beispielanwendung stellt einen benutzerdefinierten Messwert namens example_monitoring_up bereit. Die Werte dieses Messwerts finden Sie in der Google Cloud Console.

Wechseln Sie in der Google Cloud Console zur Seite Metrics Explorer.
Zum Metrics Explorer
Wählen Sie als Ressourcentyp Kubernetes Pod aus.
Wählen Sie als Messwert external/prometheus/example_monitoring_up aus.
Im Diagramm sehen Sie, dass example_monitoring_up einen wiederkehrenden Wert von 1 hat.

Messwerte mit Prometheus erfassen

Distributed Cloud Connected unterstützt die Prometheus-Messwertlösung zum Erfassen von Messwerten für Ihre Distributed Cloud Connected-Arbeitslasten.

Zu diesem Zweck erstellt Distributed Cloud Connected beim Erstellen eines Distributed Cloud Connected-Clusters einen nicht verwalteten Namespace mit dem Namen prom-monitoring. Wir empfehlen, diesen Namespace zum Bereitstellen von Prometheus zu verwenden. Sie können die erforderlichen Ressourcen auch aus dem Namespace prom-monitoring in einen Namespace Ihrer Wahl kopieren und Prometheus dort bereitstellen.

Prometheus-Messwerterfassung konfigurieren

Wenn Sie Distributed Cloud Connected-Messwerte mit Prometheus erfassen möchten, müssen Sie die Prometheus-Messwerterfassung konfigurieren. Dazu müssen Sie die ConfigMap prometheus-scrape-config in Ihrem Prometheus-Pod einbinden und die Erfassungskonfiguration aus der ConfigMap zu Ihrer Prometheus-Konfiguration hinzufügen. Beispiel:

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: prometheus-local-rolebinding
  namespace: prom-monitoring
subjects:
- kind: ServiceAccount
  name: prometheus-scrape
  namespace: prom-monitoring
roleRef:
  kind: ClusterRole
  name: gke-metrics-agent
  apiGroup: rbac.authorization.k8s.io
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: prometheus-config
  namespace: prom-monitoring
data:
  prometheus.yml: |
    global:
      scrape_interval: 5s
      evaluation_interval: 5s
    rule_files:
    scrape_config_files:
    - /etc/prometheus/scrape/*.yml
---
apiVersion: v1
kind: Service
metadata:
  name: prometheus
  namespace: prom-monitoring
spec:
  selector:
    app: prom-monitoring
  ports:
  - port: 9090
    targetPort: 9090
  type: LoadBalancer
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: prometheus-deployment
  namespace: prom-monitoring
  labels:
    app: prom-monitoring
spec:
  replicas: 1
  selector:
    matchLabels:
      app: prom-monitoring
  template:
    metadata:
      labels:
        app: prom-monitoring
    spec:
      serviceAccountName: prometheus-scrape
      containers:
        - name: prometheus
          image: prom/prometheus:main
          args:
            - "--config.file=/etc/prometheus/prometheus.yml"
            - "--storage.tsdb.path=/prometheus/"
          ports:
            - containerPort: 9090
          volumeMounts:
            - name: prometheus-config-volume
              mountPath: /etc/prometheus/
            - name: prometheus-scrape-config-volume
              mountPath: /etc/prometheus/scrape/
            - name: prometheus-storage-volume
              mountPath: /prometheus/
            - name: prometheus-scrape-token
              mountPath: /var/run/secrets/kubernetes.io/stackdriver-prometheus-scrape
            - name: stackdriver-prometheus-scrape-cert
              mountPath: /certs/stackdriver-prometheus-scrape
            - name: stackdriver-prometheus-etcd-scrape
              mountPath: /stackdriver-prometheus-etcd-scrape
      volumes:
        - name: prometheus-storage-volume
          emptyDir: {}
        - name: prometheus-config-volume
          configMap:
            defaultMode: 420
            name: prometheus-config
        - name: prometheus-scrape-config-volume
          configMap:
            defaultMode: 420
            name: prometheus-scrape-config
        - name: prometheus-scrape-token
          secret:
            defaultMode: 420
            secretName: prometheus-scrape
        - name: stackdriver-prometheus-scrape-cert
          secret:
            defaultMode: 420
            optional: true
            secretName: stackdriver-prometheus-scrape-cert
        - name: stackdriver-prometheus-etcd-scrape
          secret:
            defaultMode: 420
            optional: true
            secretName: stackdriver-prometheus-etcd-scrape

Wenn Sie Arbeitslastmesswerte mit Prometheus erfassen möchten, müssen Sie den Diensten und Pods, die die Zielarbeitslasten ausführen, Annotationen hinzufügen:

Wenn Sie Messwerte sowohl an Cloud Monitoring als auch an Prometheus senden möchten, verwenden Sie die Annotationen unter Benutzerdefinierte Logs und Messwerte exportieren.
Wenn Sie Messwerte nur an Prometheus senden möchten, verwenden Sie die folgenden Annotationen:

prometheus.io/unmanaged_scrape: "true"
prometheus.io/unmanaged_path: "ENDPOINT_PATH"
prometheus.io/unmanaged_port: "PORT_NUMBER"

Logs mit Kafka erfassen

Distributed Cloud Connected unterstützt die Apache Kafka-Lösung zum Erfassen von Logs für Arbeitslasten, die in Ihrer Distributed Cloud Connected-Bereitstellung ausgeführt werden.

Sie müssen eine funktionierende Kafka-Bereitstellung haben, bevor Sie die Schritte in diesem Abschnitt ausführen. Ihre Kafka-Broker müssen ihre Listener im Modus PLAINTEXT ankündigen. SSL/SASL-bezogene Variablen werden nicht unterstützt.

Wenn Sie einen Cluster für das Kafka-Logging konfigurieren möchten, müssen Sie eine JSON-Datei erstellen, in der Add-ons konfiguriert werden, die Sie im Cluster ausführen möchten. Geben Sie diese Datei beim Erstellen eines Clusters mit dem Flag --system-addons-config an. Wenn Sie die Kafka-Konfiguration ändern müssen, müssen Sie den Cluster löschen und mit den neuen Kafka-Einstellungen neu erstellen.

Fügen Sie der Konfigurationsdatei für System-Add-ons den folgenden Abschnitt hinzu:

{
        "systemAddonsConfig": {
          "unmanagedKafkaConfig": {
            "brokers": "BROKERS",
            "topics": "TOPICS"
     "topic_key": "TOPIC_KEY, 
          }
      }
}

Ersetzen Sie Folgendes:

BROKERS: eine durch Kommas getrennte Liste von Broker-IP-Adressen und Portpaaren im Format ip_address:port.
TOPICS: eine durch Kommas getrennte Liste von Kafka-Themen.
TOPIC_KEY: ein Kafka-Themenschlüssel. Damit kann Kafka ein Thema auswählen, wenn mehrere Themen vorhanden sind.

Wenn Kafka nach dem Erstellen Ihres Distributed Cloud Connected-Clusters keine Logs erfasst, prüfen Sie Folgendes:

Serverseite:Prüfen Sie die Fehlerlogs in Ihrer Kafka-Bereitstellung auf Hinweise auf ein Problem.
Clientseite: Wenden Sie sich an den Google-Support, um System-Pod-Logs abzurufen und zu prüfen.

Roh-Arbeitslastlogs für die externe Verarbeitung erfassen

Sie können Distributed Cloud Connected so konfigurieren, dass Roh-Arbeitslast-Pod-Logs (unverarbeitet und ohne Tags) nach /var/logs/export exportiert werden. So können Sie Ihren eigenen Log-Collector für die Logverarbeitung verwenden.

Wenn Sie den Export von Roh-Arbeitslastlogs konfigurieren möchten, erstellen Sie eine benutzerdefinierte Ressource LogExport mit dem folgenden Inhalt und wenden Sie sie auf Ihren Cluster an:

apiVersion: gdc.addons.gke.io/v1
kind: LogExport
metadata:
  name: my-log-export
spec:
  namespaces:
  - namespace1
  - namespace2
  - namespace3

Geben Sie im Feld namespaces die Arbeitslast-Namespaces an, für die Sie Roh-Pod-Logs exportieren möchten. Das Feld akzeptiert keine System-Namespaces, z. B. die unter Einschränkungen für Management-Namespaces aufgeführten.

Nächste Schritte

Audit-Logging

Logs und Messwerte Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.