Esegui il bootstrap automatico dei nodi GKE con i DaemonSet

Standard

---

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

Se gli strumenti e i sistemi che utilizzi per inizializzare i tuoi cluster sono diversi agli strumenti e ai sistemi che utilizzi per eseguire i carichi di lavoro, aumenti l'impegno per gestire l'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ò causare un comportamento che potrebbe influire negativamente sull'integrità di carichi di lavoro e nodi. Non tutte le personalizzazioni sono supportate. Assicurati di implementare test approfonditi di eventuali personalizzazioni prima di eseguirne il deployment sui cluster che eseguono 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 in modo che venga eseguito solo su nodi a cui è applicata l'etichetta default-init. Tuttavia, per dimostrare flessibilità di questo meccanismo, puoi creare un altro pool di nodi e applicare alternative-init etichetta ai nodi in 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 sistema operativo del nodo gestore di pacchetti di sistema.
3. Carica un insieme di moduli 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 basata sull'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud potrebbero essere idonei per una prova gratuita.

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. 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. Esegui il provisioning di un account di servizio con privilegi limitati per i nodi nel 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. Abilita 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, concedere 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 Monitoring (roles/monitoring.viewer). Questo ruolo fornisce accesso di sola lettura alla console e all'API di Cloud Monitoring.
• Ruolo Writer metriche Monitoring (roles/monitoring.metricWriter). Questo consente di scrivere dati di monitoraggio.
• Ruolo Scrittore di log (roles/logging.logWriter). Questo ruolo fornisce le autorizzazioni minime 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 classe La procedura di inizializzazione simula l'account di servizio per eseguire operazioni aziendali.
• Ruolo Amministratore Compute (roles/compute.admin). Questo ruolo fornisce il controllo completo di tutte le risorse Compute Engine. In questo tutorial, il servizio account necessita 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 avvierai il cluster GKE, concederai le autorizzazioni, e completare 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. Creazione di un cluster con un pool di nodi (quello predefinito). Quindi etichetta tutti i nodi nel pool di nodi predefinito con l'etichetta default-init.

• In Cloud Shell, crea e avvia regionale Cluster GKE:

  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 del disponibili nel sistema operativo sottostante. In questo caso, per Ad esempio, i nodi dei cluster GKE eseguono Ubuntu, per consentirti tutti gli strumenti installati per Ubuntu, come Gestore di pacchetti APT.

esegui il deployment del DaemonSet

In questa sezione imparerai a:

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

Il DaemonSet esegue queste 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 container init che esegue la procedura di inizializzazione e poi viene terminato 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 container normale, questo esegue la procedura di inizializzazione e verrà terminato al termine dell'operazione. Per impostazione predefinita, il DaemonSet riprogramma all'interno del 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 privilegi con privilegi e senza privilegi operazioni aziendali. 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 come parte della procedura di inizializzazione deve essere disponibile nei container eseguiti dal DaemonSet. È consigliabile nel contenitore o fornite montando i necessari volumi dal nodo cluster.

Ti consigliamo di esaminare attentamente ogni procedura di inizializzazione, la procedura potrebbe modificare lo stato dei nodi del cluster. Poco le persone devono avere il diritto di modificare tali procedure, in quanto queste procedure possono influire notevolmente sulla disponibilità e sulla sicurezza dei 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 controllo degli accessi basato su ruoli per proteggere le risorse in questo spazio dei nomi dedicato.

Per eseguire il deployment del ConfigMap e del DaemonSet:

1. In Cloud Shell, cambia la directory di lavoro in $HOME directory:

   cd "$HOME"
   

2. Clona il repository Git che contiene gli script e il 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, per questo tutorial devi utilizzare un cluster non di produzione.

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

   kubectl get ds --watch
   

   Attendi che il DaemonSet venga segnalato come pronto e aggiornato, 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 di pacchetti del sistema operativo del nodo ha installato i 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 che hai 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 ripulire 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 che hai 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 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.

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

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