Versione 1.4. Questa versione non è più supportata come descritto nelle norme relative al supporto delle versioni di Anthos. Per le patch e gli aggiornamenti più recenti per vulnerabilità di sicurezza, esposizioni e problemi che interessano i cluster Anthos su VMware (GKE on-prem), esegui l'upgrade a una versione supportata. La versione più recente è disponibile qui.

Versioni disponibili

Utilizzo di Logging e Monitoring

In questa pagina viene spiegato come utilizzare Cloud Logging, Cloud Monitoring e Prometheus e Grafana per il logging e il monitoraggio. Per un riepilogo delle opzioni di configurazione disponibili, consulta la panoramica su logging e monitoraggio.

Utilizzo di Cloud Logging e Cloud Monitoring

Le seguenti sezioni spiegano come utilizzare il logging e il monitoraggio con i cluster GKE On-Prem.

Risorse monitorate

Le risorse monitorate sono il modo in cui Google rappresenta risorse come cluster, nodi, pod e container. Per saperne di più, consulta la documentazione dei tipi di risorse monitorate di Cloud Monitoring.

Per eseguire query su log e metriche, devi conoscere almeno queste etichette di risorse:

project_id: ID progetto per il progetto associato al cluster GKE On-Prem.
location: una regione Google Cloud in cui vuoi archiviare i log di logging e le metriche di Monitoring. È una buona opzione scegliere una regione vicina al data center on-premise. Hai fornito questo valore durante l'installazione nel campo stackdriver.clusterlocation del file di configurazione GKE On-Prem.
cluster_name: nome del cluster che hai scelto durante la creazione del cluster.

Puoi recuperare il valore cluster_name per l'amministratore o il cluster utente controllando la risorsa personalizzata Stackdriver:
```
  kubectl -n kube-system get stackdrivers stackdriver -o yaml | grep 'clusterName:'
```

Accesso ai dati dei log

Puoi accedere ai log tramite Esplora log nella console Google Cloud. Ad esempio, per accedere ai log di un container:

Apri Esplora log nella console Google Cloud per il tuo progetto.
Trova i log per un container in base a:
1. Fai clic sulla casella a discesa del catalogo dei log in alto a sinistra e seleziona Container Kubernetes.
2. Seleziona il nome del cluster, quindi lo spazio dei nomi e quindi un container dalla gerarchia.

Creazione di dashboard per monitorare l'integrità del cluster

I cluster GKE On-Prem sono configurati, per impostazione predefinita, per monitorare le metriche di sistema e del container. Dopo aver creato un cluster (amministratore o utente), una best practice consiste nel creare le dashboard seguenti con Monitoring per consentire al team delle operazioni on-prem di GKE di monitorare l'integrità del cluster:

Dashboard dello stato del piano di controllo
Dashboard dello stato dei pod

Questa sezione descrive come creare queste dashboard. Per ulteriori informazioni sul processo di creazione delle dashboard descritto nelle sezioni seguenti, consulta Gestire le dashboard tramite API.

Prerequisiti

Il tuo Account Google deve disporre delle seguenti autorizzazioni per creare dashboard:

monitoring.dashboards.create
monitoring.dashboards.delete
monitoring.dashboards.update

Avrai queste autorizzazioni se il tuo account ha uno dei seguenti ruoli. Puoi controllare le tue autorizzazioni (nella console Google Cloud):

monitoring.dashboardsEditor
monitoring.editor
Progetto editor
Progetto owner

Inoltre, per utilizzare gcloud (gcloud CLI) per creare dashboard, il tuo Account Google deve disporre dell'autorizzazione serviceusage.services.use.

Il tuo account avrà questa autorizzazione se ha uno dei seguenti ruoli:

roles/serviceusage.serviceUsageConsumer
roles/serviceusage.serviceUsageAdmin
roles/owner
roles/editor
Progetto editor
Progetto owner

Crea una dashboard dello stato del piano di controllo

Il piano di controllo GKE On-Prem è costituito dal server API, dallo scheduler, dal gestore del controller e così via. Per monitorare lo stato del piano di controllo, crea una dashboard che monitori lo stato di questi componenti.

