Il prodotto descritto in questa documentazione, Cluster Anthos su AWS (generazione precedente), è ora in modalità di manutenzione. Tutte le nuove installazioni devono utilizzare il prodotto di generazione attuale, Cluster Anthos su AWS.

Logging e monitoraggio per Cluster Anthos on AWS

Questo argomento mostra come esportare log e metriche da un cluster Anthos clusters on AWS a Cloud Logging e Cloud Monitoring.

Panoramica

Esistono diverse opzioni per il logging e il monitoraggio con Cluster Anthos on AWS. Anthos può essere integrato con Cloud Logging e Cloud Monitoring. Poiché Anthos si basa su Kubernetes open source, sono disponibili molti strumenti open source e di terze parti.

Opzioni di logging e monitoraggio

Hai diverse opzioni di logging e monitoraggio per il tuo cluster Anthos:

Esegui il deployment degli agenti Cloud Logging e Cloud Monitoring per monitorare e visualizzare i log dai tuoi carichi di lavoro nella console Google Cloud. Questo argomento spiega questa soluzione.
Usa strumenti open source come Prometheus, Grafana ed Elasticsearch. Questo argomento non descrive questa soluzione.
Utilizzare soluzioni di terze parti come Datadog. Questo argomento non descrive questa soluzione.

Cloud Logging e Cloud Monitoring

Con Anthos, Cloud Logging e Cloud Monitoring puoi creare dashboard, inviare avvisi, monitorare ed esaminare i log per i carichi di lavoro in esecuzione nel tuo cluster. Devi configurare gli agenti Cloud Logging e Cloud Monitoring per raccogliere log e metriche nel tuo progetto Google Cloud. Se non configuri questi agenti, Cluster Anthos on AWS non raccoglie dati di logging o monitoraggio.

Quali dati vengono raccolti

Se configurati, gli agenti raccolgono log e dati delle metriche dal cluster e dai carichi di lavoro in esecuzione nel cluster. Questi dati vengono archiviati nel progetto Google Cloud. Configura l'ID progetto nel campo project_id di un file di configurazione quando installi l'inoltro log.

Tra i dati raccolti sono incluse le seguenti informazioni:

Log per i servizi di sistema su ciascuno dei nodi worker.
Log delle applicazioni per tutti i carichi di lavoro in esecuzione sul cluster.
Metriche per i servizi cluster e di sistema. Per ulteriori informazioni su metriche specifiche, consulta Metriche di Anthos.
Se le tue applicazioni sono configurate con target di scraping Prometheus e annotate con una configurazione che include prometheus.io/scrape, prometheus.io/path e prometheus.io/port, le metriche delle applicazioni per i pod.

Gli agenti possono essere disattivati in qualsiasi momento. Per ulteriori informazioni, consulta la sezione Pulizia. I dati raccolti dagli agenti possono essere gestiti ed eliminati come qualsiasi altra metrica di log e dati, come descritto nella documentazione di Cloud Monitoring e di Cloud Logging.

I dati di log vengono archiviati in base alle regole di conservazione configurate. La conservazione dei dati delle metriche varia in base al tipo.

Logging e monitoraggio dei componenti

Per esportare la telemetria a livello di cluster da Cluster Anthos su AWS in Google Cloud, esegui il deployment dei seguenti componenti nel cluster:

Stackdriver Log Forwarder (stackdriver-log-forwarder-*). Un Fluentbit DaemonSet che inoltra i log da ciascun nodo Kubernetes a Cloud Logging.
Agente GKE Metrics (gke-metrics-agent-*). Un DaemonSet basato su OpenTelemetry Collector che raccoglie i dati delle metriche e li inoltra a Cloud Monitoring.

I manifest per questi componenti si trovano nel repository anthos-samples su GitHub.

Prerequisiti

Un progetto Google Cloud con fatturazione abilitata. Per ulteriori informazioni sui costi, consulta i prezzi della suite operativa di Google Cloud.

Il progetto deve inoltre avere le API Cloud Logging e Cloud Monitoring abilitate. Per abilitare queste API, esegui questi comandi:
```
gcloud services enable logging.googleapis.com
gcloud services enable monitoring.googleapis.com
```
Un cluster Anthos su AWS, incluso un cluster utente registrato con Connect. Esegui questo comando per verificare che il cluster sia registrato.
```
gcloud container fleet memberships list
```
Se il cluster è registrato, Google Cloud CLI stampa il nome e l'ID del cluster.
```
NAME       EXTERNAL_ID
cluster-0  1abcdef-1234-4266-90ab-123456abcdef
```
Se il tuo cluster non è presente nell'elenco, consulta Connessione a un cluster con Connect
Installa lo strumento a riga di comando git sulla macchina.

Configurazione delle autorizzazioni per la suite operativa di Google Cloud

Gli agenti di logging e monitoraggio utilizzano Fleet Workload Identity per comunicare con Cloud Logging e Cloud Monitoring. L'identità richiede le autorizzazioni per scrivere i log e le metriche nel progetto. Per aggiungere le autorizzazioni, esegui questi comandi:

gcloud projects add-iam-policy-binding PROJECT_ID \
  --member="serviceAccount:PROJECT_ID.svc.id.goog[kube-system/stackdriver]" \
  --role=roles/logging.logWriter
gcloud projects add-iam-policy-binding PROJECT_ID \
  --member="serviceAccount:PROJECT_ID.svc.id.goog[kube-system/stackdriver]" \
  --role=roles/monitoring.metricWriter

Sostituisci PROJECT_ID con il tuo progetto Google Cloud.

Connetti al bastion host

Per connetterti ai cluster Anthos sulle risorse AWS, esegui questi passaggi: Seleziona questa opzione se disponi di un VPC AWS (o connessione diretta al tuo VPC) esistente o se hai creato un VPC dedicato durante la creazione del servizio di gestione.

VPC esistente

Se hai una connessione diretta o VPN a un VPC esistente, ometti la riga env HTTP_PROXY=http://localhost:8118 dai comandi in questo argomento.

VPC dedicato

Quando crei un servizio di gestione in un VPC dedicato, Cluster Anthos on AWS include un host bastion in una subnet pubblica.

Per connetterti al servizio di gestione, segui questi passaggi:

Passa alla directory con la configurazione di Cluster Anthos on AWS. Hai creato questa directory durante l'installazione del servizio di gestione.
```
cd anthos-aws
```
Per aprire il tunnel, esegui lo script bastion-tunnel.sh. Il tunnel inoltra a localhost:8118.

Per aprire un tunnel al bastion host, esegui il comando seguente:
```
./bastion-tunnel.sh -N
```
I messaggi del tunnel SSH vengono visualizzati in questa finestra. Quando è tutto pronto per chiudere la connessione, interrompi il processo utilizzando Ctrl+C o chiudendo la finestra.
Apri un nuovo terminale e passa alla directory anthos-aws.
```
cd anthos-aws
```
Verifica di poter connetterti al cluster con kubectl.
```
env HTTPS_PROXY=http://localhost:8118 \
kubectl cluster-info
```
L'output include l'URL del server API del servizio di gestione.

Cloud Logging e Cloud Monitoring sui nodi del piano di controllo

Con i cluster Anthos su AWS 1.8.0 e versioni successive, Cloud Logging e Cloud Monitoring per i nodi del piano di controllo possono essere configurati automaticamente durante la creazione di nuovi cluster utente. Per abilitare Cloud Logging o Cloud Monitoring, completa la sezione controlPlane.cloudOperations della configurazione AWSCluster.

cloudOperations:
  projectID: PROJECT_ID
  location: GC_REGION
  enableLogging: ENABLE_LOGGING
  enableMonitoring: ENABLE_MONITORING

Sostituisci quanto segue:

PROJECT_ID: l'ID del tuo progetto.
GC_REGION: la regione di Google Cloud in cui vuoi archiviare i log. Scegli una regione vicina a quella AWS. Per maggiori informazioni, consulta Località globali - Regioni e zone, ad esempio us-central1.
ENABLE_LOGGING: true o false, sia che Cloud Logging sia abilitato sui nodi del piano di controllo.
ENABLE_MONITORING: true o false, indipendentemente dal fatto che Cloud Monitoring sia abilitato sui nodi del piano di controllo.

Ora segui la procedura descritta in Creare un cluster utente personalizzato.

Cloud Logging e Cloud Monitoring sui nodi worker

Rimozione della versione precedente in corso...

Se hai configurato una versione precedente degli agenti di logging e monitoraggio che include stackdriver-log-aggregator (Fluentd) e stackdriver-prometheus-k8s (Prometheus), ti consigliamo di disinstallarli prima di continuare.

