Kubeflow – Workstation Installation

Docs: Kubeflow on Linux

Mon, 01 Jan 0001 00:00:00 +0000

For Linux servers you can install Kubeflow natively using MicroK8s. This is perfect for Linux hosts and virtual machines, such as VMs in OpenStack, VMware or public clouds like GCP, AWS and Azure.

For Linux desktop, you can install Kubeflow with any of the options listed below.

MicroK8s

MicroK8s is a lightweight zero-ops Kubernetes which runs natively on every Linux distribution that supports snaps. MicroK8s is highly available from 3+ nodes and includes a single-command install of Kubeflow.

To get Kubeflow:

Install MicroK8s
Install Kubeflow by running: microk8s enable kubeflow

The full set of instructions are available on the Kubeflow on MicroK8s page.

MiniKF

MiniKF is a Kubeflow appliance, a predefined virtual machine that has Kubeflow already installed. It installs onto VirtualBox through Vagrant. Once the necessary supporting software is installed no further installation steps are required.

The only following applications are required to use MiniKF:

Install Vagrant
Install Virtual Box

Follow the instructions on MiniKF getting started to complete this path.

Minikube

Minikube is a tool for installing a single node Kubernetes in a virtual machine. After starting the virtual machine, you need to install Kubeflow.

Install Minikube

Follow the instructions on Kubeflow on MiniKube to complete this path.

Multipass

Multipass creates a Linux virtual machine on Windows, Mac or Linux systems. The VM contains a complete Ubuntu operating system which can then be used to deploy Kubernetes and Kubeflow.

Install Multipass

Follow instructions on Kubeflow on Multipass to complete this path.

Docs: Kubeflow on macOS

Mon, 01 Jan 0001 00:00:00 +0000

To install Kubeflow locally on a macOS system you have a few options (listed below).

Note: It is recommended that you have at least 12GB of RAM and 50GB of storage available.

MicroK8s

MicroK8s is a lightweight zero-ops Kubernetes which has a native installer for macOS. MicroK8s is highly available from 3+ nodes and includes a single-command install of Kubeflow.

To get Kubeflow:

Install MicroK8s
Install Kubeflow by running: microk8s enable kubeflow

The full set of instructions are available on the Kubeflow on MicroK8s page.

MiniKF

The only following applications are required to use MiniKF:

Install Vagrant
Install Virtual Box

Follow the instructions on MiniKF getting started to complete this path.

Minikube

Minikube is a tool for installing a single node Kubernetes in a virtual machine. After starting the virtual machine, you need to install Kubeflow.

Install Minikube

Follow the instructions on Kubeflow on MiniKube to complete this path.

Multipass

Multipass creates a Linux virtual machine on Windows, macOS or Linux systems. The VM contains a complete Ubuntu operating system which can then be used to deploy Kubernetes and Kubeflow.

Install Multipass

Follow instructions on Kubeflow on Multipass to complete this path.

Docs: Kubeflow on Windows

Mon, 01 Jan 0001 00:00:00 +0000

To install Kubeflow locally on a Windows system you have a few options (listed below).

Note: It is recommended that you have at least 12GB of RAM and 50GB of storage available.

MicroK8s

MicroK8s is a lightweight zero-ops Kubernetes which has a native installer for Windows. MicroK8s is highly available from 3+ nodes and includes a single-command install of Kubeflow.

To get Kubeflow:

Install MicroK8s
Install Kubeflow by running: microk8s enable kubeflow

The full set of instructions are available on the Kubeflow on MicroK8s page.

MiniKF

The only following applications are required to use MiniKF:

Install Vagrant
Install Virtual Box

Follow the instructions on MiniKF getting started to complete this path.

Minikube

Minikube is a tool for installing a single node Kubernetes in a virtual machine. After starting the virtual machine, you need to install Kubeflow.

Install Minikube

Follow the instructions on Kubeflow on MiniKube to complete this path.

Multipass

