Chameleon/ChameleonEdge tutorials

This tutorial will let you get started using EnOSlib and Chameleon/ChameleonEdge. Chameleon provider is a specialization of the OpenStack provider (so this should be theoretically possible to work with a custom OpenStack platform, but we didn’t push too much effort on this lately :))

Here we present you the bare minimum to install the library with the required dependencies.

Hint

For a complete schema reference see Openstack Schema

Installation

# This will install the openstack clients
$ pip install enoslib[chameleon]

Note

It’s a good practice to use a virtualenv or a python version manager like pyenv.

Chameleon Bare-metal Example

The following reserve 2 nodes on the chameleon bare-metal infrastructure. The preferred way of authenticating to the Chameleon provider using EnOSlib is through application credentials (EnOSlib will transparently source your application credentials when needed)

import enoslib as en

en.init_logging()
en.check()

provider_conf = {
    "key_name": "enos_matt",
    "lease_name": "mylease",
    "rc_file": "./my-app-cred-edge-openrc.sh",  # FIXME use your OPENRC file
    "resources": {
        "machines": [
            {
                "roles": ["server"],
                "flavour": "compute_skylake",
                "number": 1,
            },
            {
                "roles": ["client"],
                "flavour": "compute_skylake",
                "number": 1,
            },
        ],
        "networks": ["network_interface"],
    },
}

tc = {
    "enable": True,
    "default_delay": "20ms",
    "default_rate": "1gbit",
}
conf = en.CBMConf.from_dictionary(provider_conf)
provider = en.CBM(conf)

roles, networks = provider.init()

roles = en.sync_info(roles, networks)

# Experimentation logic starts here
with en.actions(roles=roles) as p:
    # flent requires python3, so we default python to python3
    p.apt_repository(
        repo="deb http://deb.debian.org/debian stretch main    contrib non-free",
        state="absent",
    )
    p.apt(
        name=["flent", "netperf", "python3-setuptools", "python3-matplotlib"],
        allow_unauthenticated=True,
        state="present",
    )

with en.actions(pattern_hosts="server", roles=roles) as p:
    p.shell("nohup netperf &")

with en.actions(pattern_hosts="client", roles=roles) as p:
    p.shell(
        "flent rrul -p all_scaled "
        + "-l 60 "
        + "-H {{ hostvars[groups['server'][0]].ansible_default_ipv4.address }} "
        + "-t 'bufferbloat test' "
        + "-o result.png"
    )
    p.fetch(src="result.png", dest="result")

Note

Similarly to other provider the configuration can be generated programmatically instead of using a dict.

The result of the above code is the following:

Chameleon / ChameleonEdge Example

To mimic an FOG deployment you can claim resources on the Chameleon Infrastructure (acting as the Cloud) and the ChameleonEdge Infrastructure (acting as the Edge). The following example lets you deploy a simple Machine Learning pipeline: images are collected at the Edge and sent to the cloud for inference. We show the main script, other resources can be found in EnOSlib source code.

# Chameleon User Guide: Edge to Cloud
# This example is based on:
# https://www.chameleoncloud.org/experiment/share/37991779-fd7b-4ab0-8d6f-e726a9204946

import logging
import os
import time

import enoslib as en

en.init_logging(level=logging.INFO)
logging.basicConfig(level=logging.INFO)
en.check()

prefix = os.getlogin()
_walltime = "02:00:00"
providers = []
# Leasing resources on Chameleon Cloud
provider_conf = {
    "walltime": _walltime,
    "lease_name": f"{prefix}-enoslib-chicloud-lease",
    "rc_file": "./my-app-cred-cloud-openrc.sh",  # FIXME use your OPENRC file
    "key_name": "drosendo",  # FIXME use your key_name
    "image": "CC-Ubuntu20.04",
    "resources": {
        "machines": [
            {
                "roles": ["server"],
                "flavour": "gpu_rtx_6000",
                "number": 1,
            }
        ],
        "networks": ["network_interface"],
    },
}
conf = en.CBMConf().from_dictionary(provider_conf)
provider = en.CBM(conf)
roles, networks = provider.init()
providers.append(provider)
roles = en.sync_info(roles, networks)
floating_ip = roles["server"][0].extra["gateway"]  # 192.5.87.127

# Leasing resources on Chameleon Edge
provider_conf = {
    "walltime": _walltime,
    "lease_name": f"{prefix}-enoslib-chiedge-lease",
    "rc_file": "./my-app-cred-edge-openrc.sh",  # FIXME use your OPENRC file
    "resources": {
        "machines": [
            {
                "roles": ["client"],
                "device_name": "iot-rpi4-03",
                "container": {
                    "name": "cli-container",
                    "image": "arm64v8/ubuntu",
                },
            }
        ],
    },
}
conf = en.ChameleonEdgeConf.from_dictionary(provider_conf)
provider = en.ChameleonEdge(conf)
roles_edge, networks_edge = provider.init()
providers.append(provider)

# Merging Chameleon Cloud and Edge resources
for role, hosts in roles_edge.items():
    roles[role] = hosts
logging.info("*" * 40 + f" roles{type(roles)} = {roles}")
logging.info("*" * 40 + f" networks{type(networks)} = {networks}")

# Experimentation logic starts here
# Chameleon Cloud
dest_dir = "/tmp"
with en.play_on(roles=roles["server"]) as p:
    p.copy(src="./artifacts_cloud/", dest=dest_dir)
    p.shell(f"cd {dest_dir} && bash {dest_dir}/cloud_worker.sh > {dest_dir}/tests")
# Chameleon Edge
for device in roles["client"]:
    cmd_upload = device.upload("./artifacts_edge/", "/")
    cmd_execute = device.execute(f"bash /edge_worker.sh edge_data 100 {floating_ip}")

logging.info("Running experiment for 600 secs...")
time.sleep(600)
# How to check execution?  ssh to the Cloud server: ssh cc@<floating_ip>
# cc@<floating_ip>:~# tail -f /tmp/predict.log you may also check mosquitto
# topic (mosquitto_sub_img.py downloads images received in running dir):

# $) python mosquitto_sub_img.py --topic edge_data --mqtt_broker 192.5.87.127

# Releasing resources from Chameleon Cloud and Edge
logging.info("Releasing resources.")
for p in providers:
    p.destroy()