Scarica la configurazione della dashboard: control-plane-status.json
Crea una dashboard personalizzata con il file di configurazione eseguendo questo comando:
```
gcloud monitoring dashboards create --config-from-file=control-plane-status.json
```
Nella console Google Cloud, seleziona Monitoring o utilizza il pulsante seguente:

Vai a Monitoring
Seleziona Risorse > Dashboard e visualizza la dashboard denominata Anthos GKE On-Prem Control Plane Status (preview). Lo stato del piano di controllo di ogni cluster utente viene raccolto da spazi dei nomi separati all'interno del cluster di amministrazione. Il campo namespace_name è il nome del cluster utente.

In ogni grafico è impostata una soglia dell'obiettivo del livello di servizio (SLO) di 0,999.
Crea facoltativamente criteri di avviso.

Fai clic per visualizzare una dashboard di esempio.

Crea una dashboard dello stato dei pod

Per creare una dashboard che includa la fase di ogni pod, nonché i tempi di riavvio e l'utilizzo delle risorse per ogni container, segui questi passaggi:

Scarica la configurazione della dashboard: pod-status.json
Crea una dashboard personalizzata con il file di configurazione eseguendo questo comando:
```
gcloud monitoring dashboards create --config-from-file=pod-status.json
```
Nella console Google Cloud, seleziona Monitoring o utilizza il pulsante seguente:

Vai a Monitoring
Seleziona Risorse > Dashboard e visualizza la dashboard denominata Anthos GKE On-Prem Pod Status (preview).
Crea facoltativamente criteri di avviso.

Fai clic per visualizzare una dashboard di esempio.

Accedere ai dati delle metriche

Puoi scegliere tra oltre 1500 metriche utilizzando Metrics Explorer. Per accedere a Metrics Explorer:

Nella console Google Cloud, seleziona Monitoring o utilizza il pulsante seguente:

Vai a Monitoring
Seleziona Risorse > Metrics Explorer.

Accesso ai metadati di Monitoring

I metadati vengono utilizzati indirettamente tramite le metriche. Quando filtri le metriche in Monitoring Metrics Metrics, visualizzi le opzioni per filtrare le metriche per metadata.systemLabels e metadata.userLabels. Le etichette di sistema sono etichette come nome del nodo e nome del servizio per i pod. Le etichette utente sono etichette assegnate ai pod nei file YAML di Kubernetes nella sezione "metadati" delle specifiche dei pod.

Limiti di quota predefiniti di Cloud Monitoring

Il monitoraggio on-prem di GKE ha un limite predefinito di 6000 chiamate API al minuto per ogni progetto. Se superi questo limite, le tue metriche potrebbero non essere visualizzate. Se hai bisogno di un limite di monitoraggio più elevato, richiedine uno tramite la console Google Cloud.

Problema noto: condizione di errore di Cloud Monitoring

(ID problema 159761921)

In determinate condizioni, il pod Cloud Monitoring predefinito, di cui è stato eseguito il deployment per impostazione predefinita in ogni nuovo cluster, può smettere di rispondere. Quando viene eseguito l'upgrade dei cluster, ad esempio i dati di archiviazione possono danneggiarsi quando i pod in statefulset/prometheus-stackdriver-k8s vengono riavviati.

In particolare, è possibile rilevare il pod di monitoraggio stackdriver-prometheus-k8s-0 in un loop quando i dati danneggiati impediscono la scrittura prometheus-stackdriver-sidecar nell'archiviazione cluster PersistentVolume.

Puoi diagnosticare e recuperare manualmente l'errore seguendo questa procedura.

Diagnosticare l'errore di Cloud Monitoring

Quando il pod di monitoraggio non va a buon fine, i log segnaleranno quanto segue:

{"log":"level=warn ts=2020-04-08T22:15:44.557Z caller=queue_manager.go:534 component=queue_manager msg=\"Unrecoverable error sending samples to remote storage\" err=\"rpc error: code = InvalidArgument desc = One or more TimeSeries could not be written: One or more points were written more frequently than the maximum sampling period configured for the metric.: timeSeries[0-114]; Unknown metric: kubernetes.io/anthos/scheduler_pending_pods: timeSeries[196-198]\"\n","stream":"stderr","time":"2020-04-08T22:15:44.558246866Z"}

{"log":"level=info ts=2020-04-08T22:15:44.656Z caller=queue_manager.go:229 component=queue_manager msg=\"Remote storage stopped.\"\n","stream":"stderr","time":"2020-04-08T22:15:44.656798666Z"}

{"log":"level=error ts=2020-04-08T22:15:44.663Z caller=main.go:603 err=\"corruption after 29032448 bytes: unexpected non-zero byte in padded page\"\n","stream":"stderr","time":"2020-04-08T22:15:44.663707748Z"}

{"log":"level=info ts=2020-04-08T22:15:44.663Z caller=main.go:605 msg=\"See you next time!\"\n","stream":"stderr","time":"2020-04-08T22:15:44.664000941Z"}

Ripristino dall'errore di Cloud Monitoring

Per recuperare Cloud Monitoring manualmente:

Interrompi il monitoraggio del cluster. Fai lo scale down dell'operatore stackdriver per evitare il monitoraggio della riconciliazione:
```
kubectl --kubeconfig /ADMIN_CLUSTER_KUBCONFIG --namespace kube-system scale deployment stackdriver-operator --replicas 0
```

Elimina i carichi di lavoro della pipeline di monitoraggio:

kubectl --kubeconfig /ADMIN_CLUSTER_KUBCONFIG --namespace kube-system delete statefulset stackdriver-prometheus-k8s

Elimina la pipeline di monitoraggio PersistentVolumeClaim (PVC):

kubectl --kubeconfig /ADMIN_CLUSTER_KUBCONFIG --namespace kube-system delete pvc -l app=stackdriver-prometheus-k8s

Riavvia il monitoraggio del cluster. Fai lo scale up dell'operatore stackdriver per reinstallare una nuova pipeline di monitoraggio e riprendere la riconciliazione:
```
kubectl --kubeconfig /ADMIN_CLUSTER_KUBCONFIG --namespace kube-system scale deployment stackdriver-operator --replicas=1
```

Prometheus e Grafana

Le seguenti sezioni spiegano come utilizzare Prometheus e Grafana con i cluster GKE on-prem.

Abilitare Prometheus e Grafana

A partire da GKE On-Prem versione 1.2, puoi scegliere se abilitare o disabilitare Prometheus e Grafana. Nei nuovi cluster utente, Prometheus e Grafana sono disabilitati per impostazione predefinita.

Il cluster utente ha un oggetto Monitoring denominato monitoring-sample. Apri l'oggetto da modificare:
```
kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] edit \
   monitoring monitoring-sample --namespace kube-system
```
dove [USER_CLUSTER_KUBECONFIG] è il file kubeconfig per il cluster utente.

Per attivare Prometheus e Grafana, imposta enablePrometheus su true. Per disattivare Prometheus e Grafana, imposta enablePrometheus su false:

apiVersion: addons.k8s.io/v1alpha1
kind: Monitoring
metadata:
 labels:
   k8s-app: monitoring-operator
 name: monitoring-sample
 namespace: kube-system
spec:
 channel: stable
 ...
 enablePrometheus: true

Salva le modifiche chiudendo la sessione di modifica.

Problema noto

Nei cluster utente, Prometheus e Grafana vengono disattivati automaticamente durante l'upgrade. I dati della configurazione e delle metriche, tuttavia, non vanno persi.

Per risolvere il problema, dopo l'upgrade apri monitoring-sample per la modifica e imposta enablePrometheus su true.

Accedere alle metriche di monitoraggio dalle dashboard di Grafana

Grafana mostra le metriche raccolte dai tuoi cluster. Per visualizzare queste metriche, devi accedere alle dashboard di Grafana:

