AWS RoboMaker Sample Application - CloudWatch Monitoring

Monitor health and operational metrics for a fleet of robots in a simulated home using AWS CloudWatch Metrics and AWS CloudWatch Logs. Streamed metrics include speed, distance to nearest obstacle, distance to current goal, robot CPU utilization, and RAM usage.

It demonstrates how to emit metrics and logs to AWS CloudWatch to monitor your robots.

RoboMaker sample applications include third-party software licensed under open-source licenses and is provided for demonstration purposes only. Incorporation or use of RoboMaker sample applications in connection with your production workloads or a commercial products or devices may affect your legal rights or obligations under the applicable open-source licenses. Source code information can be found here.

Installation

The following will be installed

Colcon - Used for building and bundling the application.
vcstool - Used to pull in sample app dependencies that are only available from source, not from apt or pip.
rosdep - rosdep is a command-line tool for installing system dependencies of ROS packages.

If ROS is detected, then ROS Installation will be skipped.

ROS Melodic - Other versions may work, however they have not been tested

AWS Setup

AWS Credentials

You will need to create an AWS Account and configure the credentials to be able to communicate with AWS services. You may find AWS Configuration and Credential Files helpful.

AWS Permissions

To run this application you will need an IAM user with the following permissions:

   logs:PutLogEvents
   logs:DescribeLogGroups
   logs:DescribeLogStreams
   logs:CreateLogStream
   logs:CreateLogGroup

You can find instructions for creating a new IAM Policy here. In the JSON tab paste the following policy document:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "CloudWatchRobotRole",
      "Effect": "Allow",
      "Action": [
        "cloudwatch:PutMetricData",
        "logs:PutLogEvents",
        "logs:DescribeLogGroups",
        "logs:DescribeLogStreams",
        "logs:CreateLogStream",
        "logs:CreateLogGroup"
      ],
      "Resource": "*"
    }
  ]
}

Build

Install requirements

Follow links above for instructions on installing required software.

Full Setup Including ROS Install currently only melodic is supported, ROS Installation will be skipped if its already present.

source scripts/setup.sh

Robot

cd robot_ws
colcon build

Simulation

cd simulation_ws
colcon build

Run

The TURTLEBOT3_MODEL environment variable must be set when running both robot and simulation application. Currently only waffle_pi is supported. Set it by

export TURTLEBOT3_MODEL=waffle_pi

Launch the application with the following commands:

Running Robot Application on a Robot

source robot_ws/install/local_setup.sh
roslaunch cloudwatch_robot deploy_rotate.launch

Running Robot Application in a Simulation
```
source robot_ws/install/local_setup.sh
roslaunch cloudwatch_robot [command]
```
There are two robot launch commands:
- rotate.launch - The robot starts rotating
- await_commands.launch - The robot is idle waiting movement commands, use this for teleop and navigation
Running Simulation Application
```
source simulation_ws/install/local_setup.sh
roslaunch cloudwatch_simulation [command]
```
There are three simulation launch commands for three different worlds:
- empty_world.launch - Empty world with some balls surrounding the turtlebot at (0,0)
- bookstore_turtlebot_navigation.launch - A retail space where the robot navigates to random goals
- small_house_turtlebot_navigation.launch - A retail space where the robot navigates to random goals
Alternatively, to run turtlebot navigation to follow dynamic goals,
```
roslaunch cloudwatch_simulation [command] follow_route:=false dynamic_route:=true
```

Note that when running robot applications on a robot, use_sim_time should be set to false (which is the default value in deploy_rotate.launch and deploy_await_commands.launch). When running robot applications along with simulation applications, use_sim_time should be set to true for both applications (which is the default value in rotate.launch, await_commands.launch and all the launch files in simulation workspace).

When running simulation applications, run command with gui:=true to run gazebo client for visualization.

For navigation, you can generate a map with map generation plugin. See this for instructions.

Run with a AWS Robomaker WorldForge world

Pre-requisite: Generate a map for your worldforge exported world following these instructions.

Build your workspace to reference the newly generated maps,

cd simulation_ws
colcon build

Launch the navigation application with the following commands:

