Questa pagina è stata tradotta dall'API Cloud Translation.

Esegui il deployment di Redis in GKE utilizzando Spotahome

Autopilot Standard

Redis è un database NoSQL in memoria open source principalmente utilizzato per la memorizzazione nella cache. Dispone di replica integrata, scripting Lua, espulsione LRU, transazioni, persistenza su disco e alta disponibilità.

Questa guida è rivolta ad amministratori della piattaforma, architetti del cloud e professionisti delle operazioni interessati a eseguire il deployment di cluster Redis su Google Kubernetes Engine (GKE).

La guida mostra come utilizzare l'operatore Redis di Spotahome per eseguire il deployment di cluster Redis.

L'operatore è in possesso della licenza ai sensi della licenza Apache 2.0.

Spotahome offre i seguenti vantaggi:

Gestione di cluster Redis nativi Kubernetes
Alta disponibilità fornita da Redis Sentinel
Integrazione perfetta di Prometheus per l'osservabilità del database
Supporto per l'impostazione di configurazioni Redis personalizzate

Obiettivi

Pianifica ed esegui il deployment dell'infrastruttura GKE per Redis
Esegui il deployment e configura l'operatore Redis di Spotahome
Configura Redis utilizzando l'operatore per garantire disponibilità, sicurezza, osservabilità e prestazioni

Architettura di deployment

In questo tutorial utilizzerai l'operatore Redis di Spotahome per eseguire il deployment e la configurazione di un cluster Redis ad alta disponibilità in GKE con un nodo leader e due repliche di lettura, insieme al cluster Redis Sentinel costituito da tre repliche.

Redis Sentinel è un sistema di monitoraggio e alta disponibilità per Redis open source. Monitora continuamente le istanze Redis, incluso il leader e le relative repliche associate. Se il nodo leader non funziona, Sentinel può promuovere automaticamente una delle repliche come nuovo leader, garantendo che sia sempre disponibile un nodo leader funzionante per le letture e le scritture dei dati. Quando si verificano eventi significativi in un cluster Redis, ad esempio un errore del leader o un evento di failover, Sentinel può inviare notifiche agli amministratori o ad altri sistemi via email o tramite altri meccanismi di notifica.

Esegui inoltre il deployment di un cluster GKE regionale a disponibilità elevata per Redis, con più nodi Kubernetes distribuiti su diverse zone di disponibilità. Questa configurazione contribuisce a garantire tolleranza di errore, scalabilità e ridondanza geografica. Consente aggiornamenti e manutenzione graduali, fornendo al contempo SLA per uptime e disponibilità. Per ulteriori informazioni, consulta Cluster regionali.

Il seguente diagramma mostra come un cluster Redis viene eseguito su più nodi e zone in un cluster GKE:

Nel diagramma, il StatefulSet Redis viene disegnato su tre nodi in tre zone diverse. Puoi controllare il modo in cui GKE esegue il deployment del StatefulSet su nodi e zone impostando le regole di affinità e di distribuzione della topologia dei pod nella specifica della risorsa personalizzata RedisFailover.

Se una zona non funziona, utilizzando la configurazione consigliata, GKE riprogramma i pod sui nuovi nodi.

Il seguente diagramma mostra un deployment di Sentinel pianificato su tre nodi in tre zone diverse:

Costi

In questo documento utilizzi i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi basata sull'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud potrebbero essere idonei per una prova gratuita.

Al termine delle attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la sezione Pulizia.

Prima di iniziare

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

Note: If you installed the gcloud CLI previously, make sure you have the latest version by running

gcloud components
      update

Create or select a Google Cloud project.

Create a Google Cloud project:
```
gcloud projects create PROJECT_ID
```
Replace PROJECT_ID with a name for the Google Cloud project you are creating.
Select the Google Cloud project that you created:
```
gcloud config set project PROJECT_ID
```
Replace PROJECT_ID with your Google Cloud project name.

Make sure that billing is enabled for your Google Cloud project.

Enable the Compute Engine, IAM, GKE, Backup for GKE, and Resource Manager APIs:

gcloud services enable compute.googleapis.com iam.googleapis.com container.googleapis.com gkebackup.googleapis.com cloudresourcemanager.googleapis.com

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

