Anthos clusters on bare metal ora è Google Distributed Cloud (solo software) per bare metal. Per ulteriori informazioni, consulta la panoramica del prodotto.

Questa pagina è stata tradotta dall'API Cloud Translation.

Abilitazione di Logging e Monitoring per le applicazioni

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

Abilita Google Cloud Managed Service per Prometheus impostando enableGMPForApplications su true nell'oggetto Stackdriver. Questa configurazione ti consente di monitorare e creare avvisi sui tuoi carichi di lavoro a livello globale utilizzando Prometheus. Per istruzioni e informazioni aggiuntive, consulta Abilitare Google Cloud Managed Service per Prometheus in questa pagina.
Attiva 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 Attivare Cloud Logging per le applicazioni utente in questa pagina.

Attivare Google Cloud Managed Service per Prometheus

La configurazione di Google Cloud 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 Google Cloud Managed Service per Prometheus.

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

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.

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

Salva e chiudi il file modificato.

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

Controlla i componenti di 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

Google Cloud Managed Service per Prometheus supporta la valutazione delle regole e gli avvisi. Per configurare 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 le metriche Prometheus sulla porta metrics. L'applicazione utilizza tre repliche.

Per eseguire il deployment dell'applicazione:

Crea lo spazio dei nomi gmp-test per le risorse che crei nell'ambito dell'applicazione di esempio:
```
kubectl --kubeconfig=CLUSTER_KUBECONFIG create ns gmp-test
```

Applica il manifest dell'applicazione con il seguente comando:

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

Configurare una risorsa PodMonitoring

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

Una risorsa personalizzata PodMonitoring esegue lo scraping dei target solo nello spazio dei nomi in cui è dipiattaforma. Per eseguire lo scraping dei target in più spazi dei nomi, esegui il deployment della stessa risorsa personalizzataPodMonitoring in ogni spazio dei nomi. Puoi verificare che la risorsa PodMonitoring sia installata nello spazio dei nomi previsto eseguendo il seguente comando:

kubectl --kubeconfig CLUSTER_KUBECONFIG get podmonitoring -A

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

Il seguente manifest definisce una risorsa PodMonitoring, prom-example, nello spazio dei nomi gmp-test. La risorsa trova tutti i pod nello spazio dei nomi con 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 CLUSTER_KUBECONFIG -n gmp-test apply \
    -f https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/v0.4.1/examples/pod-monitoring.yaml

Google Cloud Managed Service per Prometheus ora esegue lo scraping dei pod corrispondenti.

Dati delle metriche delle query

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:

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

Vai a Monitoring
Nel riquadro di navigazione, seleziona Metrics Explorer.
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 nell'opzione 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 sul numero medio di secondi trascorsi dalle CPU in ogni modalità nell'ora precedente, 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.

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

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

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

Attiva Cloud Logging per le applicazioni utente

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

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.

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

Salva e chiudi il file modificato.

Esegui un'applicazione di esempio

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

Salva i seguenti 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

Crea il deployment

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

Visualizza log applicazione

Console

Vai a Esplora log nella console Google Cloud.

Vai a Esplora log
Fai clic su Risorsa. Nel menu TUTTI I TIPI DI RISORSE, seleziona Container Kubernetes.
In CLUSTER_NAME, seleziona il nome del cluster di utenti.
In NAMESPACE_NAME, seleziona predefinito.
Fai clic su Aggiungi e poi su Esegui query.

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

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.

Nell'output, puoi vedere le voci di log del monitoring-example Deployment. 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.

Definire i filtri dei log delle applicazioni

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

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.

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

Salva e chiudi il file modificato.
(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
```
In genere, podLabelSelectors diventano effettivi dopo 10 minuti. Il riavvio del stackdriver-log-forwarder DaemonSet consente di applicare le modifiche 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 delle applicazioni. 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 dei log dell'applicazione:

Specifica un filtro per i 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
...

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 le voci INFO.

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 filtro 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

Abilitazione di Logging e Monitoring per le applicazioni

Attivare Google Cloud Managed Service per Prometheus

Esegui un'applicazione di esempio

Configurare una risorsa PodMonitoring

Dati delle metriche delle query

Attiva Cloud Logging per le applicazioni utente

Esegui un'applicazione di esempio

Visualizza log applicazione

Console

Interfaccia a riga di comando gcloud

Filtrare i log delle applicazioni

Definire i filtri dei log delle applicazioni

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

Definizione dell'API filtro log delle applicazioni

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