Per informazioni sulla versione, consulta le note di rilascio di Distributed Cloud connesso.

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

Log e metriche

Questa pagina spiega come Google Distributed Cloud connected registra vari tipi di informazioni sul suo funzionamento e come visualizzarle. La raccolta di alcuni tipi di log e metriche comporta costi aggiuntivi. Per ulteriori informazioni, consulta Fatturazione per log e metriche.

Configurazione di logging e monitoraggio

Prima di poter iniziare a raccogliere log e metriche, devi:

Abilitare le API Logging utilizzando i seguenti comandi:

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

Sostituisci PROJECT_ID con l'ID del progetto di destinazione Google Cloud .

Concedere i ruoli necessari per scrivere log e metriche:

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

Sostituisci PROJECT_ID con l'ID del progetto di destinazione Google Cloud .

Log

Questa sezione elenca i tipi di risorse Cloud Logging supportati da Distributed Cloud. Per visualizzare i log di Distributed Cloud, utilizza Esplora log nella Google Cloud console. Il logging di Distributed Cloud è sempre abilitato.

I tipi di risorse registrate di Distributed Cloud connected sono le seguenti risorse Kubernetes standard:

k8s_container
k8s_node

Puoi anche acquisire e recuperare i log di Distributed Cloud connected utilizzando l'API Cloud Logging. Per informazioni su come configurare questo meccanismo di logging, consulta la documentazione delle librerie client di Cloud Logging.

Metriche

Questa sezione elenca le metriche di Cloud Monitoring supportate da Distributed Cloud. Per visualizzare le metriche di Distributed Cloud, utilizza Esplora metriche nella Google Cloud console.

Metriche dei cluster Distributed Cloud connected

Per i cluster Distributed Cloud connected, Distributed Cloud connected fornisce i seguenti tipi di metriche generate dai nodi Distributed Cloud connected:

Le metriche delle risorse forniscono informazioni sulle prestazioni dei nodi e dei pod di Distributed Cloud connected, ad esempio il carico della CPU e la memoria utilizzata.
Le metriche delle applicazioni di sistema forniscono informazioni sui carichi di lavoro di sistema di Distributed Cloud connected, ad esempio coredns.

Per un elenco di queste metriche, consulta Metriche di Google Distributed Cloud e Google Distributed Cloud.

Distributed Cloud connected non fornisce metriche generate dai piani di controllo Kubernetes associati ai cluster Distributed Cloud connected.

Metriche hardware di Distributed Cloud connected

Distributed Cloud connected fornisce metriche per l'hardware Distributed Cloud connected utilizzando i seguenti tipi di risorse:

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

Metriche delle risorse `Machine`

Distributed Cloud connected scrive le seguenti metriche dell'API Cloud Monitoring per la risorsa edgecontainer.googleapis.com/Machine:

