skip to navigation
skip to content

Not Logged In

cloudlet 0.8

Cloudlet library for cloud computing at the edge

Latest Version: 0.8.2

Elijah: Cloudlet Infrastructure for Mobile Computing
A cloudlet is a new architectural element that arises from the convergence of
mobile computing and cloud computing. It represents the middle tier of a
3-tier hierarchy:  mobile device - cloudlet - cloud.   A cloudlet can be
viewed as a "data center in a box" whose  goal is to "bring the cloud closer".
A cloudlet has four key attributes:

Copyright (C) 2011-2012 Carnegie Mellon University
This is a developing project and some features might not be stable yet.
Please visit our website at [Elijah page](


All source code, documentation, and related artifacts associated with the
cloudlet open source project are licensed under the [Apache License, Version


You will need:

* qemu-kvm
* libvirt-bin
* gvncviewer
* python-libvirt
* python-xdelta3
* python-dev (for message pack)
* liblzma-dev (for pyliblzma)
* Java JRE (for UPnP server)
* apparmor-utils (for disable apparmor for libvirt)
* libc6-i386 (for extracting free memory of 32 bit vm)
* python library
    - bson
        - pyliblzma
        - psutil
        - SQLAlchemy
        - fabric

To run install script:

                > $ sudo apt-get install fabric openssh-server
                > $ fab localhost install

To install manually:

        1. install required package
                        > $ sudo apt-get install qemu-kvm libvirt-bin gvncviewer python-libvirt python-xdelta3 python-dev openjdk-6-jre liblzma-dev apparmor-utils libc6-i386 python-pip
                        > $ sudo pip install bson pyliblzma psutil sqlalchemy

        2. Disable security module. This is for allowing custom KVM.
        Example at Ubuntu 12

                        > $ sudo aa-complain /usr/sbin/libvirtd

        3. add current user to kvm, libvirtd group.

                        > $ sudo adduser [your_account_name] kvm
                        > $ sudo adduser [your_account_name] libvirtd

        4. change permission of the fuse access (The qemu-kvm library changes fuse
           access permission while it's being installed, and the permission is
           recovered if you reboot the host.  We believe this is a bug in qemu-kvm
           installation script, so you can either reboot the machine to have valid
           permission of just revert the permission manually as bellow).

                   > $ sudo chmod 1666 /dev/fuse

Recommended platform

We have tested at __Ubuntu 12.04 LTS 64-bit__

This version of Cloudlet has several dependencies on other projects for
further optimization, and currently we include this dependency as a binary.
Therefore, we recommend you to use __Ubuntu 12.04 LTS 64-bit__

How to use

1. Creating ``base vm``.
        You will first create ``base vm`` from a regular VM disk image. This ``base
        vm`` will be a template VM for overlay VMs. To create ``base vm``, you need
        regular VM disk image in a raw format.

        > $ cd ./bin
        > $ ./cloudlet base /path/to/base_disk.img
        > (__Use raw file format__)

        This will launch remote connection(VNC) to guest OS and cloudlet module
        will automatically start creating ``base vm`` when you close VNC window.
        After finishing all the processing, you can check generated ``base vm``
        using below command.

        > $ cd ./bin
        > $ ./cloudlet list_base

2. Creating ``overlay vm`` on top of ``base vm``.
    Now you can create your customized VM based on top of ``base vm``

        > $ cd ./bin
        > $ ./cloudlet overlay /path/to/base_disk.img

        This will launch VNC again. On top of this ``base vm``, you can install(and
        execute) your custom server. For example, if you're a developer of ``face
        recognition`` backend server, we will install required libraries and start
        your server. Cloudlet will automatically extracts this customized part from
        the ``base vm`` when you close VNC, and it will be your overlay.

        ``overlay VM`` is composed of 2 files; 1) ``overlay-meta file`` ends with
        .overlay-meta, 2) compressed ``overlay blob files`` ends with .xz

        Note: if your application need specific port and you want to make a port
        forwarding host to VM, you can use -redir parameter as below.

        > $ ./cloudlet overlay /path/to/base_disk.img -- -redir tcp:2222::22 -redir tcp:8080::80

        This will forward client connection at host port 2222 to VM's 22 and 8080
        to 80, respectively.

        ### Note

        If you have experience kernel panic error like
        [this](, You should
        follow workaround of this link. It happens at a machine that does not have
        enough memory with EPT support, and you can avoid this problem by disabling
        EPT support. We're current suspicious about kernel bug, and we'll report
        this soon.

3. Synthesizing ``overlay vm``

        Here, we'll show 3 different ways to perform VM synthesis using ``overlay
        vm`` that you just generated; 1) verifying synthesis using command line
        interface, 2) synthesize over network using desktop client, and 3)
        synthesize over network using Android client.

    1) Command line interface: You can resume your ``overlay vm`` using

        > $ cd ./bin
        > $ ./cloudlet synthesis /path/to/base_disk.img /path/to/overlay-meta

    2) Network client (python version)

        We have a synthesis server that received ``VM synthesis`` request from
        mobile client and you can start the server as below.

        > $ cd ./bin
        > $ ./server

        You can test this server using the client. You also need to copy the
        overlay that you like to reconstruct to the other machine when you execute
        this client.

        > $ ./ -s [cloudlet ip address] -o [/path/to/overlay-meta]

    3) Network client (Android version)

        We have source codes for android client at ./src/client/andoid and you can
        import it to ``Eclipse`` as an Android porject. This client program will
        automatically find nearby Cloudlet using UPnP if both client and Cloudlet
        are located in same broadcasting domain (ex. share WiFi access point)

        Once installing application at your mobile device, you should copy your
        overlay VM (both overlay-meta and xz file) to Android phone. You can copy
        it to /sdcard/Cloudlet/overlay/ directory creating your overlay directory
        name.  For example, you can copy your ``face recognition overlay vm`` to
        /sdcard/Cloudlet/overlay/face/ directory. This directory name will be
        appeared to your Android application when you're asked to select ``overlay
        vm``.  Right directory name is important since the directory name will be
        saved as appName in internal data structure and being used to launch
        associated mobile application after finishing ``VM synthesis``. See more
        details at handleSucessSynthesis() method at file.

Compiling external library that Cloudlet uses

You will need:

* qemu-kvm 1.1.1 (for Free memory and TRIM support)
* libc6-dev-i386 (for Free memory support)

Research works

* [The Case for VM-based Cloudlets in Mobile Computing](
* The Impact of Mobile Multimedia Applications on Data Center Consolidation (To be appeared)
* [Just-in-Time Provisioning for Cyber Foraging](
* [Scalable Crowd-Sourcing of Video from Mobile Devices](
File Type Py Version Uploaded on Size
cloudlet-0.8.tar.gz (md5) Source 2013-08-16 5MB
  • Downloads (All Versions):
  • 74 downloads in the last day
  • 301 downloads in the last week
  • 709 downloads in the last month