Fai clic per visualizzare i comandi per disinstallare la versione precedente.

    kubectl delete -n kube-system statefulset stackdriver-log-aggregator
    kubectl delete -n kube-system configmap stackdriver-log-aggregator-input-config
    kubectl delete -n kube-system configmap stackdriver-log-aggregator-output-config
    kubectl delete -n kube-system networkpolicy stackdriver-log-aggregator-in-forward
    kubectl delete -n kube-system networkpolicy stackdriver-log-aggregator-prometheus-scrape
    kubectl delete -n kube-system serviceaccount stackdriver-log-aggregator
    kubectl delete -n kube-system service stackdriver-log-aggregator-in-forward
    kubectl delete -n kube-system statefulset stackdriver-prometheus-k8s
    kubectl delete -n kube-system service stackdriver-prometheus-k8s
    kubectl delete -n kube-system secret stackdriver-prometheus-scrape
    kubectl delete -n kube-system clusterrolebinding stackdriver-prometheus-scrape
    kubectl delete -n kube-system clusterrole stackdriver-prometheus-scrape
    kubectl delete -n kube-system serviceaccount stackdriver-prometheus-scrape
    kubectl delete -n kube-system clusterrolebinding stackdriver-user:prometheus
    kubectl delete -n kube-system clusterrole stackdriver-user:prometheus
    kubectl delete -n kube-system serviceaccount stackdriver-prometheus
    kubectl delete -n kube-system configmap stackdriver-prometheus-k8s
    kubectl delete -n kube-system configmap stackdriver-prometheus-sidecar-config
    kubectl delete -n kube-system pvc/stackdriver-log-aggregator-persistent-volume-claim-stackdriver-log-aggregator-0
    kubectl delete -n kube-system pvc/stackdriver-log-aggregator-persistent-volume-claim-stackdriver-log-aggregator-1
    kubectl delete -n kube-system pvc/stackdriver-prometheus-data-stackdriver-prometheus-k8s-0
    kubectl delete secret google-cloud-credentials -n kube-system

Installazione dello strumento di forwarding di logging

In questa sezione, installerai il servizio Stackdriver Log Forwarder sul cluster.

Dalla directory anthos-samples/aws-logging-monitoring/, passa alla directory logging/.
```
cd logging/
```
Modifica il file forwarder.yaml in modo che corrisponda alla configurazione del progetto:
```
sed -i "s/PROJECT_ID/PROJECT_ID/g" forwarder.yaml
sed -i "s/CLUSTER_NAME/CLUSTER_NAME/g" forwarder.yaml
sed -i "s/CLUSTER_LOCATION/GC_REGION/g" forwarder.yaml
```
Sostituisci quanto segue:
- PROJECT_ID: l'ID del tuo progetto.
- CLUSTER_NAME: il nome del tuo cluster, ad esempio cluster-0
- GC_REGION: la regione di Google Cloud in cui vuoi archiviare i log. Scegli una regione vicina a quella AWS. Per maggiori informazioni, consulta Località globali - Regioni e zone , ad esempio us-central1.
(Facoltativo) In base ai tuoi carichi di lavoro, al numero di nodi nel cluster e al numero di pod per nodo, potresti dover impostare richieste di risorse di memoria e CPU. Per ulteriori informazioni, consulta Allocazione consigliata di CPU e memoria.
Dalla directory anthos-aws, utilizza anthos-gke per cambiare contesto nel cluster utente.
```
cd anthos-aws
env HTTPS_PROXY=http://localhost:8118 \
  anthos-gke aws clusters get-credentials CLUSTER_NAME
```
Sostituisci CLUSTER_NAME con il nome del tuo cluster utente.

Crea l'account di servizio stackdriver se non esiste ed esegui il deployment dell'inoltro log nel cluster.

env HTTPS_PROXY=http://localhost:8118 \
  kubectl create serviceaccount stackdriver -n kube-system
env HTTPS_PROXY=http://localhost:8118 \
  kubectl apply -f forwarder.yaml

Usa kubectl per verificare che i pod siano stati avviati.

env HTTPS_PROXY=http://localhost:8118 \
  kubectl get pods -n kube-system | grep stackdriver-log

Dovresti vedere un pod di forwarding per nodo in un pool di nodi. Ad esempio, in un cluster a 6 nodi dovresti vedere sei pod di inoltro.

stackdriver-log-forwarder-2vlxb              2/2     Running   0          21s
stackdriver-log-forwarder-dwgb7              2/2     Running   0          21s
stackdriver-log-forwarder-rfrdk              2/2     Running   0          21s
stackdriver-log-forwarder-sqz7b              2/2     Running   0          21s
stackdriver-log-forwarder-w4dhn              2/2     Running   0          21s
stackdriver-log-forwarder-wrfg4              2/2     Running   0          21s

Test dell'inoltro dei log

In questa sezione, eseguirai il deployment nel tuo cluster di un carico di lavoro contenente un server web HTTP di base con un generatore di carico. Quindi verificherai che i log siano presenti in Cloud Logging.

Prima di installare questo carico di lavoro, puoi verificare i manifest per il server web e il generatore di carico.

Eseguire il deployment del server web e del generatore di carico nel cluster.

env HTTPS_PROXY=http://localhost:8118 \
  kubectl apply -f  https://raw.githubusercontent.com/GoogleCloudPlatform/istio-samples/master/sample-apps/helloserver/server/server.yaml
env HTTPS_PROXY=http://localhost:8118 \
  kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/istio-samples/master/sample-apps/helloserver/loadgen/loadgen.yaml

Per verificare che tu possa visualizzare i log del cluster nella dashboard di Cloud Logging, vai a Esplora log nella console Google Cloud:

Vai a Esplora log
Copia la seguente query di esempio nel campo Query builder.
```
resource.type="k8s_container" resource.labels.cluster_name="CLUSTER_NAME"
```
Sostituisci CLUSTER_NAME con il nome del tuo cluster.
Fai clic su Esegui query. I log recenti del cluster dovrebbero essere visualizzati in Risultati delle query.

Dopo aver verificato che i log vengano visualizzati nei risultati della query, rimuovi il generatore di carico e il server web.

env HTTPS_PROXY=http://localhost:8118 \
  kubectl delete -f https://raw.githubusercontent.com/GoogleCloudPlatform/istio-samples/master/sample-apps/helloserver/loadgen/loadgen.yaml

env HTTPS_PROXY=http://localhost:8118 \
  kubectl delete -f https://raw.githubusercontent.com/GoogleCloudPlatform/istio-samples/master/sample-apps/helloserver/server/server.yaml

Installazione del raccoglitore delle metriche

In questa sezione installerai un agente per inviare dati a Cloud Monitoring.

Dalla directory anthos-samples/aws-logging-monitoring/logging/, passa alla directory anthos-samples/aws-logging-monitoring/monitoring/.
```
cd ../monitoring
```
Modifica il file gke-metrics-agent.yaml in modo che corrisponda alla configurazione del progetto:
```
sed -i "s/PROJECT_ID/PROJECT_ID/g" gke-metrics-agent.yaml
sed -i "s/CLUSTER_NAME/CLUSTER_NAME/g" gke-metrics-agent.yaml
sed -i "s/CLUSTER_LOCATION/GC_REGION/g" gke-metrics-agent.yaml
```
Sostituisci quanto segue:
- PROJECT_ID: l'ID del tuo progetto.
- CLUSTER_NAME: il nome del tuo cluster, ad esempio cluster-0
- GC_REGION: la regione di Google Cloud in cui vuoi archiviare i log. Scegli una regione vicina a quella AWS. Per maggiori informazioni, consulta Località globali - Regioni e zone , ad esempio us-central1.
(Facoltativo) In base ai tuoi carichi di lavoro, al numero di nodi nel cluster e al numero di pod per nodo, potresti dover impostare richieste di risorse di memoria e CPU. Per ulteriori informazioni, consulta Allocazione consigliata di CPU e memoria.

Crea l'account di servizio stackdriver se non esiste ed esegui il deployment dell'agente delle metriche nel cluster.

env HTTPS_PROXY=http://localhost:8118 \
  kubectl create serviceaccount stackdriver -n kube-system
env HTTPS_PROXY=http://localhost:8118 \
  kubectl apply -f gke-metrics-agent.yaml

Usa lo strumento kubectl per verificare che il pod gke-metrics-agent sia in esecuzione.

env HTTPS_PROXY=http://localhost:8118 \
  kubectl get pods -n kube-system | grep gke-metrics-agent

Dovresti vedere un pod dell'agente per nodo in un pool di nodi. Ad esempio, in un cluster a tre nodi dovresti vedere tre pod agente.

gke-metrics-agent-gjxdj                    2/2     Running   0          102s
gke-metrics-agent-lrnzl                    2/2     Running   0          102s
gke-metrics-agent-s6p47                    2/2     Running   0          102s

Per verificare che le metriche del cluster siano esportate in Cloud Monitoring, vai a Metrics Explorer nella console Google Cloud:

