Abilitazione di Logging e Monitoring per le applicazioni

Questa pagina mostra come configurare un cluster per GKE su Bare Metal in modo che log e metriche personalizzate delle applicazioni utente vengano inviati a Cloud Logging, Cloud Monitoring e Managed Service per Prometheus.

Per un'esperienza ottimale di logging e monitoraggio delle applicazioni utente, ti consigliamo vivamente di utilizzare la seguente configurazione:

  • Abilita Google Cloud Managed Service per Prometheus impostando enableGMPForApplications su true nell'oggetto Stackdriver. Questa configurazione consente di monitorare e creare avvisi sui carichi di lavoro a livello globale utilizzando Prometheus. Per istruzioni e informazioni aggiuntive, consulta Abilitare Managed Service per Prometheus in questa pagina.

  • Abilita Cloud Logging per le applicazioni utente impostando enableCloudLoggingForApplications su true nell'oggetto Stackdriver. Questa configurazione fornisce il logging per i carichi di lavoro. Per istruzioni e informazioni aggiuntive, consulta Abilitare Cloud Logging per le applicazioni utente in questa pagina.

  • Disabilita Logging e Monitoring legacy per le applicazioni utente impostando enableApplication su false nella risorsa del cluster. La disattivazione di questa funzionalità impedisce che le metriche delle applicazioni vengano raccolte due volte. Segui la procedura descritta in Abilitare Logging e Monitoring per le applicazioni utente (legacy), ma imposta enableApplication su false anziché true.

Abilita Managed Service per Prometheus

La configurazione per Managed Service per Prometheus è specificata in un oggetto Stackdriver denominato stackdriver. Per ulteriori informazioni, tra cui best practice e risoluzione dei problemi, consulta la documentazione di Managed Service per Prometheus.

Per configurare l'oggetto stackdriver per abilitare Google Cloud Managed Service per Prometheus:

  1. Apri l'oggetto Stackdriver per la modifica:

    kubectl --kubeconfig=CLUSTER_KUBECONFIG \
        --namespace kube-system edit stackdriver stackdriver
    

    Sostituisci CLUSTER_KUBECONFIG con il percorso del file kubeconfig del cluster.

  2. In spec, imposta enableGMPForApplications su true:

    apiVersion: addons.gke.io/v1alpha1
    kind: Stackdriver
    metadata:
      name: stackdriver
      namespace: kube-system
    spec:
      projectID: ...
      clusterName: ...
      clusterLocation: ...
      proxyConfigSecretName: ...
      enableGMPForApplications: true
      enableVPC: ...
      optimizedMetrics: true
    
  3. Salva e chiudi il file modificato.

    I componenti Prometheus gestiti da Google vengono avviati automaticamente nel cluster nello spazio dei nomi gmp-system.

  4. Controlla i componenti Prometheus gestiti da Google:

    kubectl --kubeconfig=CLUSTER_KUBECONFIG --namespace gmp-system get pods
    

    L'output di questo comando è simile al seguente:

    NAME                              READY   STATUS    RESTARTS        AGE
    collector-abcde                   2/2     Running   1 (5d18h ago)   5d18h
    collector-fghij                   2/2     Running   1 (5d18h ago)   5d18h
    collector-klmno                   2/2     Running   1 (5d18h ago)   5d18h
    gmp-operator-68d49656fc-abcde     1/1     Running   0               5d18h
    rule-evaluator-7c686485fc-fghij   2/2     Running   1 (5d18h ago)   5d18h
    

Managed Service per Prometheus supporta la valutazione e gli avvisi delle regole. Per impostare la valutazione delle regole, consulta Valutazione delle regole.

Esegui un'applicazione di esempio

Il servizio gestito fornisce un manifest per un'applicazione di esempio, prom-example, che emette metriche Prometheus sulla porta metrics. L'applicazione utilizza tre repliche.

Per eseguire il deployment dell'applicazione:

  1. Crea lo spazio dei nomi gmp-test per le risorse che crei come parte dell'applicazione di esempio:

    kubectl --kubeconfig=CLUSTER_KUBECONFIG create ns gmp-test
    
  2. Applica il manifest dell'applicazione con il comando seguente:

    kubectl -n gmp-test apply \
        -f https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/v0.4.1/examples/example-app.yaml
    

Configura una risorsa PodMonitoring

In questa sezione configurerai una risorsa personalizzata PodMonitoring per acquisire i dati delle metriche emessi dall'applicazione di esempio e inviarli a Managed Service per Prometheus. La risorsa personalizzata PodMonitoring utilizza lo scraping di destinazione. In questo caso, gli agenti raccoglitori eseguono lo scraping dell'endpoint /metrics su cui l'applicazione di esempio emette dati.

Una risorsa personalizzata PodMonitoring esegue lo scraping delle destinazioni nello spazio dei nomi in cui viene eseguito solo il deployment. Per eseguire lo scraping di destinazioni in più spazi dei nomi, esegui il deployment della stessa risorsa personalizzata PodMonitoring in ogni spazio dei nomi. Puoi verificare che la risorsa PodMonitoring sia installata nello spazio dei nomi previsto eseguendo questo comando:

kubectl --kubeconfig CLUSTER_KUBECONFIG get podmonitoring -A

Per la documentazione di riferimento su tutte le risorse personalizzate di Managed Service per Prometheus, consulta il riferimento prometheus-engine/doc/api.

Il manifest seguente definisce una risorsa PodMonitoring, prom-example, nello spazio dei nomi gmp-test. La risorsa trova tutti i pod nello spazio dei nomi che hanno l'etichetta app con il valore prom-example. Esegui lo scraping dei pod corrispondenti su una porta denominata metrics, ogni 30 secondi, nel percorso HTTP /metrics.

apiVersion: monitoring.googleapis.com/v1
kind: PodMonitoring
metadata:
  name: prom-example
spec:
  selector:
    matchLabels:
      app: prom-example
  endpoints:
  - port: metrics
    interval: 30s

Per applicare questa risorsa, esegui questo comando:

kubectl --kubeconfig CLUSTER_KUBECONFIG -n gmp-test apply \
    -f https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/v0.4.1/examples/pod-monitoring.yaml

Managed Service per Prometheus sta eseguendo lo scraping dei pod corrispondenti.

Esegui query sui dati delle metriche

Il modo più semplice per verificare che i dati di Prometheus vengano esportati è utilizzare le query PromQL in Metrics Explorer nella console Google Cloud.

Per eseguire una query PromQL, segui questi passaggi:

  1. Nella console Google Cloud, vai alla pagina Monitoring o fai clic sul pulsante seguente:

    Vai a Monitoring

  2. Nel riquadro di navigazione, seleziona Metrics Explorer.

  3. Utilizza Prometheus Query Language (PromQL) per specificare i dati da visualizzare nel grafico:

    1. Nella barra degli strumenti del riquadro Seleziona una metrica, seleziona Editor di codice.

    2. Seleziona PromQL nel pulsante di attivazione/disattivazione Lingua. L'opzione di attivazione/disattivazione della lingua si trova nella parte inferiore del riquadro Editor di codice.

    3. Inserisci la query nell'Editor query. Ad esempio, per rappresentare su grafico il numero medio di secondi di CPU utilizzati in ogni modalità nell'ultima ora, utilizza la seguente query:

      avg(rate(kubernetes_io:anthos_container_cpu_usage_seconds_total
      {monitored_resource="k8s_node"}[1h]))
      

    Per ulteriori informazioni sull'utilizzo di PromQL, consulta PromQL in Cloud Monitoring.

Il seguente screenshot mostra un grafico che mostra la metrica anthos_container_cpu_usage_seconds_total:

Grafico di Managed Service per Prometheus per la metrica "anthos_container_cpu_usage_seconds_total" di Prometheus.

Se raccogli grandi quantità di dati, ti consigliamo di filtrare le metriche esportate per ridurre i costi.

Abilita Cloud Logging per le applicazioni utente

La configurazione di Cloud Logging e Cloud Monitoring si trova in un oggetto Stackdriver denominato stackdriver.

  1. Apri l'oggetto Stackdriver per la modifica:

    kubectl --kubeconfig=CLUSTER_KUBECONFIG \
        --namespace kube-system edit stackdriver stackdriver
    

    Sostituisci CLUSTER_KUBECONFIG con il percorso del file kubeconfig del cluster utente.

  2. Nella sezione spec, imposta enableCloudLoggingForApplications su true:

    apiVersion: addons.gke.io/v1alpha1
      kind: Stackdriver
      metadata:
        name: stackdriver
        namespace: kube-system
      spec:
        projectID: ...
        clusterName: ...
        clusterLocation: ...
        proxyConfigSecretName: ...
        enableCloudLoggingForApplications: true
        enableVPC: ...
        optimizedMetrics: true
    
  3. Salva e chiudi il file modificato.