export TURTLEBOT3_MODEL=waffle_pi
source simulation_ws/install/local_setup.sh
roslaunch cloudwatch_simulation worldforge_turtlebot_navigation.launch

Monitoring with CloudWatch Logs

Robot logs from ROS nodes are streamed into CloudWatch Logs to Log Group robomaker_cloudwatch_monitoring_example. See cloudwatch_robot/config/cloudwatch_logs_config.yaml.

Monitoring with CloudWatch Metrics

Robot metrics from ROS nodes are reported into CloudWatch Metrics robomaker_cloudwatch_monitoring_example. Metric resolution is configured at 10 seconds. See cloudwatch_robot/config/cloudwatch_metrics_config.yaml.

Operational metrics include:

linear speed
angular speed
distance to nearest obstacle (closest lidar scan return)
distance to planned goal (bookstore only, requires its navigation system)

Health metrics include CPU and RAM usage.

Using this sample with RoboMaker

You first need to install colcon-ros-bundle. Python 3.5 or above is required.

pip3 install colcon-ros-bundle

After colcon-ros-bundle is installed you need to build your robot or simulation, then you can bundle with:

# Bundling Robot Application
cd robot_ws
source install/local_setup.sh
colcon bundle

# Bundling Simulation Application
cd simulation_ws
source install/local_setup.sh
colcon bundle

This produces the artifacts robot_ws/bundle/output.tar and simulation_ws/bundle/output.tar respectively.

You'll need to upload these to an s3 bucket, then you can use these files to create a robot application, create a simulation application, and create a simulation job in RoboMaker.

Generate Occupancy Map via map generation plugin

Procedurally generate an occupancy map for any gazebo world. This map can then be plugged in to navigate a robot in Worldforge worlds. For other aws-robotics worlds, this procedure is optional for the use-cases mentioned in this README.

Generate map for a aws-robotics world with default config

Currently, the following aws-robotics worlds are supported,

To generate a map, simply run

./scripts/genmap_script.sh <world_name>

where <world_name> can be any value in the list above.

Generate map for a WorldForge world with default config

After exporting a world from WorldForge, unzip and move the contents under simulation_ws workspace

unzip exported_world.zip
mv aws_robomaker_worldforge_pkgs simulation_ws/src/

#For worldforge worlds, set WORLD_ID to the name of your WF exported world (eg: generation_40r67s111n9x_world_3),
export WORLD_ID=<worldforge-world-name>

# Run map generation script
./scripts/genmap_script.sh worldforge

Generate map for a custom world with custom config

# Install dependencies (Ubuntu >18.04)
sudo apt-get install ruby-dev libxml-xpath-perl libxml2-utils

# Fetch and install ROS dependencies
cd simulation_ws
vcs import < .rosinstall
rosdep install --from-paths src -r -y
cd ..

# Run plugin with custom world/config,
python scripts/add_map_plugin.py custom -c <path-to-config> -w <path-to-world> -o <output-path>

# Build with plugin added
cd simulation_ws
colcon build
source install/local_setup.sh

# Start map service (for custom worlds, relocate your world file with the added plugin to src/cloudwatch_simulation/worlds/map_plugin.world before running this)
roslaunch cloudwatch_simulation start_map_service.launch

# Generate map (start in a different terminal AFTER you see "[INFO] [*] occupancy map plugin started" message in previous terminal)
rosservice call /gazebo_2Dmap_plugin/generate_map

# Save map
rosrun map_server map_saver -f <path-to-file> /map:=/map2d

# Move the generated map file to cloudwatch_simulation simulation workspace map directory
mv <path-to-file> simulation_ws/src/cloudwatch_simulation/maps/map.yaml

AWS ROS Packages used by this Sample

RoboMakerUtils-Common
RoboMakerUtils-ROS1
CloudWatch-Common
CloudWatchLogs-ROS1
CloudWatchMetrics-ROS1
HealthMetricsCollector-ROS1
MonitoringMessages-ROS1

License

MIT-0 - See LICENSE for further information

How to Contribute

Create issues and pull requests against this Repository on Github

malife/aws-robomaker-sample-application-cloudwatch