Ottieni il nome del pod Grafana in esecuzione nello spazio dei nomi kube-system del cluster utente:
```
kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] -n kube-system get pods
```
dove [USER_CLUSTER_KUBECONFIG] è il file kubeconfig del cluster utente.
Il container nel pod Grafana è in ascolto sulla porta TCP 3000. Inoltra una porta locale alla porta 3000 nel pod per poter visualizzare le dashboard di Grafana da un browser web.

Ad esempio, supponiamo che il nome del pod sia grafana-0. Per inoltrare la porta 50000 alla porta 3000 nel pod, inserisci questo comando:
```
kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] -n kube-system port-forward grafana-0 50000:3000
```
Da un browser web, apri http://localhost:50000. Dovrebbe essere caricata la dashboard della home page di Ramana del cluster utente.
Per accedere ad altre dashboard, fai clic sul menu a discesa Home nell'angolo in alto a sinistra della pagina.

Per un esempio di utilizzo di Grafana, vedi Creare una dashboard di Grafana.

Accesso agli avvisi

Prometheus Alertmanager raccoglie gli avvisi dal server Prometheus. Puoi visualizzare questi avvisi in una dashboard di Grafana. Per visualizzare gli avvisi, devi accedere alla dashboard:

Il container nel pod alertmanager-0 rimane in ascolto sulla porta TCP 9093. Inoltra una porta locale alla porta 9093 nel pod:
```
kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] port-forward \
   -n kube-system alertmanager-0 50001:9093
```
Da un browser web, apri http://localhost:50001.

Modifica della configurazione Alertmanager Prometheus

Puoi modificare la configurazione predefinita di Alertme Prometheus modificando il file monitoring.yaml del tuo cluster utente. Devi eseguire questa operazione se vuoi indirizzare gli avvisi a una destinazione specifica, anziché tenerli nella dashboard. Puoi scoprire come configurare Alertmanager nella documentazione sulla configurazione di Prometheus.

Per modificare la configurazione di Alertmanager, procedi nel seguente modo:

Crea una copia del file manifest monitoring.yaml del cluster utente:

kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] -n kube-system \
   get monitoring monitoring-sample -o yaml > monitoring.yaml

Per configurare Alertmanager, apporta modifiche ai campi in spec.alertmanager.yml. Al termine, salva il manifest modificato.

Applica il manifest al tuo cluster:

kubectl apply --kubeconfig [USER_CLUSTER_KUBECONIFG] -f monitoring.yaml

Scalabilità delle risorse Prometheus

La configurazione di monitoraggio predefinita supporta fino a cinque nodi. Per i cluster più grandi, puoi regolare le risorse di Prometheus Server. Sono consigliati 50 m core di CPU e 500 Mi di memoria per nodo cluster. Assicurati che il cluster contenga due nodi, ciascuno con risorse sufficienti per adattarsi a Prometheus. Per saperne di più, consulta Ridimensionare un cluster utente.

Per modificare le risorse di Prometheus Server, procedi nel seguente modo:

Crea una copia del file manifest monitoring.yaml del cluster utente:

kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] -n kube-system get monitoring monitoring-sample -o yaml > monitoring.yaml

Per eseguire l'override delle risorse, apporta modifiche ai campi in spec.resourceOverride. Al termine, salva il manifest modificato. Esempio:

spec:
  resourceOverride:
  - component: Prometheus
    resources:
      requests:
        cpu: 300m
        memory: 3000Mi
      limits:
        cpu: 300m
        memory: 3000Mi

Applica il manifest al tuo cluster:

kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] apply -f monitoring.yaml

Creare una dashboard di Grafana

Hai eseguito il deployment di un'applicazione che espone una metrica, hai verificato che la metrica sia esposta e hai verificato che Prometheus ne esegue il scraping. Ora puoi aggiungere la metrica a livello di applicazione a una dashboard Grafana personalizzata.

Per creare una dashboard Grafana, procedi nel seguente modo:

