Eseguire il deployment di Redis in GKE utilizzando Redis Enterprise

La guida mostra come eseguire il deployment di Redis Enterprise nei cluster Google Kubernetes Engine (GKE).

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

Redis Enterprise è una soluzione di livello aziendale che estende l'open source Redis con una gestione semplificata che include la distribuzione dei dati con replica geografica, la scalabilità lineare della velocità effettiva delle operazioni, il livello dei dati, le funzionalità di sicurezza avanzate e altro ancora.

Redis Enterprise ha prezzi diversi per ogni opzione di deployment, tra cui: Software, Cloud o Ambiente ibrido e multi-cloud.

Questa guida è rivolta agli amministratori di piattaforma, ai Cloud Architect e ai professionisti operativi interessati al deployment di Redis Enterprise su Google Kubernetes Engine (GKE).

Obiettivi

  • Pianifica ed esegui il deployment dell'infrastruttura GKE per Redis
  • Esegui il deployment dell'operatore Redis Enterprise
  • Esegui il deployment di un cluster Redis Enterprise
  • Crea un database Redis Enterprise
  • Dimostra l'autenticazione del database

Vantaggi

Redis Enterprise offre i seguenti vantaggi:

  • Un modo nativo di Kubernetes per gestire il ciclo di vita di Redis Enterprise Cluster (REC) e dei database Redis Enterprise (REDB)
  • Utilizzo delle risorse mediante la co-localizzazione di più database Redis all'interno di un singolo pod Kubernetes
  • Ha ridotto l'overhead operativo gestendo le attività di manutenzione di routine come le patch e gli upgrade
  • Supporto per immagini software Redis da registri di container privati, come Artifact Registry, per migliorare la sicurezza e la disponibilità dei container
  • Supporto per Google Cloud Managed Service per Prometheus per il monitoraggio e l'osservabilità dei database
  • Funzionalità di sicurezza avanzate come crittografia, controlli dell'accesso e integrazione con Kubernetes RBAC (Role-Based Access Control)
  • Metodi di autenticazione avanzati, tra cui LDAP e gestori delle credenziali di terze parti come Vault
  • Possibilità di configurare i backup pianificati

Architettura di deployment

Redis Enterprise gestisce le seguenti risorse Kubernetes:

  • Il cluster Enterprise e la relativa configurazione in uno StatefulSet. Il cluster è costituito da nodi Redis (pod) con pacchetti Redis installati. Questi nodi hanno processi in esecuzione per garantire che facciano parte di un cluster. Ogni nodo fornisce un container per eseguire più istanze di database (shard). Anche se le best practice di Kubernetes stabiliscono che un pod deve rappresentare un'applicazione con un solo container, Redis Enterprise esegue il deployment di più database Redis in un singolo container. Questo approccio migliora l'utilizzo delle risorse, le prestazioni e la velocità effettiva di rete. Ogni container dispone inoltre di un proxy a latenza zero per instradare e gestire il traffico verso specifici processi di database Redis all'interno di un container.
  • La risorsa personalizzata RedisEnterpriseDatabase (REDBs) che rappresenta le istanze di database Redis create all'interno di REC
  • Servizi Kubernetes che gestiscono le istanze REDB come endpoint di database
  • Un pod controller chiamato Service Rigger che crea ed elimina gli endpoint quando un database viene creato o eliminato

In questo tutorial, creerai un deployment one-to-many eseguendo il deployment di una casella di controllo REC in uno spazio dei nomi dedicato e utilizzando spazi dei nomi separati per i deployment delle applicazioni, in modo da migliorare l'isolamento.

Il seguente diagramma descrive i componenti Redis Enterprise e il modo in cui sono interconnessi:

Il diagramma mostra un esempio di architettura di Redis Enterprise.
Figura 1: un esempio di architettura di Redis Enterprise.

In questo tutorial configurerai Redis Enterprise Cluster per l'alta disponibilità. A questo scopo, il record REC richiede un numero dispari di nodi e un minimo di tre nodi. Puoi anche impostare regole di affinità, anti-affinità e incompatibilità dei nodi per garantire che ogni nodo Redis sia posizionato in un nodo Kubernetes diverso e che i nodi Redis siano distribuiti uniformemente nel cluster Kubernetes.

L'utilizzo di più nodi e zone è fondamentale per ottenere un cluster GKE a disponibilità elevata per i seguenti motivi:

  • Tolleranza di errore: più nodi distribuiscono il carico di lavoro nel cluster, garantendo che in caso di guasto di un nodo, gli altri possano prendere il controllo delle attività, evitando tempi di inattività e interruzioni del servizio.
  • Scalabilità: la presenza di più nodi consente la scalabilità orizzontale mediante l'aggiunta o la rimozione di nodi in base alle esigenze, garantendo un'allocazione ottimale delle risorse e soddisfacendo l'aumento del traffico o delle esigenze dei carichi di lavoro.
  • Alta disponibilità: l'utilizzo di più zone all'interno di una regione garantisce la ridondanza e riduce al minimo il rischio di un single point of failure. Se si verifica un'interruzione di un'intera zona di disponibilità, il cluster può continuare a essere eseguito in altre zone, mantenendo la disponibilità del servizio.
  • Ridondanza geografica: coprendo i nodi tra le regioni, i dati e i servizi del cluster sono distribuiti geograficamente, offrendo resilienza contro calamità naturali, interruzioni di corrente o altre interruzioni locali che potrebbero interessare una singola zona.
  • Aggiornamenti e manutenzione in sequenza: utilizzando più nodi, puoi eseguire aggiornamenti e manutenzione in sequenza sui singoli nodi senza influire sulla disponibilità complessiva del cluster. Questo garantisce il servizio continuo, consentendoti di eseguire gli aggiornamenti necessari e di applicare le patch senza problemi.
  • Accordo sul livello del servizio (SLA): Google Cloud fornisce SLA (accordi sul livello del servizio) per i deployment multizona, garantendo un livello minimo di uptime e disponibilità.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud possono essere idonei a una prova senza costi aggiuntivi.

Una volta completate le attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la pagina Pulizia.

Prima di iniziare

  1. Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.
  2. Installa Google Cloud CLI.

  3. Per initialize gcloud CLI, esegui questo comando: 

    gcloud init

  4. 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.

  5. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

  6. Abilita le API Compute Engine, IAM, GKE, and Resource Manager. 

    gcloud services enable compute.googleapis.com iam.googleapis.com container.googleapis.com cloudresourcemanager.googleapis.com
    7.
  7. Installa Google Cloud CLI.

  8. Per initialize gcloud CLI, esegui questo comando: 

    gcloud init

  9. 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.

  10. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

  11. Abilita le API Compute Engine, IAM, GKE, and Resource Manager. 

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

  12. Concedi i ruoli al tuo Account Google. Esegui questo comando una volta per ciascuno dei seguenti ruoli IAM: roles/compute.securityAdmin, roles/compute.viewer, roles/container.clusterAdmin, roles/container.admin, roles/iam.serviceAccountAdmin, roles/iam.serviceAccountUser 

    gcloud projects add-iam-policy-binding PROJECT_ID --member="user:EMAIL_ADDRESS" --role=ROLE
    • Sostituisci PROJECT_ID con l'ID progetto.
    • Sostituisci EMAIL_ADDRESS con il tuo indirizzo email.
    • Sostituisci ROLE con ogni singolo ruolo.

configura l'ambiente

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

Per configurare il tuo ambiente con Cloud Shell, segui questi passaggi:

  1. Avvia una sessione di Cloud Shell dalla console Google Cloud, facendo clic su Icona di attivazione di Cloud Shell Attiva Cloud Shell nella console Google Cloud. In questo modo viene avviata una sessione nel riquadro inferiore della console Google Cloud.

  2. Imposta le variabili di ambiente:

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

    Sostituisci PROJECT_ID: il tuo Google Cloud con il tuo ID progetto.

  3. Clona il repository GitHub:

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

  4. Passa alla directory di lavoro:

    cd kubernetes-engine-samples/databases/redis-enterprise-operator

Crea l'infrastruttura del cluster

In questa sezione eseguirai uno script Terraform per creare un cluster GKE privato e ad alta disponibilità a livello di regione e un VPC.

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

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

  cd terraform/gke-standard
  export GOOGLE_OAUTH_ACCESS_TOKEN=$(gcloud auth print-access-token)
  terraform init
  terraform 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 mostri lo stato Pronto.

