Ein GPU-Basis-Image erstellen Erstellen eines Images für die Roboteranwendung Erstellen eines Images für die Simulationsanwendung Anwendung ausführen und an Amazon ECR übertragen

Ende des Supporthinweises: Am 10. September 2025 AWS wird der Support für AWS RoboMaker eingestellt. Nach dem 10. September 2025 können Sie nicht mehr auf die AWS RoboMaker Konsole oder die AWS RoboMaker Ressourcen zugreifen. Weitere Informationen AWS Batch zur Umstellung auf containerisierte Simulationen finden Sie in diesem Blogbeitrag.

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Ausführen einer GPU-Beispielanwendung mit ROS2 Foxy und Gazebo 11

In diesem Tutorial wird erklärt, wie GPU-Treiber in Container-Images verwendet werden, um mit ROS 2 Foxy und Gazebo 11 zu entwickeln, indem die Hello World-Roboteranwendung und Simulationsanwendung mithilfe von drei Container-Images erstellt und ausgeführt werden, die im folgenden Beispiel beschrieben werden.


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

Jedes Dockerfile enthält die Anweisungen, die zum Erstellen der einzelnen Images erforderlich sind.

Das Dockerfile für das Basis-Image enthält Befehle zum Einrichten von ROS-, Gazebo- und GPU-Treibern.
Das Dockerfile für die Roboteranwendung enthält die Befehle zum Einrichten der Hello World-Roboteranwendung.
Das Dockerfile für die Simulationsanwendung enthält die Befehle zum Einrichten der Hello World-Simulationsanwendung.

Sowohl die Roboteranwendung als auch die Simulationsanwendung verfügen über ein Einstiegsskript. Diese Skripts beziehen die Umgebungen für ihre jeweiligen Anwendungen und richten den Pfad ein, auf dem Sie Befehle ausführen können, um Ihre Roboter- und Simulationsanwendungen zu starten.

Ein GPU-Basis-Image erstellen

Das folgende Dockerfile enthält die Befehle zum Erstellen eines Basis-Images aus NVIDIA OpenGL und zur Installation von DCV.

Speichern Sie die folgenden Befehle in der Dockerfile in derSampleGPUBaseAppVerzeichnis.


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

Nachdem Sie das Dockerfile erstellt haben, erstellen Sie es mit den folgenden Befehlen auf Ihrem Terminal.


cd SampleGPUBaseApp
docker build -t samplegpubaseapp:latest .

Beim Erstellen des Basis-Images werden ROS 2 Foxy, Gazebo 11, NVIDIA OpenGL und NICE-DCV installiert.

Erstellen eines Images für die Roboteranwendung

Nachdem Sie das Basis-Image erstellt haben, können Sie das Image für Ihre Roboteranwendung erstellen. Speichern Sie das folgende Skript im Dockerfile in derSampleGPURobotAppVerzeichnis und baue es. Dieses Skript lädt die Hello World-Roboteranwendung herunter und richtet sie ein.


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

Im Folgenden finden Sie den Inhalt des Skripts, das Sie speichern alsrobot-entrypoint.sh. Dieses Skript bezieht die Umgebung für die Roboteranwendung.


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

Der folgende Befehl erstellt das Image für die Roboteranwendung aus der Dockerfile.


cd SampleGPURobotApp
docker build -t samplegpurobotapp:latest .

Erstellen eines Images für die Simulationsanwendung

Erstellen eines Images für die Simulationsanwendung

Nachdem Sie das Basisimage und das Image für die Roboteranwendung erstellt haben, können Sie das Image für Ihre Simulationsanwendung erstellen. Sie speichern das folgende Skript in einem Dockerfile in derSampleGPUSimulationAppVerzeichnis und erstellen Sie es dann. Dieses Skript lädt die Hello World-Simulationsanwendung herunter und richtet sie ein.


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

Im Folgenden finden Sie den Inhalt des Skripts, das Sie speichern alssimulation-entrypoint.sh. Dieses Skript bezieht die Umgebung für die Simulationsanwendung.


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

Mit dem folgenden Befehl wird das Bild erstellt.



                cd SampleGPUSimulationApp
                docker build -t samplegpusimulationapp:latest .

Anwendung ausführen und an Amazon ECR übertragen

Nachdem Sie Ihre Images erstellt haben, stellen Sie sicher, dass sie in Ihrer lokalen Linux-Umgebung ordnungsgemäß ausgeführt werden. Nachdem Sie überprüft haben, ob Ihr Image ausgeführt wird, können Sie Ihr Docker-Image an Amazon ECR übertragen und einen Simulationsjob erstellen.

Mit den folgenden Befehlen können Sie die Hello World-Anwendung in Ihrer lokalen Linux-Umgebung ausführen.


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

Wenn Sie die Container der Roboteranwendung und der Simulationsanwendung ausführen, können Sie die Simulation mit dem Gazebo-GUI-Tool visualisieren. Verwenden Sie die folgenden Befehle, um:

Stellen Sie eine Verbindung zu Ihrem Container her, auf dem die Simulationsanwendung ausgeführt wird.
Visualisieren Sie Ihre Anwendung, indem Sie die grafische Benutzeroberfläche (GUI) von Gazebo ausführen.


# 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

Sie können Ihren Bildern Tags hinzufügen. Die folgenden Befehle geben Ihnen die Möglichkeit, Ihre Bilder zu taggen.


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

Nachdem Sie überprüft haben, dass die Anwendung ordnungsgemäß funktioniert, können Sie sie mithilfe der folgenden Befehle an Amazon ECR übertragen.


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

Mit diesen Images können Sie jetzt einen Simulationsjob mit GPU Compute ausführen. Weitere Informationen zu Simulationsaufträgen finden Sie unterSimulation mitAWS RoboMaker.

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Ausführen einer Beispielanwendung mit ROS Melodic und Gazebo 9

Simulation