Metrica	Descrizione
`/machine/cpu/total_cores` Tipo: `GAUGE` Tipo: `INT`	Numero totale di core del processore fisico presenti sulla macchina.
`/machine/cpu/usage_time` Tipo: `CUMULATIVE` Tipo: `DOUBLE` Unità: `Seconds`	Tempo di utilizzo cumulativo della CPU per tutti i core della macchina. Il tipo può essere `workload` (carichi di lavoro dei clienti) o `system` (tutto il resto).
`/machine/cpu/utilization` Tipo: `GAUGE` Tipo: `DOUBLE`	Percentuale di utilizzo della CPU sulla macchina. L'intervallo è compreso tra 0 e 1. Il tipo può essere `workload` (carichi di lavoro dei clienti) o `system` (tutto il resto).
`/machine/memory/total_bytes` Tipo: `GAUGE` Tipo: `INT64`	Numero di byte della memoria totale sulla macchina.
`/machine/memory/used_bytes` Tipo: `GAUGE` Tipo: `INT64`	Numero di byte della memoria utilizzata sulla macchina. `memory_type` è `evictable` (recuperabile dal kernel) o `non-evictable` (non recuperabile).`evictablenon-evictable`
`/machine/memory/utilization` Tipo: `GAUGE` Tipo: `DOUBLE`	Percentuale di utilizzo della memoria sulla macchina. L'intervallo è compreso tra 0 e 1. `memory_type` è `evictable` (recuperabile dal kernel) o `non-evictable` (non recuperabile).
`/machine/network/up` Tipo: `GAUGE` Tipo: `BOOL`	Indica se l'interfaccia di rete è attiva e in esecuzione. Include schede primarie, schede secondarie e porte.
`/machine/network/link_speed` Tipo: `GAUGE` Tipo: `DOUBLE` Unità: byte al secondo	Velocità di collegamento della scheda di interfaccia di rete principale.
`/machine/network/received_bytes_count` Tipo: `CUMULATIVE` Tipo: `DOUBLE`	Numero di byte ricevuti per la scheda di interfaccia di rete principale.
`/machine/network/sent_bytes_count` Tipo: `CUMULATIVE` Tipo: `DOUBLE`	Numero di byte inviati per la scheda di interfaccia di rete principale.
`/machine/network/connectivity` Tipo: `GAUGE` Tipo: `BOOL`	Indica se la scheda di interfaccia di rete principale ha la connettività a internet.
`/machine/disk/total_bytes` Tipo: `GAUGE` Tipo: `INT64`	Numero di byte dello spazio su disco totale sulla macchina.
`/machine/disk/used_bytes` Tipo: `GAUGE` Tipo: `INT64`	Numero di byte dello spazio su disco utilizzato sulla macchina.
`/machine/disk/utilization` Tipo: `GAUGE` Tipo: `DOUBLE`	Percentuale di utilizzo dello spazio su disco sulla macchina. L'intervallo è compreso tra 0 e 1.
`/machine/restart_count` Tipo: `CUMULATIVE` Tipo: `INT`	Numero di riavvii della macchina.
`/machine/uptime` Tipo: `GAUGE` Tipo: `INT` Unità: `Seconds`	Tempo di attività della macchina dall'ultimo riavvio.
`/machine/connected` Tipo: `GAUGE` Tipo: `INT64`	Indica se la macchina è connessa a Google Cloud.

Metriche delle risorse `Rack`

Distributed Cloud connected scrive le seguenti metriche dell'API Cloud Monitoring per la risorsa edgecontainer.googleapis.com/Rack:

Metrica	Descrizione
`/router/bgp_up` Tipo: `GAUGE` Tipo: `BOOL`	Indica se la sessione di peering BGP sul router è attiva e integra. `router_id` identifica il router specifico (fino a 2 per rack).
`/router/connected` Tipo: `GAUGE` Tipo: `BOOL`	Indica se il router BGP è connesso a Google Cloud. `router_id` identifica il router specifico (fino a 2 per rack).

Esportare log e metriche delle applicazioni personalizzate

Distributed Cloud connected esporta automaticamente i log per le applicazioni in esecuzione sui carichi di lavoro Distributed Cloud connected. Per esportare le metriche di un'applicazione in esecuzione sui carichi di lavoro Distributed Cloud connected, devi annotarla come descritto nella sezione successiva.

Annotare il carico di lavoro per abilitare l'esportazione delle metriche

Per abilitare la raccolta di metriche personalizzate da un'applicazione, aggiungi le seguenti annotazioni al manifest del servizio o del deployment dell'applicazione:

prometheus.io/scrape: "true"
prometheus.io/path: "ENDPOINT_PATH". Sostituisci ENDPOINT_PATH con il percorso completo dell'endpoint delle metriche dell'applicazione di destinazione.
prometheus.io/port: "PORT_NUMBER": la porta su cui l'endpoint delle metriche dell'applicazione è in ascolto delle connessioni.

Eseguire un'applicazione di esempio

In questa sezione creerai un'applicazione che scrive log personalizzati ed espone un endpoint di metrica personalizzata.

Salva i seguenti manifest di servizio e deployment in un file denominato my-app.yaml. Tieni presente che il servizio ha l'annotazione 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

Crea il deployment e il servizio:

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

Visualizza log applicazione

Console

Nella console Google Cloud , vai alla pagina Esplora log.
Vai a Esplora log
Fai clic su Risorsa.
Nell'elenco Tutti i tipi di risorse, seleziona Kubernetes Container.
In Nome cluster, seleziona il nome del cluster utente.
In Nome spazio dei nomi, seleziona default.
Fai clic su Aggiungi e poi su Esegui query.

Nella sezione Risultati delle query, puoi visualizzare le voci di log del deployment monitoring-example. Ad esempio:

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

Utilizza il comando gcloud logging read:

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

Sostituisci PROJECT_ID con l'ID del tuo progetto.

Nell'output, puoi visualizzare le voci di log del deployment monitoring-example. Ad esempio:

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'