Esegui un'applicazione di esempio

In questa sezione creerai un'applicazione che scrive log personalizzati.

  1. Salva i seguenti manifest del deployment in un file denominato my-app.yaml.

    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
    
  2. Crea il deployment

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

Visualizza log applicazione

Console

  1. Vai a Esplora log nella console Google Cloud.

    Vai a Esplora log

  2. Fai clic su Risorsa. Nel menu TUTTI I TIPI DI RISORSE, seleziona Container Kubernetes.

  3. In CLUSTER_NAME, seleziona il nome del cluster utente.

  4. In NAMESPACE_NAME, seleziona valore predefinito.

  5. Fai clic su Aggiungi e quindi su Esegui query.

  6. In 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"
    }
    

Interfaccia a riga di comando gcloud

  1. Esegui questo comando:

    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.

  2. Nell'output, puoi vedere 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'
    

Filtra log delle applicazioni

Il filtro dei log delle applicazioni può ridurre la fatturazione dei log delle applicazioni e il traffico di rete dal cluster a Cloud Logging. A partire da GKE su Bare Metal versione 1.15.0, quando enableCloudLoggingForApplications è impostato su true, puoi filtrare i log delle applicazioni in base ai seguenti criteri:

  • Etichette pod (podLabelSelectors)
  • Spazi dei nomi (namespaces)
  • Espressioni regolari per contenuti di log (contentRegexes)

GKE su Bare Metal invia solo i risultati del filtro a Cloud Logging.

Definisci i filtri dei log delle applicazioni

La configurazione per Logging è specificata in un oggetto Stackdriver denominato stackdriver.

  1. Apri l'oggetto stackdriver da modificare:

    kubectl --kubeconfig USER_CLUSTER_KUBECONFIG --namespace kube-system \
        edit stackdriver stackdriver
    

    Sostituisci USER_CLUSTER_KUBECONFIG con il percorso del file kubeconfig del cluster utente.

  2. Aggiungi una sezione appLogFilter a spec:

      apiVersion: addons.gke.io/v1alpha1
      kind: Stackdriver
      metadata:
        name: stackdriver
        namespace: kube-system
      spec:
        enableCloudLoggingForApplications: true
        projectID: ...
        clusterName: ...
        clusterLocation: ...
        appLogFilter:
          keepLogRules:
          - namespaces:
            - prod
            ruleName: include-prod-logs
          dropLogRules:
          - podLabelSelectors:
            - disableGCPLogging=yes
            ruleName: drop-logs
    
  3. Salva e chiudi il file modificato.

  4. (Facoltativo) Se utilizzi podLabelSelectors, riavvia il DaemonSet stackdriver-log-forwarder per applicare le modifiche il prima possibile:

    kubectl --kubeconfig USER_CLUSTER_KUBECONFIG --namespace kube-system \
        rollout restart daemonset stackdriver-log-forwarder
    

    Normalmente, podLabelSelectors sono efficaci dopo 10 minuti. Riavviando il DaemonSet stackdriver-log-forwarder, le modifiche vengono applicate più rapidamente.

Esempio: includi i log ERROR o WARN solo nello spazio dei nomi prod

L'esempio seguente illustra il funzionamento di un filtro dei log dell'applicazione. Puoi definire un filtro che utilizza uno spazio dei nomi (prod), un'espressione regolare (.*(ERROR|WARN).*) e un'etichetta pod (disableGCPLogging=yes). Quindi, per verificare che il filtro funzioni, esegui un pod nello spazio dei nomi prod per testare queste condizioni di filtro.

Per definire e testare un filtro dei log dell'applicazione:

  1. Specifica un filtro log dell'applicazione nell'oggetto Stackdriver:

    Nell'esempio appLogFilter seguente, vengono conservati solo i log ERROR o WARN nello spazio dei nomi prod. Tutti i log per i pod con l'etichetta disableGCPLogging=yes vengono eliminati:

    apiVersion: addons.gke.io/v1alpha1
    kind: Stackdriver
    metadata:
      name: stackdriver
      namespace: kube-system
    spec:
      ...
      appLogFilter:
        keepLogRules:
        - namespaces:
          - prod
          contentRegexes:
          - ".*(ERROR|WARN).*"
          ruleName: include-prod-logs
        dropLogRules:
        - podLabelSelectors:
          - disableGCPLogging=yes # kubectl label pods pod disableGCPLogging=yes
          ruleName: drop-logs
    ...
    
  2. Esegui il deployment di un pod nello spazio dei nomi prod ed esegui uno script che generi voci di log ERROR e INFO:

    kubectl --kubeconfig USER_CLUSTER_KUBECONFIG run pod1 \
        --image gcr.io/cloud-marketplace-containers/google/debian10:latest \
        --namespace prod --restart Never --command -- \
        /bin/sh -c "while true; do echo 'ERROR is 404\\nINFO is not 404' && sleep 1; done"
    

    I log filtrati devono contenere solo le voci ERROR, non le voci INFO.

  3. Aggiungi l'etichetta disableGCPLogging=yes al pod:

    kubectl --kubeconfig USER_CLUSTER_KUBECONFIG label pods pod1 \
        --namespace prod disableGCPLogging=yes
    

    Il log filtrato non deve più contenere voci per il pod pod1.

Definizione API filtro log applicazioni

La definizione del filtro dei log dell'applicazione viene dichiarata all'interno della definizione della risorsa personalizzata Stackdriver.

Per ottenere la definizione della risorsa personalizzata Stackdriver, esegui il comando seguente:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG get crd stackdrivers.addons.gke.io \
    --namespace kube-system -o yaml

Abilita Logging e Monitoring per le applicazioni utente (legacy)

Ti consigliamo vivamente di seguire la guida alla configurazione all'inizio di questo documento.

I seguenti passaggi funzionano ancora, ma non sono consigliati. Leggi questo problema noto prima di eseguire la seguente procedura.

Per abilitare Logging e Monitoring per le tue applicazioni, utilizza il campo spec.clusterOperations.enableApplication nel file di configurazione del cluster.

  1. Aggiorna il file di configurazione del cluster per impostare enableApplication su true:

    apiVersion: v1
    kind: Namespace
    metadata:
      name: cluster-user-basic
    ---
    apiVersion: baremetal.cluster.gke.io/v1
    kind: Cluster
    metadata:
      name: user-basic
      namespace: cluster-user-basic
    spec:
      type: user
      ...
      clusterOperations:
        projectID: project-fleet
        location: us-central1
        enableApplication: true
        ...
    
  2. Utilizza bmctl update per applicare le modifiche:

    bmctl update cluster -c CLUSTER_NAME --admin-kubeconfig=ADMIN_KUBECONFIG
    

    Sostituisci quanto segue:

    • CLUSTER_NAME: il nome del cluster di cui eseguire l'upgrade.
    • ADMIN_KUBECONFIG: il percorso del file kubeconfig del cluster di amministrazione.

Annota i carichi di lavoro

Per abilitare la raccolta di metriche personalizzate da un'applicazione, aggiungi l'annotazione prometheus.io/scrape: "true" al manifest Service o Pod dell'applicazione oppure aggiungi la stessa annotazione alla sezione spec.template nel manifest del deployment o del DaemonSet per farla passare ai relativi pod.

Esegui un'applicazione di esempio

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

  1. Salva i seguenti manifest di servizio e deployment in un file denominato my-app.yaml. Nota 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
    
  2. Crea il deployment e il servizio:

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

Visualizza log applicazione

Console

  1. Vai a Esplora log nella console Google Cloud.

    Vai a Esplora log

  2. Fai clic su Risorsa. In TUTTI I TIPI DI RISORSE, seleziona Container Kubernetes.

  3. In CLUSTER_NAME, seleziona il nome del cluster utente.

  4. In NAMESPACE_NAME, seleziona valore predefinito.

  5. Fai clic su Aggiungi e quindi su Esegui query.

  6. In 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"
    }
    

Interfaccia a riga di comando gcloud

  1. Esegui questo comando:

    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.

  2. Nell'output, puoi vedere 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'
    

Visualizzare le metriche delle applicazioni nella console Google Cloud

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

  1. Vai a Metrics Explorer nella console Google Cloud.

    Vai a Metrics Explorer

  2. In Tipo di risorsa, seleziona Kubernetes Pod o Kubernetes Container.

  3. Per metrica, seleziona external.googleapis.com/prometheus/example_monitoring_up.

  4. Nel grafico, puoi vedere che example_monitoring_up ha un valore ripetuto di 1.