Déploiement sur IBM Cloud Kubernetes [contribution de la communauté]

Table des matières

À propos
ROS2 sur IBM Cloud
Étape 1 : Configurer votre système
- a) Fichiers Docker ?
- b) Image ROS2
Étape 2 : Exécution de l’image sur IBM Cloud
Étape 3 : Utilisation de packages ROS2 personnalisés
- Supplément : suppression des images Docker
Étape 4 : Kubernetes
- a) Création du cluster
- b) Déploiement de votre image Docker Enfin !
Étape 5 : Utilisation de la CLI pour votre image Docker
Remarques finales

À propos 

Cet article décrit comment exécuter ROS2 sur IBM Cloud à l’aide de fichiers Docker. Il donne d’abord un bref aperçu des images Docker et de leur fonctionnement local, puis explore IBM Cloud et comment l’utilisateur peut y déployer ses conteneurs. Ensuite, une brève description de la façon dont l’utilisateur peut utiliser ses propres packages personnalisés pour ROS2 à partir de github sur IBM Cloud est fournie. Une procédure pas à pas expliquant comment créer un cluster et utiliser Kubernetes sur IBM Cloud est fournie et enfin l’image Docker est déployée sur le cluster. Publié à l’origine ici et `ici <https://medium.com/@mahmoud-nasr/running-ros2-on-ibm-cloud-1b1284cbd487> `__.

ROS2 sur IBM Cloud 

Dans ce didacticiel, nous montrons comment vous pouvez facilement intégrer et exécuter ROS2 sur IBM Cloud avec vos packages personnalisés.

ROS2 est la nouvelle génération de ROS qui donne plus de contrôle sur les formations multi-robots. Avec les progrès de l’informatique en nuage, la robotique en nuage devient de plus en plus importante à l’ère actuelle. Dans ce didacticiel, nous allons passer par une brève introduction sur l’exécution de ROS2 sur IBM Cloud. À la fin du didacticiel, vous serez en mesure de créer vos propres packages dans ROS2 et de les déployer dans le cloud à l’aide de fichiers Docker.

Les instructions suivantes supposent que vous utilisez Linux et que vous avez été testé avec Ubuntu 18.04 (Bionic Beaver).

Étape 1 : Configurer votre système 

Avant d’aborder le fonctionnement exact du processus, assurons-nous d’abord que tous les logiciels requis sont correctement installés. Nous vous dirigerons vers les sources appropriées pour configurer votre système et ne mettrons en évidence que les détails qui se rapportent à notre cas d’utilisation.

a) Fichiers Docker ?

Les fichiers Docker sont une forme de conteneurs qui peuvent s’exécuter séparément de votre système, de cette façon, vous pouvez configurer potentiellement des centaines de projets différents sans s’affecter les uns les autres. Vous pouvez même configurer différentes versions de Linux sur une seule machine, sans avoir besoin d’une machine virtuelle. Les fichiers Docker ont l’avantage d’économiser de l’espace et d’utiliser uniquement les ressources de votre système lors de l’exécution. De plus, les dockers sont polyvalents et transférables. Ils contiennent tous les prérequis requis pour s’exécuter séparément, ce qui signifie que vous pouvez facilement utiliser un fichier docker pour un système ou un service spécifique sans aucune étape fastidieuse !

Excité encore? Commençons par installer docker sur votre système en suivant le lien suivant. À partir du didacticiel, vous devriez avoir effectué quelques vérifications pour vous assurer que Docker est correctement configuré. Juste au cas où, exécutons à nouveau la commande suivante qui utilise l’image docker hello-world :

$ sudo docker run hello-world

Vous devriez obtenir la sortie suivante :

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

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (amd64)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/get-started/

b) Image ROS2 

ROS a annoncé conteneurs d’images pour plusieurs distributions ROS en janvier 2019. Des instructions plus détaillées sur l’utilisation des images docker ROS2 peuvent être trouvées ici.

Passons à cela et passons tout de suite à la vraie affaire; création d’un docker ROS2 local. Nous allons créer notre propre Dockerfile (au lieu d’utiliser une image prête) car nous aurons besoin de cette méthode pour le déploiement sur IBM Cloud. Tout d’abord, nous créons un nouveau répertoire qui contiendra notre Dockerfile et tous les autres fichiers dont nous aurons besoin plus tard et y naviguerons. À l’aide de votre $EDITOR préféré, ouvrez un nouveau fichier nommé Dockerfile (assurez-vous que le nom du fichier est correct) :

$ mkdir ~/ros2_docker

$ cd ~/ros2_docker

$ $EDITOR Dockerfile

Insérez ce qui suit dans le Dockerfile et enregistrez-le (également trouvé ici):

FROM ros:foxy

# install ros package
RUN apt-get update && apt-get install -y \
      ros-${ROS_DISTRO}-demo-nodes-cpp \
      ros-${ROS_DISTRO}-demo-nodes-py && \
    rm -rf /var/lib/apt/lists/* && mkdir /ros2_home

WORKDIR /ros2_home

# launch ros package
CMD ["ros2", "launch", "demo_nodes_cpp", "talker_listener.launch.py"]

FROM : crée un calque à partir de l’image Docker ros:foxy
RUN : construit votre conteneur en y installant vim et en créant un répertoire appelé /ros2_home
WORKDIR : indique au conteneur où le répertoire de travail doit être pour lui

Bien sûr, vous êtes libre de changer la distribution ROS (foxy est utilisé ici) ou de changer le nom du répertoire. Le fichier docker ci-dessus configure ROS-foxy et installe les nœuds de démonstration pour C++ et Python. Ensuite, il lance un fichier qui exécute un nœud de locuteur et un nœud d’écoute. Nous le verrons en action dans quelques-uns, mais ils agissent de manière très similaire à l’exemple de l’éditeur-abonné trouvé dans le wiki ROS

Maintenant, nous sommes prêts à construire l’image docker pour y exécuter ROS2 (oui, c’est SI facile !).

Remarque : si vous rencontrez des erreurs dues à des privilèges insuffisants ou à une autorisation refusée, essayez d’exécuter la commande avec les privilèges sudo :

$ docker build .

# You will see a bunch of lines that execute the docker file instructions followed by:
Successfully built 0dc6ce7cb487

0dc6ce7cb487 sera très probablement différent pour vous, alors notez-le et copiez-le quelque part pour référence. Vous pouvez toujours revenir en arrière et vérifier les images docker que vous avez sur votre système en utilisant :

$ sudo docker ps -as

Maintenant, exécutez le fichier docker en utilisant :

$ docker run -it 0dc6ce7cb487
[INFO] [launch]: All log files can be found below /root/.ros/log/2020-10-28-02-41-45-177546-0b5d9ed123be-1
[INFO] [launch]: Default logging verbosity is set to INFO
[INFO] [talker-1]: process started with pid [28]
[INFO] [listener-2]: process started with pid [30]
[talker-1] [INFO] [1603852907.249886590] [talker]: Publishing: 'Hello World: 1'
[listener-2] [INFO] [1603852907.250964490] [listener]: I heard: [Hello World: 1]
[talker-1] [INFO] [1603852908.249786312] [talker]: Publishing: 'Hello World: 2'
[listener-2] [INFO] [1603852908.250453386] [listener]: I heard: [Hello World: 2]
[talker-1] [INFO] [1603852909.249882257] [talker]: Publishing: 'Hello World: 3'
[listener-2] [INFO] [1603852909.250536089] [listener]: I heard: [Hello World: 3]
[talker-1] [INFO] [1603852910.249845718] [talker]: Publishing: 'Hello World: 4'
[listener-2] [INFO] [1603852910.250509355] [listener]: I heard: [Hello World: 4]
[talker-1] [INFO] [1603852911.249506058] [talker]: Publishing: 'Hello World: 5'
[listener-2] [INFO] [1603852911.250152324] [listener]: I heard: [Hello World: 5]
[talker-1] [INFO] [1603852912.249556670] [talker]: Publishing: 'Hello World: 6'
[listener-2] [INFO] [1603852912.250212678] [listener]: I heard: [Hello World: 6]

Si cela fonctionne correctement, vous devriez voir quelque chose de similaire à ce qui est montré ci-dessus. Comme on peut le voir, il y a deux nœuds ROS (un éditeur et un abonné) en cours d’exécution et leur sortie nous est fournie via ROS INFO.

Étape 2 : Exécution de l’image sur IBM Cloud 

Les étapes suivantes supposent que vous disposez d’un compte IBM Cloud et que l’interface de ligne de commande ibmcloud est installée. Si ce n’est pas le cas, consultez ce lien pour le faire en premier.

Nous devons également nous assurer que le plug-in CLI pour IBM Cloud Container Registry est installé en exécutant la commande

$ ibmcloud plugin install container-registry

Ensuite, connectez-vous à votre compte ibmcloud via le terminal :

$ ibmcloud login --sso

À partir de là, créons un espace de noms de registre de conteneurs. Assurez-vous d’utiliser un nom unique qui soit également descriptif de ce qu’il est. Ici, j’ai utilisé ros2nasr.

$ ibmcloud cr namespace-add ros2nasr

Le cloud IBM propose de nombreux raccourcis qui nous aideraient à mettre immédiatement notre conteneur sur le cloud. La commande ci-dessous crée le conteneur et le balise avec le nom ros2foxy et la version de 1. Assurez-vous d’utiliser le nom de registre correct que vous avez créé et vous êtes libre de modifier le nom du conteneur comme vous le souhaitez. Le . à la fin indique que le Dockerfile est dans le répertoire courant (et c’est important), sinon, changez-le pour qu’il pointe vers le répertoire contenant le Dockerfile.

$ ibmcloud cr build --tag registry.bluemix.net/ros2nasr/ros2foxy:1 .

Vous pouvez maintenant vous assurer que le conteneur a été poussé vers le registre que vous avez créé en exécutant la commande suivante

$ ibmcloud cr image-list
Listing images...

REPOSITORY               TAG   DIGEST         NAMESPACE   CREATED         SIZE     SECURITY STATUS
us.icr.io/ros2nasr/ros2foxy   1     031be29301e6   ros2nasr    36 seconds ago   120 MB   No Issues

OK

Ensuite, il est important de vous connecter à votre registre pour exécuter l’image docker. Encore une fois, si vous rencontrez une erreur * autorisation refusée *, exécutez la commande avec les privilèges sudo. Ensuite, exécutez votre fichier docker comme indiqué ci-dessous.

$ ibmcloud cr login
Logging in to 'registry.ng.bluemix.net'...
Logged in to 'registry.ng.bluemix.net'.
Logging in to 'us.icr.io'...
Logged in to 'us.icr.io'.

OK

$ docker run -v -it registry.ng.bluemix.net/ros2nasr/ros2foxy:1

Où ros2nasr est le nom du registre que vous avez créé et ros2foxy:1 est la balise du conteneur docker et la version comme expliqué précédemment.

Vous devriez maintenant voir votre fichier docker s’exécuter et fournir une sortie similaire à celle que vous avez vue lorsque vous l’avez exécuté localement sur votre machine.

Étape 3 : Utilisation de packages ROS2 personnalisés 

Nous avons donc maintenant le pipeline complet qui fonctionne, depuis la création du Dockerfile jusqu’à son déploiement et son fonctionnement sur IBM Cloud. Mais que se passe-t-il si nous voulons utiliser un ensemble personnalisé de packages que nous (ou quelqu’un d’autre) avons créés ?

Eh bien, tout cela a à voir avec la façon dont vous configurez votre Dockerfile. Utilisons l’exemple fourni par ROS2 ici. Créez un nouveau répertoire avec un nouveau Dockerfile (ou écrasez celui existant) et ajoutez-y ce qui suit (ou téléchargez le fichier ici)

ARG FROM_IMAGE=ros:foxy
ARG OVERLAY_WS=/opt/ros/overlay_ws

# multi-stage for caching
FROM $FROM_IMAGE AS cacher

# clone overlay source
ARG OVERLAY_WS
WORKDIR $OVERLAY_WS/src
RUN echo "\
repositories: \n\
  ros2/demos: \n\
    type: git \n\
    url: https://github.com/ros2/demos.git \n\
    version: ${ROS_DISTRO} \n\
" > ../overlay.repos
RUN vcs import ./ < ../overlay.repos

# copy manifests for caching
WORKDIR /opt
RUN mkdir -p /tmp/opt && \
    find ./ -name "package.xml" | \
      xargs cp --parents -t /tmp/opt && \
    find ./ -name "COLCON_IGNORE" | \
      xargs cp --parents -t /tmp/opt || true

# multi-stage for building
FROM $FROM_IMAGE AS builder

# install overlay dependencies
ARG OVERLAY_WS
WORKDIR $OVERLAY_WS
COPY --from=cacher /tmp/$OVERLAY_WS/src ./src
RUN . /opt/ros/$ROS_DISTRO/setup.sh && \
    apt-get update && rosdep install -y \
      --from-paths \
        src/ros2/demos/demo_nodes_cpp \
        src/ros2/demos/demo_nodes_py \
      --ignore-src \
    && rm -rf /var/lib/apt/lists/*

# build overlay source
COPY --from=cacher $OVERLAY_WS/src ./src
ARG OVERLAY_MIXINS="release"
RUN . /opt/ros/$ROS_DISTRO/setup.sh && \
    colcon build \
      --packages-select \
        demo_nodes_cpp \
        demo_nodes_py \
      --mixin $OVERLAY_MIXINS

# source entrypoint setup
ENV OVERLAY_WS $OVERLAY_WS
RUN sed --in-place --expression \
      '$isource "$OVERLAY_WS/install/setup.bash"' \
      /ros_entrypoint.sh

# run launch file
CMD ["ros2", "launch", "demo_nodes_cpp", "talker_listener.launch.py"]

En parcourant les lignes affichées, nous pouvons voir comment nous pouvons ajouter des packages personnalisés à partir de github en 4 étapes :

Créez une superposition avec des packages personnalisés clonés à partir de Github :

ARG OVERLAY_WS
WORKDIR $OVERLAY_WS/src
RUN echo "\
repositories: \n\
  ros2/demos: \n\
    type: git \n\
    url: https://github.com/ros2/demos.git \n\
    version: ${ROS_DISTRO} \n\
" > ../overlay.repos
RUN vcs import ./ < ../overlay.repos

Installer les dépendances de package à l’aide de rosdep

# install overlay dependencies
ARG OVERLAY_WS
WORKDIR $OVERLAY_WS
COPY --from=cacher /tmp/$OVERLAY_WS/src ./src
RUN . /opt/ros/$ROS_DISTRO/setup.sh && \
    apt-get update && rosdep install -y \
      --from-paths \
        src/ros2/demos/demo_nodes_cpp \
        src/ros2/demos/demo_nodes_py \
      --ignore-src \
    && rm -rf /var/lib/apt/lists/*

Construisez les packages * dont vous avez besoin *

# build overlay source
COPY --from=cacher $OVERLAY_WS/src ./src
ARG OVERLAY_MIXINS="release"
RUN . /opt/ros/$ROS_DISTRO/setup.sh && \
    colcon build \
      --packages-select \
        demo_nodes_cpp \
        demo_nodes_py \
      --mixin $OVERLAY_MIXINS

Exécution du fichier de lancement

# run launch file
CMD ["ros2", "launch", "demo_nodes_cpp", "talker_listener.launch.py"]

De même, nous pouvons modifier les packages utilisés, installer leurs dépendances, puis les exécuter.

Retour à IBM Cloud

Avec ce Dockerfile, nous pouvons suivre les mêmes étapes que nous avons suivies auparavant pour le déployer sur IBM Cloud. Puisque nous avons déjà créé notre registre et que nous sommes connectés à IBM Cloud, nous construisons directement notre nouveau Dockerfile. Remarquez comment j’ai gardé la même balise mais changé la version, de cette façon je peux mettre à jour l’image docker créée précédemment. (Vous êtes libre d’en créer un complètement nouveau si vous le souhaitez)

$ ibmcloud cr build --tag registry.bluemix.net/ros2nasr/ros2foxy:2 .

Ensuite, assurez-vous d’être connecté au registre et exécutez la nouvelle image Docker :

$ ibmcloud cr login
Logging in to 'registry.ng.bluemix.net'...
Logged in to 'registry.ng.bluemix.net'.
Logging in to 'us.icr.io'...
Logged in to 'us.icr.io'.

OK

$ docker run -v -it registry.ng.bluemix.net/ros2nasr/ros2foxy:2

Vous devriez voir, encore une fois, la même sortie. Cependant, cette fois, nous l’avons fait via des packages personnalisés de github, ce qui nous permet d’utiliser nos packages créés personnellement pour ROS2 sur IBM Cloud.

Supplément : suppression des images Docker 

Comme vous pourriez avoir besoin de supprimer une ou plusieurs images Docker spécifiques d’IBM Cloud, voici comment procéder !

Listez toutes les images que vous avez et trouvez toutes celles qui partagent le nom IMAGE correspondant à registry.ng.bluemix.net/ros2nasr/ros2foxy:2 (dans mon cas). Supprimez-les ensuite en utilisant leurs NOMS

$ docker rm your_docker_NAMES

Supprimez l’image docker d’IBM Cloud en utilisant son nom IMAGE

$ docker rmi registry.ng.bluemix.net/ros2nasr/ros2foxy:2

Étape 4 : Kubernetes 

a) Création du cluster 

Créez un cluster à l’aide de la console. Les instructions se trouvent ici. Les paramètres utilisés sont détaillés ci-dessous. Ce ne sont que des suggestions et peuvent être modifiées si nécessaire. Cependant, assurez-vous de bien comprendre les implications de vos choix :

Forfait : Standard
Service d’orchestration : Kubernetes v1.18.10
Infrastructure : Classique
Emplacement:

Groupe de ressources : Par défaut
Géographie : Amérique du Nord (vous êtes libre de changer cela)
Disponibilité : Zone unique (vous êtes libre de modifier cela, mais assurez-vous de comprendre l’impact de vos choix en consultant la documentation IBM Cloud.)
Zone de travail : Toronto 01 (choisissez l’emplacement qui est physiquement le plus proche de vous)

Pool de travailleurs :

Virtuel - partagé, Ubuntu 18
Mémoire : 16 Go
Nœuds de travail par zone : 1

Point de terminaison de service principal : Points de terminaison privés et publics
Détails des ressources (totalement flexibles) :

Nom du cluster : mycluster-tor01-rosibm
Balises : version:1

Après avoir créé votre cluster, vous serez redirigé vers une page qui détaille comment vous pouvez configurer les outils CLI et accéder à votre cluster. Veuillez suivre ces instructions (ou consultez les instructions ici) et attendez que la barre de progression indiquez que les noeuds worker que vous avez créés sont prêts en indiquant Normal à côté du nom du cluster. Vous pouvez également accéder à cet écran à partir d’IBM Cloud Console dans Kubernetes.

b) Déploiement de votre image Docker Enfin !

Créez un fichier yaml de configuration de déploiement nommé ros2-deployment.yaml à l’aide de votre $EDITOR préféré et insérez-y les éléments suivants :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: <deployment>
spec:
  replicas: <number_of_replicas>
  selector:
    matchLabels:
      app: <app_name>
  template:
    metadata:
      labels:
        app: <app_name>
    spec:
      containers:
      - name: <app_name>
        image: <region>.icr.io/<namespace>/<image>:<tag>

Vous devez remplacer les balises affichées entre « < » « > » comme décrit ici. Le fichier dans mon cas ressemblerait à ceci:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ros2-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ros2-ibmcloud
  template:
    metadata:
      labels:
        app: ros2-ibmcloud
    spec:
      containers:
      - name: ros2-ibmcloud
        image: us.icr.io/ros2nasr/ros2foxy:2

Déployez le fichier à l’aide de la commande suivante

$ kubectl apply -f ros2-deployment.yaml
deployment.apps/ros2-deployment created

Votre image docker est maintenant entièrement déployée sur votre cluster !

Étape 5 : Utilisation de la CLI pour votre image Docker 

Accédez à votre cluster via la console IBM Cloud Kubernetes.
Cliquez sur tableau de bord Kubernetes dans le coin supérieur droit de la page.

Vous devriez maintenant pouvoir voir une liste complète de tous les différents paramètres de votre cluster ainsi que son utilisation du processeur et de la mémoire.

Accédez à Pods et cliquez sur votre déploiement.
Dans le coin supérieur droit, cliquez sur Exec into pod

Vous êtes maintenant à l’intérieur de votre image docker ! Vous pouvez sourcer votre espace de travail (si nécessaire) et exécuter ROS2 ! Par exemple:

root@ros2-deployment-xxxxxxxx:/opt/ros/overlay_ws# . install/setup.sh
root@ros2-deployment-xxxxxxxx:/opt/ros/overlay_ws# ros2 launch demo_nodes_cpp talker_listener.launch.py

Remarques finales 

À ce stade, vous êtes capable de créer votre propre image docker à l’aide des packages ROS2 sur github. Il est également possible, avec peu de modifications, d’utiliser également les packages ROS2 locaux. Cela pourrait faire l’objet d’un autre article. Cependant, nous vous encourageons à consulter le Dockerfile suivant qui utilise une copie locale du référentiel de démonstrations. De même, vous pouvez utiliser votre propre package local.