Creazione di un'immagine GPU di base Creazione di un'immagine per l'applicazione Robot Creazione di un'immagine per l'applicazione di simulazione Esecuzione dell'applicazione e invio ad Amazon ECR

Esecuzione di un'applicazione di esempio GPU con ROS2 Foxy e Gazebo 11

Questo tutorial spiega come utilizzare i driver GPU all'interno delle immagini dei container da sviluppare con ROS 2 Foxy e Gazebo 11 creando ed eseguendo l'applicazione robotica e l'applicazione di simulazione Hello World utilizzando tre immagini del contenitore descritte nell'esempio seguente.


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

Ogni Dockerfile contiene le istruzioni necessarie per creare ogni immagine.

Il Dockerfile per l'immagine di base include i comandi per configurare i driver ROS, Gazebo e GPU.
Il Dockerfile per l'applicazione robot include i comandi per configurare l'applicazione robot Hello World.
Il Dockerfile per l'applicazione di simulazione include i comandi per configurare l'applicazione di simulazione Hello World.

Sia l'applicazione robotica che l'applicazione di simulazione dispongono di uno script entrypoint. Questi script forniscono gli ambienti per le rispettive applicazioni e impostano il percorso in cui eseguire i comandi per avviare il robot e le applicazioni di simulazione.

Creazione di un'immagine GPU di base

Il seguente Dockerfile contiene i comandi per creare un'immagine di base da NVIDIA OpenGL e installare DCV.

Salva i seguenti comandi nel Dockerfile inSampleGPUBaseApprubrica.


# 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'

Dopo aver creato il Dockerfile, crealo utilizzando i seguenti comandi sul tuo terminale.


cd SampleGPUBaseApp
docker build -t samplegpubaseapp:latest .

La creazione dell'immagine di base installa ROS 2 Foxy, Gazebo 11, NVIDIA OpenGL e NICE-DCV.

Creazione di un'immagine per l'applicazione Robot

Dopo aver creato l'immagine di base, puoi creare l'immagine per la tua applicazione robotica. Salva il seguente script nel Dockerfile inSampleGPURobotAppdirectory e compilala. Questo script scarica l'applicazione robot Hello World e la configura.


# 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" ]

Di seguito sono riportati i contenuti dello script che si salva con nomerobot-entrypoint.sh. Questo script fornisce l'ambiente per l'applicazione robotica.


#!/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}"

Il comando seguente crea l'immagine per l'applicazione robot dal Dockerfile.


cd SampleGPURobotApp
docker build -t samplegpurobotapp:latest .

Creazione di un'immagine per l'applicazione di simulazione

Creazione di un'immagine per l'applicazione di simulazione

Dopo aver creato l'immagine di base e l'immagine per l'applicazione robot, puoi creare l'immagine per la tua applicazione di simulazione. Si salva il seguente script in un Dockerfile nelSampleGPUSimulationAppcartella e poi compilala. Questo script scarica l'applicazione di simulazione Hello World e la configura.


# 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" ]

Di seguito sono riportati i contenuti dello script che si salva con nomesimulation-entrypoint.sh. Questo script fornisce l'ambiente per l'applicazione di simulazione.


#!/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}"

Il comando seguente crea l'immagine.



                cd SampleGPUSimulationApp
                docker build -t samplegpusimulationapp:latest .

Esecuzione dell'applicazione e invio ad Amazon ECR

Dopo aver creato le immagini, assicurati che funzionino correttamente nell'ambiente Linux locale. Dopo aver verificato che l'immagine venga eseguita, puoi inviare l'immagine Docker ad Amazon ECR e creare un processo di simulazione.

I seguenti comandi ti danno la possibilità di eseguire l'applicazione Hello World nel tuo ambiente Linux locale.


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

Quando esegui l'applicazione robotica e i contenitori delle applicazioni di simulazione, puoi visualizzare la simulazione utilizzando lo strumento GUI di Gazebo. Usa i seguenti comandi per:

Connettiti al tuo contenitore su cui è in esecuzione l'applicazione di simulazione.
Visualizza la tua applicazione eseguendo l'interfaccia grafica utente (GUI) di 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

Puoi aggiungere tag alle tue immagini. I seguenti comandi ti danno la possibilità di etichettare le tue immagini.


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

Dopo aver verificato il corretto funzionamento dell'applicazione, puoi inviarla ad Amazon ECR utilizzando i seguenti comandi.


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

Ora puoi eseguire un lavoro di simulazione con GPU Compute utilizzando queste immagini. Per ulteriori informazioni sui lavori di simulazione, vedereSimulazione conAWS RoboMaker.

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Esecuzione di un'applicazione di esempio con ROS Melodic e Gazebo 9

Simulation