Multipass creates a Linux virtual machine on Windows, macOS or Linux systems. The VM contains a complete Ubuntu operating system which can then be used to deploy Kubernetes and Kubeflow.

Install Multipass

Follow instructions on Kubeflow on Multipass to complete this path.

Docs: MiniKF

Mon, 01 Jan 0001 00:00:00 +0000

Out of date

This guide contains outdated information pertaining to Kubeflow 1.0. This guide needs to be updated for Kubeflow 1.1.

A production-ready, full-fledged, local Kubeflow deployment that installs in minutes.

MiniKF is a fast and easy way to get started with Kubeflow. With just a few clicks, you are up for experimentation, and for running complete Kubeflow Pipelines.

To train at scale, move to a Kubeflow cloud deployment with one click, without having to rewrite anything.

Please see the official announcement and the rationale behind MiniKF.

Join the discussion on the #minikf Slack channel, ask questions, request features, and get support for MiniKF.

To join the Kubeflow Slack workspace, please request an invite.

System requirements

For a smooth experience we recommend that your system meets the following requirements:

12GB RAM
2 CPUs
50GB disk space

Operating systems

MiniKF runs on all major operating systems:

Linux
macOS
Windows

Prerequisites

Before installing MiniKF, you need to have Vagrant and VirtualBox installed on your laptop.

Install Vagrant
Install Virtual Box

MiniKF installation

Open a terminal on your laptop, create a new directory, switch into it, and run the following commands to install MiniKF:

vagrant init arrikto/minikf
vagrant up

MiniKF will take a few minutes to boot. When this is done, navigate to http://10.10.10.10 and follow the on-screen instructions to start Kubeflow and Rok.

MiniKF upgrade

Here are step-by-step instructions for upgrading from a previous version:

Upgrade the MiniKF box to the latest version:

vagrant box update

Ensure you have updated to the latest version:

vagrant box list

Upgrade the vagrant-persistent-storage plugin to v0.0.47 or later:

vagrant plugin update vagrant-persistent-storage

Destroy the VM:

vagrant destroy

Remove all local state. This will remove all of your customization in MiniKF (notebooks, pipelines, Rok snapshots):
- [Windows] del minikf-user-data.vdi
- [Linux/macOS] rm minikf-user-data.vdi
Re-create your VM:

vagrant up

End-to-end example on MiniKF

Notebooks & Kubeflow Pipelines on the new MiniKF. Run an e2e ML pipeline following this tutorial.

Installation video

Here is a demo of installing MiniKF from scratch:

Docs: Deploy Kubeflow using MiniKF on Google Cloud

Mon, 01 Jan 0001 00:00:00 +0000

This guide describes how to launch a MiniKF virtual machine (VM) on Google Cloud. MiniKF is a single VM solution on the Google Cloud Marketplace, and installs:

Kubernetes (using Minikube)
Kubeflow
Kale, a tool to convert general purpose Jupyter Notebooks to Kubeflow Pipelines workflows (GitHub)
Arrikto’s Rok, a data management software for data versioning and reproducibility

MiniKF supports NVIDIA GPUs.

Before you start

Before installing MiniKF, make sure that your Google Cloud project meets the minimum requirements described below:

Select or create a project on the Google Cloud Console.
Make sure that you have the editor role role for the project. You can add a member to a project and grant them a Cloud IAM role using the Cloud Console.
Make sure that billing is enabled for your project. For more info, see the Modify a Project’s Billing Settings guide.
If you are using the Google Cloud Free Tier or the 12-month trial period with $300 credit, note that you can’t run the default Google Cloud installation of MiniKF, because the free tier does not offer enough resources. You need to upgrade to a paid account.
Read the Google Cloud guide to resource quotas to understand the quotas on resource usage that Compute Engine enforces, and to learn how to check your quota and how to request an increase in quota.

Installing MiniKF on Google Cloud

To install MiniKF on Google Cloud, follow the steps below:

