Creazione di un'immagine di base Creazione di un'immagine per l'applicazione robotica Creazione di un'immagine per l'applicazione di simulazione Esecuzione dell'applicazione e invio dell'applicazione a ECR

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

Il seguente tutorial mostra come utilizzare le immagini dei container per lo sviluppo con ROS e Gazebo 9 creando ed eseguendo l'applicazione e l'applicazione di simulazione robot Hello World. È possibile far funzionare l'applicazione di esempio eseguendo i comandi descritti in questo documento.

Per questo tutorial, creiamo e utilizziamo tre immagini di contenitori. Quanto segue mostra la struttura delle directory che utilizziamo per questa applicazione di esempio.


├── HelloWorldSampleAppROSMelodicGazebo9 // Base Image
│   └── Dockerfile
├── HelloWorldSampleAppROSMelodicGazebo9RobotApp // Image for Robot App
│   ├── Dockerfile
│   └── robot-entrypoint.sh
├── HelloWorldSampleAppROSMelodicGazebo9SimApp // Image for Simulation App
│   ├── Dockerfile
│   └── simulation-entrypoint.sh

Ogni Dockerfile contiene le istruzioni necessarie per creare ogni immagine.

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

Sia l'applicazione robotica che l'applicazione di simulazione dispongono di script entrypoint. Questi script forniscono gli ambienti per le rispettive applicazioni. Ti impostano il percorso per eseguire comandi che ti danno la possibilità di eseguire il tuo robot e le applicazioni di simulazione.

Creazione di un'immagine di base

Per creare un'immagine di base, salva i comandi nell'esempio per creare il tuo ambiente in un Dockerfile. Quindi, crea il Dockerfile.

Salva i seguenti comandi in un Dockerfile.


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

ENV DEBIAN_FRONTEND noninteractive

RUN apt-get clean
RUN apt-get update && apt-get install -y \
    lsb  \
    unzip \
    wget \
    curl \
    sudo \
    python-vcstool \
    python-rosinstall \
    python3-colcon-common-extensions \
    ros-melodic-rviz \
    ros-melodic-rqt \
    ros-melodic-rqt-common-plugins \
    devilspie \
    xfce4-terminal \
    ros-melodic-gazebo-ros-pkgs \
    ros-melodic-gazebo-ros-control \
    ros-melodic-turtlebot3

ENV QT_X11_NO_MITSHM=1

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

RUN sh -c 'cd /home/$USERNAME'

# Download and build our Robot and Simulation application
RUN sh -c 'mkdir -p /home/robomaker/workspace'
RUN sh -c 'cd /home/robomaker/workspace && wget https://github.com/aws-robotics/aws-robomaker-sample-application-helloworld/archive/ros1.zip && unzip ros1.zip'
RUN sh -c 'cd /home/robomaker/workspace/aws-robomaker-sample-application-helloworld-ros1'

RUN sudo rosdep fix-permissions
RUN rosdep update

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


cd ../HelloWorldSampleAppROSMelodicGazebo9
docker build -t helloworldsampleapprosmelodicgazebo9:latest .

La creazione dell'immagine di base installa ROS Melodic e Gazebo 9. È necessario installare entrambe le librerie per eseguire correttamente le applicazioni.

Creazione di un'immagine per l'applicazione robotica

Dopo aver creato l'immagine di base, crea l'immagine per la tua applicazione robot.

Salva il seguente script in un Dockerfile e crealo. 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 helloworldsampleapprosmelodicgazebo9:latest

# Build the Robot application
RUN cd /home/robomaker/workspace/aws-robomaker-sample-application-helloworld-ros1/robot_ws && \
 /bin/bash -c "source /opt/ros/melodic/setup.bash && vcs import < .rosinstall && rosdep install --rosdistro melodic --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 roslaunch hello_world_robot rotate.launch
ENTRYPOINT [ "/home/robomaker/robot-entrypoint.sh" ]

Usa il seguente comando per creare l'immagine per l'applicazione robot dal Dockerfile.


cd HelloWorldSampleAppROSMelodicGazebo9RobotApp/HelloWorldSampleAppROSMelodicGazebo9RobotApp 
docker build -t helloworldsampleapprosmelodicgazebo9robotapp:latest image/.

Di seguito sono riportati i contenuti dello script che è possibile salvare comerobot-entrypoint.sh. Questo script fornisce l'ambiente per l'applicazione robotica.


#!/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-ros1/robot_ws
source /opt/ros/melodic/setup.bash
source /usr/share/gazebo-9/setup.sh
source ./install/setup.sh

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

printenv

exec "${@:1}"

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.

Salva il seguente script in un Dockerfile e crealo. 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 helloworldsampleapprosmelodicgazebo9:latest

# Build the Simulation application
RUN cd /home/robomaker/workspace/aws-robomaker-sample-application-helloworld-ros1/simulation_ws && \
    /bin/bash -c "source /opt/ros/melodic/setup.bash && vcs import < .rosinstall && rosdep install --rosdistro melodic --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 roslaunch hello_world_simulation empty_world.launch
ENTRYPOINT [ "/home/robomaker/simulation-entrypoint.sh" ]

Salva quanto seguesimulation-entrypoint.shsceneggiatura. 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-ros1/simulation_ws
source /opt/ros/melodic/setup.bash
source /usr/share/gazebo-9/setup.sh
source ./install/setup.sh

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

printenv

exec "${@:1}"

Esecuzione dell'applicazione e invio dell'applicazione a ECR

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

Usa i seguenti comandi per eseguire l'applicazione Hello World nel tuo ambiente Linux locale.


docker run -it -e DISPLAY -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 \
helloworldsampleapprosmelodicgazebo9robotapp:latest


docker run -it -e DISPLAY -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 \
helloworldsampleapprosmelodicgazebo9simapp:latest

Esegui i contenitori delle applicazioni robotiche e delle applicazioni di simulazione per visualizzare la simulazione utilizzando lo strumento GUI 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 sim_app bash

# Launch Gazebo from within the container
$ rosrun gazebo_ros gzclient

Aggiungi tag alle tue immagini per tenerle organizzate. Usa i seguenti comandi per etichettare le tue immagini.


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


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

Dopo aver verificato il corretto funzionamento dell'applicazione, puoi inviare il push 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/helloworldsampleapprosmelodicgazebo9robotapp:latest 
docker push accountID.dkr.ecr.us-west-2.amazonaws.com/helloworldsampleapprosmelodicgazebo9simapp:latest

È quindi possibile eseguire un processo di simulazione sull'immagine. 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 2 Foxy e Gazebo 11

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