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

Questa pagina è stata tradotta dall'API Cloud Translation.

Logging e monitoraggio per GKE su AWS

Questo argomento mostra come esportare log e metriche da un cluster utente GKE su AWS a Cloud Logging e Cloud Monitoring.

Panoramica

Esistono diverse opzioni per il logging e il monitoraggio con GKE su AWS. GKE Enterprise può essere integrato con Cloud Logging e Cloud Monitoring. Poiché GKE Enterprise è basato su Kubernetes open source, molti strumenti open source e di terze parti sono compatibili.

Opzioni di logging e monitoraggio

Hai a disposizione diverse opzioni di logging e monitoraggio per il tuo cluster GKE Enterprise:

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

Cloud Logging e Cloud Monitoring

Con GKE Enterprise, Cloud Logging e Cloud Monitoring, puoi creare dashboard, inviare avvisi, monitorare ed esaminare i log per i carichi di lavoro in esecuzione sul 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, GKE su 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 sul cluster. Questi dati vengono archiviati nel tuo progetto Google Cloud. Configura l'ID progetto nel campo project_id in un file di configurazione quando installi il forwarding dei log.

I dati raccolti includono:

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

Gli agenti possono essere disabilitati in qualsiasi momento. Per ulteriori informazioni, consulta la pagina Pulizia. I dati raccolti dagli agenti possono essere gestiti ed eliminati come qualsiasi altra metrica e dato di log, come descritto nella documentazione di Cloud Monitoring e 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.

Componenti di logging e monitoraggio

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

Stackdriver Log Forwarder (stackdriver-log-forwarder-*). Un DaemonSet Fluentbit che inoltra i log da ciascun nodo Kubernetes a Cloud Logging.
Agente metriche GKE (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 la sezione Prezzi per l'osservabilità di Google Cloud.

Nel progetto devono essere abilitate anche le API Cloud Logging e Cloud Monitoring. Per abilitare queste API, esegui questi comandi:
```
gcloud services enable logging.googleapis.com
gcloud services enable monitoring.googleapis.com
```
Un ambiente GKE 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 cluster non è elencato, consulta Connessione a un cluster con Connect.
Installa lo strumento a riga di comando git sulla tua macchina.

Configurazione delle autorizzazioni per l'osservabilità di Google Cloud

Gli agenti di logging e monitoraggio utilizzano Fleet Workload Identity per comunicare con Cloud Logging e Cloud Monitoring. L'identità deve avere le autorizzazioni per scrivere log e 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.

Connettersi al bastion host

Per connetterti alle tue risorse GKE su AWS, segui questi passaggi. Seleziona se disponi già di un VPC AWS (o di una connessione diretta al tuo VPC) o 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, GKE su AWS include un host bastion in una subnet pubblica.

Per connetterti al servizio di gestione, segui questi passaggi:

Passa alla directory con la tua configurazione GKE su 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 rimanda a localhost:8118.

Per aprire un tunnel sul bastion host, esegui questo comando:
```
./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 GKE 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, devi compilare la sezione controlPlane.cloudOperations della configurazione di AWSCluster.

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

Sostituisci quanto segue:

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

A questo punto, segui i passaggi descritti in Creazione di 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 Logging e Monitoring 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 del forwarding del logging

In questa sezione installerai il forwarder di log di Stackdriver sul tuo 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 tuo 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: il tuo ID progetto.
- CLUSTER_NAME: il nome del cluster, ad esempio cluster-0
- GC_REGION: la regione Google Cloud in cui vuoi archiviare i log. Scegli una regione vicina a quella AWS. Per maggiori informazioni, consulta la sezione Località globali - Regioni e zone, ad esempio us-central1.
(Facoltativo) A seconda dei carichi di lavoro, del numero di nodi nel cluster e del numero di pod per nodo, potrebbe essere necessario impostare le richieste di memoria e risorse di CPU. Per ulteriori informazioni, consulta Allocazioni di CPU e memoria consigliate.
Dalla directory anthos-aws, utilizza anthos-gke per cambiare contesto al 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 dei 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 forwarding.

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 di un carico di lavoro contenente un server web HTTP di base con un generatore di carico nel cluster. Quindi verificherai la presenza dei log in Cloud Logging.

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

Esegui 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 di poter visualizzare i log del tuo cluster nella dashboard di Cloud Logging, vai a Esplora log nella console Google Cloud:

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

Dopo aver confermato che i log vengono 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 tuo 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: il tuo ID progetto.
- CLUSTER_NAME: il nome del cluster, ad esempio cluster-0
- GC_REGION: la regione Google Cloud in cui vuoi archiviare i log. Scegli una regione vicina a quella AWS. Per maggiori informazioni, consulta la sezione Località globali - Regioni e zone, ad esempio us-central1.
(Facoltativo) A seconda dei carichi di lavoro, del numero di nodi nel cluster e del numero di pod per nodo, potrebbe essere necessario impostare le richieste di memoria e risorse di CPU. Per ulteriori informazioni, consulta Allocazioni di CPU e memoria consigliate.

Crea l'account di servizio stackdriver se non esiste ed esegui il deployment dell'agente 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 di agente per nodo in un pool di nodi. Ad esempio, in un cluster a tre nodi dovresti vedere tre pod di agenti.

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 vengano esportate in Cloud Monitoring, vai a Metrics Explorer nella console Google Cloud:

Vai a Metrics Explorer
In Metrics Explorer, fai clic su Editor query e copia il comando seguente:
```
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: il tuo ID progetto.
- CLUSTER_NAME: il nome del cluster utilizzato durante la creazione di un cluster utente, ad esempio cluster-0.
Fai clic su Esegui query. Viene visualizzata la frequenza di punti metriche inviati a Cloud Monitoring da ogni pod gke-metrics-agent nel cluster.

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

Ecco alcune altre metriche che vale la pena provare, a titolo esemplificativo:
- kubernetes.io/anthos/container_memory_working_set_bytes: memoria del container utilizzata;
- kubernetes.io/anthos/container_cpu_usage_seconds_total: utilizzo della CPU del container;
- kubernetes.io/anthos/apiserver_aggregated_request_total: conteggio delle richieste kube-apiserver, disponibile solo se Cloud Monitoring è abilitato sul piano di controllo.
Per un elenco completo delle metriche disponibili, consulta Metriche Anthos. 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 per monitorare lo stato dei container nel tuo 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 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 alle dashboard di Cloud Monitoring 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.

esegui la pulizia

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

Elimina la dashboard di monitoraggio nella visualizzazione elenco delle 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/

Allocazioni di CPU e memoria consigliate

Questa sezione include la CPU consigliata e le allocazioni per i singoli componenti utilizzati per il logging e il 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 delle 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`	gke-metrics-agent	30 min	100 min	50 km	500 km
`logging/forwarder.yaml`	stackdriver-log-forwarder	50 min	100 min	100 km	600 km

10-100 nodi

File	Risorsa	Richieste di CPU	Limiti di CPU	Richieste di memoria	Limiti di memoria
`monitoring/gke-metrics-agent.yaml`	gke-metrics-agent	50 min	100 min	50 km	500 km
`logging/forwarder.yaml`	stackdriver-log-forwarder	60 min	100 min	100 km	600 km

Più di 100 nodi

File	Risorsa	Richieste di CPU	Limiti di CPU	Richieste di memoria	Limiti di memoria
`monitoring/gke-metrics-agent.yaml`	gke-metrics-agent	50 min	100 min	100 km	N/A
`logging/forwarder.yaml`	stackdriver-log-forwarder	60 min	100 min	100 km	600 km