Exécution d'un exemple d'application GPU avec ROS2 Foxy et Gazebo 11

Mode de mise au point

Exécution d'un exemple d'application GPU avec ROS2 Foxy et Gazebo 11 - AWS RoboMaker

Création d'une image GPU de base Création d'une image pour l'application Robot Création d'une image pour l'application de simulation Exécution de l'application et transfert vers Amazon ECR

Avis de fin de support : le 10 septembre 2025, AWS le support de AWS RoboMaker. Après le 10 septembre 2025, vous ne pourrez plus accéder à la AWS RoboMaker console ni aux AWS RoboMaker ressources. Pour plus d'informations sur la transition AWS Batch afin de faciliter l'exécution de simulations conteneurisées, consultez ce billet de blog.

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Ce didacticiel explique comment utiliser les pilotes GPU dans les images de conteneur pour développer avec ROS 2 Foxy et Gazebo 11 en créant et en exécutant l'application robot Hello World et l'application de simulation à l'aide de trois images de conteneur décrites dans l'exemple suivant.


├── SampleGPUBaseApp // Base Image
│   └── Dockerfile
├── SampleGPURobotApp // Image for Robot App
│   ├── Dockerfile
│   └── robot-entrypoint.sh
├── SampleGPUSimulationApp // Image for Simulation App
│   ├── Dockerfile
│   └── simulation-entrypoint.sh

Chaque Dockerfile contient les instructions nécessaires pour créer chaque image.

Le Dockerfile pour l'image de base inclut des commandes pour configurer les pilotes ROS, Gazebo et GPU.
Le Dockerfile de l'application robot inclut les commandes permettant de configurer l'application robot Hello World.
Le Dockerfile de l'application de simulation inclut les commandes permettant de configurer l'application de simulation Hello World.

L'application robot et l'application de simulation disposent toutes deux d'un script de point d'entrée. Ces scripts fournissent les environnements pour leurs applications respectives et définissent le chemin à suivre pour exécuter des commandes pour démarrer votre robot et vos applications de simulation.

Création d'une image GPU de base

Le Dockerfile suivant contient les commandes permettant de créer une image de base à partir de NVIDIA OpenGL et d'installer DCV.

Enregistrez les commandes suivantes dans le Dockerfile du SampleGPUBaseApp répertoire.


# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: MIT-0
FROM nvidia/opengl:1.0-glvnd-runtime-ubuntu20.04

ENV DEBIAN_FRONTEND="noninteractive"
ENV QT_X11_NO_MITSHM=1

RUN apt-get clean
RUN apt-get update && apt-get install -y --no-install-recommends \
        ca-certificates \
        devilspie \
        gnupg2 \
        mesa-utils \
        sudo \
        unzip \
        wget \
        xfce4-terminal

RUN wget https://d1uj6qtbmh3dt5.cloudfront.net/NICE-GPG-KEY && gpg --import NICE-GPG-KEY && \
        wget https://d1uj6qtbmh3dt5.cloudfront.net/2021.2/Servers/nice-dcv-2021.2-11048-ubuntu1804-x86_64.tgz && \
        tar xvzf nice-dcv-2021.2-11048-ubuntu1804-x86_64.tgz && \
        cd nice-dcv-2021.2-11048-ubuntu1804-x86_64 && \
        apt install -y ./nice-dcv-gl_2021.2.944-1_amd64.ubuntu1804.deb

RUN apt update && apt -y install locales && \
        locale-gen en_US en_US.UTF-8 && \
        update-locale LC_ALL=en_US.UTF-8 LANG=en_US.UTF-8

ENV LANG=en_US.UTF-8

RUN apt-get update && apt-get install -y --no-install-recommends curl lsb-release

RUN curl -sSL https://raw.githubusercontent.com/ros/rosdistro/master/ros.key  -o /usr/share/keyrings/ros-archive-keyring.gpg && \
        curl -s https://raw.githubusercontent.com/ros/rosdistro/master/ros.asc | apt-key add - && \
        echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/ros-archive-keyring.gpg] http://packages.ros.org/ros2/ubuntu $(lsb_release -cs) main" | tee /etc/apt/sources.list.d/ros2.list > /dev/null && \
        apt update && \
        apt install -y ros-foxy-desktop && \
        /bin/bash -c "source /opt/ros/foxy/setup.bash"

RUN apt -y install ros-foxy-gazebo-ros-pkgs

RUN apt-key adv --fetch-keys 'http://packages.osrfoundation.org/gazebo.key' && \
        apt update && \
        apt install -y python3-rosdep git

RUN if [ ! -f "/etc/ros/rosdep/sources.list.d/20-default.list" ]; then \
        rosdep init; \
    fi

RUN rosdep update

RUN apt-get install -y python3-apt python3-pip python3-vcstool python3-testresources

RUN pip3 install -U pytest setuptools colcon-ros-bundle

RUN useradd --create-home robomaker && \
        sh -c 'echo "robomaker ALL=(root) NOPASSWD:ALL" >> /etc/sudoers'

RUN sh -c 'mkdir -p /home/robomaker/workspace' && \
        sh -c 'cd /home/robomaker/workspace && wget https://github.com/aws-robotics/aws-robomaker-sample-application-helloworld/archive/ros2.zip && unzip ros2.zip'

Après avoir créé le Dockerfile, créez-le à l'aide des commandes suivantes sur votre terminal.


cd SampleGPUBaseApp
docker build -t samplegpubaseapp:latest .

La création de l'image de base installe ROS 2 Foxy, Gazebo 11, NVIDIA OpenGL et NICE-DCV.

Création d'une image pour l'application Robot

Après avoir créé l'image de base, vous pouvez créer l'image pour l'application de votre robot. Enregistrez le script suivant dans le Dockerfile du SampleGPURobotApp répertoire et créez-le. Ce script télécharge l'application robot Hello World et la configure.


# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: MIT-0
FROM samplegpubaseapp:latest

# Build the Robot application
RUN cd /home/robomaker/workspace/aws-robomaker-sample-application-helloworld-ros2/robot_ws && \
 /bin/bash -c "source /opt/ros/foxy/setup.bash && vcs import < .rosinstall && rosdep install --rosdistro foxy --from-paths src --ignore-src -r -y && colcon build"

COPY robot-entrypoint.sh /home/robomaker/robot-entrypoint.sh
RUN sh -c 'sudo chmod +x /home/robomaker/robot-entrypoint.sh'
RUN sh -c 'sudo chown robomaker:robomaker /home/robomaker/robot-entrypoint.sh'

CMD ros2 launch hello_world_robot rotate.launch.py
ENTRYPOINT [ "/home/robomaker/robot-entrypoint.sh" ]

Vous trouverez ci-dessous le contenu du script sous lequel vous enregistrezrobot-entrypoint.sh. Ce script fournit l'environnement de l'application du robot.


#!/bin/bash
cd /home/robomaker/workspace/aws-robomaker-sample-application-helloworld-ros2/robot_ws
source /opt/ros/foxy/setup.bash
source /usr/share/gazebo-11/setup.sh
source ./install/setup.sh
printenv

exec "${@:1}"

La commande suivante crée l'image de l'application robot à partir du Dockerfile.


cd SampleGPURobotApp
docker build -t samplegpurobotapp:latest .

Création d'une image pour l'application de simulation

Création d'une image pour l'application de simulation

Après avoir créé l'image de base et l'image pour l'application robot, vous pouvez créer l'image pour votre application de simulation. Vous enregistrez le script suivant dans un Dockerfile du SampleGPUSimulationApp répertoire, puis vous le créez. Ce script télécharge l'application de simulation Hello World et la configure.


# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: MIT-0
FROM samplegpubaseapp:latest

# Build the Simulation application
RUN cd /home/robomaker/workspace/aws-robomaker-sample-application-helloworld-ros2/simulation_ws && \
 /bin/bash -c "source /opt/ros/foxy/setup.bash && vcs import < .rosinstall && rosdep install --rosdistro foxy --from-paths src --ignore-src -r -y && colcon build"

COPY simulation-entrypoint.sh /home/robomaker/simulation-entrypoint.sh

RUN sh -c 'sudo chmod +x /home/robomaker/simulation-entrypoint.sh'
RUN sh -c 'sudo chown robomaker:robomaker /home/robomaker/simulation-entrypoint.sh'

CMD ros2 launch hello_world_simulation empty_world.launch.py
ENTRYPOINT [ "/home/robomaker/simulation-entrypoint.sh" ]

Vous trouverez ci-dessous le contenu du script sous lequel vous enregistrezsimulation-entrypoint.sh. Ce script fournit l'environnement de l'application de simulation.


#!/bin/bash
if [ ! -z $GAZEBO_MASTER_URI ]; then
   tmp_GAZEBO_MASTER_URI=$GAZEBO_MASTER_URI
fi

cd /home/robomaker/workspace/aws-robomaker-sample-application-helloworld-ros2/simulation_ws
source /opt/ros/foxy/setup.bash
source /usr/share/gazebo-11/setup.sh

 if [ ! -z $tmp_GAZEBO_MASTER_URI ]; then
    export GAZEBO_MASTER_URI=$tmp_GAZEBO_MASTER_URI
    unset tmp_GAZEBO_MASTER_URI 
fi

source ./install/setup.sh
printenv

exec "${@:1}"

La commande suivante crée l'image.



                cd SampleGPUSimulationApp
                docker build -t samplegpusimulationapp:latest .

Exécution de l'application et transfert vers Amazon ECR

Après avoir créé vos images, assurez-vous qu'elles s'exécutent correctement dans votre environnement Linux local. Après avoir vérifié que votre image fonctionne, vous pouvez transférer votre image Docker vers Amazon ECR et créer une tâche de simulation.

Les commandes suivantes vous permettent d'exécuter l'application Hello World dans votre environnement Linux local.


docker run -it -e DISPLAY -v /tmp/.X11-unix/:/tmp/.X11-unix/ --name gpu_robot_app \
-u robomaker -e ROBOMAKER_GAZEBO_MASTER_URI=http://localhost:5555 \
-e ROBOMAKER_ROS_MASTER_URI=http://localhost:11311 \
samplegpurobotapp:latest                   
                
docker run -it -e DISPLAY -v /tmp/.X11-unix/:/tmp/.X11-unix/ --name gpu_sim_app \
-u robomaker -e ROBOMAKER_GAZEBO_MASTER_URI=http://localhost:5555 \
-e ROBOMAKER_ROS_MASTER_URI=http://localhost:11311 \
samplegpusimulationapp:latest

Lorsque vous exécutez l'application robot et les conteneurs d'applications de simulation, vous pouvez visualiser la simulation à l'aide de l'outil graphique Gazebo. Utilisez les commandes suivantes pour :

Connectez-vous à votre conteneur en exécutant l'application de simulation.
Visualisez votre application en exécutant l'interface utilisateur graphique (GUI) de Gazebo.


# Enable access to X server to launch Gazebo from docker container
$ xhost +

# Check that the robot_app and sim_app containers are running. The command should list both containers
$ docker container ls

# Connect to the sim app container
$ docker exec -it gpu_sim_app bash

# Launch Gazebo from within the container
$ /home/robomaker/simulation-entrypoint.sh ros2 launch gazebo_ros gzclient.launch.py

Vous pouvez ajouter des tags à vos images. Les commandes suivantes vous permettent de baliser vos images.


docker tag samplegpurobotapp:latest accountID.dkr.ecr.us-west-2.amazonaws.com/samplegpurobotapp:latest
              
docker tag samplegpusimulationapp:latest accountID.dkr.ecr.us-west-2.amazonaws.com/samplegpusimulationapp:latest

Après avoir vérifié que l'application fonctionne correctement, vous pouvez la transférer vers Amazon ECR à l'aide des commandes suivantes.


aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin accountID.dkr.ecr.us-west-2.amazonaws.com
docker push accountID.dkr.ecr.us-west-2.amazonaws.com/samplegpurobotapp:latest 
docker push accountID.dkr.ecr.us-west-2.amazonaws.com/samplegpusimulationapp:latest

Vous pouvez désormais exécuter une tâche de simulation avec GPU Compute à l'aide de ces images. Pour plus d'informations sur les tâches de simulation, consultezSimulation avec AWS RoboMaker.

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.