Se necessario, ottenere l'accesso a Grafana.
Nella dashboard della home page, fai clic sul menu a discesa Home nell'angolo in alto a sinistra della pagina.
Nel menu a destra, fai clic su Nuova dashboard.
Nella sezione Nuovo riquadro, fai clic su Grafico. Viene visualizzata una dashboard del grafico vuota.
Fai clic su Titolo del pannello, quindi su Modifica. Nel riquadro Grafico inferiore si apre la scheda Metriche.
Dal menu a discesa Origine dati, seleziona utente. Fai clic su Aggiungi query e inserisci foo nel campo Cerca.
Fai clic sul pulsante Torna alla dashboard nell'angolo in alto a destra dello schermo. Viene visualizzata la dashboard.
Per salvare la dashboard, fai clic su Salva dashboard nell'angolo in alto a destra dello schermo. Scegli un nome per la dashboard, poi fai clic su Salva.

Disabilitazione del monitoraggio nel cluster

Per disabilitare il monitoraggio nel cluster, ripristina le modifiche apportate all'oggetto monitoring-sample:

Apri l'oggetto monitoring-sample da modificare:
```
kubectl --kubeconfig USER_CLUSTER_KUBECONFIG edit \
   monitoring monitoring-sample --namespace kube-system
```
Sostituisci USER_CLUSTER_KUBECONFIG con il file kubeconfig per il cluster utente.

Per disattivare Prometheus e Grafana, imposta enablePrometheus su false:

   apiVersion: addons.k8s.io/v1alpha1
   kind: Monitoring
   metadata:
     labels:
       k8s-app: monitoring-operator
     name: monitoring-sample
     namespace: kube-system
   spec:
     channel: stable
     ...
     enablePrometheus: false

Salva le modifiche chiudendo la sessione di modifica.
Conferma che gli StatefulSet prometheus-0, prometheus-1 e grafana-0 siano stati eliminati:
```
kubectl --kubeconfig USER_CLUSTER_KUBECONFIG get pods --namespace kube-system
```

Esempio: aggiungere metriche a livello di applicazione a una dashboard di Grafana

Le seguenti sezioni illustrano come aggiungere metriche per un'applicazione. In questa sezione completerai queste attività:

Esegui il deployment di un'applicazione di esempio che espone una metrica chiamata foo.
Verifica che Prometheus esponga e applichi la metrica.
Crea una dashboard Grafana personalizzata.

Esegui il deployment dell'applicazione di esempio

L'applicazione di esempio viene eseguita in un unico pod. il container del pod espone una metrica foo con un valore costante di 40.

Crea il seguente manifest del pod, pro-pod.yaml:

apiVersion: v1
kind: Pod
metadata:
  name: prometheus-example
  annotations:
    prometheus.io/scrape: 'true'
    prometheus.io/port: '8080'
    prometheus.io/path: '/metrics'
spec:
  containers:
  - image: registry.k8s.io/prometheus-dummy-exporter:v0.1.0
    name: prometheus-example
    command:
    - /bin/sh
    - -c
    - ./prometheus_dummy_exporter --metric-name=foo --metric-value=40 --port=8080

Quindi applica il manifest del pod al tuo cluster utente:

kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] apply -f pro-pod.yaml

Verificare che la metrica sia esposta e che sia stata appropriata

Il container nel pod prometheus-example rimane in ascolto sulla porta TCP 8080. Inoltra una porta locale alla porta 8080 nel pod:
```
kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] port-forward prometheus-example 50002:8080
```
Per verificare che l'applicazione mostri la metrica, esegui questo comando:
```
curl localhost:50002/metrics | grep foo
```
Il comando restituisce il seguente output:
```
# HELP foo Custom metric
# TYPE foo gauge
foo 40
```
Il container nel pod prometheus-0 rimane in ascolto sulla porta TCP 9090. Inoltra una porta locale alla porta 9090 nel pod:
```
kubectl --kubeconfig [USER_CLUSTER_KUBECONFIG] port-forward prometheus-0 50003:9090
```
Per verificare che Prometheus esegua il scraping della metrica, vai a http://localhost:50003/targets, che dovrebbe accedere al pod prometheus-0 nel gruppo di destinazione prometheus-io-pods.
Per visualizzare le metriche in Prometheus, vai a http://localhost:50003/graph. Nel campo di ricerca, inserisci foo e fai clic su Esegui. La pagina dovrebbe mostrare la metrica.