Implementa IBM Db2 Warehouse en Google Kubernetes Engine con almacenamiento de NFS

En este instructivo, se muestra cómo crear un clúster de IBM Db2 Warehouse en Google Kubernetes Engine (GKE) con un volumen del sistema de archivos de red (NFS) como la capa de almacenamiento. Usarás Filestore como el backend de NFS para la solución de almacenamiento compartido. Sin embargo, puedes elegir cualquier otra solución de NFS que pueda implementarse en la nube.

Este instructivo te resultará útil si eres administrador de sistemas, desarrollador, ingeniero o administrador de bases de datos y deseas implementar un clúster de IBM Db2 Warehouse en Google Cloud.

Para obtener una descripción general de IBM Db2 Warehouse y las opciones de implementación en Google Cloud, consulta la descripción general de la serie.

En este instructivo, usarás el siguiente software:

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

Objetivos

• Obtener acceso a las imágenes de Docker de IBM Db2 Warehouse en la Docker Store
• Crear una instancia de Filestore
• Iniciar un clúster de GKE
• Verificar que el clúster esté en funcionamiento
• Inicializar la autenticación de Docker Store en el clúster de GKE
• Implementar y ejecutar el aprovisionador de cliente de NFS en el clúster
• Implementar y ejecutar los contenedores de IBM Db2 Warehouse en el clúster
• Subir datos de muestra en IBM Db2 Warehouse
• Conectarse a la Consola del administrador de IBM Db2

Costos

En este instructivo, se usan los siguientes componentes facturables de Google Cloud:

• GKE
• Filestore
• Redes

Usa la calculadora de precios para generar una estimación de los costos según el uso previsto.

Antes de comenzar

1. Accede a tu cuenta de Google Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

2. En la página del selector de proyectos de Google Cloud Console, selecciona o crea un proyecto de Google Cloud.

   Nota: Si no planeas conservar los recursos que creaste durante este procedimiento, crea un proyecto en lugar de seleccionar uno existente. Cuando termines, puedes borrar el proyecto y quitar todos los recursos asociados con él.

   Ir al selector de proyectos

3. Asegúrate de que la facturación esté habilitada para tu proyecto de Cloud. Descubre cómo confirmar que tienes habilitada la facturación en un proyecto.

4. Habilita las API de GKE and Filestore.

   Habilita las API

5. Si no tienes un ID de Docker, crea uno en Docker Store.

En este instructivo, usarás IBM Db2 Warehouse Enterprise Edition. Si aún no tienes una licencia de este software, tal vez puedas usar una versión de prueba gratuita para este instructivo.

Cuando finalices este instructivo, podrás borrar los recursos creados para evitar que se te siga facturando. Para obtener más información, consulta cómo hacer una limpieza.

Arquitectura

En este instructivo, implementarás un clúster de Kubernetes mediante GKE en tres zonas diferentes de Google Cloud. En el clúster, implementarás tres instancias de IBM Db2 Warehouse:

• En un principio, una instancia llamada db2wh-1 se designa como el nodo principal.
• Al comienzo, las instancias llamadas db2wh-2 y db2wh-3 se designan como nodos de datos.

La función (nodo principal o de datos) de cada instancia puede cambiar si falla el nodo principal.

También implementas una instancia de Filestore llamada db2wh-data-nfs, que actúa como el almacenamiento compartido para los nodos del clúster.

La arquitectura se muestra en el siguiente diagrama:

Obtén acceso a las imágenes de Docker de IBM Db2 Warehouse Edition

En este instructivo, permitirás que tu cuenta de Docker Store descargue una versión de prueba gratuita de IBM Db2 Warehouse Edition desde Docker Store. Esto implica descargar dos imágenes distintas: un servidor y un cliente.

1. En tu navegador, ve a la imagen de Docker de IBM Db2 Warehouse EE.

2. Accede con tu nombre de usuario y contraseña de Docker.

3. Haz clic en Proceed to checkout (Ir a confirmación de compra).

4. Completa tus datos.

5. Si estás de acuerdo con los términos, selecciona las casillas de verificación I agree... (Acepto…) y I acknowledge… (Reconozco...) que aparecen a la derecha.

6. Haz clic en Get content (Obtener contenido).

   Esta acción te llevará a la página Setup (Configuración). No es necesario que sigas las instrucciones, ya que realizarás esos pasos más adelante en el instructivo.

7. Repite el proceso para la imagen de IBM Db2 Warehouse Client.

Prepara tu entorno

En este instructivo, debes usar us-central1 como la región predeterminada y us-central1-b como la zona predeterminada. Para ahorrar tiempo cuando escribas las opciones de la zona de Compute Engine en la herramienta de línea de comandos de gcloud, debes establecer la región y la zona como predeterminadas.

Realizarás la mayoría de los pasos de este instructivo en Cloud Shell. Cuando abras Cloud Shell, también podrás clonar automáticamente el repositorio de GitHub que está asociado a este instructivo.

1. Abre Cloud Shell:

   Abrir Cloud Shell

2. Establece la región y la zona predeterminadas:

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

Crea la instancia de Filestore

El siguiente paso es crear la instancia de base de datos de Filestore.

• En Cloud Shell, crea una instancia de 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"
  

  Esto crea una instancia de Filestore de nivel estándar llamada db2wh-data-nfs con capacidad de 1 TB y un punto de activación llamado db2whdata.

Aprovisiona una cuenta de servicio para administrar clústeres de GKE

En este instructivo, crearás una cuenta de servicio a fin de administrar las instancias de Compute Engine en el clúster de GKE. Los nodos de clúster de GKE usarán esta cuenta de servicio en lugar de la cuenta de servicio predeterminada. Se recomienda limitar la cuenta de servicio a los permisos de acceso y funciones necesarios para ejecutar la aplicación.

La única función necesaria para la cuenta de servicio es la función de administrador de Compute (roles/compute.admin). Esta función proporciona control total de todos los recursos de Compute Engine. La cuenta de servicio necesita esta función para administrar los nodos del clúster de GKE.

1. En Cloud Shell, crea una variable de entorno que almacena el nombre de la cuenta de servicio mediante el comando siguiente:

   export GKE_SERVICE_ACCOUNT_NAME=db2dw-gke-service-account
   

2. Crea una cuenta de servicio:

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

3. Crea una variable de entorno que almacene el nombre de la cuenta de correo electrónico de la cuenta de servicio:

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

4. Vincula la función compute.admin a la cuenta de servicio:

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

Prepara el clúster de GKE

En esta sección, iniciarás el clúster de GKE, otorgarás permisos y finalizarás la configuración del clúster.

Inicia el clúster de GKE

Ahora puedes crear y, luego, iniciar el clúster de GKE.

• En Cloud Shell, crea un clúster de GKE regional con un nodo único en cada zona mediante el siguiente comando:

  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
  

  Esto crea un clúster llamado ibm-db2dw-demo.

Debido a que creas este clúster con un solo grupo de nodos (el predeterminado), todos los nodos de este clúster serán aptos para ejecutar las cargas de trabajo de IBM Db2 Warehouse. Solo los nodos etiquetados son aptos para alojar pods de IBM Db2 Warehouse. Si deseas más separación, por ejemplo, deseas nodos dedicados para IBM Db2 Warehouse, puedes crear un grupo de nodos nuevo o un clúster dedicado.

Administra la autenticación de Docker Store

En este instructivo, crearás un secreto para almacenar tus credenciales de Docker Store, de modo que tu clúster de GKE pueda descargar la imagen de Docker de IBM Db2 Warehouse desde Docker Store. Para obtener más detalles, consulta la sección relevante de la documentación de Kubernetes. Este enfoque también es válido para instancias privadas del registro de Docker.

1. En Cloud Shell, accede a Docker Store (la instancia del registro de Docker que usarás) mediante este comando:

   docker login
   

2. Crea un secreto de Kubernetes con tus credenciales de Docker Store:

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

Otorga privilegios de administrador de clúster al usuario

Debes otorgar a tu usuario la capacidad de crear funciones nuevas en GKE, como se describe en la documentación de GKE.

• En Cloud Shell, otorga el permiso para crear funciones nuevas de tu usuario mediante este comando:

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

Implementa el aprovisionador del cliente de NFS

En este instructivo, implementarás un aprovisionador del cliente de NFS en el clúster. Este aprovisionador se encarga de inicializar PersistentVolumes en la instancia de Filestore para respaldar PersistentVolumeClaims.

1. En Cloud Shell, crea una cuenta de servicio para administrar los recursos de NFS:

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

2. Implementa el aprovisionador del cliente de NFS:

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

3. Crea un StorageClass para respaldar PersistentVolumeClaims con volúmenes de NFS:

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

4. Espera a que los pods del aprovisionar del cliente de NFS se registren como Running:

   kubectl get pods --watch
   

   Cuando se estén ejecutando, verás Running en el resultado:

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

Crea los archivos de nodos

Ahora puedes crear un archivo de configuración que IBM Db2 Warehouse necesita para el arranque de cada instancia.

1. En Cloud Shell, crea los archivos 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 que contenga el archivo nodes:

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

Nota: Un requisito conocido de la versión actual de IBM Db2 Warehouse es que cada vez que desees cambiar la topología de la red, por ejemplo, escalarla, debes detener todas las instancias, actualizar el archivo nodes y, luego, reiniciar las instancias. Por lo general, cuando un pod de Kubernetes se reprograma, también cambia la topología de la red. La implementación lo evita mediante los siguientes métodos:

• El uso de la afinidad de nodo. Los pods de IBM Db2 Warehouse se programan solo en los nodos que tienen la etiqueta app=db2wh.
• El uso de la antiafinidad del pod. Solo puede haber un pod de IBM Db2 Warehouse por nodo.
• el uso de redes de host para pods de IBM Db2 Warehouse con el fin de evitar detener y reiniciar todos los pods in en StatefulSet en cada reprogramación de pod.

Implementa pods de IBM Db2 Warehouse

Ahora, crearás todos los pods de GKE que son necesarios para ejecutar IBM Db2 Warehouse.

1. En Cloud Shell, crea PersistentVolumeClaim mediante el siguiente comando. El objeto PersistentVolumeClaim permite que el clúster active el almacenamiento de NFS como un PersistentVolume en varios pods al mismo tiempo.

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

2. Ejecuta un trabajo que copie el archivo nodes en el volumen NFS:

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

3. Verifica si se ejecutó el trabajo de implementación del archivo nodes:

   kubectl get jobs --watch
   

   El trabajo se ejecutó cuando nodes-config se reportó como Successful:

   NAME           DESIRED   SUCCESSFUL   AGE
   nodes-config   1         1            19s
   

4. Implementa un servicio LoadBalancer para permitir el acceso a la Consola del administrador de IBM Db2 Warehouse:

   kubectl apply -f solutions-db2wh/service.yaml
   

5. Espera a que se asigne una dirección IP externa al servicio de balanceador de cargas llamado db2wh-ext:

   kubectl get services --watch
   

   En el resultado, verás una dirección IP para CLUSTER-IP y 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. Implementa StatefulSet para iniciar los pods de IBM Db2 Warehouse:

   kubectl apply -f solutions-db2wh/statefulset.yaml
   

7. Verifica que los pods de IBM Db2 Warehouse (db2wh-0, db2wh-1 y db2wh-2) estén en ejecución:

   kubectl get pods --watch
   

   Esto puede llevar algunos minutos.

   Si ves el estado Running en todos los pods, significa que se están ejecutando.

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

8. Crea una variable de entorno que almacene la dirección IP del nodo que ejecuta el nodo principal de IBM Db2 Warehouse:

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

9. Crea una variable de entorno que almacene el nombre del pod del nodo 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. Comprueba los registros de uno de los pods para garantizar que el proceso de arranque se esté ejecutando sin problemas:

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

    Esto puede llevar entre 40 y 60 minutos, tiempo durante el cual es posible que detectes algunos errores. Puedes ignorarlos en este instructivo.

    Si ves el estado running successfully en el resultado, significa que el proceso se está ejecutando de forma correcta.

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

11. Configura la contraseña de la Consola del administrador:

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

Nota: GKE marca como Ready solo al pod que ejecuta el nodo principal porque solo ese pod ejecuta la Consola del administrador. Los otros pods, incluso si no están marcados como Ready, alojan un nodo de datos.

Prueba la implementación

Terminaste la configuración de los pods, por lo que ahora puedes probar la implementación.

Implementa el contenedor de IBM Db2 Warehouse Client

Ahora, a fin de subir datos a IBM Db2 Warehouse, implementarás el contenedor del Client y le asignarás los datos de muestra con ConfigMap de Kubernetes.

1. En Cloud Shell, crea un ConfigMap que contenga los datos de muestra mediante el siguiente comando:

   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 la Implementación para iniciar el contenedor de IBM Db2 Warehouse Client:

   kubectl apply -f solutions-db2wh/client.yaml
   

3. Verifica que se esté ejecutando el pod de IBM Db2 Warehouse Client:

   kubectl get pods --watch
   

   Esto puede llevar algunos minutos.

   Si ves Running en el estado, entonces el pod se está ejecutando.

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

Sube los datos de muestra

Para ayudarte a probar la implementación, sube datos de muestra al servidor de IBM Db2 Warehouse.

1. En Cloud Shell, muestra la contraseña creada anteriormente mediante este comando:

   echo $DB2_ADMIN_PASSWORD
   

2. Crea una variable de entorno que almacene el nombre del contenedor de IBM Db2 Warehouse Client:

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

3. Abre una ventana de shell en el contenedor cliente:

   kubectl exec -it $CLIENT_CONTAINER_NAME -- cli
   

4. Crea una variable de entorno que almacene la contraseña, en que [PASSWORD] es la contraseña que obtuviste anteriormente en este procedimiento:

   DB_PASSWORD=[PASSWORD]
   

5. Crea una variable de entorno que almacene el alias de la base de datos:

   DB_ALIAS=BLUDB
   

   BLUDB es el nombre de la base de datos predeterminada de IBM Db2 Warehouse.

6. Crea una variable de entorno que almacene el nombre del host de la base de datos:

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

7. Configura el catálogo de la base de datos:

   db_catalog --add $DB_HOST --alias $DB_ALIAS
   

8. Crea una tabla para contener los datos de muestra en el servidor de IBM Db2 Warehouse:

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

9. Sube los datos al servidor de 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. Cierra el shell de IBM Db2 Warehouse Client:

    exit
    

Valida los datos con la Consola del administrador

Ahora, conéctate a la Consola del administrador de IBM Db2 Warehouse y verifica los datos que subiste.

1. En Cloud Shell, busca la dirección IP externa del servicio:

   kubectl get svc db2wh-ext
   

2. Abre un navegador y ve a la siguiente URL, en la cual [EXTERNAL_IP] es la dirección IP del paso anterior:

   https://[EXTERNAL_IP]:8443
   

   Puedes omitir la advertencia de seguridad.

3. Accede con las siguientes credenciales:

   • Nombre de usuario: bluadmin
   • Contraseña: (la que creaste en el procedimiento anterior)

4. Si aceptas el CLUF (Contrato de licencia para el usuario final) de IBM Db2 Warehouse, haz clic en Accept (Aceptar).

5. En el lado izquierdo, abre el menú y luego selecciona Administer > Tablas (Tables):

   

6. Cierra la ventana emergente Recorrido rápido.

7. Haz clic en NYC_FREE_PUBLIC_WIFI:

   

8. Haz clic en la pestaña Data Distribution (Distribución de datos) y asegúrate de que se hayan propagado los datos en la tabla:

   

   Verás 2,871 filas en total, que es el conjunto de datos completo.

9. Haz clic en Generate SQL (Generar SQL).

10. Selecciona SELECT statement (Instrucción SELECT).

11. Haz clic en Aceptar.

    La pestaña Generate SQL se abre y ya está propagada con la declaración SELECT generada de forma automática.

12. Agrega una cláusula LIMIT a la instrucción SELECT generada de forma automática para limitar los resultados a los primeros cinco registros:

    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. Haz clic en Ejecutar (Run) y luego selecciona Run all.

    Aparecerá una lista de registros en la pestaña Result Set para indicar que subiste con éxito los datos de muestra.

    

Limpia

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en este instructivo, borra el proyecto que contiene los recursos o conserva el proyecto y borra los recursos individuales.

Borra el proyecto

Precaución: Borrar un proyecto tiene estas consecuencias:
• Se borra todo en el proyecto. Si utilizaste un proyecto existente para este instructivo, cuando lo borres, también borrarás cualquier otro trabajo que hayas realizado en el proyecto.
• Se pierden los ID personalizados de proyectos. Cuando creaste este proyecto, es posible que hayas creado un ID del proyecto personalizado que desees utilizar en el futuro. Para conservar las URL que utilizan el ID del proyecto, como una URL appspot.com, borra los recursos seleccionados dentro del proyecto en lugar de borrar todo el proyecto.
1. En Cloud Console, ve a la página Administrar recursos.

   Ir a Administrar recursos

2. En la lista de proyectos, elige el proyecto que quieres borrar y haz clic en Borrar.
3. En el diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrar el proyecto.

Próximos pasos

• Lee otros documentos de esta serie:
  • Estrategias de implementación de IBM Db2 Warehouse en Google Cloud (descripción general)
  • Implementa IBM Db2 Warehouse en Google Kubernetes Engine con almacenamiento de GlusterFS
  • Implementación de IBM Db2 Warehouse en Compute Engine con almacenamiento de NFS
  • Implementación de IBM Db2 Warehouse en Compute Engine con almacenamiento de GlusterFS
• Lee acerca de la arquitectura de IBM Db2 Warehouse.
• Lee acerca de los requisitos de IBM Db2 Warehouse.
• Explora arquitecturas de referencia, diagramas, instructivos y prácticas recomendadas sobre Google Cloud. Consulta nuestro Cloud Architecture Center.