Chameleon is always chasing the frontier of research, a task made all the more difficult by the various directions the frontier is spreading. One such interesting area is edge computing and IoT. That's why, last year, we worked to build a new testbed tailoring to the needs of research on the edge—we call it CHI@Edge!
What's in a name?
First, it's important to define what we mean by "edge," as the terminology is still evolving and there are many interpretations of what an edge device is. CHI@Edge currently is built for what we call "fat" devices: single-board computers with relatively high processing capabilities, yet low power consumption and form factor. This is in our estimation the category of devices most widely deployed at the edge today. The CHI@Edge testbed has support for Raspberry Pis, as well as Jetson Nano and Jetson Xavier devices.
As a user interested in edge research, you can make leases for exclusive use of one or more of these devices. You can then launch application containers directly on the device via a web, Python, or command line interface. Any containers you launch are internally networked and addressable, allowing you to create many different network topologies across a large physical area. You can also use a Floating IP to allow public connectivity to a container from the internet. Most aspects of the container can be controlled by you, such as the image, execution environment, command string, even mounted configuration files or Linux devices. With these building blocks, you can express a wide variety of edge and IoT experiments.
Last summer we released an early preview of CHI@Edge, which was immediately popular and used by many projects, culminating in a community workshop on edge to cloud experimentation. Researchers used CHI@Edge to profile workloads across different device types, deploy code for autonomous aquatic vehicles tasked with surveying fish populations, and create the foundation for a new wireless testbed.
Counting fish with object detection models deployed at the edge. Read the blog about this project!
In general, we noticed several patterns. Researchers often wanted to collect data at the edge, with a variety of local sensors or other connected peripherals. That data may be processed on the device, or sent to the cloud (a significant number of questions arise on when it's worthwhile to pay the network cost in this arrangement.) The availability of GPUs or other accelerators on the edge introduces even more research opportunities as to local processing and decision-making. Increasingly, it became clear that we as testbed operators would not be able to provide enough hardware in enough places to properly serve the research community by ourselves. Therefore, it was paramount that, in an edge environment, we allow our users to bring their own devices, using CHI@Edge to manage the complexity around provisioning and access management.
Bring Your Own Device
Enrolling a device you already control to CHI@Edge comes with several benefits:
You can manage your device with powerful yet friendly interfaces, without compromising on ownership—you can keep your device exclusive to you and your collaborators.
You avoid solving problems of application provisioning and network connectivity through firewalls or NATs.
You can temporarily share access to the device with others, for example during digital artifact review.
You can use one set of interfaces to instrument both the cloud and the edge, making it much simpler to perform such experiments.
For example, one of our users teaches a class on self-driving cars (read more in the workshop report). He created several custom car rigs, consisting of a modified RC car and front-facing camera integrated with a Raspberry Pi. Each car's Pi was enrolled in CHI@Edge. The instructor did not need to set up any special networking for the cars except allowing them access to a WiFi network. The cars could only be reserved by students, who could then use a Jupyter Notebook to deploy new code to the cars and remotely start their test runs. Detailed race data could be saved or uploaded to the cloud after each run. Students could experiment with training the model on Chameleon's bare metal testbed, which has much more powerful GPUs. CHI@Edge made it easier for the instructor to introduce students to the important parts of the class, as the testbed handled complexities around networking the cars to a control plane, managing the lifecycle of code deployed to the car, and remote access and Jupyter integration.
Adding a device you already own to the testbed is easy with the CHI@Edge SDK, which you can install via Pip, the Python package manager. The SDK comes with a simple CLI tool that lets you manage any devices you've enrolled. You can see all your devices and their status, and get more details about a particular device's state, but most importantly can enroll new devices. Device enrollment consists of downloading a supported base image, "baking" it with device-specific information generated by the SDK, and then flashing the image onto an SD card and inserting it into your target device–that's it! Once the device powers on, it will self-register and appear in the CHI@Edge web interface, at which point you can reserve it via any supported testbed interface and use it just like any of the Chameleon-provided devices. You can connect various peripherals to your device to add, e.g., additional USB storage, camera or GPIO or serial interface. It's also possible to allow access to local networks the device is connected to, if you wish. Many things are possible and we're still exploring use cases with our edge community.
You can get started with CHI@Edge immediately by making a reservation for any of the devices installed and maintained by the Chameleon team. These include numerous Raspberry Pis, Jetson Nanos and Xaviers (with GPUs.) Some of these devices have additional capabilities, like an attached camera. If you already have a compatible device, use the CHI@Edge SDK to enroll it and start taking advantage of the testbed platform!
To see an example of a full edge-to-cloud experiment setup, expressed as a Jupyter Notebook, refer to our Edge-to-Cloud User Guide on Trovi.
Check out a screencast we put together, which describes the edge testbed and also covers device enrollment.
To learn more about CHI@Edge and see what others are doing on the testbed, check out our Google Group—we announce new platform features and changes there, as well as answer questions and solicit feedback. Help us shape the testbed to make your research possible!