Logging e monitoraggio delle applicazioni

Questa pagina mostra come configurare un cluster utente per Google Distributed Cloud in modo che i log e le metriche personalizzate provenienti dalle applicazioni utente vengano inviati a Cloud Logging e Cloud Monitoring. Le metriche delle applicazioni utente vengono raccolte con Google Cloud Managed Service per Prometheus.

Abilitazione di Managed Service per Prometheus per le applicazioni utente

La configurazione di Managed Service per Prometheus è memorizzata in un oggetto Stackdriver denominato stackdriver.

  1. Apri l'oggetto stackdriver per la modifica:

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

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

  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. Chiudi il file modificato. In questo modo, nel cluster verranno eseguiti componenti Prometheus (GMP) gestiti da Google.

  4. Per verificare i componenti, esegui questo comando:

    kubectl --kubeconfig=USER_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 configurare per la valutazione delle regole, consulta Valutazione delle regole.

Esecuzione di un'applicazione di esempio

In questa sezione creerai un'applicazione che emette metriche Prometheus e usano Prometheus gestito da Google per raccogliere le metriche. Per ulteriori informazioni, consulta Google Cloud Managed Service per Prometheus.

Esegui il deployment dell'applicazione di esempio

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

    kubectl --kubeconfig=USER_CLUSTER_KUBECONFIG create ns gmp-test
    
  2. Il servizio gestito fornisce un manifest per un'applicazione di esempio che emette Metriche Prometheus sulla porta metrics. L'applicazione utilizza tre repliche.

    Per eseguire il deployment dell'applicazione di esempio, esegui questo comando:

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

Configurare una risorsa PodMonitoring

Per importare i dati delle metriche emessi dall'applicazione di esempio, utilizza lo scremamento del target. Il servizio gestito utilizza Risorse personalizzate di PodMonitoring (RP) per configurare lo scraping dei target e l'importazione delle metriche. Puoi convertire le risorse prometheus-operator esistenti in risorse CR PodMonitoring.

Una RP PodMonitoring esegue lo scraping delle destinazioni solo nello spazio dei nomi in cui viene eseguito il deployment della RP. Per eseguire lo scraping dei target 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 dello spazio dei nomi previsto eseguendo il comando:

 kubectl --kubeconfig USER_CLUSTER_KUBECONFIG get podmonitoring -A

Per la documentazione di riferimento su tutte le risorse gestite di Managed Service per Prometheus, consulta la documentazione di riferimento dell'API prometheus-engine/doc.

Il seguente manifest definisce una risorsa PodMonitoring, prom-example, in lo spazio dei nomi gmp-test. La risorsa trova tutti i pod nello spazio dei nomi che hanno l'etichettaapp con il valore prom-example. I pod corrispondenti vengono sottoposti a scansione 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 il seguente comando:

kubectl --kubeconfig USER_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 ora esegue lo scraping dei pod corrispondenti.

Dati delle metriche per le query

Il modo più semplice per verificare che i dati Prometheus vengano esportati è utilizzare 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 pulsante:

    Vai a Monitoring

  2. Nel riquadro di navigazione, seleziona Esplora metriche.

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

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

    2. Seleziona PromQL nel pulsante di attivazione/disattivazione Lingua. Il pulsante di attivazione/disattivazione della lingua si trova in fondo al riquadro Editor di codice.

    3. Inserisci la query nell'editor delle query. Ad esempio, per tracciare un grafico il numero medio di secondi di CPU impiegati in ciascuna 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 anthos_container_cpu_usage_seconds_total metrica:

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

Se raccogli molti dati, potresti voler filtrare le metriche esportate per contenere i costi.

Abilitazione di Cloud Logging per le applicazioni utente in corso...

La configurazione di Logging è contenuta in un oggetto Stackdriver denominato stackdriver.

  1. Apri l'oggetto stackdriver per la modifica:

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

    Sostituisci USER_CLUSTER_KUBECONFIG con il percorso dell'utente kubeconfig del cluster.

  2. Inferiore a 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. Chiudi il file modificato.

Esecuzione di un'applicazione di esempio

In questa sezione, crei un'applicazione che scrive log personalizzati.

  1. Salva il seguente manifest di 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 USER_CLUSTER_KUBECONFIG apply -f my-app.yaml
    

Visualizzazione dei log delle applicazioni

Console

  1. Vai a Esplora log nella console Google Cloud.

    Vai a Esplora log

  2. Fai clic su Risorsa. In ALL_RESOURCE_TYPES, seleziona Kubernetes Container.

  3. In CLUSTER_NAME, seleziona il nome del cluster di utenti.

  4. In NAMESPACE_NAME, seleziona default.

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

  6. In Risultati delle query puoi visualizzare le voci di log del monitoring-example Deployment. 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

  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 di monitoraggio del logging.

  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'
    

Filtrare i log delle applicazioni

Il filtro dei log delle applicazioni può ridurre la fatturazione del logging delle applicazioni e il traffico di rete dal cluster a Cloud Logging. A partire dalla release 1.15.0 di Google Distributed Cloud, 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 i contenuti dei log (contentRegexes)

Google Distributed Cloud invia solo i risultati del filtro a Cloud Logging.

Definisci i filtri del log delle applicazioni

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

  1. Apri l'oggetto stackdriver per la modifica:

    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 stackdriver-log-forwarder DaemonSet per applicare le modifiche non appena possibili:

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

    In genere, podLabelSelectors diventano effettivi dopo 10 minuti. Il riavvio del L'elemento DaemonSet stackdriver-log-forwarder rende le modifiche più efficaci rapidamente.

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

L'esempio seguente illustra il funzionamento di un filtro di log dell'applicazione. Definisci un filtro che utilizza uno spazio dei nomi (prod), un'espressione regolare (.*(ERROR|WARN).*) e un'etichetta del pod (disableGCPLogging=yes). Poi, 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 del log dell'applicazione:

  1. Specifica un filtro dei log delle applicazioni nell'oggetto Stackdriver:

    Nel seguente esempio appLogFilter, 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 genera 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 INFO le voci corrispondenti.

  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 dell'API del filtro dei log delle applicazioni

La definizione del filtro dei log delle applicazioni è dichiarata all'interno della definizione della risorsa personalizzata di Stackdriver.

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

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