Terraform crea le risorse seguenti:

  • 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
  • Un pool di nodi con scalabilità automatica abilitata (da uno a due nodi per zona, uno minimo per zona)

L'output è simile al seguente:

...
Apply complete! Resources: 14 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 Redis Enterprise nel cluster

In questa sezione, eseguirai il deployment dell'operatore Redis Enterprise nel tuo cluster Kubernetes.

  1. Crea spazi dei nomi per il registro delle imprese e le sue applicazioni:

    kubectl create namespace rec-ns
kubectl create namespace application

  2. Assegna un'etichetta agli spazi dei nomi:

    kubectl label namespace rec-ns connection=redis
kubectl label namespace application connection=redis

  3. Scarica la versione più recente del pacchetto dell'operatore Redis Enterprise:

    VERSION=`curl --silent https://api.github.com/repos/RedisLabs/redis-enterprise-k8s-docs/releases/latest | grep tag_name | awk -F'"' '{print $4}'`

  4. Installa l'operatore Redis Enterprise:

    kubectl apply -n rec-ns -f https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/$VERSION/bundle.yaml

    L'output è simile al seguente:

    role.rbac.authorization.k8s.io/redis-enterprise-operator created
rolebinding.rbac.authorization.k8s.io/redis-enterprise-operator created
serviceaccount/redis-enterprise-operator created
service/admission created
customresourcedefinition.apiextensions.k8s.io/redisenterpriseclusters.app.redislabs.com created
customresourcedefinition.apiextensions.k8s.io/redisenterprisedatabases.app.redislabs.com created
customresourcedefinition.apiextensions.k8s.io/redisenterpriseremoteclusters.app.redislabs.com created
customresourcedefinition.apiextensions.k8s.io/redisenterpriseactiveactivedatabases.app.redislabs.com created
deployment.apps/redis-enterprise-operator created

Esegui il deployment di Redis Enterprise Cluster

  1. Applica il manifest al tuo cluster:

    kubectl apply -n rec-ns -f manifests/01-basic-cluster/rec.yaml

    Il completamento del comando potrebbe richiedere diversi minuti.

  2. Controlla lo stato della distribuzione di REC:

    kubectl get rec -n rec-ns

    L'output è simile al seguente:

    NAME      NODES   VERSION    STATE     SPEC STATUS   LICENSE STATE   SHARDS LIMIT   LICENSE EXPIRATION DATE   AGE
gke-rec   3       7.2.4-52   Running   Valid         Valid           4              2023-09-29T20:15:32Z      4m7s

    Il cluster è pronto quando STATE è RUNNING.

(Facoltativo) Configura il controller di ammissione

Facoltativamente, puoi configurare l'infrastruttura per la convalida del database al momento del deployment.

  1. Configura il controller di ammissione e controlla se il secret tls di ammissione è presente:

    kubectl get secret admission-tls -n rec-ns

  2. Scarica il certificato:

    export CERT=$(kubectl get secret admission-tls -n rec-ns -o jsonpath='{.data.cert}')

  3. Copia il certificato nel file webhook.yaml:

    sed -i -e 's/CRT/'$CERT'/g' manifests/01-basic-cluster/webhook.yaml

  4. Esegui il deployment del webhook di convalida:

    sed -i -e 's/CRT/'$CERT'/g' manifests/01-basic-cluster/webhook.yaml

    Il controller di ammissione convalida la sintassi del database negli spazi dei nomi etichettati.

  5. Verifica il controller di ammissione creando un database non funzionale:

    kubectl apply -n rec-ns -f - << EOF
apiVersion: app.redislabs.com/v1alpha1
kind: RedisEnterpriseDatabase
metadata:
  name: redis-enterprise-database
spec:
  evictionPolicy: illegal
EOF

    L'output è simile al seguente:

    Error from server: error when creating "STDIN": admission webhook "redisenterprise.admission.redislabs" denied the request: 'illegal' is an invalid value for 'eviction_policy'. Possible values are ['volatile-lru', 'volatile-ttl', 'volatile-random', 'allkeys-lru', 'allkeys-random', 'noeviction', 'volatile-lfu', 'allkeys-lfu']

Crea spazi dei nomi

Per impostazione predefinita, l'operatore Redis Enterprise non ha privilegi per eseguire azioni al di fuori del proprio spazio dei nomi. Per consentire all'operatore Redis Enterprise di creare endpoint REDB e di database in altri spazi dei nomi, devi configurare RBAC.

  1. Applica l'associazione del ruolo e del ruolo corrispondente nello spazio dei nomi dell'applicazione:

    kubectl apply -f manifests/01-basic-cluster/role.yaml -n application
kubectl apply -f manifests/01-basic-cluster/role-binding.yaml -n application

  2. Crea l'associazione del ruolo del cluster e del ruolo del cluster nello spazio dei nomi rec-ns:

    kubectl apply -n rec-ns -f manifests/01-basic-cluster/cluster_role.yaml
kubectl apply -n rec-ns -f manifests/01-basic-cluster/cluster_role_binding.yaml

  3. Modifica il ConfigMap REC per aggiungere il controllo sullo spazio dei nomi dell'applicazione:

    kubectl patch ConfigMap/operator-environment-config --type merge -p '{"data": {"REDB_NAMESPACES_LABEL": "connection=redis"}}' -n rec-ns

    A ogni spazio dei nomi etichettato come ConfigMap viene applicata una patch.

  4. Controlla lo stato delle risorse nella tua infrastruttura Redis nello spazio dei nomi rec-ns:

    kubectl get pod,deploy,svc,rec,statefulset,cm,secrets -n rec-ns

    L'output è simile al seguente:

    NAME                                             READY   STATUS    RESTARTS        AGE
pod/gke-rec-0                                    2/2     Running   0               172m
pod/gke-rec-1                                    2/2     Running   0               171m
pod/gke-rec-2                                    2/2     Running   0               168m
pod/gke-rec-services-rigger-5f885f59dc-gc79g     1/1     Running   0               172m
pod/redis-enterprise-operator-6668ccd8dc-kx29z   2/2     Running   2 (5m58s ago)   5h

NAME                                        READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/gke-rec-services-rigger     1/1     1            1           172m
deployment.apps/redis-enterprise-operator   1/1     1            1           5h

NAME                   TYPE        CLUSTER-IP    EXTERNAL-IP   PORT(S)             AGE
service/admission      ClusterIP   10.52.11.13   <none>        443/TCP             5h
service/gke-rec        ClusterIP   10.52.5.44    <none>        9443/TCP,8001/TCP   172m
service/gke-rec-prom   ClusterIP   None          <none>        8070/TCP            172m
service/gke-rec-ui     ClusterIP   10.52.3.29    <none>        8443/TCP            172m

NAME                                               NODES   VERSION    STATE     SPEC STATUS   LICENSE STATE   SHARDS LIMIT   LICENSE EXPIRATION DATE   AGE
redisenterprisecluster.app.redislabs.com/gke-rec   3       7.2.4-52   Running   Valid         Valid           4              2023-10-05T11:07:20Z      172m

NAME                       READY   AGE
statefulset.apps/gke-rec   3/3     172m

NAME                                    DATA   AGE
configmap/gke-rec-bulletin-board        1      172m
configmap/gke-rec-health-check          5      172m
configmap/kube-root-ca.crt              1      5h2m
configmap/operator-environment-config   1      5h

NAME                   TYPE     DATA   AGE
secret/admission-tls   Opaque   2      5h
secret/gke-rec         Opaque   2      172m

Esegui il deployment dei database Redis Enterprise

  1. Crea database Redis Enterprise negli spazi dei nomi dell'applicazione:

    kubectl apply -f manifests/01-basic-cluster/a-rdb.yaml -n application

  2. Controlla lo stato REDB:

    kubectl get redb --all-namespaces

    L'output è simile al seguente:

    NAMESPACE       NAME       VERSION   PORT    CLUSTER   SHARDS   STATUS   SPEC STATUS   AGE
application   app-db   7.2.0     12999   gke-rec   1        active   Valid         15s

  3. Verifica che i servizi per ogni REDB siano in esecuzione:

    kubectl get svc --all-namespaces

    L'output è simile al seguente:

    NAMESPACE      NAME      TYPE          CLUSTER-IP   EXTERNAL-IP                           PORT(S)    AGE
application  app-db  ExternalName  <none>       redis-12999.rec-ns.svc.cluster.local  12999/TCP  72m

  4. Verifica che il secret sia stato creato:

    kubectl get secrets -n application

    L'output è simile al seguente:

    NAME            TYPE     DATA   AGE
redb-app-db   Opaque   3      96m

Esegui l'autenticazione utilizzando password

Puoi connetterti a REDB utilizzando un pod con redis-cli nello spazio dei nomi dell'applicazione. Il pod client utilizza i secret disponibili nello spazio dei nomi dell'applicazione (REDB) per stabilire una connessione.

I database creati con la risorsa REDB personalizzata supportano solo l'autenticazione delle password senza ACL.

  1. Crea il pod del client:

    kubectl apply -n application -f manifests/03-auth/client_pod.yaml

  2. Connettiti al pod del client:

    kubectl exec -n application -i -t redis-client -c redis-client -- /bin/sh

  3. Connettiti al database:

    redis-cli -h $SERVICE -p $PORT --pass $PASS

  4. Crea una chiave:

    SET mykey "Hello World"

    L'output è simile al seguente:

    OK

  5. Ottieni la chiave:

    GET mykey

    L'output è simile al seguente:

    "Hello World"

  6. Esci dalla shell del pod

    exit

Scopri in che modo Prometheus raccoglie le metriche per il tuo cluster Redis

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

Nel diagramma, un cluster privato GKE contiene:

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

L'operatore Redis Enterprise espone le metriche del cluster in formato Prometheus.

  1. Crea il deployment metric-proxy:

    kubectl apply -n rec-ns -f manifests/02-prometheus-metrics/metrics-proxy.yaml

    Poiché l'operatore fornisce solo un endpoint HTTPS con il certificato autofirmato e la risorsa PodMonitoring non supporta la disattivazione della verifica del certificato TLS, utilizza il pod metrics-proxy come proxy inverso per questo endpoint al fine di esporre le metriche sulla porta HTTP.

  2. Crea la risorsa PodMonitoring per eseguire lo scraping delle metriche in base a labelSelector:

    kubectl apply -n rec-ns -f manifests/02-prometheus-metrics/pod-monitoring.yaml

  3. Nella console Google Cloud, vai alla pagina Dashboard dei cluster GKE.

    Vai alla dashboard dei cluster GKE

    La dashboard mostra una frequenza di importazione di metriche diverse da zero.

Creare una dashboard

Puoi visualizzare le metriche creando una dashboard.

  1. Crea la dashboard:

    gcloud --project "${PROJECT_ID}" monitoring dashboards create --config-from-file monitoring/dashboard.json

    L'output è simile al seguente:

    Created [f4efbe4e-2605-46b4-9910-54b13d29b3be].

  2. Nella console Google Cloud, vai alla pagina Dashboard.

    Vai a Dashboard

  3. Apri la dashboard di Redis Enterprise Cluster. Il provisioning automatico della dashboard potrebbe richiedere diversi minuti.

Verifica le metriche esportate

Per verificare le metriche, crea un nuovo database ed esaminale.

  1. Apri la dashboard di Redis Enterprise Cluster.

  2. Crea un database Redis aggiuntivo:

    kubectl apply -n rec-ns -f manifests/02-prometheus-metrics/c-rdb.yaml

    Il valore di Conteggio database nella dashboard dovrebbe essere aggiornato.

  3. Crea un pod client per la connessione al nuovo database:

    kubectl apply -n rec-ns -f manifests/02-prometheus-metrics/client_pod.yaml

  4. Connettiti al pod del client e prepara le variabili:

    kubectl exec -it redis-client-c -n rec-ns -- /bin/bash

  5. Usa lo strumento redis-cli per creare nuove chiavi:

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

  6. Aggiorna la pagina e osserva che i grafici sono stati aggiornati in modo da mostrare lo stato effettivo del database.

  7. Esci dalla shell del pod

    exit

Esegui la pulizia

Elimina il progetto

    Elimina un progetto Google Cloud:

    gcloud projects delete PROJECT_ID

Elimina singole risorse

  1. Imposta le variabili di ambiente.

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

  2. Esegui il comando terraform destroy:

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

    Quando richiesto, digita yes.

  3. 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)")

  4. 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

  5. Elimina il repository GitHub:

    rm -r ~/kubernetes-engine-samples/

Passaggi successivi

  • Esplora le architetture di riferimento, i diagrammi e le best practice su Google Cloud. Visita il nostro Cloud Architecture Center.