Prérequis Création de conteneurs d'applications à partir d'un espace de travail ROS Testez vos conteneurs

Création de conteneurs d'applications

La soumission d'une tâche de simulation comporte trois étapesAWS RoboMaker : créer les conteneurs d'applications, lier le conteneur à uneAWS RoboMaker application et utiliser les conteneurs pour soumettre une tâche de simulation. Cette section explique comment générer des conteneurs d'applications à l'aide de Docker pourAWS RoboMaker. Nous utilisons l'exemple d'application hello-world pour démontrer les étapes requises pour créer des exemples de robots et de conteneurs d'applications de simulation pour un exemple basé sur ROS. Cette page explique également comment tester votre conteneur localement.

Si vous n'utilisez pas ROS, consultez l'article de blog qui décrit comment exécuter n'importe quelle simulation haute fidélitéAWS RoboMaker avec la prise en charge des GPU et des conteneurs.

Sections

Prérequis
Création de conteneurs d'applications à partir d'un espace de travail ROS
Testez vos conteneurs

Prérequis

Avant de commencer, assurez-vous que votre environnement de développement possède les dépendances nécessaires. DockerAWS CLI, le et l'outil d'importation VCS doivent être installés sur votre machine.

Installez leAWS CLI : https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install .html
Installez Docker : https://docs.docker.com/get-docker/
Installez l'outil d'importation VCS (si nécessaire pour votre flux de travail) :


sudo pip3 install vcstool

Vous devez également disposer d'unAWS compte doté d'un rôle IAM contenant les autorisations suivantes :

Créer un rôle IAM
Création deAWS RoboMaker ressources (tâches de simulation, robots et applications de simulation)
Création et chargement de référentiels Amazon ECR

Enfin, vous devez connaître votre numéro de compte et sélectionner la région dans laquelle exécuter la simulation. AWS RoboMakerest pris en charge dans les régions répertoriées ci-dessousAWS RoboMaker points de terminaison et quotas

Création de conteneurs d'applications à partir d'un espace de travail ROS

AWS RoboMakerles simulations se composent d'une application de simulation et d'une application robotique optionnelle. Chacune de ces applications est définie par un nom et une image de conteneur. Cette section explique comment créer l'image du conteneur à la fois pour une application de simulation et pour une application robot. Dans l'exemple suivant, les deux applications sont générées dans un seul espace de travail. L'approche qui suit est facilement généralisable à n'importe quel projet ROS.

Pour commencer, clonez lehello world référentiel et importez la source.


git clone https://github.com/aws-robotics/aws-robomaker-sample-application-helloworld.git helloworld 
cd helloworld
vcs import robot_ws < robot_ws/.rosinstall
vcs import simulation_ws < simulation_ws/.rosinstall

Ensuite, créez un nouveau fichier texte dans lehelloworld répertoire et nommez-leDockerfile. Copiez et collez le contenu suivant :


# ======== ROS/Colcon Dockerfile ========
# This sample Dockerfile will build a Docker image for AWS RoboMaker 
# in any ROS workspace where all of the dependencies are managed by rosdep.
# 
# Adapt the file below to include your additional dependencies/configuration 
# outside of rosdep.
# =======================================

# ==== Arguments ====
# Override the below arguments to match your application configuration.
# ===================

# ROS Distribution (ex: melodic, foxy, etc.)
ARG ROS_DISTRO=melodic
# Application Name (ex: helloworld)
ARG APP_NAME=robomaker_app
# Path to workspace directory on the host (ex: ./robot_ws)
ARG LOCAL_WS_DIR=workspace
# User to create and use (default: robomaker)
ARG USERNAME=robomaker
# The gazebo version to use if applicable (ex: gazebo-9, gazebo-11)
ARG GAZEBO_VERSION=gazebo-9
# Where to store the built application in the runtime image.
ARG IMAGE_WS_DIR=/home/$USERNAME/workspace

# ======== ROS Build Stages ========
# ${ROS_DISTRO}-ros-base
#   -> ros-robomaker-base 
#      -> ros-robomaker-application-base
#         -> ros-robomaker-build-stage
#         -> ros-robomaker-app-runtime-image
# ==================================

