Skip to content

Instantly share code, notes, and snippets.

@fjudith

fjudith/h2o-kubeflow_guide_fre.md

Last active November 12, 2018 16:40
Show Gist options
  • Save fjudith/108080886754c328ef7a23d811f1afb5 to your computer and use it in GitHub Desktop.
Save fjudith/108080886754c328ef7a23d811f1afb5 to your computer and use it in GitHub Desktop.
Download ZIP
Guide H2O Kubeflow
Raw
h2o-kubeflow_guide_fre.md

H2O + Kubeflow/Kubernetes How-To

Introduction

Ce guide est une transposition du billet de Nicholas PNG publié le 29 Mars 2018 sur le blog h2o.ai dans la solution coreos-kubernetes

https://blog.h2o.ai/2018/03/h2o-kubeflow-kubernetes-how-to/

Attention: Ksonnet est instable sur Git-Bash pour Windows. Il est recommandé d'exécuter les étapes de ce guide dans WSL (Windows Subsystem for Linux).

Environnement

Minimum Recommandé
4 Virtual core = 2 CPU-core 16 GB RAM + Hyperthreading 8 Virtual core: 4-core 32GB RAM + Hyperthreading
Window 10 Fall Creator Update Window 10 Fall Creator Update
Kubernetes cluster 1.9+ coreos-kubernetes
1 controller (1GB), 1 etcd (512MB), 2 worker (4GB) 3 controller (1GB), 3 etcd (512MB), 3 worker (4GB)
100GB SSD (5 heures) 360GB SSD (permanant)
  • Chocolatey
  • ConEmu
  • Git-For-Windows
  • VirtualBox (n. VMware Workstation/Fusion pour les VMs Multi-CPU)
  • Vagrant (n. Extension payante pour VMware Workstation/Fusion)
  • Docker Client
  • Docker-Machine
  • Docker Compose
  • Kubectl
choco install conemu docker docker-compose docker-machine docker-machine-vmwareworkstation git.install kubernetes-cli vagrant virtualbox

Etapes

  • Télécharger la Vagrant Box CoreOS
  • Installer WSL
  • Installer ksonnet
  • Installer kubectl
  • Télécharger le notebook jupyter H2O
  • Installer H2O-Kubeflow
  • Déployer le Notebook H2O
  • Validation

Télécharger la Box Vagrant CoreOS

Le Notebook Jupyter du projet h2o-kubeflow est trops volumineux pour la Vagrant Box CoreOS. Il est donc nécessaire de télécharger manuellement la box afin de pouvoir redimenssionner le disque.

Procédure pour Virtual Box

PATH=${PATH}:"/c/Program Files/Oracle/VirtualBox/"
PROVIDER='virtualbox'
COREOS_RELEASE='stable'
VERSION='1688.5.3'
vagrant box add coreos-${COREOS_RELEASE} --box-version=${VERSION} https://${COREOS_RELEASE}.release.core-os.net/amd64-usr/${VERSION}/coreos_production_vagrant.json
VBoxManage modifyhd --resize 40960 ~/.vagrant.d/boxes/coreos-${COREOS_RELEASE}/${VERSION}/${PROVIDER}/coreos_production_vagrant_image.vmdk

Procédure pour VMware Workstation/Fusion

PATH=${PATH}:"/c/Program Files (x86)/VMware/VMware Workstation/"
PROVIDER='vmware_fusion'
COREOS_RELEASE='stable'
VERSION='1688.5.3'
vagrant box add coreos-${COREOS_RELEASE} --box-version=${VERSION} https://${COREOS_RELEASE}.release.core-os.net/amd64-usr/${VERSION}/coreos_production_vagrant_${PROVIDER}.json
vmware-vdiskmanager -x 40GB ~/.vagrant.d/boxes/coreos-${COREOS_RELEASE}/${VERSION}/${PROVIDER}/coreos_production_vagrant_${PROVIDER}_image.vmdk

Installer WSL

Attention: Cette Procédue n'est applicable que sur Windows 10 Fall Creators Update

Lancer Windows Powershell en tant qu'Administrateur, puis exécuter la commande suivante:

Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Windows-Subsystem-Linux

Lancer le Microsoft Store, puis instaler Ubuntu.

Une fois Ubuntu installé.

Cliquer le bouton Lancer. Créer le compte Linux, puis exécuter la commande suivante pour mettre à jour la distribution.

