Deployment di IBM Db2 Warehouse su Google Kubernetes Engine con archiviazione NFS

Questo tutorial illustra come creare un cluster IBM Db2 Warehouse su Google Kubernetes Engine (GKE) con un volume NFS (Network File System) come livello di archiviazione. Utilizzi Filestore come backend NFS per la soluzione di archiviazione condivisa. Tuttavia, puoi scegliere qualsiasi altra soluzione NFS di cui è possibile eseguire il deployment nel cloud.

Questo tutorial è utile se sei un amministratore di sistema, uno sviluppatore, un tecnico o un amministratore di database e vuoi eseguire il deployment di un cluster IBM Db2 Warehouse su Google Cloud.

Per una panoramica di IBM Db2 Warehouse e delle opzioni di deployment su Google Cloud, consulta la panoramica della serie.

In questo tutorial utilizzerai il seguente software:

  • Ubuntu-server 16.04
  • IBM Db2 Warehouse Enterprise Edition
  • Client IBM Db2 Warehouse

Obiettivi

  • Accedi alle immagini Docker IBM Db2 Warehouse nel Docker Store.
  • Creare un'istanza di Filestore.
  • Avvia il cluster GKE.
  • Verifica che il cluster sia operativo.
  • Inizializza l'autenticazione Docker Store nel cluster GKE.
  • Esegui il deployment ed esegui il provisioner NFS-Client nel cluster.
  • Deployment ed esecuzione di container IBM Db2 Warehouse nel cluster.
  • Caricare dati di esempio in IBM Db2 Warehouse.
  • Connettiti alla console di amministrazione IBM Db2.

Costi

Questo tutorial utilizza componenti fatturabili di Google Cloud, tra cui:

Utilizza il Calcolatore prezzi per generare una stima dei costi in base all'utilizzo previsto.

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. Nella pagina del selettore dei progetti in Google Cloud Console, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  3. Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.

  4. Abilita le API GKE and Filestore.

    Abilita le API

  5. Nella pagina del selettore dei progetti in Google Cloud Console, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  6. Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.

  7. Abilita le API GKE and Filestore.

    Abilita le API

  8. Se non hai un ID Docker, creane uno nel Docker Store.

In questo tutorial viene utilizzato IBM Db2 Warehouse Enterprise Edition. Se non hai già una licenza per questo software, potresti essere in grado di utilizzare una versione di prova gratuita per questo tutorial.

Al termine di questo tutorial, puoi evitare una fatturazione continua eliminando le risorse che hai creato. Per scoprire di più, vedi Pulizia.

Architettura

In questo tutorial, eseguirai il deployment di un cluster Kubernetes utilizzando GKE in tre diverse zone di Google Cloud. Nel cluster, esegui il deployment di tre istanze di IBM Db2 Warehouse:

  • Un'istanza denominata db2wh-1 è inizialmente designata come nodo head.
  • Le istanze denominate db2wh-2 e db2wh-3 sono inizialmente definite come nodi di dati.

Il ruolo (nodo di testa o di dati) delle singole istanze può cambiare se si verifica il funzionamento del nodo di testa.

Esegui anche il deployment di un'istanza Filestore denominata db2wh-data-nfs, che funge da spazio di archiviazione condiviso per i nodi del cluster.

L'architettura è mostrata nel seguente diagramma:

Architettura

Accesso alle immagini Docker IBM Db2 Warehouse Edition

In questo tutorial, consenti al tuo account Docker Store di scaricare una versione di prova gratuita di IBM Db2 Warehouse Edition dal Docker Store. Questo implica il download di due immagini separate: un server e un client.

  1. Nel browser, vai all'immagine Docker EEB Db2 Warehouse EE.

  2. Accedi con il nome utente e la password Docker.

  3. Fai clic su Vai alla cassa.

  4. Inserisci i tuoi dati.

  5. Se accetti i termini, seleziona le caselle di controllo Accetto ... e Confermo ... a destra.

  6. Fai clic su Get Content.

    Viene visualizzata la pagina Configurazione. Non è necessario seguire queste istruzioni, perché verranno eseguiti più avanti nel tutorial.

  7. Ripeti la procedura per l'immagine client IDA Db2 Warehouse.