Vai a Metrics Explorer
In Metrics Explorer, fai clic su Editor query, quindi copia il seguente comando:
```
fetch k8s_container
| metric 'kubernetes.io/anthos/otelcol_exporter_sent_metric_points'
| filter
    resource.project_id == 'PROJECT_ID'
    && (resource.cluster_name =='CLUSTER_NAME')
| align rate(1m)
| every 1m
```
Sostituisci quanto segue:
- PROJECT_ID: l'ID del tuo progetto.
- CLUSTER_NAME: il nome del cluster che hai utilizzato durante la creazione di un cluster utente, ad esempio cluster-0.
Fai clic su Esegui query. Viene visualizzata la frequenza di punti metrica inviati a Cloud Monitoring da ogni pod gke-metrics-agent nel cluster.

Nota: potrebbe essere necessario attendere diversi minuti prima che le metriche siano visibili in Metrics Explorer.

Prova anche altre metriche, ad esempio:
- kubernetes.io/anthos/container_memory_working_set_bytes: utilizzo della memoria del container;
- kubernetes.io/anthos/container_cpu_usage_seconds_total: utilizzo della CPU del container;
- kubernetes.io/anthos/apiserver_aggregated_request_total: numero di richieste kube-apiserver, disponibile solo se Cloud Monitoring è abilitato sul piano di controllo.
Per un elenco completo delle metriche disponibili, consulta Anthos Metrics. Per informazioni su come utilizzare l'interfaccia utente, consulta Metrics Explorer.

Creazione di una dashboard in Cloud Monitoring

In questa sezione creerai una dashboard di Cloud Monitoring che monitora lo stato dei container nel cluster.

Dalla directory anthos-samples/aws-logging-monitoring/monitoring/, passa alla directory anthos-samples/aws-logging-monitoring/monitoring/dashboards.
```
cd dashboards
```
Sostituisci le istanze della stringa CLUSTER_NAME in pod-status.json con il nome del cluster.
```
sed -i "s/CLUSTER_NAME/CLUSTER_NAME/g" pod-status.json
```
Sostituisci CLUSTER_NAME con il nome del tuo cluster.
Crea una dashboard personalizzata con il file di configurazione eseguendo questo comando:
```
gcloud monitoring dashboards create --config-from-file=pod-status.json
```
Per verificare che la dashboard sia stata creata, vai a Cloud Monitoring Dashboard nella console Google Cloud.

Vai a Dashboard

Apri la dashboard appena creata con un nome nel formato CLUSTER_NAME (Anthos cluster on AWS) pod status.

Eseguire la pulizia

In questa sezione, rimuoverai i componenti di logging e monitoraggio dal tuo cluster.

Elimina la dashboard di monitoraggio nella visualizzazione elenco Dashboard nella console Google Cloud facendo clic sul pulsante Elimina associato al nome della dashboard.
Passa alla directory anthos-samples/aws-logging-monitoring/.
```
cd anthos-samples/aws-logging-monitoring
```

Per rimuovere tutte le risorse create in questa guida, esegui questi comandi:

env HTTPS_PROXY=http://localhost:8118 \
  kubectl delete -f logging/
env HTTPS_PROXY=http://localhost:8118 \
  kubectl delete -f monitoring/

Allocazione di CPU e memoria consigliata

Questa sezione include le CPU e le allocazioni consigliate per i singoli componenti utilizzati nel logging e nel monitoraggio. In ognuna delle seguenti tabelle sono elencate le richieste di CPU e memoria per un cluster con un intervallo di dimensioni dei nodi. Puoi impostare le richieste di risorse per un componente nel file elencato nella tabella.

Per ulteriori informazioni, consulta Best practice per Kubernetes: richieste e limiti di risorse e Gestione delle risorse per i container.

1-10 nodi

File	Risorsa	Richieste di CPU	Limiti di CPU	Richieste di memoria	Limiti di memoria
`monitoring/gke-metrics-agent.yaml`	agente-metriche-gke	30 min	100m	50 mi	500 mi
`logging/forwarder.yaml`	stacker-log-forwarder	50 min	100m	160 km	600 mi

10-100 nodi

File	Risorsa	Richieste di CPU	Limiti di CPU	Richieste di memoria	Limiti di memoria
`monitoring/gke-metrics-agent.yaml`	agente-metriche-gke	50 min	100m	50 mi	500 mi
`logging/forwarder.yaml`	stacker-log-forwarder	60m	100m	160 km	600 mi

Più di 100 nodi

File	Risorsa	Richieste di CPU	Limiti di CPU	Richieste di memoria	Limiti di memoria
`monitoring/gke-metrics-agent.yaml`	agente-metriche-gke	50 min	100m	160 km	N/D
`logging/forwarder.yaml`	stacker-log-forwarder	60m	100m	160 km	600 mi