Go to the MiniKF page on Google Cloud Marketplace.
Click on the LAUNCH button
In the Configure & Deploy window, choose:

Deployment name: a name for your MiniKF instance
Zone: the Google Cloud zone that you will deploy MiniKF
Machine type: a machine type with at least 2 vCPUs and 16 GB of RAM. If in doubt, use the default machine type, n1–standard-8, which has 8 vCPUs and 30 GB of RAM.
Boot Disk: a boot disk. This is the disk that holds the images that MiniKF needs. Use the default value of 200 GB SSD Persistent Disk.
Data Disk: a data disk. This is the disk that holds your snapshots. Use an SSD Persistent Disk of at least 500 GB capacity.
GPUs: add one or more GPUs if you are running computationally intensive ML workloads.

Then click Deploy:

Now wait for the VM to boot.
When the VM is up, ensure that MiniKF is up and running. Before visiting the MiniKF dashboard, ensure that Minikube, Kubeflow, and Rok (Snapshot Store) are up and running. To do so, click on the SSH button to connect to the MiniKF VM and follow the on-screen instructions.
MiniKF dashboard, username, and password. Now that Minikube, Kubeflow, and Rok are up-and-running, close the SSH browser window, as you will not need it anymore. On your current view, please find the MiniKF dashboard URL, MiniKF username, and MiniKF password. You will need them to log in to Kubeflow and Rok. You should see a table like the one below:
Log in to MiniKF. Visit the MiniKF dashboard URL and log in to MiniKF using the MiniKF username and password.

Once you log in, you will see the Central Dashboard

Congratulations! You have successfully deployed MiniKF on Google Cloud. You can now create notebooks, write your ML code, and run Kubeflow Pipelines.

Docs: Deploying with minikube on a single node

Mon, 01 Jan 0001 00:00:00 +0000

This guide covers the installation of minikube and Kubeflow in a single-node Ubuntu system. minikube provides a single-node Kubernetes cluster, making it easy to learn and and develop for Kubernetes.

The guide covers the following topics:

installation of docker-community edition (docker-ce), kubectl, and Minikube
installation of Kubeflow
launch of Kubeflow central dashboard
execution of an MNIST on-prem notebook

Prerequisites

Ubuntu 18 machine with min 8 cores, 16GB RAM, 250GB storage
Root privileges on a Ubuntu machine

Installation of Docker CE, kubectl, and Minikube

Minikube provides a no-driver mode based on Docker without requiring a hypervisor.

Install Docker CE

Run the following commands to install Docker CE:

apt-get update
apt-get install -y apt-transport-https ca-certificates curl software-properties-common
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | apt-key add -
add-apt-repository \
   "deb [arch=amd64] https://download.docker.com/linux/ubuntu \
   $(lsb_release -cs) \
   stable"
apt-get update
apt-get install docker-ce docker-ce-cli containerd.io

To verify your installation, run:

docker run hello-world

The expected output looks like this:

Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
1b930d010525: Pull complete                                                                                        Digest: sha256:fc6a51919cfeb2e6763f62b6d9e8815acbf7cd2e476ea353743570610737b752
Status: Downloaded newer image for hello-world:latest

Hello from Docker!
This message shows that your installation appears to be working correctly.

Install kubectl

kubectl is a Kubernetes command-line tool that allows you to run commands against Kubernetes clusters. The following instructions install version 1.15 of kubectl. If you are looking for a specific version, see the kubectl installation guide.

curl -LO https://storage.googleapis.com/kubernetes-release/release/v1.15.0/bin/linux/amd64/kubectl
chmod +x ./kubectl
mv ./kubectl /usr/local/bin/kubectl

Install minikube

Run the command lines below to install the latest version of minikube. If you are looking for a specific version, refer to the Kubernetes: minikube releases page.

 curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
 sudo install minikube-linux-amd64 /usr/local/bin/minikube

Start minikube

You can launch minikune with the minikube start command. For example, if you want to specify 6 CPUs, 12288 memory, 120G disk size:

minikube start --cpus 6 --memory 12288 --disk-size=120g --extra-config=apiserver.service-account-issuer=api --extra-config=apiserver.service-account-signing-key-file=/var/lib/minikube/certs/apiserver.key --extra-config=apiserver.service-account-api-audiences=api

Installation of Kubeflow

Follow these steps to install Kubeflow:

Download the kfctl v1.1.0 release from the Kubeflow releases page.
Extract the zipped TAR file:
```
tar -xvf {KFCTL_TAR_GZ_FILE}
```
where {KFCTL_TAR_GZ_FILE} should be replaced with the name of the kfctl release file you have just downloaded.

Run the commands below to set up and deploy Kubeflow. One of them includes an optional command to add the binary kfctl to your path. If you don’t add the binary to your path, you must use the full path to the kfctl binary each time you run it.

# The following command is optional making the kfctl binary easier to use.
export PATH=$PATH:<path to where kfctl was unpacked>

# Set KF_NAME to the name of your Kubeflow deployment. This also becomes the
# name of the directory containing your configuration.
# For example, your deployment name can be 'my-kubeflow' or 'kf-test'.
export KF_NAME=<your choice of name for the Kubeflow deployment>

# Set the path to the base directory where you want to store one or more 
# Kubeflow deployments. For example, /opt/.
# Then set the Kubeflow application directory for this deployment.
export BASE_DIR=<path to a base directory>
export KF_DIR=${BASE_DIR}/${KF_NAME}

# Set the configuration file to use, such as the file specified below:
export CONFIG_URI="https://raw.githubusercontent.com/kubeflow/manifests/v1.1-branch/kfdef/kfctl_k8s_istio.v1.1.0.yaml"

# Generate and deploy Kubeflow:
mkdir -p ${KF_DIR}
cd ${KF_DIR}
kfctl apply -V -f ${CONFIG_URI}

${KF_NAME} - The name of your Kubeflow deployment. If you want a custom deployment name, specify that name here. For example, my-kubeflow or kf-test. The value of KF_NAME must consist of lower case alphanumeric characters or ‘-’, and must start and end with an alphanumeric character. The value of this variable cannot be greater than 25 characters. It must contain just a name, not a directory path. This value also becomes the name of the directory where your Kubeflow configurations are stored, that is, the Kubeflow application directory.
${KF_DIR} - The full path to your Kubeflow application directory.

The following example installs Kubeflow v1.0.0 under the /root/kubeflow/v1.0 directory:

mkdir -p /root/kubeflow/v1.0
cd /root/kubeflow/v1.0
wget https://github.com/kubeflow/kfctl/releases/download/v1.0/kfctl_v1.0-0-g94c35cf_linux.tar.gz

tar -xvf kfctl_v1.0-0-g94c35cf_linux.tar.gz			
export PATH=$PATH:/root/kubeflow/v1.0
export KF_NAME=my-kubeflow
export BASE_DIR=/root/kubeflow/v1.0
export KF_DIR=${BASE_DIR}/${KF_NAME}
export CONFIG_URI="https://raw.githubusercontent.com/kubeflow/manifests/v1.1-branch/kfdef/kfctl_k8s_istio.v1.1.0.yaml" 

mkdir -p ${KF_DIR}
cd ${KF_DIR}
kfctl apply -V -f ${CONFIG_URI}

After the installation, run the following command to check whether all the pods are in running status:

kubectl get pod -n kubeflow

It may take a few minutes to reach full running status.

Expected output:

NAME                                                           READY   STATUS      RESTARTS   AGE
admission-webhook-bootstrap-stateful-set-0                     1/1     Running     0          10m
admission-webhook-deployment-64cb96ddbf-w7ptd                  1/1     Running     0        9m33s
application-controller-stateful-set-0                          1/1     Running     0          13m
argo-ui-778676df64-kjw6s                                       1/1     Running     0          10m
centraldashboard-7dd7dd685d-hvll8                              1/1     Running     0          10m
jupyter-web-app-deployment-89789fd5-cjkwf                      1/1     Running     0          10m
katib-controller-6b789b6cb5-kgzv8                              1/1     Running     1          10m
katib-db-manager-64f548b47c-sszv9                              1/1     Running     3        9m59s
katib-mysql-57884cb488-d4qt2                                   1/1     Running     0        9m59s
katib-ui-5c5cc6bd77-2kqvc                                      1/1     Running     0        9m59s
kfserving-controller-manager-0                                 2/2     Running     1          10m
metacontroller-0                                               1/1     Running     0          10m
metadata-db-76c9f78f77-7r8vb                                   0/1     Running     1          10m
metadata-deployment-674fdd976b-hzmzx                           0/1     Running     0          10m
metadata-envoy-deployment-5688989bd6-rqtrk                     1/1     Running     0          10m
metadata-grpc-deployment-5579bdc87b-xx9fk                      1/1     Running     6          10m
metadata-ui-9b8cd699d-scs9d                                    1/1     Running     0          10m
minio-755ff748b-lxsb6                                          1/1     Running     0        9m55s
ml-pipeline-79b4f85cbc-8tjff                                   1/1     Running     0        9m55s
ml-pipeline-ml-pipeline-visualizationserver-5fdffdc5bf-zsngc   1/1     Running     0        9m42s
ml-pipeline-persistenceagent-645cb66874-b465h                  1/1     Running     0        9m54s
ml-pipeline-scheduledworkflow-6c978b6b85-cffng                 1/1     Running     0        9m42s
ml-pipeline-ui-6995b7bccf-s642q                                1/1     Running     0        9m45s
ml-pipeline-viewer-controller-deployment-8554dc7b9f-vgw9r      1/1     Running     0        9m44s
mysql-598bc897dc-lsmqc                                         1/1     Running     0        9m54s
notebook-controller-deployment-7db57b9ccf-vw9vw                1/1     Running     0          10m
profiles-deployment-5d87dd4f87-7gfrj                           2/2     Running     0        9m41s
pytorch-operator-5fd5f94bdd-kfgvp                              1/1     Running     2          10m
seldon-controller-manager-679fc777cd-4n229                     1/1     Running     0        9m39s
spark-operatorcrd-cleanup-kxr7g                                0/2     Completed   0          10m
spark-operatorsparkoperator-c7b64b87f-cfptj                    1/1     Running     0          10m
spartakus-volunteer-6b767c8d6-4v6hc                            1/1     Running     0          10m
tensorboard-6544748d94-8ctk8                                   1/1     Running     0          10m
tf-job-operator-7d7c8fb8bb-xz5pw                               1/1     Running     1          10m
workflow-controller-945c84565-57c72                            1/1     Running     0          10m

Launch of Kubeflow central dashboard

You can access the Kubeflow dashboard using the istio-ingressgateway service. To check your settings for istio-ingressgateway, execute the following commands:

export INGRESS_HOST=$(minikube ip)
export INGRESS_PORT=$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.spec.ports[?(@.name=="http2")].nodePort}')

Then you can access the Kubeflow dashboard in a web browser:

http://<INGRESS_HOST>:<INGRESS_PORT>

Running the MNIST on-prem Jupyter notebook

The MNIST on-prem notebook builds a Docker image, launches a TFJob to train a model, and creates an InferenceService (KFServing) to deploy the trained model.

Prerequisites

Step 1: Set up Python environment

You need Python 3.5 or later:

apt-get update; apt-get install -y wget bzip2
wget https://repo.continuum.io/miniconda/Miniconda3-latest-Linux-x86_64.sh
bash Miniconda3-latest-Linux-x86_64.sh

Re-open your current shell.

Create a Python 3.7 environment named mlpipeline (or any name that you prefer):

conda create --name mlpipeline python=3.7
conda init
conda activate mlpipeline

Step 2: Install Jupyter Notebooks

Run the following command to install Jupyter Notebooks:

pip install --upgrade pip
pip install jupyter

You can find the full instructions in the Jupyter documentation.

Step 3: Create a Docker ID

In order to build Docker images from your notebook, you need a Docker registry to store the images. If you don’t have a Docker ID, follow the Docker documentation to create one.

Step 4: Create a namespace to run the MNIST on-prem notebook

The following commands create a namespace called mnist. You can use any name you like:

kubectl create ns mnist
kubectl label namespace mnist serving.kubeflow.org/inferenceservice=enabled

Step 5: Download the MNIST on-prem notebook

Run the following commands to download the notebook:

cd /root/kubeflow
git clone https://github.com/kubeflow/fairing.git

Launch Jupyter Notebook

Run the following commands to launch a Jupyter Notebooks server:

cd /root/kubeflow/fairing/examples/mnist
conda activate mlpipeline
docker login
jupyter notebook --allow-root

Your output should be similar to this:

[I 21:17:37.473 NotebookApp] Writing notebook server cookie secret to /root/.local/share/jupyter/runtime/notebook_cookie_secret
[I 21:17:37.784 NotebookApp] Serving notebooks from local directory: /root/kubeflow/fairing/examples/mnist
[I 21:17:37.784 NotebookApp] The Jupyter Notebook is running at:
[I 21:17:37.784 NotebookApp] http://localhost:8888/?token=06cd43860cb7cb214bba30028d4b93f9f1acb08e3121ee13
[I 21:17:37.784 NotebookApp]  or http://127.0.0.1:8888/?token=06cd43860cb7cb214bba30028d4b93f9f1acb08e3121ee13
[I 21:17:37.784 NotebookApp] Use Control-C to stop this server and shut down all kernels (twice to skip confirmation).
[W 21:17:37.789 NotebookApp] No web browser found: could not locate runnable browser.
[C 21:17:37.789 NotebookApp]

    To access the notebook, open this file in a browser:
        file:///root/.local/share/jupyter/runtime/nbserver-16796-open.html
    Or copy and paste one of these URLs:
        http://localhost:8888/?token=06cd43860cb7cb214bba30028d4b93f9f1acb08e3121ee13
     or http://127.0.0.1:8888/?token=06cd43860cb7cb214bba30028d4b93f9f1acb08e3121ee13

See the hints and tips section to learn how to access the notebook user interface (UI) remotely.

Execute MNIST on-prem notebook

After launching Jupyter Notebooks, click mnist_e2e_on_prem.ipynb to open the notebook. Take the following steps before running the notebook:

Under Configure The Docker Registry For Kubeflow Fairing, modify the cell to use your Docker ID and namespace created above.
```
   DOCKER_REGISTRY = 'index.docker.io/<your Docker ID>'
   my_namespace = 'mnist'
```
The MNIST on-prem notebook assumes that an NFS server is available or an existing persistent volume (PV) and persistent volume claim (PVC) is created. The NFS server is not installed with Minikube. If you don’t have an NFS server and don’t have any existing PV and PVC, you can instruct the notebook to create a PV and PVC by making the following change:

Under Create PV/PVC to Store The Exported Model:
1. In the first cell, comment out nfs_server and nfs_path:
```
# nfs_server = '172.16.189.69'
# nfs_path = '/opt/kubeflow/data/mnist'
pv_name = 'mnist-e2e-pv'
pvc_name = 'mnist-e2e-pvc'
```
1. In the second cell, change the nfs section to hostPath:
```
nfs:
  path: {nfs_path}
  server: {nfs_server}
```
  to
```
hostPath:
  path: /mnt/data
```

Hints and tips

Access a Jupyter Notebook UI remotely

If your Jupyter Notebooks server is hosted in a Linux machine and you want to access a notebook UI from your Windows/Mac machine, you can use the following port forwarding technique:

General syntax for port forwarding from XXXX to YYYY:

ssh -N -f -L localhost:YYYY:localhost:XXXX remoteuser@remotehost

Below is an example of accessing a Jupyter notebook hosted in a Linux machine, remotehost.com (port 8888), in a Windows machine using port 8889.

In the Windows machine, issue the following command:
```
ssh -N -f -L localhost:8889:localhost:8888 root@remotehost.com
```
Enter a password when prompted to access remotehost.com
In the Windows machine, open a web browser and enter the following URL:
```
localhost:8889
```

TroubleShooting

AttributeError when create namespace object

When using Kubeflow Fairing to build a Docker image and launch a training job (part of the notebook), you may see the following error:

AttributeError: 'V1TFJob' object has no attribute 'openapi_types'

This is caused by an existing issue in Kubernetes client API.

To bypass this issue, install Kubernetes Client API version 10.0.1:

pip install kubernetes==10.0.1

Docs: Kubeflow on MicroK8s

Mon, 01 Jan 0001 00:00:00 +0000

Introduction

This guide describes how to deploy and run Kubeflow using MicroK8s - a small enterprise Kubernetes cluster — locally on built-in hypervisors.

MicroK8s is available on Windows, macOS and any Linux distribution that supports Snaps. You can download and install MicroK8s by following the installation steps on the official website.

Alternatively, you can install MicroK8s on a Linux appliance with Multipass, which gives you a disposable Ubuntu command line on Windows, macOS or Linux. Refer to the official documentation for more details.

Installing and enabling Kubeflow using MicroK8s

To get Kubeflow running using MicroK8s, you’ll need to install MicroK8s, enable basic services, and then enable Kubeflow.

Note: You need MicroK8s version 1.18 and above to enable and run Kubeflow.

Install MicroK8s with Snap by running the following command:
```
sudo snap install microk8s --classic
```
Verify that MicroK8s is running:
```
microk8s status --wait-ready
```
Having installed MicroK8s, you can now enable common services on your MicroK8s deployment. To do that, run the following command:
```
microk8s enable dns dashboard storage
```
Optional: To enable NVIDIA GPU hardware support, also run microk8s enable gpu.
Deploy Kubeflow by running this command:
```
microk8s enable kubeflow
```
The deployment process may take a few minutes. Once it is complete, the script will print out the port number and credentials to access the Kubeflow dashboard.

Accessing the Kubeflow dashboard

On your Linux machine

If you installed MicroK8s directly on your Linux machine, you can view the Kubeflow dashboard as follows:

Open a web browser window.
Access the link provided after you have enabled Kubeflow (for example, 10.64.140.43.xip.io).

On Windows, macOS, Multipass or a virtual machine

When running MicroK8s on Windows, macOS, Multipass or a virtual machine, you need to create a SOCKS proxy to access the Kubeflow dashboard:

Logout from the current session in your terminal using the exit command.
Re-establish connection to the machine using SSH, enabling SOCKS proxy with the -D9999 parameter.

In the VM case, run the following command, where <machine_public_ip> is your machine’s public IP:
```
ssh -D9999 ubuntu@<machine_public_ip>
```
On Windows, macOS or Multipass, you can check for the IP first with:
```
multipass list`
```
and then, run this command, replacing <multipass_public_ip> with that IP:
```
ssh -D9999 multipass@<multipass_public_ip>
```
In your host operating system, go to Settings > Network > Network Proxy, and enable SOCKS proxy pointing to: 127.0.0.1:9999.
Finally, access the Kubeflow dashboard by:
1. Opening a new web browser window.
2. Accessing the link provided after you have enabled Kubeflow (for example, 10.64.140.43.xip.io).

Additional guides

MicroK8s: troubleshooting
Multipass: documentation
Kubeflow: documentation
Kubeflow components: documentation
Jupyter notebooks in Kubeflow: documentation