Visualizza metriche delle applicazioni

L'applicazione di esempio espone una metrica personalizzata denominata example_monitoring_up. Puoi visualizzare i valori di questa metrica nella Google Cloud console.

Nella Google Cloud console, vai alla pagina Esplora metriche.
Vai a Esplora metriche
In Tipo di risorsa, seleziona Kubernetes Pod.
In Metrica, seleziona external/prometheus/example_monitoring_up.
Nel grafico, puoi vedere che example_monitoring_up ha un valore ripetuto di 1.

Raccogliere metriche con Prometheus

Distributed Cloud connected supporta la soluzione di metriche Prometheus per la raccolta di metriche sui carichi di lavoro Distributed Cloud connected.

A questo scopo, Distributed Cloud connected crea uno spazio dei nomi non gestito con il nome prom-monitoring quando crei un cluster Distributed Cloud connected. Ti consigliamo di utilizzare questo spazio dei nomi per eseguire il deployment di Prometheus. Puoi anche copiare le risorse richieste dallo spazio dei nomi prom-monitoring a uno spazio dei nomi di tua scelta ed eseguire il deployment di Prometheus.

Configurare l'estrazione delle metriche di Prometheus

Per raccogliere le metriche di Distributed Cloud connected con Prometheus, devi configurare l'estrazione delle metriche di Prometheus. Per farlo, monta l'oggetto ConfigMap prometheus-scrape-config nel pod Prometheus e aggiungi la configurazione di estrazione dall'oggetto ConfigMap alla configurazione di Prometheus. Ad esempio:

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

Per raccogliere le metriche dei carichi di lavoro con Prometheus, devi aggiungere le annotazioni ai servizi e ai pod che eseguono i carichi di lavoro di destinazione come segue:

Per inviare le metriche sia a Cloud Monitoring sia a Prometheus, utilizza le annotazioni descritte in Esportare log e metriche personalizzate.
Per inviare le metriche solo a Prometheus, utilizza le seguenti annotazioni:

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

Raccogliere i log con Kafka

Distributed Cloud connected supporta la soluzione Apache Kafka per la raccolta di log sui carichi di lavoro in esecuzione sul deployment Distributed Cloud connected.

Prima di completare i passaggi descritti in questa sezione, devi avere un deployment Kafka funzionante. I broker Kafka devono pubblicizzare i propri listener in modalità PLAINTEXT. Le variabili correlate a SSL/SASL non sono supportate.

Per configurare un cluster per il logging di Kafka, devi creare un file JSON che configuri i componenti aggiuntivi che vuoi eseguire sul cluster. Specifica questo file quando crei un cluster utilizzando il flag --system-addons-config. Se devi modificare la configurazione di Kafka, devi eliminare e ricreare il cluster con le nuove impostazioni di Kafka.

Aggiungi la seguente sezione al file di configurazione dei componenti aggiuntivi di sistema:

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

Sostituisci quanto segue:

BROKERS: un elenco separato da virgole di coppie di indirizzi IP e porte del broker nel formato ip_address:port.
TOPICS: un elenco separato da virgole di argomenti Kafka.
TOPIC_KEY: una chiave dell'argomento Kafka; in questo modo Kafka può selezionare un argomento se ne esistono più di uno.

Se Kafka non raccoglie i log dopo aver creato il cluster Distributed Cloud connected, controlla quanto segue:

Lato server: controlla i log degli errori nel deployment di Kafka per verificare la presenza di indicazioni di un problema.
Lato client: contatta l'assistenza Google per recuperare ed esaminare i log dei pod di sistema.

Raccogliere i log dei carichi di lavoro non elaborati per l'elaborazione esterna

Puoi configurare Distributed Cloud connected per esportare i log dei pod dei carichi di lavoro non elaborati (non elaborati e senza tag) in /var/logs/export, in modo da poter utilizzare il tuo raccoglitore di log per l'elaborazione dei log.

Per configurare l'esportazione dei log dei carichi di lavoro non elaborati, crea una risorsa personalizzata LogExport con i seguenti contenuti, quindi applicala al cluster:

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

Nel campo namespaces, elenca gli spazi dei nomi dei carichi di lavoro per i quali vuoi esportare i log dei pod non elaborati. Il campo non accetta spazi dei nomi di sistema, come quelli elencati in Limitazioni dello spazio dei nomi di gestione.

Passaggi successivi

Audit logging

Log e metriche Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.