Déployer IBM Db2 Warehouse sur Google Kubernetes Engine avec le stockage NFS

Ce tutoriel explique comment créer un cluster IBM Db2 Warehouse sur Google Kubernetes Engine (GKE) avec un volume NFS (Network File System) en tant que couche de stockage. Vous utiliserez Cloud Filestore en tant que backend NFS pour la solution de stockage partagé. Cependant, vous pouvez choisir n'importe quelle autre solution NFS déployable dans le cloud.

Ce tutoriel est utile si vous êtes un administrateur système, un développeur, un ingénieur ou un administrateur de base de données qui souhaite déployer un cluster IBM Db2 Warehouse sur Google Cloud.

Pour en savoir plus sur IBM Db2 Warehouse et les options de déploiement sur Google Cloud, consultez la présentation de la série.

Dans ce tutoriel, vous utiliserez les logiciels suivants :

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

Objectifs

• Accéder aux images Docker IBM Db2 Warehouse dans Docker Store
• Créer une instance Filestore
• Lancer le cluster GKE
• Vérifier que le cluster est opérationnel
• Initialiser l'authentification de Docker Store dans le cluster GKE
• Déployer et exécuter l'approvisionneur NFS-Client dans le cluster
• Déployer et exécuter les conteneurs IBM Db2 Warehouse dans le cluster
• Importer des exemples de données dans IBM Db2 Warehouse
• Se connecter à la console d'administration IBM Db2

Coûts

Ce tutoriel utilise des composants facturables de Google Cloud, dont :

• GKE
• Filestore
• Mise en réseau

Utilisez le simulateur de coût pour générer une estimation des coûts en fonction de votre utilisation prévue.

Avant de commencer

1. Connectez-vous à votre compte Google Cloud. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.

2. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

   Remarque : Si vous ne comptez pas conserver les ressources créées dans cette procédure, créez un projet au lieu de sélectionner un projet existant. Après avoir suivi ces étapes, vous pouvez supprimer le projet. Cela entraîne la suppression de toutes les ressources qui lui sont associées.

   Accéder au sélecteur de projet

3. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

4. Activer les API GKE and Filestore.

   Activer les API

5. Si vous n'avez pas d'ID Docker, créez-en un dans Docker Store.

Dans ce tutoriel, vous utiliserez IBM Db2 Warehouse Enterprise Edition. Si vous ne possédez pas encore de licence pour ce logiciel, vous pourrez peut-être utiliser une version d'évaluation gratuite pour ce tutoriel.

Une fois que vous avez terminé ce tutoriel, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Consultez la page Effectuer un nettoyage pour en savoir plus.

Architecture

Dans ce tutoriel, vous allez déployer un cluster Kubernetes à l'aide de GKE dans trois zones Google Cloud différentes. Dans le cluster, vous allez déployer trois instances d'IBM Db2 Warehouse :

• Une instance nommée db2wh-1 est initialement désignée comme nœud principal.
• Les instances nommées db2wh-2 et db2wh-3 sont initialement désignées comme nœuds de données.

Le rôle des instances individuelles (nœud principal ou de données) peut changer en cas de basculement du nœud principal.

Vous allez également déployer une instance Cloud Filestore nommée db2wh-data-nfs, qui sert d'espace de stockage partagé pour les nœuds de cluster.

L'architecture est représentée dans le schéma suivant :

Accéder aux images Docker IBM Db2 Warehouse Edition

Dans ce tutoriel, vous allez autoriser votre compte Docker Store à télécharger une version d'évaluation gratuite d'IBM Db2 Warehouse Edition à partir de Docker Store. Cela implique le téléchargement de deux images distinctes : une image serveur et une image client.

1. Dans votre navigateur, accédez à l'image Docker IBM Db2 Warehouse EE.

2. Connectez-vous à l'aide de votre nom d'utilisateur et de votre mot de passe Docker.

3. Cliquez sur Proceed to checkout (Procéder au paiement).

4. Saisissez les informations demandées.

5. Si vous acceptez les conditions, cochez les cases I agree ... (J'accepte) et I acknowledge ... (Je confirme) situées sur la droite.

6. Cliquez sur Get Content (Obtenir le contenu).

   La page de configuration s'affiche. Vous n'avez pas besoin de suivre ces instructions, car vous exécuterez ces étapes dans la suite de ce tutoriel.

7. Répétez ce processus pour l'image client IBM Db2 Warehouse.

Préparer l'environnement

Dans ce tutoriel, la région par défaut est us-central1 et la zone par défaut est us-central1-b. Pour gagner du temps lors de la saisie de vos options de zone Compute Engine dans l'outil de ligne de commande gcloud, vous allez définir cette région et cette zone en tant que valeurs par défaut.

Vous effectuerez la plupart des étapes de ce tutoriel dans Cloud Shell. Lorsque vous ouvrez Cloud Shell, vous pouvez également cloner automatiquement le dépôt GitHub associé à ce tutoriel.

1. Ouvrez Cloud Shell.

   Ouvrir Cloud Shell

2. Définissez la région et la zone par défaut :

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

Créer l'instance Filestore

L'étape suivante consiste à créer l'instance de base de données Filestore.

• Dans Cloud Shell, créez une instance Filestore comme suit :

  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"
  

  Cela crée une instance Cloud Filestore de niveau standard nommée db2wh-data-nfs avec une capacité de 1 To et un point d'installation nommé db2whdata.

Provisionner un compte de service pour gérer les clusters GKE

Dans le cadre de ce tutoriel, vous allez créer un compte de service pour gérer les instances Compute Engine dans le cluster GKE. Les nœuds de cluster GKE utiliseront ce compte de service au lieu du compte de service par défaut. Il est recommandé de limiter le compte de service aux seuls rôles et aux seules autorisations d'accès nécessaires à l'exécution de l'application.

Le seul rôle requis pour le compte de service est le rôle Administrateur de Compute (roles/compute.admin). Ce rôle fournit un contrôle complet sur toutes les ressources Compute Engine. Le compte de service a besoin de ce rôle pour gérer les nœuds de cluster GKE.

1. Dans Cloud Shell, créez une variable d'environnement qui stocke le nom du compte de service :

   export GKE_SERVICE_ACCOUNT_NAME=db2dw-gke-service-account
   

2. Créez un compte de service :

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

3. Créez une variable d'environnement qui stocke le nom du compte de messagerie du compte de service :

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

4. Liez le rôle compute.admin au compte de service :

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

Préparer le cluster GKE

Dans cette section, vous allez lancer le cluster GKE, accorder des autorisations et terminer la configuration du cluster.

Lancer le cluster GKE

Vous pouvez maintenant créer et lancer le cluster GKE.

• Dans Cloud Shell, créez un cluster GKE régional comportant un seul nœud dans chaque zone :

  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
  

  Cette opération crée un cluster nommé ibm-db2dw-demo.

Étant donné que vous créez ce cluster avec un seul pool de nœuds (celui par défaut), tous les nœuds de ce cluster seront éligibles pour exécuter les charges de travail IBM Db2 Warehouse (seuls les nœuds étiquetés sont éligibles pour héberger des pods IBM Db2 Warehouse). Si vous souhaitez davantage de séparation (par exemple, si vous voulez des nœuds dédiés pour IBM Db2 Warehouse), vous pouvez créer un nouveau pool de nœuds ou un cluster dédié.

Gérer l'authentification de Docker Store

Dans ce tutoriel, vous allez créer un secret pour stocker vos identifiants Docker Store, afin que votre cluster GKE puisse télécharger l'image Docker IBM Db2 Warehouse à partir de Docker Store. Pour en savoir plus, consultez la section correspondante de la documentation relative à Kubernetes. Cette approche est également valable pour les instances privées de Docker Registry.

1. Dans Cloud Shell, connectez-vous à Docker Store (à l'instance de Docker Registry que vous allez utiliser) :

   docker login
   

2. Créez un secret Kubernetes avec vos identifiants Docker Store :

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

Accorder des droits d'administrateur de cluster à l'utilisateur

Vous devez accorder à votre utilisateur la possibilité de créer de nouveaux rôles dans GKE, comme décrit dans la documentation GKE.

• Dans Cloud Shell, accordez à votre utilisateur l'autorisation de créer de nouveaux rôles :

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

Déployer l'approvisionneur NFS-Client

Dans ce tutoriel, vous allez déployer un approvisionneur NFS-Client dans le cluster. Cet approvisionneur se charge de l'initialisation de PersistentVolumes dans l'instance Cloud Filestore pour sauvegarder PersistentVolumeClaims.

1. Dans Cloud Shell, créez un compte de service pour gérer les ressources NFS :

   kubectl apply -f solutions-db2wh/nfs/rbac.yaml
   

2. Déployez l'approvisionneur NFS-Client :

   kubectl apply -f solutions-db2wh/nfs/deployment.yaml
   

3. Créez une ressource StorageClass pour sauvegarder PersistentVolumeClaims avec des volumes NFS :

   kubectl apply -f solutions-db2wh/nfs/class.yaml
   

4. Attendez que les pods de l'approvisionneur NFS-Client soient signalés comme étant Running :

   kubectl get pods --watch
   

   Lorsqu'ils sont en cours d'exécution, l'état Running apparaît dans le résultat :

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

Créer les fichiers de nœuds

Vous pouvez maintenant créer un fichier de configuration nécessaire à IBM Db2 Warehouse pour amorcer chaque instance.

1. Dans Cloud Shell, créez les fichiers 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. Créez un fichier ConfigMap contenant le fichier nodes :

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

Remarque : En raison d'une exigence connue de la version actuelle d'IBM Db2 Warehouse, chaque fois que vous souhaitez modifier la topologie du réseau (par exemple, pour la faire évoluer), vous devez arrêter toutes les instances, mettre à jour le fichier nodes, puis les redémarrer. En général, lorsqu'un pod Kubernetes est replanifié, la topologie du réseau change également. Le déploiement empêche cela de différentes façons :

• Utilisation de l'affinité de nœud : les pods IBM Db2 Warehouse ne sont programmés que sur les nœuds porteurs du libellé app=db2wh.
• Utilisation de l'anti-affinité de pod : il ne peut y avoir qu'un seul pod IBM Db2 Warehouse par nœud.
• Utilisation de la mise en réseau des hôtes pour les pods IBM Db2 Warehouse : permet d'éviter l'arrêt et le redémarrage de tous les pods de StatefulSet à chaque replanification de pods.

Déployer les pods IBM Db2 Warehouse

Vous allez maintenant créer tous les pods GKE requis pour exécuter IBM Db2 Warehouse.

1. Dans Cloud Shell, créez l'objet PersistentVolumeClaim. Celui-ci permet au cluster d'installer le stockage NFS en tant que PersistentVolume sur plusieurs pods en même temps.

   kubectl apply -f solutions-db2wh/persistent-volume-claim.yaml
   

2. Exécutez une tâche qui copie le fichier nodes dans le volume NFS :

   kubectl apply -f solutions-db2wh/nodes-file-deploy-job.yaml
   

3. Vérifiez que la tâche de déploiement du fichier nodes a été exécutée :

   kubectl get jobs --watch
   

   La tâche a été exécutée lorsque nodes-config est signalé comme étant Successful :

   NAME           DESIRED   SUCCESSFUL   AGE
   nodes-config   1         1            19s
   

4. Déployez un service d'équilibrage de charge pour autoriser l'accès à la console d'administration IBM Db2 Warehouse :

   kubectl apply -f solutions-db2wh/service.yaml
   

5. Attendez qu'une adresse IP externe soit attribuée au service d'équilibrage de charge nommé db2wh-ext :

   kubectl get services --watch
   

   Dans le résultat, une adresse IP s'affiche pour CLUSTER-IP et 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. Déployez StatefulSet pour démarrer les pods IBM Db2 Warehouse :

   kubectl apply -f solutions-db2wh/statefulset.yaml
   

7. Vérifiez que les pods IBM Db2 Warehouse (db2wh-0, db2wh-1 et db2wh-2) sont en cours d'exécution :

   kubectl get pods --watch
   

   Cela peut prendre quelques minutes.

   Les pods sont en cours d'exécution lorsque l'état Running apparaît pour tous les pods :

   db2wh-1   0/1       Running   0         3m
   db2wh-2   0/1       Running   0         3m
   db2wh-0   0/1       Running   0         3m
   

8. Créez une variable d'environnement qui stocke l'adresse IP du nœud qui exécute le nœud principal d'IBM Db2 Warehouse :

   HEAD_NODE_IP=$(grep "head_node" nodes | awk -F ':' '{print $2}')
   

9. Créez une variable d'environnement qui stocke le nom du pod du nœud principal :

   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. Consultez les journaux de l'un des pods pour vous assurer que le processus d'amorçage s'exécute sans problème :

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

    Cela peut prendre entre 40 et 60 minutes, au cours desquelles des erreurs peuvent être détectées. Vous pouvez les ignorer dans le cadre de ce tutoriel.

    Le processus s'exécute correctement lorsque l'état running successfully apparaît dans le résultat :

    HA Management up and running successfully!
    Successfully started IBM Db2 Warehouse service stack!
    

11. Configurez le mot de passe de la console d'administration :

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

Remarque : Seul le pod qui exécute le nœud principal est signalé comme étant Ready par GKE, car c'est le seul qui exécute la console d'administration. Les autres pods, même s'ils ne sont pas signalés comme étant Ready, hébergent un nœud de données.

Tester votre déploiement

Vous avez à présent terminé la configuration des pods. Vous pouvez donc tester le déploiement.

Déployer le conteneur client IBM Db2 Warehouse

Afin d'importer des données dans IBM Db2 Warehouse, vous allez maintenant déployer le conteneur client et y mapper les exemples de données à l'aide d'un ConfigMap Kubernetes.

1. Dans Cloud Shell, créez un ConfigMap contenant les exemples de données :

   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. Créez le déploiement pour démarrer le conteneur client IBM Db2 Warehouse :

   kubectl apply -f solutions-db2wh/client.yaml
   

3. Vérifiez que le conteneur client IBM Db2 Warehouse est en cours d'exécution :

   kubectl get pods --watch
   

   Cela peut prendre quelques minutes.

   Le pod est en cours d'exécution lorsque l'état Running apparaît :

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

Importer des exemples de données

Afin de tester le déploiement, vous allez importer des exemples de données dans le serveur IBM Db2 Warehouse.

1. Dans Cloud Shell, affichez le mot de passe créé précédemment :

   echo $DB2_ADMIN_PASSWORD
   

2. Créez une variable d'environnement qui stocke le nom du conteneur client IBM Db2 Warehouse :

   CLIENT_CONTAINER_NAME=$(kubectl get pods -l app=db2wh-client -o=jsonpath='{.items[0].metadata.name}')
   

3. Ouvrez une fenêtre de l'interface système dans le conteneur client :

   kubectl exec -it $CLIENT_CONTAINER_NAME -- cli
   

4. Créez une variable d'environnement qui stocke le mot de passe, dans laquelle [PASSWORD] correspond au mot de passe que vous avez obtenu précédemment dans la procédure :

   DB_PASSWORD=[PASSWORD]
   

5. Créez une variable d'environnement qui stocke l'alias de la base de données :

   DB_ALIAS=BLUDB
   

   BLUDB correspond au nom de la base de données par défaut dans IBM Db2 Warehouse.

6. Créez une variable d'environnement qui stocke le nom d'hôte de la base de données :

   DB_HOST=db2wh-ext.default.svc.cluster.local
   

7. Configurez le catalogue de base de données :

   db_catalog --add $DB_HOST --alias $DB_ALIAS
   

8. Créez une table permettant de stocker les exemples de données sur le serveur IBM Db2 Warehouse :

   dbsql -f /sample-table.sql -d $DB_ALIAS -h $DB_HOST -u bluadmin -W $DB_PASSWORD
   

9. Importez les données dans le serveur 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. Fermez l'interface système client IBM Db2 Warehouse :

    exit
    

Valider les données à l'aide de la console d'administration

Vous allez maintenant vous connecter à la console d'administration IBM Db2 Warehouse et valider les données que vous avez importées.

1. Dans Cloud Shell, recherchez l'adresse IP externe du service :

   kubectl get svc db2wh-ext
   

2. Ouvrez un navigateur et accédez à l'URL suivante, dans laquelle [EXTERNAL_IP] correspond à l'adresse IP de l'étape précédente :

   https://[EXTERNAL_IP]:8443
   

   Vous pouvez ignorer l'avertissement de sécurité.

3. Connectez-vous à l'aide des identifiants suivants :

   • Nom d'utilisateur : bluadmin
   • Mot de passe : le mot de passe que vous avez créé lors de la procédure précédente

4. Si vous acceptez le CLUF IBM Db2 Warehouse, cliquez sur Accept (Accepter).

5. Sur la gauche, ouvrez le menu puis sélectionnez Administer (Administrer) > Tables :

   

6. Fermez le pop-up Quick Tour (Visite guidée rapide).

7. Cliquez sur NYC_FREE_PUBLIC_WIFI :

   

8. Cliquez sur l'onglet Data Distribution (Distribution des données) et assurez-vous que la table est remplie :

   

   Vous voyez 2871 lignes au total, ce qui correspond à l'intégralité de l'ensemble de données.

9. Cliquez sur Generate SQL (Générer SQL).

10. Sélectionnez SELECT statement (instruction SELECT).

11. Cliquez sur OK.

    L'onglet Generate SQL (Générer SQL) s'ouvre. Il est pré-rempli et contient une instruction SELECT générée automatiquement.

12. Ajoutez une clause LIMIT à l'instruction SELECT générée automatiquement pour limiter les résultats aux cinq premiers enregistrements :

    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. Cliquez sur Run (Exécuter), puis sélectionnez Run All (Tout exécuter).

    La liste des enregistrements s'affiche dans l'onglet Result Set (Ensemble de résultats), ce qui indique que vous avez importé avec succès les exemples de données.

    

Nettoyer

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et les ressources individuelles.

Supprimer le projet

Attention : La suppression d'un projet aura les effets suivants :
• Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour ce tutoriel et que vous le supprimez, vous supprimerez également tout autre travail effectué dans le projet.
• Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.
1. Dans Cloud Console, accédez à la page Gérer les ressources.

   Accéder à la page Gérer les ressources

2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Étapes suivantes

• Consultez d'autres documents de cette série :
  • Stratégies de déploiement d'IBM Db2 Warehouse sur Google Cloud (Présentation)
  • Déployer IBM Db2 Warehouse sur Google Kubernetes Engine avec le stockage GlusterFS
  • Déployer IBM Db2 Warehouse sur Compute Engine avec le stockage NFS
  • Déployer IBM Db2 Warehouse sur Compute Engine avec le stockage GlusterFS
• Découvrez l'architecture IBM Db2 Warehouse.
• Découvrez les conditions requises d'IBM Db2 Warehouse.
• Découvrez des architectures de référence, des schémas, des tutoriels et des bonnes pratiques concernant Google Cloud. Consultez notre Centre d'architecture cloud.