This page describes basic information about CREATE Containers and provides an overview of how to use it. More details are available in the Containers Guide.
What are Containers?
The Containers system enables experimenters to create large-scale CREATE topologies that support differing degrees of fidelity in individual elements. In order to create an experiment larger than the 400+ computers available in CREATE Core, experimenters must use virtualization, simulation, or some other abstraction to represent their topology. The Containers system guides this process allowing experimenters to create large experimental environments that may be used to gather correct results.
The Containers system is built on top of the resource allocation that underlies the CREATE testbed, extending it to provide multiple implementations of virtual nodes. Most CREATE tools that run on physical experiments may be used directly on containerized experiments. Experimenters find working in a containerized experiment very similar to working in physical CREATE experiments.
How does it work?
An experimenter comes to CREATE with an experimental topology of computers and networks and an experiment to carry out on that topology, and the Containers system allocates resources in the configuration specified. The experimenter may directly access the computers in order to carry out the experiment. The computers themselves are either physical computers or some virtual computers that emulate a computer at an acceptable level of fidelity. Multiple experiments may be in progress at once using DETER resources, and they are protected from interfering with one another.
Containers present researchers with more resources while preserving the CREATE interfaces. The process of converting a topology description to an isolated collection of networked computers is basically the same as when an experimenter creates a physical topology on CREATE. The difference is that a containerized experiment is configured to present more experimental resources than physical ones, preserving the CREATE interface.
A little more completely, the Containers system lays out the virtual computers into a physical layout of computers and uses the resource allocation system to allocate that physical layout. Then the system installs and configures the appropriate virtualization technologies in that environment to create the virtual environment.
As in physical CREATE experiments, the experiment's topology is written in an extended version of DETER's ns2 syntax, or in topdl, a topology description language.
Currently experimenters pick containers directly using those languages.
Kinds of Containers
A container is a virtualization technology, like a virtual machine implementation. We use the term ''container'' to mean any one of the various virtualization technologies from an openvz container to a physical machine to a simulation. The Containers system gives us a way to create interconnections of containers (in our sense) holding different experiment elements. A containerized topology might include a physical machine, a qemu virtual machine and an openvz container that can all communicate transparently.
The Containers system framework supports multiple kinds of containers, but at this point researchers may request these:
|Physical Machine||Complete fidelity||1 per physical machine|
|Qemu virtual Machine||Virtual hardware||10's of containers per physical machine|
|Openvz container||Partitioned resources in one Linux kernel||100's of contatiners per physical machine|
|ViewOS process||Process with isolated network stack||1000's of containers per physical machine|
How do I use Containers?
In general, once you have a CREATE account, you follow these steps. The CREATE Containers Guide will walk you through a basic tutorial of these steps.
1. Design the topology
Every experiment in CREATE is based on a network topology file written in NS format and saved on the
users node. In a containerized experiment, the topology will typically be a large one with more than 400 nodes.
sample of topology
2. Run containerized experiment with the containerize.py command
The Containers system will build the containerized experiment on top of an existing CREATE physical experiment by running the
containerize.py command from the shell on
users.create.iucc.ac.il, as in the following example:
$ /share/containers/containerize.py DeterTest example1 ~/example1.tcl
where ''DeterTest'' and ''example1'' are the project and experiment name, respectively, of the physical CREATE experiment and ''example.tcl'' is the topology file.
With these default parameters,
containerize.py will put each node into an Openvz container with at most 10 containers per physical node.
3. View results by accessing nodes, modify the experiment as needed.
In a containerized experiment, you can access the virtual nodes with the same directories mounted as in a physical CREATE experiment. You can load and run software and conduct experiments as you would in a physical experiment.
4. Save your work and swap out your experiment (release the resources)
As with all CREATE experiment, when you are ready to stop working on an experiment but know you want to work on it again, save your files in specific protected directories and swap-out (via web interface or commandline) to release resources back to the testbed. This helps ensure there are enough resources for all CREATE users.
For more detailed information about Containers, read the following: