Esegui il bootstrap automatico dei nodi GKE con i DaemonSet

Standard

---

Questo tutorial mostra come personalizzare i nodi di un cluster Google Kubernetes Engine (GKE) utilizzando DaemonSets. Un DaemonSet garantisce che tutti i nodi (o quelli selezionati) eseguano una copia di un pod. Questo approccio ti consente di utilizzare gli stessi strumenti per orchestrare i carichi di lavoro che utilizzi per modificare i nodi GKE.

Se gli strumenti e i sistemi che utilizzi per inizializzare i cluster sono diversi da quelli che utilizzi per eseguire i workload, aumenti lo sforzo necessario per gestire il tuo ambiente. Ad esempio, se utilizzi uno strumento di gestione della configurazione per inizializzare i nodi del cluster, fai affidamento su una procedura al di fuori dell'ambiente di runtime in cui vengono eseguiti gli altri carichi di lavoro.

L'obiettivo di questo tutorial è aiutare gli amministratori di sistema, gli ingegneri di sistema o gli operatori dell'infrastruttura a semplificare l'inizializzazione dei cluster Kubernetes.

Attenzione: la personalizzazione dei nodi GKE può comportare comportamenti indesiderati che potrebbero influire negativamente sull'integrità dei carichi di lavoro e dei nodi. Non tutte le personalizzazioni sono supportate. Assicurati di implementare test approfonditi di eventuali personalizzazioni prima di eseguirne il deployment sui cluster che eseguono i carichi di lavoro di produzione.

Prima di leggere questa pagina, assicurati di conoscere:

• Kubernetes
• GKE
• Docker
• chroot

In questo tutorial imparerai a utilizzare le etichette e i selettori Kubernetes per scegliere quale procedura di inizializzazione eseguire in base alle etichette applicate a un nodo. In questi passaggi, esegui il deployment di un DaemonSet da eseguire solo sui nodi su cui è applicata l'etichetta default-init. Tuttavia, per dimostrare la flessibilità di questo meccanismo, puoi creare un altro pool di nodi e applicare l'etichetta alternative-init ai nodi di questo nuovo pool. Nel cluster, potresti quindi eseguire il deployment di un altro DaemonSet configurato per l'esecuzione solo sui nodi con l'etichetta alternative-init.

Inoltre, puoi eseguire più procedure di inizializzazione su ciascun nodo, non solo una. Puoi sfruttare questo meccanismo per strutturare meglio le procedure di inizializzazione, separando chiaramente le preoccupazioni di ciascuna.

In questo tutorial, ad esempio, la procedura di inizializzazione esegue le seguenti azioni su ogni nodo etichettato con l'etichetta default-init:

1. Collega un altro disco al nodo.
2. Installa un insieme di pacchetti e librerie utilizzando il gestore di pacchetti del sistema operativo del nodo.
3. Carica un insieme di moduli del kernel Linux.

Obiettivi

In questo tutorial imparerai a:

• Esegui il provisioning e la configurazione di un cluster GKE.
• Prepara un descrittore DaemonSet per inizializzare i nodi del cluster.
• Esegui il deployment del DaemonSet nel cluster.
• Verifica che i nodi del cluster siano stati inizializzati.

Costi

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

• GKE

Per generare una stima dei costi in base all'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

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

2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

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

4. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

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

Esegui il bootstrap dell'ambiente

In questa sezione:

1. Abilita le API Cloud necessarie.
2. Provisiona un account di servizio con privilegi limitati per i nodi del cluster GKE.
3. Prepara il cluster GKE.
4. Concedi all'utente i privilegi di amministrazione del cluster.

Abilita Cloud APIs

1. Apri Cloud Shell.

   Apri Cloud Shell

2. Seleziona il progetto Google Cloud:

   gcloud config set project project-id
   

   Sostituisci project-id con l'ID del progetto Google Cloud che hai creato o selezionato per questo tutorial.

3. Attiva l'API Google Kubernetes Engine:

   gcloud services enable container.googleapis.com
   

Esegui il provisioning di un account di servizio per gestire i cluster GKE

In questa sezione crei un account di servizio associato ai nodi del cluster. In questo tutorial, i nodi GKE utilizzano questo account di servizio anziché quello predefinito. Come best practice, concedi all'account di servizio solo i ruoli e le autorizzazioni di accesso necessari per eseguire l'applicazione.

I ruoli richiesti per l'account di servizio sono i seguenti:

• Ruolo Visualizzatore monitoraggio (roles/monitoring.viewer). Questo ruolo consente di accedere con accesso di sola lettura alla console e all'API Cloud Monitoring.
• Ruolo Monitoring Metric Writer (roles/monitoring.metricWriter). Questo ruolo consente di scrivere i dati di monitoraggio.
• Ruolo Scrittore di log (roles/logging.logWriter). Questo ruolo concede autorizzazioni appena sufficienti per scrivere log.
• Ruolo Utente account di servizio (roles/iam.serviceAccountUser). Questo ruolo consente di accedere agli account di servizio di un progetto. In questo tutorial, la procedura di inizializzazione simula l'identità dell'account di servizio per eseguire operazioni con privilegi.
• Ruolo Amministratore Compute (roles/compute.admin). Questo ruolo fornisce il controllo completo di tutte le risorse Compute Engine. In questo tutorial, l'account servizio ha bisogno di questo ruolo per collegare dischi aggiuntivi ai nodi del cluster.

Per eseguire il provisioning di un account di servizio:

1. In Cloud Shell, inizializza una variabile di ambiente che memorizzi il nome dell'account di servizio:

   GKE_SERVICE_ACCOUNT_NAME=ds-init-tutorial-gke
   

2. Crea un account di servizio:

   gcloud iam service-accounts create "$GKE_SERVICE_ACCOUNT_NAME" \
     --display-name="$GKE_SERVICE_ACCOUNT_NAME"
   

3. Inizializza una variabile di ambiente che memorizza il nome dell'account email dell'account di servizio:

   GKE_SERVICE_ACCOUNT_EMAIL="$(gcloud iam service-accounts list \
       --format='value(email)' \
       --filter=displayName:"$GKE_SERVICE_ACCOUNT_NAME")"
   

4. Associa i ruoli IAM (Identity and Access Management) all'account di servizio:

   gcloud projects add-iam-policy-binding \
       "$(gcloud config get-value project 2> /dev/null)" \
       --member serviceAccount:"$GKE_SERVICE_ACCOUNT_EMAIL" \
       --role roles/compute.admin
   gcloud projects add-iam-policy-binding \
       "$(gcloud config get-value project 2> /dev/null)" \
       --member serviceAccount:"$GKE_SERVICE_ACCOUNT_EMAIL" \
       --role roles/monitoring.viewer
   gcloud projects add-iam-policy-binding \
       "$(gcloud config get-value project 2> /dev/null)" \
       --member serviceAccount:"$GKE_SERVICE_ACCOUNT_EMAIL" \
       --role roles/monitoring.metricWriter
   gcloud projects add-iam-policy-binding \
       "$(gcloud config get-value project 2> /dev/null)" \
       --member serviceAccount:"$GKE_SERVICE_ACCOUNT_EMAIL" \
       --role roles/logging.logWriter
   gcloud projects add-iam-policy-binding \
       "$(gcloud config get-value project 2> /dev/null)" \
       --member serviceAccount:"$GKE_SERVICE_ACCOUNT_EMAIL" \
       --role roles/iam.serviceAccountUser
   

Prepara il cluster GKE

In questa sezione, avvii il cluster GKE, concedi le autorizzazioni e completi la configurazione del cluster.

Per questo tutorial, è sufficiente un cluster con un numero relativamente ridotto di nodi di piccole dimensioni e general purpose per dimostrare il concetto di questo tutorial. Creazione di un cluster con un pool di nodi (quello predefinito). Poi etichetta tutti i nodi nel pool di nodi predefinito con l'etichetta default-init.

• In Cloud Shell, crea e avvia un cluster GKE a livello di regione:

  gcloud container clusters create ds-init-tutorial \
      --enable-ip-alias \
      --image-type=ubuntu_containerd \
      --machine-type=n1-standard-2 \
      --metadata disable-legacy-endpoints=true \
      --node-labels=app=default-init \
      --node-locations us-central1-a,us-central1-b,us-central1-c \
      --no-enable-basic-auth \
      --no-issue-client-certificate \
      --num-nodes=1 \
      --region us-central1 \
      --service-account="$GKE_SERVICE_ACCOUNT_EMAIL"
  

Nota: la procedura di inizializzazione dei nodi deve tenere conto degli strumenti disponibili nel sistema operativo di base. In questo caso, ad esempio, i nodi del cluster GKE eseguono Ubuntu, consentendoti di utilizzare tutti gli strumenti installati per Ubuntu, come il gestore pacchetti APT.

Esegui il deployment del DaemonSet

In questa sezione:

1. Crea il ConfigMap che memorizza la procedura di inizializzazione.
2. Esegui il deployment del DaemonSet che pianifica ed esegue la procedura di inizializzazione.

DaemonSet esegue le seguenti operazioni:

1. Configura un volume che rende disponibili i contenuti del ConfigMap per i container gestiti dal DaemonSet.
2. Configura i volumi per le aree del file system con privilegi del nodo del cluster sottostante. Queste aree consentono ai contenitori pianificati dal DaemonSet di interagire direttamente con il nodo che li esegue.
3. Pianifica ed esegue un contenitore di inizializzazione che esegue la procedura di inizializzazione e poi viene terminato al completamento.
4. Pianifica ed esegue un contenitore che rimane inattivo e non consuma risorse.

Il contenitore inattivo garantisce che un nodo venga inizializzato una sola volta. I DaemonSet sono progettati in modo che tutti i nodi idonei eseguano una copia di un pod. Se utilizzi un normale contenitore, questo esegue la procedura di inizializzazione e viene terminato al termine. Per impostazione predefinita, il DaemonSet riprogramma il pod. Per evitare la "riprogrammazione continua", DaemonSet esegue prima la procedura di inizializzazione in un contenitore di inizializzazione e poi lascia in esecuzione un contenitore.

Nota: in questo tutorial esegui il deployment di una procedura di inizializzazione "una tantum". Puoi implementare un'altra procedura che monitora costantemente lo stato del nodo e agisce di conseguenza per ottenere una soluzione di "autoguarigione".

La seguente procedura di inizializzazione contiene operazioni con privilegi e senza privilegi. Utilizzando chroot, puoi eseguire i comandi come se li stessi eseguendo direttamente sul nodo, non solo all'interno di un contenitore.

# Copyright 2019 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: entrypoint
  labels:
    app: default-init
data:
  entrypoint.sh: |
    #!/usr/bin/env bash

    set -euo pipefail

    DEBIAN_FRONTEND=noninteractive
    ROOT_MOUNT_DIR="${ROOT_MOUNT_DIR:-/root}"

    echo "Installing dependencies"
    apt-get update
    apt-get install -y apt-transport-https curl gnupg lsb-release

    echo "Installing gcloud SDK"
    export CLOUD_SDK_REPO="cloud-sdk-$(lsb_release -c -s)"
    echo "deb https://packages.cloud.google.com/apt $CLOUD_SDK_REPO main" | tee -a /etc/apt/sources.list.d/google-cloud-sdk.list
    curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add -
    apt-get update
    apt-get install -y google-cloud-sdk

    echo "Getting node metadata"
    NODE_NAME="$(curl -sS http://metadata.google.internal/computeMetadata/v1/instance/name -H 'Metadata-Flavor: Google')"
    ZONE="$(curl -sS http://metadata.google.internal/computeMetadata/v1/instance/zone -H 'Metadata-Flavor: Google' | awk -F  "/" '{print $4}')"

    echo "Setting up disks"
    DISK_NAME="$NODE_NAME-additional"

    if ! gcloud compute disks list --filter="name:$DISK_NAME" | grep "$DISK_NAME" > /dev/null; then
        echo "Creating $DISK_NAME"
        gcloud compute disks create "$DISK_NAME" --size=1024 --zone="$ZONE"
    else
        echo "$DISK_NAME already exists"
    fi

    if ! gcloud compute instances describe "$NODE_NAME" --zone "$ZONE" --format '(disks[].source)' | grep "$DISK_NAME" > /dev/null; then
        echo "Attaching $DISK_NAME to $NODE_NAME"
        gcloud compute instances attach-disk "$NODE_NAME" --device-name=sdb --disk "$DISK_NAME" --zone "$ZONE"
    else
        echo "$DISK_NAME is already attached to $NODE_NAME"
    fi

    # We use chroot to run the following commands in the host root (mounted as the /root volume in the container)
    echo "Installing nano"
    chroot "${ROOT_MOUNT_DIR}" apt-get update
    chroot "${ROOT_MOUNT_DIR}" apt-get install -y nano

    echo "Loading Kernel modules"
    # Load the bridge kernel module as an example
    chroot "${ROOT_MOUNT_DIR}" modprobe bridge
...

Nota: i comandi che intendi eseguire nell'ambito della procedura di inizializzazione devono essere disponibili nei contenitori in cui viene eseguito il DaemonSet. Ti consigliamo di installarli nel contenitore o di fornirli montando i volumi necessari dal nodo del cluster.

Ti consigliamo di esaminare attentamente ogni procedura di inizializzazione, perché la procedura potrebbe alterare lo stato dei nodi del cluster. Solo un piccolo gruppo di persone dovrebbe avere il diritto di modificare queste procedure, perché possono influire notevolmente sulla disponibilità e sulla sicurezza dei tuoi cluster.

Attenzione: in questo tutorial esegui il deployment del ConfigMap e del DaemonSet nello spazio dei nomi predefinito. In un ambiente di produzione, ti consigliamo di utilizzare un ambito di nomi dedicato per separare queste attività di inizializzazione dal resto dei carichi di lavoro. Inoltre, ti consigliamo di utilizzare il controllo dell'accesso basato sui ruoli per contribuire a proteggere le risorse in questo spazio dei nomi dedicato.

Per eseguire il deployment del ConfigMap e del DaemonSet:

1. In Cloud Shell, imposta la directory di lavoro sulla directory $HOME:

   cd "$HOME"
   

2. Clona il repository Git contenente gli script e i file manifest per eseguire il deployment e configurare la procedura di inizializzazione:

   git clone https://github.com/GoogleCloudPlatform/solutions-gke-init-daemonsets-tutorial
   

3. Cambia la directory di lavoro impostandola sulla directory del repository appena clonato:

   cd "$HOME"/solutions-gke-init-daemonsets-tutorial
   

4. Crea un ConfigMap per contenere lo script di inizializzazione del nodo:

   kubectl apply -f cm-entrypoint.yaml
   

5. Esegui il deployment del DaemonSet:

   kubectl apply -f daemon-set.yaml
   

   Attenzione: questo DaemonSet esegue il deployment di un container di inizializzazione con privilegi. Per questo motivo, ti consigliamo di utilizzare un cluster non di produzione per questo tutorial.

6. Verifica che l'inizializzazione del nodo sia completata:

   kubectl get ds --watch
   

   Attendi che il DaemonSet venga segnalato come pronto e aggiornato, come indicato da un output simile al seguente:

   NAME              DESIRED   CURRENT   READY     UP-TO-DATE   AVAILABLE   NODE SELECTOR   AGE
   node-initializer   3         3         3         3            3          <none>  2h
   

Convalida e verifica la procedura di inizializzazione

Dopo che ogni nodo del cluster contrassegnato con l'etichetta default-init ha eseguito la procedura di inizializzazione, puoi verificare i risultati.

Nota: in questo esempio, verifichi i risultati manualmente. In un ambiente di produzione, ti consigliamo di configurare il sistema di monitoraggio in modo che monitori continuamente il cluster per verificare che la procedura di inizializzazione venga eseguita correttamente su ogni nodo appena aggiunto, anziché fare affidamento sulla verifica manuale.

Per ogni nodo, la procedura di verifica controlla quanto segue:

1. Un disco aggiuntivo è collegato e pronto per essere utilizzato.
2. Il gestore dei pacchetti del sistema operativo del nodo ha installato pacchetti e librerie.
3. I moduli del kernel sono caricati.

Esegui la procedura di verifica:

• In Cloud Shell, esegui lo script di verifica:

  kubectl get nodes -o=jsonpath='{range .items[?(@.metadata.labels.app=="default-init")]}{.metadata.name}{" "}{.metadata.labels.failure-domain\.beta\.kubernetes\.io/zone}{"\n"}{end}' | while IFS= read -r line ; do ./verify-init.sh $line < /dev/null; done
  

  Attendi l'esecuzione dello script e controlla che ogni nodo sia stato inizializzato correttamente, come indicato da un output simile al seguente:

  Verifying gke-ds-init-tutorial-default-pool-5464b7e3-nzjm (us-central1-c) configuration
  Disk configured successfully on gke-ds-init-tutorial-default-pool-5464b7e3-nzjm (us-central1-c)
  Packages installed successfully in gke-ds-init-tutorial-default-pool-5464b7e3-nzjm (us-central1-c)
  Kernel modules loaded successfully on gke-ds-init-tutorial-default-pool-5464b7e3-nzjm (us-central1-c)
  Verifying gke-ds-init-tutorial-default-pool-65baf745-0gwt (us-central1-a) configuration
  Disk configured successfully on gke-ds-init-tutorial-default-pool-65baf745-0gwt (us-central1-a)
  Packages installed successfully in gke-ds-init-tutorial-default-pool-65baf745-0gwt (us-central1-a)
  Kernel modules loaded successfully on gke-ds-init-tutorial-default-pool-65baf745-0gwt (us-central1-a)
  Verifying gke-ds-init-tutorial-default-pool-6b125c50-3xvl (us-central1-b) configuration
  Disk configured successfully on gke-ds-init-tutorial-default-pool-6b125c50-3xvl (us-central1-b)
  Packages installed successfully in gke-ds-init-tutorial-default-pool-6b125c50-3xvl (us-central1-b)
  Kernel modules loaded successfully on gke-ds-init-tutorial-default-pool-6b125c50-3xvl (us-central1-b)
  

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, puoi eliminare il progetto creato per questo tutorial. Se hai creato un progetto dedicato a questo tutorial, puoi eliminarlo completamente. Se hai utilizzato un progetto esistente, ma non vuoi eliminarlo, segui questi passaggi per ripulirlo.

Ripulire il progetto

Per eseguire la pulizia di un progetto senza eliminarlo, devi rimuovere le risorse che hai creato in questo tutorial.

1. In Cloud Shell, elimina il cluster GKE:

   gcloud container clusters delete ds-init-tutorial --quiet --region us-central1
   

2. Elimina i dischi aggiuntivi che hai creato nell'ambito di questa procedura di inizializzazione di esempio:

   gcloud compute disks list --filter="name:additional" --format="csv[no-heading](name,zone)" | while IFS= read -r line ; do DISK_NAME="$(echo $line | cut -d',' -f1)"; ZONE="$(echo $line | cut -d',' -f2)"; gcloud compute disks delete "$DISK_NAME" --quiet --zone "$ZONE" < /dev/null; done
   

3. Elimina l'account di servizio:

   gcloud iam service-accounts delete "$GKE_SERVICE_ACCOUNT_EMAIL" --quiet
   

4. Elimina la directory del repository clonato:

   rm -rf "$HOME"/solutions-gke-init-daemonsets-tutorial
   

Elimina il progetto

Il modo più semplice per eliminare la fatturazione è quello di eliminare il progetto creato per il tutorial.

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 URL appspot.com, 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.

1. In the Google Cloud console, go to the Manage resources page.

   Go to Manage resources

2. In the project list, select the project that you want to delete, and then click Delete.
3. In the dialog, type the project ID, and then click Shut down to delete the project.

Passaggi successivi

• Scopri di più su GKE.
• Implementa una catena di fornitura di software sicura.
• Scopri come rafforzare la sicurezza del tuo cluster GKE.
• Esplora architetture di riferimento, diagrammi e best practice su Google Cloud. Consulta il nostro Cloud Architecture Center.