Preparazione dell'ambiente

In questo tutorial, utilizzerai us-central1 come area geografica predefinita e us-central1-b come zona predefinita. Per risparmiare tempo digitando le opzioni della zona Compute Engine nell'interfaccia a riga di comando di Google Cloud, puoi impostare l'area geografica e la zona come predefinite.

Esegui la maggior parte dei passaggi di questo tutorial in Cloud Shell. Quando apri Cloud Shell, puoi anche clonare automaticamente il repository GitHub associato a questo tutorial.

  1. Apri Cloud Shell:

    APRI Cloud Shell

  2. Imposta la zona e l'area geografica predefinite:

    gcloud config set compute/region us-central1
    gcloud config set compute/zone us-central1-b
    

Creazione dell'istanza Filestore

Il passaggio successivo consiste nel creare l'istanza di database Filestore.

  • In Cloud Shell, crea un'istanza Filestore:

    gcloud beta filestore instances create db2wh-data-nfs \
        --location=us-central1-c \
        --tier=STANDARD \
        --file-share=name="db2whdata",capacity=1TB \
        --network=name="default",reserved-ip-range="10.0.0.0/29"
    

    Viene creata un'istanza Filestore di livello standard denominata db2wh-data-nfs con una capacità di 1 TB e un punto di montaggio denominato db2whdata.

Provisioning di un account di servizio per gestire i cluster GKE

Per questo tutorial, creerai un account di servizio per gestire le istanze di Compute Engine nel cluster GKE. I nodi cluster GKE utilizzano questo account di servizio anziché l'account di servizio predefinito. È buona norma limitare l'account di servizio ai soli ruoli e autorizzazioni di accesso necessari per eseguire l'applicazione.

L'unico ruolo richiesto per l'account di servizio è il ruolo Amministratore Compute (roles/compute.admin). Questo ruolo fornisce il controllo completo di tutte le risorse di Compute Engine. L'account di servizio deve avere questo ruolo per gestire i nodi del cluster GKE.

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

    export GKE_SERVICE_ACCOUNT_NAME=db2dw-gke-service-account
    
  2. Crea un account di servizio:

    gcloud iam service-accounts create $GKE_SERVICE_ACCOUNT_NAME \
        --display-name=$GKE_SERVICE_ACCOUNT_NAME
    
  3. Crea una variabile di ambiente che memorizzi il nome dell'account email dell'account di servizio:

    export GKE_SERVICE_ACCOUNT_EMAIL=$(gcloud iam service-accounts list \
        --format='value(email)' \
        --filter=displayName:"$GKE_SERVICE_ACCOUNT_NAME")
    
  4. Associa il ruolo compute.admin 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
    

Preparazione del cluster GKE

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

Avvia il cluster GKE

Ora puoi creare e avviare il cluster GKE.

  • In Cloud Shell, crea un cluster GKE a livello di area geografica con un singolo nodo in ciascuna zona:

    gcloud container clusters create ibm-db2dw-demo \
        --enable-ip-alias \
        --image-type=ubuntu \
        --machine-type=n1-standard-16 \
        --metadata disable-legacy-endpoints=true \
        --node-labels=app=db2wh \
        --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
    

    Viene creato un cluster denominato ibm-db2dw-demo.

Poiché stai creando questo cluster con un solo pool di nodi (predefinito), tutti i nodi di questo cluster saranno idonei all'esecuzione dei carichi di lavoro IBMDD2 Warehouse. (Solo i nodi etichettati sono idonei per ospitare pod IBM Db2. Se vuoi aumentare la separazione, ad esempio se vuoi nodi dedicati per IBM Db2 Warehouse, puoi creare un nuovo pool di nodi o un cluster dedicato.

Gestisci autenticazione Docker Store

In questo tutorial, creerai un secret per archiviare le tue credenziali del Docker Store, in modo che il tuo cluster GKE possa scaricare l'immagine Docker Db2 Warehouse dal Docker Store. Per maggiori dettagli, consulta la sezione pertinente della documentazione Kubernetes. Questo approccio è valido anche per le istanze private di registro di Docker.

  1. In Cloud Shell, accedi al Docker Store (l'istanza di registro Docker che utilizzerai):

    docker login
    
  2. Crea un secret Kubernetes con le tue credenziali Docker Store:

    kubectl create secret generic dockerstore \
        --type=kubernetes.io/dockerconfigjson \
        --from-file=.dockerconfigjson="$HOME"/.docker/config.json
    

Concedere i privilegi di amministratore del cluster all'utente

Devi concedere all'utente la possibilità di creare nuovi ruoli in GKE, come descritto nella documentazione di GKE.

  • In Cloud Shell, concedi l'autorizzazione per creare nuovi ruoli per il tuo utente:

    kubectl create clusterrolebinding cluster-admin-binding \
        --clusterrole cluster-admin \
        --user $(gcloud config list \
        --format 'value(core.account)')
    

Esegui il deployment del provisioner NFS-Client

In questo tutorial, eseguirai il deployment di un Provisioner NFS-Client nel cluster. Questo provisioner si occupa dell'inizializzazione di PersistentVolumes nell'istanza Filestore per eseguire il backup di PersistentVolumeClaim.

  1. In Cloud Shell, crea un account di servizio per gestire le risorse NFS:

    kubectl apply -f solutions-db2wh/nfs/rbac.yaml
    
  2. Esegui il deployment del provisioner NFS-Client:

    kubectl apply -f solutions-db2wh/nfs/deployment.yaml
    
  3. Crea un StorageClass per supportare le richieste di volumi permanenti con volumi NFS:

    kubectl apply -f solutions-db2wh/nfs/class.yaml
    
  4. Attendi che i pod del provisioner NFS-Client vengano riportati come Running:

    kubectl get pods --watch
    

    Quando sono in esecuzione, vedrai Running nell'output:

    nfs-client-provisioner   1/1       Running   0         10s
    

Crea i file dei nodi

Ora puoi creare un file di configurazione di cui IBM Db2 Warehouse deve eseguire il bootstrap di ogni istanza.

  1. In Cloud Shell, crea i file nodes:

    kubectl get nodes -o=jsonpath="{range \
    .items[?(@.metadata.labels.app=='db2wh')]}\
    {.metadata.name}{':'}{.status.addresses[?(@.type=='InternalIP')]\
    .address}{\"\n\"}{end}" | sed '1s/^/head_node=/' | \
    sed -e '2,$ s/^/data_node=/' > nodes
    
  2. Crea un ConfigMap contenente il file nodes:

    kubectl create configmap db2wh-nodes --from-file=nodes
    

Deployment dei pod IBM Db2 Warehouse

Ora crei tutti i pod GKE richiesti per eseguire IBM Db2 Warehouse.

  1. In Cloud Shell, crea l'oggetto PersistentVolumeClaim. L'oggetto PersistentVolumeClaim consente al cluster di montare l'archiviazione NFS come un PersistentVolume su più pod contemporaneamente.

    kubectl apply -f solutions-db2wh/persistent-volume-claim.yaml
    
  2. Esegui un job che copia il file nodes nel volume NFS:

    kubectl apply -f solutions-db2wh/nodes-file-deploy-job.yaml
    
  3. Verifica che il job di deployment dei file nodes sia stato eseguito:

    kubectl get jobs --watch
    

    Il job è stato eseguito quando nodes-config è segnalato come Successful:

    NAME           DESIRED   SUCCESSFUL   AGE
    nodes-config   1         1            19s
    
  4. Esegui il deployment di un servizio LoadBalancer per consentire l'accesso alla console di amministrazione IBM Db2 Warehouse:

    kubectl apply -f solutions-db2wh/service.yaml
    
  5. Attendi che al servizio bilanciatore del carico denominato db2wh-ext venga assegnato un indirizzo IP esterno:

    kubectl get services --watch
    

    Nell'output è visualizzato un indirizzo IP per CLUSTER-IP e EXTERNAL-IP:

    NAME       TYPE         CLUSTER-IP   EXTERNAL-IP  PORT(S)                         AGE
    db2wh-ext  LoadBalancer yy.yy.yy.yy  xx.xx.xx.xx  8443:30973/TCP,50000:30613/TCP  7s
    
  6. Esegui il deployment dello StatefulSet per avviare i pod IBM Db2 Warehouse:

    kubectl apply -f solutions-db2wh/statefulset.yaml
    
  7. Verifica che i pod IBM Db2 Warehouse (db2wh-0, db2wh-1 e db2wh-2) siano in esecuzione:

    kubectl get pods --watch
    

    L'operazione potrebbe richiedere alcuni minuti.

    I pod sono in esecuzione quando viene visualizzato lo stato Running per tutti i pod:

    db2wh-1   0/1       Running   0         3m
    db2wh-2   0/1       Running   0         3m
    db2wh-0   0/1       Running   0         3m
    
  8. Crea una variabile di ambiente che memorizzi l'indirizzo IP del nodo su cui è in esecuzione il nodo head IBM Db2 Warehouse:

    HEAD_NODE_IP=$(grep "head_node" nodes | awk -F ':' '{print $2}')
    
  9. Crea una variabile di ambiente che memorizzi il nome del pod del nodo head:

    HEAD_NODE_POD_NAME=$(kubectl get pods \
    --field-selector=status.phase=Running -o=jsonpath="{range \
    .items[?(@.metadata.labels.app=='db2wh')]} \
    {.metadata.name}{':'}{.status.\
    hostIP}{'\n'}{end}" | grep $HEAD_NODE_IP | awk -F ':' '{print $1}')
    
  10. Controlla i log di uno dei pod per assicurarti che il processo di bootstrap sia in esecuzione senza problemi:

    kubectl exec -it $HEAD_NODE_POD_NAME -- status --check-startup
    

    Questa operazione potrebbe richiedere 40-60 minuti, durante i quali potresti rilevare alcuni errori. Puoi ignorarli per questo tutorial.

    Il processo viene eseguito correttamente quando viene visualizzato lo stato running successfully nell'output:

    HA Management up and running successfully!
    Successfully started IBM Db2 Warehouse service stack!
    
  11. Configura la password della console di amministrazione:

    DB2_ADMIN_PASSWORD=$(openssl rand -hex 8)
    kubectl exec -it $HEAD_NODE_POD_NAME -- setpass ${DB2_ADMIN_PASSWORD}
    

Test del deployment

Hai completato la configurazione dei pod, quindi puoi provare il deployment.

Deployment del container Client IBM Db2 Warehouse

Per caricare i dati in IBM Db2 Warehouse, ora esegui il deployment del container Client e vi mappa i dati di esempio utilizzando un ConfigMap Kubernetes.

  1. In Cloud Shell, crea un ConfigMap che contenga i dati di esempio:

    kubectl create configmap sample-data \
        --from-file=solutions-db2wh/sample-data/nyc-wifi-locs.csv \
        --from-file=solutions-db2wh/sample-data/sample-table.sql
    
  2. Crea il Deployment per avviare il container IBM Db2 Warehouse Client:

    kubectl apply -f solutions-db2wh/client.yaml
    
  3. Verifica che il pod Client IBM Db2 Warehouse sia in esecuzione:

    kubectl get pods --watch
    

    L'operazione potrebbe richiedere alcuni minuti.

    Il pod è in esecuzione quando vedi Running nello stato:

    db2wh-client-xxxxx-xxxx   1/1       Running   0         3m
    

Caricare dati di esempio

Per testare il deployment, devi caricare i dati di esempio sul server IBM Db2 Warehouse.

  1. In Cloud Shell, visualizza la password creata in precedenza:

    echo $DB2_ADMIN_PASSWORD
    
  2. Crea una variabile di ambiente che memorizzi il nome del container client IBM Db2 Warehouse:

    CLIENT_CONTAINER_NAME=$(kubectl get pods -l app=db2wh-client -o=jsonpath='{.items[0].metadata.name}')
    
  3. Apri una finestra della shell nel contenitore del client:

    kubectl exec -it $CLIENT_CONTAINER_NAME -- cli
    
  4. Crea una variabile di ambiente che memorizzi la password, dove [PASSWORD] è la password che hai ricevuto in precedenza durante questa procedura:

    DB_PASSWORD=[PASSWORD]
    
  5. Crea una variabile di ambiente che memorizzi l'alias del database:

    DB_ALIAS=BLUDB
    

    BLUDB è il nome database predefinito in IBM Db2 Warehouse.

  6. Crea una variabile di ambiente che memorizzi il nome host del database:

    DB_HOST=db2wh-ext.default.svc.cluster.local
    
  7. Configura il catalogo database:

    db_catalog --add $DB_HOST --alias $DB_ALIAS
    
  8. Crea una tabella in cui inserire dati di esempio nel server IBM Db2 Warehouse:

    dbsql -f /sample-table.sql -d $DB_ALIAS -h $DB_HOST -u bluadmin -W $DB_PASSWORD
    
  9. Carica i dati sul server IBM Db2 Warehouse:

    dbload -verbose -host $DB_HOST -u bluadmin \
    -pw $DB_PASSWORD -db $DB_ALIAS -schema BLUADMIN \
    -t NYC_FREE_PUBLIC_WIFI -df /nyc-wifi-locs.csv -delim ',' \
    -quotedValue DOUBLE -timeStyle 12HOUR -skipRows 1
    
  10. Chiudi la shell client IBM Db2 Warehouse:

    exit
    

Convalidare i dati con la Console di amministrazione

Ora ti connetti alla console di amministrazione di IBM Db2 Warehouse e verifichi i dati che hai caricato.

  1. In Cloud Shell, individua l'indirizzo IP esterno del servizio:

    kubectl get svc db2wh-ext
    
  2. Apri un browser e vai all'URL seguente, dove [EXTERNAL_IP] è l'indirizzo IP del passaggio precedente:

    https://[EXTERNAL_IP]:8443
    

    Puoi ignorare l'avviso di sicurezza.

  3. Accedi con le seguenti credenziali:

    • Nome utente: bluadmin
    • Password: (la password creata nel passaggio precedente)
  4. Se accetti il Contratto di licenza con l'utente finale (EULA) di IBM Db2 Warehouse, fai clic su Accept (Accetto).

  5. Sul lato sinistro, apri il menu e seleziona Amministrazione > Tabelle:

    UI di amministrazione di IBM Db2 Warehouse, che mostra la cartella Tables

  6. Chiudi il popup Tour rapido.

  7. Fai clic su NYC_FREE_PUBLIC_WIFI:

    Elenco degli hotspot Wi-Fi disponibili

  8. Fai clic sulla scheda Data Distribution e accertati che la tabella sia compilata:

    Scheda Distribuzione dei dati nell'elenco Tabelle

    Vedrai 2871 righe in totale, che corrisponde all'intero set di dati.

  9. Fai clic su Genera SQL.

  10. Seleziona SELEZIONA istruzione.

  11. Fai clic su OK.

    La scheda Genera SQL si apre e viene precompilata con l'istruzione SELECT generata automaticamente.

  12. Aggiungi una clausola LIMIT all'istruzione SELECT generata automaticamente per limitare i risultati ai primi cinque record:

    SELECT "THE_GEOM", "OBJECTID", "BORO", "TYPE", "PROVIDER", "NAME", "LOCATION",
           "LAT", "LON", "X", "Y", "LOCATION_T", "REMARKS", "CITY", "SSID",
           "SOURCEID", "ACTIVATED", "BOROCODE", "BORONAME", "NTACODE", "NTANAME",
           "COUNDIST", "POSTCODE", "BOROCD", "CT2010", "BOROCT2010", "BIN", "BBL", "DOITT_ID"
      FROM "BLUADMIN"."NYC_FREE_PUBLIC_WIFI"
      LIMIT 5;
    
  13. Fai clic su Esegui e seleziona Esegui tutto.

    Un elenco dei record viene visualizzato nella scheda Set di risultati, a indicare che i dati di esempio sono stati caricati correttamente.

    Risultati dell'esecuzione dell'istruzione SQL in cui sono visualizzati 5 record dei dati caricati

Esegui la pulizia

Per evitare che al tuo Account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

Elimina il progetto

  1. Nella console, vai alla pagina Gestisci risorse.

    Vai a Gestisci risorse

  2. Nell'elenco dei progetti, seleziona il progetto da eliminare, quindi fai clic su Elimina.
  3. Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Passaggi successivi