sudo apt-get update -y && sudo apt-get upgrade -y

Lancer CMD en tant qu'Administrateur, puis exécuter la ligne de commande suivante pour forcer le démarrage d'Ubuntu en tant que root.

ubuntu config --default-user root

Installer Ksonnet

Lancer Ubuntu, puis exécuter les commandes suivantes pour installer l'outil de déploiement d'applications Kubernetes ks (ksonnet).

KSONNET_VERSION=0.9.2

wget --quiet https://github.com/ksonnet/ksonnet/releases/download/v${KSONNET_VERSION}/ks_${KSONNET_VERSION}_linux_amd64.tar.gz && \
    tar -zvxf ks_${KSONNET_VERSION}_linux_amd64.tar.gz && \
    mv ks_${KSONNET_VERSION}_linux_amd64/ks /usr/local/bin/ks && \
    rm -rf ks_${KSONNET_VERSION}_linux_amd64* && \
    chmod +x /usr/local/bin/ks

Installer Kubectl

Depuis la session de commande Ubuntu, exécuter les commandes suivantes pour installer le client d'administration Kubernetes kubectl.

KUBECTL_VERSION=1.10.0

curl -LO https://storage.googleapis.com/kubernetes-release/release/$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)/bin/linux/amd64/kubectl && \
chmod +x ./kubectl && \
sudo mv ./kubectl /usr/local/bin/kubectl

Initialiser kubectl

pushd ~/git/coreos-kubernetes/multi-node/vagrant && PATH=${PATH}:$(pwd) && source init-kubectl.shpu && popd

Télécharger le notebook Jupyter H2O

Le notebook H2O est particulièrement volumineux. Si ce dernier est téléchargé depuis internet, il y a de fortes chances que l'interface Jupyter retourne une erreur 500 du fait du dépassement du délais d'initialisation.

Il est donc recommandé de télécharger l'image docker sur chacun des noeuds (worker) du cluster Kubernetes manuellement.

Exemple: Cluster coreos-kubernetes à 3 noeuds initialisé avec Vagrant. Lancer git-bash, puis exécuter les commandes suivantes pour télécharger le notebook Juypter H2O

pushd ~/git/coreos-kubernetes/multi-node/vagrant

vagrant ssh w1 -c 'docker pull fjudith/h2o-kubeflow-notebook'
vagrant ssh w2 -c 'docker pull fjudith/h2o-kubeflow-notebook'
vagrant ssh w3 -c 'docker pull fjudith/h2o-kubeflow-notebook'

Installer H2O-Kubeflow

Initialiser H2O

Depuis la session de commande Ubuntu. Lancer les commandes suivantes pour initialiser et installer le bloc de construction H2O-Kubeflow* qui comprend.

  • Jupyterhub: IHM de développement pour les Data Scientists
  • TF-Operator: Opérateur des traitements Tensorflow distribué/non-distribué dans Kubernetes
  • Ambassator: API Gateway pour les microservices déployés dans Kubernetes.
# Github API token with repo/public_repo permissions
export GITHUB_TOKEN=
#

APPNAME="kubeflow-demo"
REGISTRY="github.com/fjudith/h2o-kubeflow/tree/master/h2o-kubeflow"
NAMESPACE=kubeflow
KF_ENV=default
H2O3_IMAGE="quay.io/fjudith/h2o3"

mkdir -p ~/h2oworkspace
pushd ~/h2oworkspace

ks init ${APPNAME}
cd ~/h2oworkspace/${APPNAME}

# add ksonnet registry to app containing all the kubeflow manifests as maintained by Google Kubeflow team
ks registry add kubeflow https://github.com/kubeflow/kubeflow/tree/master/kubeflow
# add ksonnet registry to app containing all the h2o component manifests
ks registry add h2o-kubeflow ${REGISTRY}
ks pkg install kubeflow/core
ks pkg install kubeflow/tf-serving
ks pkg install kubeflow/tf-job
ks pkg install h2o-kubeflow/h2o3-static

kubectl create namespace ${NAMESPACE}
ks generate core kubeflow-core --name="kubeflow-core" --namespace="${NAMESPACE}"
ks env add ${KF_ENV}
# Required only for GKE ks param set kubeflow-core cloud gke --env=cloud
ks apply ${KF_ENV} --component="kubeflow-core"

Valider que tous les Pods sont opérationnels

kubectl get pods --namespace ${NAMESPACE}
NAME                               READY     STATUS    RESTARTS   AGE
ambassador-5798c6798f-k4n76        2/2       Running   1          21h
ambassador-5798c6798f-lxz2w        2/2       Running   1          21h
ambassador-5798c6798f-wzw5c        2/2       Running   1          21h
tf-hub-0                           1/1       Running   0          20h
tf-job-operator-845d5686d4-nhw6k   1/1       Running   0          21h

Valider que les services sont bien en écoute.

kubectl get svc --namespace "${NAMESPACE}"
NAME               TYPE           CLUSTER-IP   EXTERNAL-IP   PORT(S)           AGE
ambassador         ClusterIP      10.3.0.244   <none>        80/TCP            21h
ambassador-admin   ClusterIP      10.3.0.75    <none>        8877/TCP          21h
k8s-dashboard      ClusterIP      10.3.0.52    <none>        443/TCP           21h
tf-hub-0           ClusterIP      None         <none>        8000/TCP          21h
tf-hub-lb          ClusterIP      10.3.0.154   <none>        80/TCP            21h

Déployer le volume persistent pour le notebook H2O

Les notebooks Jupyter requierts un volume de stockage persistent afin d'y stocker les développements.

Exemple: Volume persistent résidant arbitrairement le noeud sélectionné par Kubernetes à l'initialisation du Notebook H2O.

cat << EOF > local-storage-class.yaml
kind: StorageClass
apiVersion: storage.k8s.io/v1
metadata:
  name: local-storage
provisioner: kubernetes.io/no-provisioner
volumeBindingMode: WaitForFirstConsumer
EOF

kubectl apply -f local-storage-class.yaml

cat << EOF > local-volumes.yaml
apiVersion: v1
kind: PersistentVolume
metadata:
  name: local-pv1
  labels:
    type: local
    app: jupyterhub
    heritage: jupyterhub
    hub.jupyter.org/username: admin
spec:
  capacity:
    storage: 10Gi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: /tmp/data/pv1
EOF

kubectl apply -f local-volumes.yaml

Déployer le serveur H2O3

Exécuter les commandes suivantes pour initialiser le serveur H2O3.

ks prototype use io.ksonnet.pkg.h2o3-static h2o3-static \
--name h2o3-static \
--namespace kubeflow \
--memory 1 \
--cpu 1 \
--replicas 2 \
--model_server_image ${H2O3_IMAGE}

ks apply ${KF_ENV} -c h2o3-static -n kubeflow

Déployer le Notebook H2O

Exécuter la commande suivante pour initialiser un proxy vers le Jupyterhub (i.e. pod: tf-hub-0)

kubectl port-forward tf-hub-0 8000:8000 --namespace=${NAMESPACE}

Lancer une session Web vers http://localhost:8000, puis s'authentifier en tant qu'utilisateur admin.

Le mot de passe n'a pas d'importance.

Cliquer sur le bouton Start My Server, compléter le formulaire tels qu'indiqué ci-dessous.

  • Image: quay.io/fjudith/h2o-kubeflow-notebook
  • CPU: 500M
  • Memory: 1Gi
  • Extra Resource Limits: Inchangé

Cliquer sur le bouton Spawn.

Validation

Dans l'interface du notebook Juypter H2O http://localhost:8000/user/admin/tree?. Cliquer sur le bouton New, puis sélectionner Python 3. En haut à gauche, remplacer le nom Untitled par Demo.

Exécuter le code source suivant, en cliquant sur le bouton Run à chaque section.

import h2o
from h2o.automl import H2OAutoML
h2o.init(ip='h2o3-static', port='54321')

train_loc = 'https://storage.googleapis.com/h2o-bq-large-dataset/higgs_train_10k.csv'
test_loc = 'https://storage.googleapis.com/h2o-bq-large-dataset/higgs_test_5k.csv'

train = h2o.import_file(train_loc)
test = h2o.import_file(test_loc)
x = train.columns
y = "response"
x.remove(y)
train[y] = train[y].asfactor()
x = train.columns
y = "response"
x.remove(y)

train[y] = train[y].asfactor()
test[y] = test[y].asfactor()

aml = H2OAutoML(max_runtime_secs = 60)
aml.train(x = x, y = y,
          training_frame = train)
lb = aml.leaderboard
lb
preds = aml.predict(test)
print(preds.shape)
preds

Références

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment