docs/en-jupyter_notebook/azure_aks/05_deploy_containers_to_turtlebot3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5 deploy containers to turtlebot3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "change ${CORE_ROOT} to your path of `core`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "export CORE_ROOT=\"${HOME}/core\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "change ${PJ_ROOT} to your path of `example-turtlebot3`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "export PJ_ROOT=\"${HOME}/example-turtlebot3\"\n",
    "cd ${PJ_ROOT};pwd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "example)\n",
    "```\n",
    "/Users/user/example-turtlebot3\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## load environment variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "load from `core`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "source ${CORE_ROOT}/docs/environments/azure_aks/env"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "load from `example-turtlebot3`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "source ${PJ_ROOT}/docs/environments/azure_aks/env"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## setup alias"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if [ \"$(uname)\" == 'Darwin' ]; then\n",
    "  alias b64='base64 '\n",
    "elif [ \"$(expr substr $(uname -s) 1 5)\" == 'Linux' ]; then\n",
    "  alias b64='base64 -w 0 '\n",
    "else\n",
    "  echo \"Your platform ($(uname -a)) is not supported.\"\n",
    "  exit 1\n",
    "fi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## set private registry to turtlebot3's minikube"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### create service principal of Azure ACR"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* if service principal already exists, delete it before creating service principal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "EXIST_ACR_ID=$(az ad sp list --display-name ${ACR_NAME}sp --query \"[0].appId\" -o tsv)\n",
    "az ad sp delete --id ${EXIST_ACR_ID}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ACR_ID=$(az acr show --resource-group ${AKS_RG} --name ${ACR_NAME} --query \"id\" --output tsv)\n",
    "az ad sp create-for-rbac --scopes ${ACR_ID} --role Reader --name ${ACR_NAME}sp > /tmp/acrsp\n",
    "export ACR_USERNAME=$(cat /tmp/acrsp | jq .appId -r);echo \"ACR_USERNAME=${ACR_USERNAME}\"\n",
    "export ACR_PASSWORD=$(cat /tmp/acrsp | jq .password -r);echo \"ACR_PASSWORD=${ACR_PASSWORD}\"\n",
    "rm /tmp/acrsp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### set Azure ACR as private registry"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "echo \"kubectl create secret docker-registry ${ACR_NAME} --docker-server ${ACR_NAME}.azurecr.io --docker-email ${EMAIL} --docker-username ${ACR_USERNAME} --docker-password ${ACR_PASSWORD}\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **create secret to turtlebot3's minikube using above command**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## create the docker base image of remote deploy tool"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "docker run --name remote_deployer -v ${PJ_ROOT}:${PJ_ROOT} -w ${PJ_ROOT} python:3.7-alpine pip install -r ${PJ_ROOT}/tools/requirements.txt\n",
    "docker commit remote_deployer example_turtlebot3:0.0.1\n",
    "docker rm remote_deployer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## prepare turtlebot3\n",
    "You have to setup common procedure at first. And then, you have to setup either turtlebot3_simulator (A.) or actual turtlebot3 robot (B.)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### common procedure: deploy ros-master"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "docker build -t ${REPOSITORY}/roboticbase/ros-master:0.2.0 ros/ros-master"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "az acr login --name ${ACR_NAME}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "docker push ${REPOSITORY}/roboticbase/ros-master:0.2.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### apply Service"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "TOKEN=$(cat ${CORE_ROOT}/secrets/auth-tokens.json | jq '.[0].settings.bearer_tokens[0].token' -r)\n",
    "docker run -it --rm -v ${PJ_ROOT}:${PJ_ROOT} -w ${PJ_ROOT} example_turtlebot3:0.0.1 \\\n",
    "  ${PJ_ROOT}/tools/deploy_yaml.py ${PJ_ROOT}/ros/ros-master/yaml/ros-master-service.yaml https://api.${DOMAIN} ${TOKEN} ${FIWARE_SERVICE} ${DEPLOYER_SERVICEPATH} ${DEPLOYER_TYPE} ${DEPLOYER_ID}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* check minikube of turtlebot3\n",
    "\n",
    "```bash\n",
    "turtlebot3@turtlebot3:~$ kubectl get services -l app=ros-master\n",
    "NAME         TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)     AGE\n",
    "ros-master   ClusterIP   None         <none>        11311/TCP   2m\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### apply Deployment "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "envsubst < ${PJ_ROOT}/ros/ros-master/yaml/ros-master-deployment-acr.yaml > /tmp/ros-master-deployment-acr.yaml\n",
    "TOKEN=$(cat ${CORE_ROOT}/secrets/auth-tokens.json | jq '.[0].settings.bearer_tokens[0].token' -r)\n",
    "docker run -it --rm -v ${PJ_ROOT}:${PJ_ROOT} -v /tmp:/tmp -w ${PJ_ROOT} example_turtlebot3:0.0.1 \\\n",
    "  ${PJ_ROOT}/tools/deploy_yaml.py /tmp/ros-master-deployment-acr.yaml https://api.${DOMAIN} ${TOKEN} ${FIWARE_SERVICE} ${DEPLOYER_SERVICEPATH} ${DEPLOYER_TYPE} ${DEPLOYER_ID}\n",
    "rm /tmp/ros-master-deployment-acr.yaml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* check minikube of turtlebot3\n",
    "\n",
    "```bash\n",
    "turtlebot3@turtlebot3:~$ kubectl get deployments -l app=ros-master\n",
    "NAME         READY   UP-TO-DATE   AVAILABLE   AGE\n",
    "ros-master   1/1     1            1           17s\n",
    "```\n",
    "\n",
    "```bash\n",
    "turtlebot3@turtlebot3:~$ kubectl get pods -l app=ros-master\n",
    "NAME                         READY     STATUS    RESTARTS   AGE\n",
    "ros-master-b479df4b5-2wq74   1/1       Running   0          22s\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### confirm log"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```bash\n",
    "turtlebot3@turtlebot3:~$ kubectl logs -f $(kubectl get pods -l app=ros-master -o template --template \"{{(index .items 0).metadata.name}}\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### common procedure:  deploy fiware-ros-bridge"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### build container image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "export BRIDGE_GIT_REV=\"0.3.0\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "docker build -t ${REPOSITORY}/roboticbase/fiware-ros-bridge:${BRIDGE_GIT_REV} ros/fiware-ros-bridge"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "az acr login --name ${ACR_NAME}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "docker push ${REPOSITORY}/roboticbase/fiware-ros-bridge:${BRIDGE_GIT_REV}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### apply Secret"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "export MQTT_YAML_BASE64=$(cat << __EOS__ | envsubst | b64\n",
    "mqtt:\n",
    "  host: \"mqtt.${DOMAIN}\"\n",
    "  port: 8883\n",
    "  username: \"ros\"\n",
    "  password: \"${MQTT__ros}\"\n",
    "  use_ca: true\n",
    "__EOS__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "envsubst < ${PJ_ROOT}/ros/fiware-ros-bridge/yaml/fiware-ros-bridge-secret.yaml > /tmp/fiware-ros-bridge-secret.yaml\n",
    "TOKEN=$(cat ${CORE_ROOT}/secrets/auth-tokens.json | jq '.[0].settings.bearer_tokens[0].token' -r)\n",
    "docker run -it --rm -v ${PJ_ROOT}:${PJ_ROOT} -v /tmp:/tmp -w ${PJ_ROOT} example_turtlebot3:0.0.1 \\\n",
    "  ${PJ_ROOT}/tools/deploy_yaml.py /tmp/fiware-ros-bridge-secret.yaml https://api.${DOMAIN} ${TOKEN} ${FIWARE_SERVICE} ${DEPLOYER_SERVICEPATH} ${DEPLOYER_TYPE} ${DEPLOYER_ID}\n",
    "rm /tmp/fiware-ros-bridge-secret.yaml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* check minikube of turtlebot3\n",
    "\n",
    "```bash\n",
    "turtlebot3@turtlebot3:~$ kubectl get secrets -l app=ros-bridge\n",
    "NAME                 TYPE      DATA      AGE\n",
    "ros-bridge-secrets   Opaque    1         35m\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### apply ConfigMap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "envsubst < ${PJ_ROOT}/ros/fiware-ros-bridge/yaml/fiware-ros-bridge-configmap.yaml > /tmp/fiware-ros-bridge-configmap.yaml\n",
    "TOKEN=$(cat ${CORE_ROOT}/secrets/auth-tokens.json | jq '.[0].settings.bearer_tokens[0].token' -r)\n",
    "docker run -it --rm -v ${PJ_ROOT}:${PJ_ROOT} -v /tmp:/tmp -w ${PJ_ROOT} example_turtlebot3:0.0.1 \\\n",
    "  ${PJ_ROOT}/tools/deploy_yaml.py /tmp/fiware-ros-bridge-configmap.yaml https://api.${DOMAIN} ${TOKEN} ${FIWARE_SERVICE} ${DEPLOYER_SERVICEPATH} ${DEPLOYER_TYPE} ${DEPLOYER_ID}\n",
    "rm /tmp/fiware-ros-bridge-configmap.yaml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* check minikube of turtlebot3\n",
    "\n",
    "```bash\n",
    "turtlebot3@turtlebot3:~$ kubectl get configmaps -l app=ros-bridge\n",
    "NAME                    DATA      AGE\n",
    "ros-bridge-configmaps   2         33m\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### apply Service"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "TOKEN=$(cat ${CORE_ROOT}/secrets/auth-tokens.json | jq '.[0].settings.bearer_tokens[0].token' -r)\n",
    "docker run -it --rm -v ${PJ_ROOT}:${PJ_ROOT} -w ${PJ_ROOT} example_turtlebot3:0.0.1 \\\n",
    "  ${PJ_ROOT}/tools/deploy_yaml.py ${PJ_ROOT}/ros/fiware-ros-bridge/yaml/fiware-ros-bridge-service.yaml https://api.${DOMAIN} ${TOKEN} ${FIWARE_SERVICE} ${DEPLOYER_SERVICEPATH} ${DEPLOYER_TYPE} ${DEPLOYER_ID}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* check minikube of turtlebot3\n",
    "\n",
    "```bash\n",
    "turtlebot3@turtlebot3:~$ kubectl get services -l app=ros-bridge\n",
    "NAME         TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)     AGE\n",
    "ros-bridge   ClusterIP   None         <none>        11311/TCP   33m\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### apply Deployment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "envsubst < ${PJ_ROOT}/ros/fiware-ros-bridge/yaml/fiware-ros-bridge-deployment-acr.yaml > /tmp/fiware-ros-bridge-deployment-acr.yaml\n",
    "TOKEN=$(cat ${CORE_ROOT}/secrets/auth-tokens.json | jq '.[0].settings.bearer_tokens[0].token' -r)\n",
    "docker run -it --rm -v ${PJ_ROOT}:${PJ_ROOT} -v /tmp:/tmp -w ${PJ_ROOT} example_turtlebot3:0.0.1 \\\n",
    "  ${PJ_ROOT}/tools/deploy_yaml.py /tmp/fiware-ros-bridge-deployment-acr.yaml https://api.${DOMAIN} ${TOKEN} ${FIWARE_SERVICE} ${DEPLOYER_SERVICEPATH} ${DEPLOYER_TYPE} ${DEPLOYER_ID}\n",
    "rm /tmp/fiware-ros-bridge-deployment-acr.yaml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* check minikube of turtlebot3\n",
    "\n",
    "```bash\n",
    "turtlebot3@turtlebot3:~$ kubectl get deployments -l app=ros-bridge\n",
    "NAME         READY   UP-TO-DATE   AVAILABLE   AGE\n",
    "ros-bridge   1/1     1            1           5s\n",
    "```\n",
    "\n",
    "```bash\n",
    "turtlebot3@turtlebot3:~$ kubectl get pods -l app=ros-bridge\n",
    "NAME                          READY     STATUS    RESTARTS   AGE\n",
    "ros-bridge-7fdcdc7558-j66ng   1/1       Running   0          31m\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### confirm log"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```bash\n",
    "turtlebot3@turtlebot3:~$ kubectl logs -f $(kubectl get pods -l app=ros-bridge -o template --template \"{{(index .items 0).metadata.name}}\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### common procedure:  deploy fiware-ros-turtlebot3-operator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### build container image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "export OPERATOR_GIT_REV=\"0.3.0\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "docker build -t ${REPOSITORY}/roboticbase/fiware-ros-turtlebot3-operator:${OPERATOR_GIT_REV} ros/fiware-ros-turtlebot3-operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "az acr login --name ${ACR_NAME}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "docker push ${REPOSITORY}/roboticbase/fiware-ros-turtlebot3-operator:${OPERATOR_GIT_REV}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### apply ConfigMap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "TOKEN=$(cat ${CORE_ROOT}/secrets/auth-tokens.json | jq '.[0].settings.bearer_tokens[0].token' -r)\n",
    "docker run -it --rm -v ${PJ_ROOT}:${PJ_ROOT} -w ${PJ_ROOT} example_turtlebot3:0.0.1 \\\n",
    "  ${PJ_ROOT}/tools/deploy_yaml.py ${PJ_ROOT}/ros/fiware-ros-turtlebot3-operator/yaml/fiware-ros-turtlebot3-operator-configmap.yaml https://api.${DOMAIN} ${TOKEN} ${FIWARE_SERVICE}     ${DEPLOYER_SERVICEPATH} ${DEPLOYER_TYPE} ${DEPLOYER_ID}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* check minikube of turtlebot3\n",
    "\n",
    "```bash\n",
    "turtlebot3@turtlebot3:~$ kubectl get configmaps -l app=turtlebot3-operator\n",
    "NAME                             DATA      AGE\n",
    "turtlebot3-operator-configmaps   1         18s\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### apply Service"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "TOKEN=$(cat ${CORE_ROOT}/secrets/auth-tokens.json | jq '.[0].settings.bearer_tokens[0].token' -r)\n",
    "docker run -it --rm -v ${PJ_ROOT}:${PJ_ROOT} -v /tmp:/tmp -w ${PJ_ROOT} example_turtlebot3:0.0.1 \\\n",
    "  ${PJ_ROOT}/tools/deploy_yaml.py ${PJ_ROOT}/ros/fiware-ros-turtlebot3-operator/yaml/fiware-ros-turtlebot3-operator-service.yaml https://api.${DOMAIN} ${TOKEN} ${FIWARE_SERVICE} ${DEPLOYER_SERVICEPATH} ${DEPLOYER_TYPE} ${DEPLOYER_ID}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* check minikube of turtlebot3\n",
    "\n",
    "```bash\n",
    "turtlebot3@turtlebot3:~$ kubectl get services -l app=turtlebot3-operator\n",
    "NAME                  TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)     AGE\n",
    "turtlebot3-operator   ClusterIP   None         <none>        11311/TCP   15s\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### apply Deployment "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "envsubst < ${PJ_ROOT}/ros/fiware-ros-turtlebot3-operator/yaml/fiware-ros-turtlebot3-operator-deployment-acr-wide.yaml > /tmp/fiware-ros-turtlebot3-operator-deployment-acr-wide.yaml\n",
    "TOKEN=$(cat ${CORE_ROOT}/secrets/auth-tokens.json | jq '.[0].settings.bearer_tokens[0].token' -r)\n",
    "docker run -it --rm -v ${PJ_ROOT}:${PJ_ROOT} -v /tmp:/tmp -w ${PJ_ROOT} example_turtlebot3:0.0.1 \\\n",
    "  ${PJ_ROOT}/tools/deploy_yaml.py /tmp/fiware-ros-turtlebot3-operator-deployment-acr-wide.yaml https://api.${DOMAIN} ${TOKEN} ${FIWARE_SERVICE} ${DEPLOYER_SERVICEPATH} ${DEPLOYER_TYPE} ${DEPLOYER_ID}\n",
    "rm /tmp/fiware-ros-turtlebot3-operator-deployment-acr-wide.yaml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* check minikube of turtlebot3\n",
    "\n",
    "```bash\n",
    "turtlebot3@turtlebot3:~$ kubectl get deployments -l app=turtlebot3-operator\n",
    "NAME                  READY   UP-TO-DATE   AVAILABLE   AGE\n",
    "turtlebot3-operator   1/1     1            1           9s\n",
    "```\n",
    "\n",
    "```bash\n",
    "turtlebot3@turtlebot3:~$ kubectl get pods -l app=turtlebot3-operator\n",
    "NAME                                   READY     STATUS    RESTARTS   AGE\n",
    "turtlebot3-operator-85b8bbbb88-kwstt   1/1       Running   0          32s\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### confirm log"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```bash\n",
    "turtlebot3@turtlebot3:~$ kubectl logs -f $(kubectl get pods -l app=turtlebot3-operator -o template --template \"{{(index .items 0).metadata.name}}\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A. turtlebot3 simulator: deploy turtlebot3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### confirm the UID of `turtlebot3`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```bash\n",
    "turtlebot3@turtlebot3:~$ echo ${UID}\n",
    "1000\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "export TURTLEBOT3_USER=turtlebot3\n",
    "export TURTLEBOT3_UID=1000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### build container image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "docker build -t ${REPOSITORY}/roboticbase/turtlebot3-fake:0.2.0 --build-arg TURTLEBOT3_USER=${TURTLEBOT3_USER} --build-arg TURTLEBOT3_UID=${TURTLEBOT3_UID} ros/turtlebot3-fake"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "az acr login --name ${ACR_NAME}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "docker push ${REPOSITORY}/roboticbase/turtlebot3-fake:0.2.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### apply Service"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "TOKEN=$(cat ${CORE_ROOT}/secrets/auth-tokens.json | jq '.[0].settings.bearer_tokens[0].token' -r)\n",
    "docker run -it --rm -v ${PJ_ROOT}:${PJ_ROOT} -v /tmp:/tmp -w ${PJ_ROOT} example_turtlebot3:0.0.1 \\\n",
    "  ${PJ_ROOT}/tools/deploy_yaml.py ${PJ_ROOT}/ros/turtlebot3-fake/yaml/turtlebot3-fake-service.yaml https://api.${DOMAIN} ${TOKEN} ${FIWARE_SERVICE} ${DEPLOYER_SERVICEPATH} ${DEPLOYER_TYPE} ${DEPLOYER_ID}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* check minikube of turtlebot3\n",
    "\n",
    "```bash\n",
    "turtlebot3@turtlebot3:~$ kubectl get services -l app=turtlebot3-fake\n",
    "NAME              TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)     AGE\n",
    "turtlebot3-fake   ClusterIP   None         <none>        11311/TCP   11s\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### apply Deployment "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "envsubst < ${PJ_ROOT}/ros/turtlebot3-fake/yaml/turtlebot3-fake-deployment-acr.yaml > /tmp/turtlebot3-fake-deployment-acr.yaml\n",
    "TOKEN=$(cat ${CORE_ROOT}/secrets/auth-tokens.json | jq '.[0].settings.bearer_tokens[0].token' -r)\n",
    "docker run -it --rm -v ${PJ_ROOT}:${PJ_ROOT} -v /tmp:/tmp -w ${PJ_ROOT} example_turtlebot3:0.0.1 \\\n",
    "  ${PJ_ROOT}/tools/deploy_yaml.py /tmp/turtlebot3-fake-deployment-acr.yaml https://api.${DOMAIN} ${TOKEN} ${FIWARE_SERVICE} ${DEPLOYER_SERVICEPATH} ${DEPLOYER_TYPE} ${DEPLOYER_ID}\n",
    "rm /tmp/turtlebot3-fake-deployment-acr.yaml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* check minikube of turtlebot3\n",
    "\n",
    "```bash\n",
    "turtlebot3@turtlebot3:~$ kubectl get deployments -l app=turtlebot3-fake\n",
    "NAME              READY   UP-TO-DATE   AVAILABLE   AGE\n",
    "turtlebot3-fake   1/1     1            1           77s\n",
    "```\n",
    "\n",
    "```bash\n",
    "turtlebot3@turtlebot3:~$ kubectl get pods -l app=turtlebot3-fake\n",
    "NAME                               READY   STATUS    RESTARTS   AGE\n",
    "turtlebot3-fake-758f48dd49-hl5vx   1/1     Running   0          95s\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### confirm log"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```bash\n",
    "turtlebot3@turtlebot3:~$ kubectl logs -f $(kubectl get pods -l app=turtlebot3-fake -o template --template \"{{(index .items 0).metadata.name}}\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A. (alterntive) turtlebot3 simulator: run turtlebot3-fake directly"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When the pod of `turtlebot3-fake` can't start due to the trouble of OpenGL, you should try to run `turtlebot3-fake` directry "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### install telepresence to turtlebot3-fake machine"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```bash\n",
    "turtlebot3@turtlebot3-fake:~$ curl -s https://packagecloud.io/install/repositories/datawireio/telepresence/script.deb.sh | sudo bash\n",
    "```\n",
    "\n",
    "```bash\n",
    "turtlebot3@turtlebot3-fake:~$ sudo apt install --no-install-recommends telepresence\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### forward `ros-master` port"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```bash\n",
    "turtlebot3@turtlebot3-fake:~$ kubectl port-forward $(kubectl get pods -l app=ros-master -o template --template \"{{(index .items 0).metadata.name}}\") 11311:11311\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### start `turtlebot3-fake` on telepresence shell"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* cd `ros_ws`\n",
    "\n",
    "```bash\n",
    "turtlebot3@turtlebot3-fake:~$ telepresence --run-shell\n",
    "```\n",
    "\n",
    "```bash\n",
    "@minikube|bash-4.3$ cd <<path/to/ros_workspace>>\n",
    "@minikube|bash-4.3$ source /opt/ros/kinetic/setup.bash \n",
    "@minikube|bash-4.3$ source ./devel/setup.bash \n",
    "@minikube|bash-4.3$ export ROS_MASTER_URI=http://localhost:11311\n",
    "@minikube|bash-4.3$ export ROS_HOSTNAME=172.17.0.1\n",
    "@minikube|bash-4.3$ catkin_make\n",
    "@minikube|bash-4.3$ roslaunch turtlebot3_fake turtlebot3_fake.launch \n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### B. actual turtlebot3 robot: deploy turtlebot3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### set ROS workspace of turtlebot3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "export TURTLEBOT3_WORKSPACE=/home/turtlebot3/catkin_ws"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### build container image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "docker build -t ${REPOSITORY}/roboticbase/turtlebot3-bringup:0.2.0 ros/turtlebot3-bringup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "az acr login --name ${ACR_NAME}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "docker push ${REPOSITORY}/roboticbase/turtlebot3-bringup:0.2.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### apply Service"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "TOKEN=$(cat ${CORE_ROOT}/secrets/auth-tokens.json | jq '.[0].settings.bearer_tokens[0].token' -r)\n",
    "docker run -it --rm -v ${PJ_ROOT}:${PJ_ROOT} -w ${PJ_ROOT} example_turtlebot3:0.0.1 \\\n",
    "  ${PJ_ROOT}/tools/deploy_yaml.py ${PJ_ROOT}/ros/turtlebot3-bringup/yaml/turtlebot3-bringup-service.yaml https://api.${DOMAIN} ${TOKEN} ${FIWARE_SERVICE} ${DEPLOYER_SERVICEPATH} ${DEPLOYER_TYPE} ${DEPLOYER_ID}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* check minikube of turtlebot3\n",
    "\n",
    "```bash\n",
    "turtlebot3@turtlebot3:~$ kubectl get services -l app=turtlebot3-bringup\n",
    "NAME                 TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)     AGE\n",
    "turtlebot3-bringup   ClusterIP   None         <none>        11311/TCP   13s\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### apply Deployment "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "envsubst < ${PJ_ROOT}/ros/turtlebot3-bringup/yaml/turtlebot3-bringup-deployment-acr.yaml > /tmp/turtlebot3-bringup-deployment-acr.yaml\n",
    "TOKEN=$(cat ${CORE_ROOT}/secrets/auth-tokens.json | jq '.[0].settings.bearer_tokens[0].token' -r)\n",
    "docker run -it --rm -v ${PJ_ROOT}:${PJ_ROOT} -v /tmp:/tmp -w ${PJ_ROOT} example_turtlebot3:0.0.1 \\\n",
    "  ${PJ_ROOT}/tools/deploy_yaml.py /tmp/turtlebot3-bringup-deployment-acr.yaml https://api.${DOMAIN} ${TOKEN} ${FIWARE_SERVICE} ${DEPLOYER_SERVICEPATH} ${DEPLOYER_TYPE} ${DEPLOYER_ID}\n",
    "rm /tmp/turtlebot3-bringup-deployment-acr.yaml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* check minikube of turtlebot3\n",
    "\n",
    "```bash\n",
    "turtlebot3@turtlebot3:~$ kubectl get deployments -l app=turtlebot3-bringup\n",
    "NAME                 READY   UP-TO-DATE   AVAILABLE   AGE\n",
    "turtlebot3-bringup   1/1     1            1           45s\n",
    "```\n",
    "\n",
    "```bash\n",
    "turtlebot3@turtlebot3:~$ kubectl get pods -l app=turtlebot3-bringup\n",
    "NAME                                  READY     STATUS    RESTARTS   AGE\n",
    "turtlebot3-bringup-5c7b59c9b4-c56kj   1/1       Running   0          1m\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### confirm log"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```bash\n",
    "turtlebot3@turtlebot3:~$ kubectl logs -f $(kubectl get pods -l app=turtlebot3-bringup -o template --template \"{{(index .items 0).metadata.name}}\")\n",
    "```"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Bash",
   "language": "bash",
   "name": "bash"
  },
  "language_info": {
   "codemirror_mode": "shell",
   "file_extension": ".sh",
   "mimetype": "text/x-sh",
   "name": "bash"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}