Note: If you installed the gcloud CLI previously, make sure you have the latest version by running

gcloud components
      update

Create or select a Google Cloud project.

Create a Google Cloud project:
```
gcloud projects create PROJECT_ID
```
Replace PROJECT_ID with a name for the Google Cloud project you are creating.
Select the Google Cloud project that you created:
```
gcloud config set project PROJECT_ID
```
Replace PROJECT_ID with your Google Cloud project name.

Make sure that billing is enabled for your Google Cloud project.

Enable the Compute Engine, IAM, GKE, Backup for GKE, and Resource Manager APIs:

gcloud services enable compute.googleapis.com iam.googleapis.com container.googleapis.com gkebackup.googleapis.com cloudresourcemanager.googleapis.com

Grant roles to your user account. Run the following command once for each of the following IAM roles: roles/storage.objectViewer, roles/container.admin, roles/iam.serviceAccountAdmin, roles/compute.admin, roles/gkebackup.admin, roles/monitoring.viewer
```
gcloud projects add-iam-policy-binding PROJECT_ID --member="user:USER_IDENTIFIER" --role=ROLE
```
- Replace PROJECT_ID with your project ID.
- Replace USER_IDENTIFIER with the identifier for your user account. For example, user:myemail@example.com.
- Replace ROLE with each individual role.

Configura l'ambiente

In questo tutorial utilizzerai Cloud Shell per gestire le risorse ospitate su Google Cloud. Cloud Shell include il software necessario per questo tutorial, tra cui kubectl, gcloud CLI, Helm e Terraform.

Per configurare l'ambiente con Cloud Shell:

Avvia una sessione Cloud Shell dalla console Google Cloud facendo clic su Attiva Cloud Shell nella console Google Cloud. Viene avviata una sessione nel riquadro inferiore della console Google Cloud.

Imposta le variabili di ambiente:

export PROJECT_ID=PROJECT_ID
export KUBERNETES_CLUSTER_PREFIX=redis
export REGION=us-central1

Sostituisci PROJECT_ID con il tuo ID progetto Google Cloud.

Clona il repository GitHub:

git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples

Passa alla directory di lavoro:

cd kubernetes-engine-samples/databases/redis-spotahome

Crea l'infrastruttura del cluster

In questa sezione esegui uno script Terraform per creare un cluster GKE regionale privato e ad alta disponibilità. I passaggi che seguono consentono l'accesso pubblico al piano di controllo.

Puoi installare l'operatore utilizzando un cluster standard o Autopilot.

Standard

Il seguente diagramma mostra un cluster GKE regionale privato standard di cui è stato eseguito il deployment in tre zone diverse:

Per eseguire il deployment di questa infrastruttura, esegui i seguenti comandi da Cloud Shell:

export GOOGLE_OAUTH_ACCESS_TOKEN=$(gcloud auth print-access-token)
terraform -chdir=terraform/gke-standard init
terraform -chdir=terraform/gke-standard apply -var project_id=${PROJECT_ID} \
  -var region=${REGION} \
  -var cluster_prefix=${KUBERNETES_CLUSTER_PREFIX}

Quando richiesto, digita yes. Il completamento di questo comando potrebbe richiedere diversi minuti e il cluster potrebbe mostrare uno stato di disponibilità.

Terraform crea le seguenti risorse:

Una rete VPC e una subnet privata per i nodi Kubernetes
Un router per accedere a internet tramite NAT
Un cluster GKE privato nella regione us-central1
Due pool di nodi con la scalabilità automatica abilitata (da uno a due nodi per zona, minimo un nodo per zona)
Un ServiceAccount con autorizzazioni di logging e monitoraggio
Backup per GKE per il ripristino di emergenza
Google Cloud Managed Service per Prometheus per il monitoraggio dei cluster

L'output è simile al seguente:

...
Apply complete! Resources: 14 added, 0 changed, 0 destroyed.
...

Autopilot

Il seguente diagramma mostra un cluster GKE Autopilot regionale privato:

Per eseguire il deployment dell'infrastruttura, esegui i seguenti comandi da Cloud Shell:

export GOOGLE_OAUTH_ACCESS_TOKEN=$(gcloud auth print-access-token)
terraform -chdir=terraform/gke-autopilot init
terraform -chdir=terraform/gke-autopilot apply -var project_id=${PROJECT_ID} \
  -var region=${REGION} \
  -var cluster_prefix=${KUBERNETES_CLUSTER_PREFIX}

Quando richiesto, digita yes. Il completamento di questo comando potrebbe richiedere diversi minuti e il cluster potrebbe mostrare uno stato di disponibilità.

Terraform crea le seguenti risorse:

Rete VPC e subnet privata per i nodi Kubernetes
Un router per accedere a internet tramite NAT
Un cluster GKE privato nella regione us-central1
Un ServiceAccount con autorizzazione per il logging e il monitoraggio
Google Cloud Managed Service per Prometheus per il monitoraggio dei cluster

L'output è simile al seguente:

...
Apply complete! Resources: 12 added, 0 changed, 0 destroyed.
...

Connettiti al cluster

Utilizzando Cloud Shell, configura kubectl in modo che comunichi con il cluster:

gcloud container clusters get-credentials ${KUBERNETES_CLUSTER_PREFIX}-cluster --region ${REGION}

Esegui il deployment dell'operatore Spotahome nel cluster

In questa sezione, esegui il deployment dell'operatore Spotahome nel tuo cluster Kubernetes utilizzando un grafico Helm e poi esegui il deployment di un cluster Redis.

Aggiungi il repository del grafico Helm dell'operatore Redis di Spotahome:

helm repo add redis-operator https://spotahome.github.io/redis-operator

Aggiungi uno spazio dei nomi per l'operatore Spotahome e il cluster Redis:
```
kubectl create ns redis
```
Esegui il deployment dell'operatore Spotahome utilizzando lo strumento a riga di comando Helm:
```
helm install redis-operator redis-operator/redis-operator --version 3.2.9 -n redis
```

Controlla lo stato del deployment dell'operatore Spotahome utilizzando Helm:

helm ls -n redis

L'output è simile al seguente:

NAME             NAMESPACE    REVISION    UPDATED                                STATUS      CHART                   APP VERSION
redis-operator    redis      1           2023-09-12 13:21:48.179503 +0200 CEST    deployed    redis-operator-3.2.9    1.2.4

Esegui il deployment di Redis

La configurazione di base per l'istanza del cluster Redis include i seguenti componenti:

Tre repliche dei nodi Redis: un leader e due repliche di lettura.
Tre repliche di nodi Sentinel, che formano un quorum.
L'allocazione di risorse CPU di una richiesta CPU e due limiti CPU, con richieste e limiti di memoria di 4 GB per Redis e 100 m/500 m di CPU e 500 MB per Sentinel.
Tolleranza, nodeAffinities e topologySpreadConstraints configurati per ogni carico di lavoro, garantendo una distribuzione adeguata sui nodi Kubernetes, utilizzando i rispettivi node pool e diverse zone di disponibilità.

Questa configurazione rappresenta la configurazione minima richiesta per creare un cluster Redis pronto per la produzione.

Creare un cluster Redis di base

Crea un secret con le credenziali utente:
```
export PASSWORD=$(openssl rand -base64 12)
kubectl create secret generic my-user -n redis \
    --from-literal=password="$PASSWORD"
```
L'operatore non dispone di una funzionalità per generare le credenziali e la password del database deve essere pregenerata.
Crea un nuovo cluster Redis utilizzando la configurazione di base:
```
kubectl apply -n redis -f manifests/01-basic-cluster/my-cluster.yaml
```
Questo comando crea una risorsa personalizzata RedisFailover dell'operatore Spotahome che specifica richieste e limiti di CPU e memoria, nonché contaminazioni e affinità per distribuire le repliche del pod di cui è stato eseguito il provisioning sui nodi Kubernetes.

Attendi qualche minuto mentre Kubernetes avvia i carichi di lavoro richiesti:

kubectl wait pods -l redisfailovers.databases.spotahome.com/name=my-cluster --for condition=Ready --timeout=300s -n redis

Verifica che i carichi di lavoro Redis siano stati creati:

kubectl get pod,svc,statefulset,deploy,pdb -n redis

L'output è simile al seguente:

NAME                                READY   STATUS  RESTARTS   AGE
pod/redis-operator-5dc65cb7cc-krlcs   1/1   Running   0         49m
pod/rfr-my-cluster-0                2/2     Running   0         60s
pod/rfr-my-cluster-1                2/2     Running   0         60s
pod/rfr-my-cluster-2                2/2     Running   0         60s
pod/rfs-my-cluster-8475dfd96c-h5zvw   1/1   Running   0         60s
pod/rfs-my-cluster-8475dfd96c-rmh6f   1/1   Running   0         60s
pod/rfs-my-cluster-8475dfd96c-shzxh   1/1   Running   0         60s

NAME                    TYPE        CLUSTER-IP  EXTERNAL-IP   PORT(S)   AGE
service/redis-my-cluster ClusterIP   10.52.14.87   <none>       6389/TCP    55s
service/redis-operator   ClusterIP   10.52.13.217   <none>      9710/TCP    49m
service/rfr-my-cluster   ClusterIP   None           <none>      9121/TCP    61s
service/rfs-my-cluster   ClusterIP   10.52.15.197   <none>      26379/TCP   61s

NAME                            READY   AGE
statefulset.apps/rfr-my-cluster   3/3   61s

NAME                            READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/redis-operator   1/1    1           1           50m
deployment.apps/rfs-my-cluster   3/3    3           3           62s

NAME                                        MIN AVAILABLE   MAX UNAVAILABLE   ALLOWED DISRUPTIONS   AGE
poddisruptionbudget.policy/rfr-my-cluster   2               N/A             1                   64s
poddisruptionbudget.policy/rfs-my-cluster   2               N/A             1                   63s

L'operatore crea le seguenti risorse:

Un deployment di StatefulSet e Sentinel di Redis
Tre repliche di pod per Redis
Tre repliche di pod per Sentinel
Due PodDisruptionBudgets, per garantire almeno due repliche disponibili per la coerenza del cluster
Il servizio rfr-my-cluster, che espone le metriche Redis
Il servizio redis-my-cluster, che ha come target il nodo leader del cluster Redis
Il servizio rfs-my-cluster, che consente ai client di connettersi al cluster tramite i Sentinel. Il supporto di Sentinel è obbligatorio per le librerie client.

Puoi condividere le credenziali Redis con i client che utilizzano il metodo di autenticazione precedente dell'operatore Spotahome

Devi utilizzare una password del database utilizzando l'impostazione requirepass. Questa password viene poi utilizzata da tutti i client. Per gestire altri utenti, utilizza i comandi Redis CLI.

apiVersion: databases.spotahome.com/v1
kind: RedisFailover
metadata:
  name: my-cluster
spec:
  ...
  auth:
    secretPath: my-user

La condivisione delle credenziali Redis con i client che utilizzano questo metodo presenta i seguenti limiti:

Spotahome non fornisce risorse personalizzate per la gestione degli utenti. Puoi memorizzare le credenziali in Secrets e farvi riferimento nelle specifiche auth.
Non esiste un metodo per proteggere le connessioni con la crittografia TLS utilizzando la risorsa personalizzata.
L'aggiornamento in tempo reale delle credenziali è non supportato.

Connetti a Redis

Puoi eseguire il deployment di un client Redis e autenticarti utilizzando una password archiviata in un secret Kubernetes.

Esegui il pod client per interagire con il cluster Redis:
```
kubectl apply -n redis -f manifests/02-auth/client-pod.yaml
```
La variabile di ambiente PASS recupera il secret my-user dalla cassetta di sicurezza.

Attendi che il pod sia pronto, quindi connettiti:

kubectl wait pod redis-client --for=condition=Ready --timeout=300s -n redis
kubectl exec -it redis-client -n redis -- /bin/bash

Verifica che la connessione funzioni:

redis-cli -h redis-my-cluster -a $PASS --no-auth-warning SET my-key "testvalue"

L'output è simile al seguente:

OK

Ottieni il valore my-key:

redis-cli -h redis-my-cluster -a $PASS --no-auth-warning GET my-key

L'output è simile al seguente:

"testvalue"

Esci dalla shell del pod
```
exit
```

Scopri come Prometheus raccoglie le metriche per il tuo cluster Redis

Il seguente diagramma mostra come funziona la raccolta delle metriche Prometheus:

Nel diagramma, un cluster privato GKE contiene:

Un pod Redis che raccoglie le metriche sul percorso / e sulla porta 9121
Raccoglitori basati su Prometheus che elaborano le metriche del pod Redis
Una risorsa PodMonitoring che invia le metriche a Cloud Monitoring

Google Cloud Managed Service per Prometheus supporta la raccolta delle metriche nel formato Prometheus. Cloud Monitoring utilizza una dashboard integrata per le metriche Redis.

L'operatore Spotahome espone le metriche del cluster in formato Prometheus utilizzando redis_exporter come sidecar.

Crea la risorsa PodMonitoring per eseguire lo scraping delle metriche in base a labelSelector:
```
kubectl apply -n redis -f manifests/03-prometheus-metrics/pod-monitoring.yaml
```
Nella console Google Cloud, vai alla pagina Dashboard dei cluster GKE.

Vai alla dashboard dei cluster GKE

La dashboard mostra il tasso di importazione delle metriche diverse da zero.
Nella console Google Cloud, vai alla pagina Dashboard.

Accedi a Dashboard
Apri la dashboard Panoramica di Redis Prometheus. La dashboard mostra la quantità di connessioni e chiavi. Potrebbero essere necessari diversi minuti per il provisioning automatico della dashboard.

Connettiti al pod client e prepara le variabili:

kubectl exec -it redis-client -n redis -- /bin/bash

Utilizza lo strumento redis-cli per creare nuove chiavi:

for i in {1..50}; do \
  redis-cli -h redis-my-cluster -a $PASS \
  --no-auth-warning SET mykey-$i "myvalue-$i"; \
done

Aggiorna la pagina e osserva che i grafici Comandi al secondo e Chiavi sono stati aggiornati per mostrare lo stato effettivo del database.
Esci dalla shell del pod
```
exit
```

Esegui la pulizia

Elimina il progetto

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività descritte in questo documento, quando lo elimini elimini anche tutto il lavoro svolto nel progetto.
Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un appspot.com URL, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, il riuso dei progetti può aiutarti a non superare i limiti di quota.

Delete a Google Cloud project:

gcloud projects delete PROJECT_ID

Elimina singole risorse

Imposta le variabili di ambiente.

export PROJECT_ID=${PROJECT_ID}
export KUBERNETES_CLUSTER_PREFIX=redis
export REGION=us-central1

Esegui il comando terraform destroy:

export GOOGLE_OAUTH_ACCESS_TOKEN=$(gcloud auth print-access-token)
terraform -chdir=terraform/FOLDER destroy -var project_id=${PROJECT_ID} \
  -var region=${REGION} \
  -var cluster_prefix=${KUBERNETES_CLUSTER_PREFIX}

Sostituisci FOLDER con gke-autopilot o gke-standard.

Quando richiesto, digita yes.

Trova tutti i dischi scollegati:

export disk_list=$(gcloud compute disks list --filter="-users:* AND labels.name=${KUBERNETES_CLUSTER_PREFIX}-cluster" --format "value[separator=|](name,zone)")

Elimina i dischi:

for i in $disk_list; do
  disk_name=$(echo $i| cut -d'|' -f1)
  disk_zone=$(echo $i| cut -d'|' -f2|sed 's|.*/||')
  echo "Deleting $disk_name"
  gcloud compute disks delete $disk_name --zone $disk_zone --quiet
done

Passaggi successivi

Esplora architetture di riferimento, diagrammi e best practice su Google Cloud. Consulta il nostro Cloud Architecture Center.

Esegui il deployment di Redis in GKE utilizzando Spotahome

Obiettivi

Architettura di deployment

Costi

Prima di iniziare

Configura l'ambiente

Crea l'infrastruttura del cluster

Standard

Autopilot

Connettiti al cluster

Esegui il deployment dell'operatore Spotahome nel cluster

Esegui il deployment di Redis

Creare un cluster Redis di base

Condividere le credenziali Redis

Connetti a Redis

Scopri come Prometheus raccoglie le metriche per il tuo cluster Redis

Esegui la pulizia

Elimina il progetto

Elimina singole risorse

Passaggi successivi