# ==== ROS Base Image ============
# If running in production, you may choose to build the ROS base image 
# from the source instruction-set to prevent impact from upstream changes.
# ARG UBUNTU_DISTRO=focal
# FROM public.ecr.aws/lts/ubuntu:${UBUNTU_DISTRO} as ros-base
# Instruction for each ROS release maintained by OSRF can be found here: 
# https://github.com/osrf/docker_images
# ==================================

# ==== Build Stage with AWS RoboMaker Dependencies ====
# This stage creates the robomaker user and installs dependencies required 
# to run applications in RoboMaker.
# ==================================

FROM public.ecr.aws/docker/library/ros:${ROS_DISTRO}-ros-base AS ros-robomaker-base
ARG USERNAME
ARG IMAGE_WS_DIR

RUN apt-get clean
RUN apt-get update && apt-get install -y \
   lsb  \
   unzip \
   wget \
   curl \
   xterm \
   python3-colcon-common-extensions \
   devilspie \
   xfce4-terminal

RUN groupadd $USERNAME && \
   useradd -ms /bin/bash -g $USERNAME $USERNAME && \
   sh -c 'echo "$USERNAME ALL=(root) NOPASSWD:ALL" >> /etc/sudoers'
   
USER $USERNAME
WORKDIR /home/$USERNAME

RUN mkdir -p $IMAGE_WS_DIR

# ==== ROS Application Base ====
# This section installs exec dependencies for your ROS application.
# Note: Make sure you have defined 'exec' and 'build' dependencies correctly 
# in your package.xml files.
# ========================================
FROM ros-robomaker-base as ros-robomaker-application-base
ARG LOCAL_WS_DIR
ARG IMAGE_WS_DIR
ARG ROS_DISTRO
ARG USERNAME

WORKDIR $IMAGE_WS_DIR
COPY --chown=$USERNAME:$USERNAME $LOCAL_WS_DIR/src $IMAGE_WS_DIR/src

RUN sudo apt update && \ 
   rosdep update && \
   rosdep fix-permissions

# Note: This will install all dependencies. 
# You could further optimize this by only defining the exec dependencies. 
# Then, install the build dependencies in the build image.
RUN rosdep install --from-paths src --ignore-src -r -y

# ==== ROS Workspace Build Stage ==== 
# In this stage, we will install copy source files, install build dependencies
# and run a build. 
# ===================================
FROM ros-robomaker-application-base AS ros-robomaker-build-stage
LABEL build_step="${APP_NAME}Workspace_Build"
ARG APP_NAME
ARG LOCAL_WS_DIR
ARG IMAGE_WS_DIR

RUN  . /opt/ros/$ROS_DISTRO/setup.sh && \
   colcon build \
    --install-base $IMAGE_WS_DIR/$APP_NAME
    
# ==== ROS Robot Runtime Image ====
# In the final stage, we will copy the staged install directory to the runtime 
# image.
# =================================
FROM ros-robomaker-application-base AS ros-robomaker-app-runtime-image
ARG APP_NAME
ARG USERNAME
ARG GAZEBO_VERSION

ENV USERNAME=$USERNAME
ENV APP_NAME=$APP_NAME
ENV GAZEBO_VERSION=$GAZEBO_VERSION

RUN rm -rf $IMAGE_WS_DIR/src

COPY --from=ros-robomaker-build-stage $IMAGE_WS_DIR/$APP_NAME $IMAGE_WS_DIR/$APP_NAME

# Add the application source file to the entrypoint.
WORKDIR /
COPY entrypoint.sh /entrypoint.sh
RUN sudo chmod +x /entrypoint.sh && \
   sudo chown -R $USERNAME /entrypoint.sh && \
   sudo chown -R $USERNAME $IMAGE_WS_DIR/$APP_NAME
   
ENTRYPOINT ["/entrypoint.sh"]

Le Dockerfile que vous venez de générer est un jeu d'instructions utilisé pour générer des images Docker. Lisez les commentaires duDockerfile pour avoir une idée de ce qui est en cours de construction et adaptez-les selon vos besoins. Pour faciliter le développement,Dockerfile il est basé sur les images officielles de ROS Docker gérées par l'Open Source Robotics Foundation (OSRF). Toutefois, lors de l'exécution en production, vous pouvez choisir de créer l'image de base ROS avec les instructions source OSRF définies afin d'éviter tout impact dû GitHub aux modifications en amont.

Ensuite, créez un nouveau fichier appeléentrypoint.sh.


#!/bin/bash
set -e
source "/home/$USERNAME/workspace/$APP_NAME/setup.bash"
if [[ -f "/usr/share/$GAZEBO_VERSION/setup.sh" ]]
then
   source /usr/share/$GAZEBO_VERSION/setup.sh
fi
printenv
exec "${@:1}"

UnENTRYPOINT fichier est un exécutable qui s'exécute lorsque le conteneur Docker est généré. Nous utilisons un point d'entrée pour trouver l'espace de travail ROS, afin de pouvoir y exécuter facilementroslaunch des commandesAWS RoboMaker. Vous souhaiterez peut-être ajouter vos propres étapes de configuration d'environnement à ceENTRYPOINT fichier.

NotreDockerfile génération utilise une création à plusieurs étapes et une mise en cache intégrée avec Docker BuildKit. Les versions en plusieurs étapes autorisent des flux de travail comportant des étapes de génération distinctes, de sorte que les dépendances de génération et le code source ne sont pas copiés dans l'image d'exécution. Cela réduit la taille de l'image Docker et améliore les performances. Les opérations de mise en cache accélèrent les générations future en stockant les fichiers précédemment créés.

Attribuez la commande suivante pour générer l'application robot :


DOCKER_BUILDKIT=1 docker build . \
 --build-arg ROS_DISTRO=melodic \
 --build-arg LOCAL_WS_DIR=./robot_ws \
 --build-arg APP_NAME=helloworld-robot-app \
 -t robomaker-helloworld-robot-app

Une fois l'application robot créée, vous pouvez créer l'application de simulation comme suit :


DOCKER_BUILDKIT=1 docker build . \
 --build-arg GAZEBO_VERSION=gazebo-9 \
 --build-arg ROS_DISTRO=melodic \
 --build-arg LOCAL_WS_DIR=./simulation_ws \
 --build-arg APP_NAME=helloworld-sim-app \
 -t robomaker-helloworld-sim-app

Exécutez la commandedocker images pour confirmer que les images Docker ont été créées avec succès. La sortie doit ressembler à ce qui suit :


Administrator:~/environment/helloworld (ros1) $ docker images
REPOSITORY                       TAG          IMAGE ID       CREATED          SIZE
robomaker-helloworld-sim-app     latest       5cb08816b6b3   6  minutes ago  2.8GB
robomaker-helloworld-robot-app   latest       b5f6f755feec   10 minutes ago  2.79GB

À ce stade, vous avez créé avec succès vos images Docker. C'est une bonne idée de les tester localement avant de les télécharger pour les utiliser avecAWS RoboMaker. La section suivante explique comment procéder.

Testez vos conteneurs

Les commandes suivantes vous permettent d'exécuter l'application dans votre environnement de développement local.

Lancez l'application robot :


docker run -it -v /tmp/.X11-unix/:/tmp/.X11-unix/ \
-u robomaker -e ROBOMAKER_GAZEBO_MASTER_URI=http://localhost:5555 \
-e ROBOMAKER_ROS_MASTER_URI=http://localhost:11311 \
robomaker-helloworld-robot-app:latest roslaunch hello_world_robot rotate.launch

Lancez l'application de simulation :


docker run -it -v /tmp/.X11-unix/:/tmp/.X11-unix/ \
-u robomaker -e ROBOMAKER_GAZEBO_MASTER_URI=http://localhost:5555 \
-e ROBOMAKER_ROS_MASTER_URI=http://localhost:11311 \
robomaker-helloworld-sim-app:latest roslaunch hello_world_simulation empty_world.launch

Une fois que vous avez vérifié que vos conteneurs fonctionnent correctement, vous pouvez publier des conteneurs d'applications sur Amazon ECR, puis soumettre une tâche de simulation.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Développement

Exécution de conteneurs d'applications