Last Thursday, 16th of February, a Cloud Computing and OpenNebula workshop took place in Timisoara, Romania. The event was organized by a team of passionate people as an initiative to spread the word about Cloud Computing in Romania. This was the first of a series of events that are going to take place around the country, especially in the cities with internationally recognized technical Universities.

The Workshop consisted of two parts. The first part was a presentation about Cloud Computing as a concept and how Cloud Computing revolutionizes the use and deployment of IT services. The pay-as-you-grow billing model was emphasized because it helps new startups and individuals.

In the second part of the event I talked about the open source ecosystem and OpenNebula. I presented the OpenNebula architecture with emphasis on Sunstone. I haven’t presented OpenNebula in greater detail because I wanted to show the participants how easy it is to use a Cloud after it’s set up. In the next events I am planning to do a live installation together with the participants, along with a thorough explanation and presentation of OpenNebula’s internal architecture.

A small use case was shown, the implementation of an email Cloud using OpenNebula, Postfix and Cyrus-IMAP. I started with stock Debian Squeeze (6.0.4) images and with the help of the contextualization mechanism from OpenNebula I built the VM to deliver the service. The Cyrus-IMAP mailboxes, and VM files are stored on MooseFS.  I will post details about the system on this blog in the near future. I am also building a git online repo with the contextualization scripts I have used in case anybody needs them.

Taking into account the number of participants, around 35 people, and the positive feedback I have received after the event I can say that the event was a success. You can find more details about the workshop on our Facebook page. Thank you OpenNebula community for this wonderful software you are all working on!

Yesterday we presented at Cloudscape IV how a fully open cloud solution, like OpenNebula, is helping to unleash the innovation of cloud computing. OpenNebula is used by thousands of organizations to build their private cloud infrastructure. These companies, research centers  and public entities seek to cut costs, to improve their existing IT services, or to support new innovative service models. Moreover, OpenNebula is also an open cloud enabler that is helping many players in the ICT Industry to be cloud active. OpenNebula is enabling many hosting companies and telcos to offer cloud services, many technology companies to offer cloud products, and many service companies to offer cloud consulting and integration.

CloudScape IV was also an opportunity to announce the release of the last version of the new enhanced Hyper-V drivers, and to see the wide adoption of OpenNebula in the leading international projects working in cloud computing innovation and interoperability in the area of research infrastructures. Projects like VenusC, building a highly-scalable and flexible cloud infrastructure; BonFIRE, building a multi-site cloud facility for applications, services and systems research and experimentation; EGI, building a federated cloud in the European grid infrastructure; StratusLab, building a software distribution to enhance grid infrastructures with virtualization and cloud technologies; and Helix Nebula, building and european scientific cloud computing infrastructure, presented their use of OpenNebula, and how its standard APIs are helping them to offer interoperability and portability to their consumers.

Thanks for using OpenNebula and for contributing to our community!

Written in conjunction with Tino Vazquez, of the OpenNebula Project, and cross-posted on the Puppet blog.

Puppet is used for managing the infrastructure for many IaaS software packages, including Eucalyptus, OpenStack, and OpenNebula. OpenNebula is an IaaS manager which can not only manage a large amount of different virtalization and public cloud platforms, it can also emulate the API’s provided by EC2 and OCCI. It’s great for creating private and public clouds, as well as hybrids of the two.

Puppet Labs (or, more specifically, Ken Barber) has developed a powerful integration between OpenNebula and Puppet. The installation and configuration of OpenNebula be managed with this solution, and a virtualized infrastructure can be provisioned starting from bare metal using only Puppet recipes. The module for Puppet that integrates with OpenNebula can be downloaded from the Forge here: http://forge.puppetlabs.com/puppetlabs/opennebula

Installation and Configuration

The Puppet module contains several classes, types and providers for managing OpenNebula resources and installing OpenNebula.

The class ‘opennebula::controller’ is used for managing the main controller node for OpenNebula and is a simple class. An example usage would be:

class { "opennebula::controller":
  oneadmin_password => "mypassword",
}

This will configure the necessary parts for the main controller node, applying the necessary password for the primary ‘oneadmin’ user.

The class opennebula::node can be applied to nodes that will act as hypervisors. This class configures the necessary package and SSH authorization that is used by the SSH transfer, information and virtualization driver in OpenNebula.

The class itself really needs to know the location of its master, and uses stored configurations for shipping the necessary SSH keys across:

class { "opennebula::node":
  controller => "one1.mydomain.com",
}

The Sunstone GUI can be remotely managed using the ‘opennebula::sunstone’ class. The module also can manage the EC2 gateway using ‘opennebula::econe’.

Managing OpenNebula Resources

OpenNebula has many elements that can be managed on the command line:

  • Hosts
  • Images
  • Virtual Networks
  • Virtual Machines

What’s great about OpenNebula is that the same resources can be managed using their own GUI, namely ‘Sunstone’:

Sunstone

We provide some resource types through the Puppet OpenNebula module that allow managing these elements via Puppet as well. The detailed documentation for each of these is provided in the README file for the module, but let’s talk about one in particular: the onevm resource.

The onevm resource allows you to actually manage a virtual machine as if it was a Puppet resource. An example usage in Puppet would be:

onevm { "db1.vms.cloud.bob.sh":
  memory => "256",
  cpu => 1,
  vcpu => 1,
  os_arch => "x86_64",
  disks => [
    { image => "debian-wheezy-amd64",
      driver => "qcow2",
      target => "vda" }
  ],
  graphics_type => "vnc",
  graphics_listen => "0.0.0.0",
  context => {
    hostname => '$NAME',
    gateway => '$NETWORK[GATEWAY]',
    dns => '$NETWORK[DNS]',
    ip => '$NIC[IP]',
    files => '/var/lib/one/context/init.sh',
    target => "vdb",
  }
}

As you can see, this mirrors all of the options made available via the template when creating virtual machines using the command line or Sunstone GUI in OpenNebula:

options

Using Puppet provides just another capability for managing OpenNebula. Upon creation, the VM will be created just like any other VM and now appear when running ‘onevm list’ or viewing the list of virtual machines in Sunstone:

the list of virtual machines in sunstone

Managing Applications End-to-End

An end-to-end example to demonstrate the capabilities of this integration is the deployment of a sample pastie/pastebin application with redundant web servers:

OG- application architecture

The sample content to build such an infrastructure is located here: http://github.com/kbarber/puppet-onedemo

In this demo content we deploy the IaaS manager OpenNebula, correctly configured and including its dependencies like libvirt. We then use the newly installed virtualization engine to start a virtualized application consisting of web servers behind a load balancer.

Combining OpenNebula and Puppet allows you to achieve a fairly complete end-to-end architecture for rapid deployment within a private cloud infrastructure. The following diagram shows some of the necessary elements in such an end-to-end architecture:

Development Progress

Currently the puppetlabs-opennebula module is OpenNebula 2.2 specific, but we are looking to add OpenNebula 3.0 support once it becomes available in the distributions (such as Debian). If you like the idea of having Puppet manage OpenNebula for installation, configuration or for management we are looking for more code contributors, testers and users.

Bugs can be raised in the Puppet Redmine project for our public modules here.

And the code is available here: https://github.com/puppetlabs/puppetlabs-opennebula

Any help or comments are much appreciated, your feedback will be used to refine the integration and make it more functional. We are confident that this integration adds value to your IaaS and Private Cloud projects, and we hope you enjoy using it as much as we did implementing it.

Additional Resources

  • More information on the Puppet/OpenNebula integration, in slides and video.

A new How-to has been included in the OpenNebula Community Wiki. This guide can be used to develop new drivers in order to interact with external Cloud providers in an OpenNebula Hybrid Cloud deployment.  Currently the OpenNebula distribution includes drivers to interact with EC2 to combine local resources with resources from EC2 .

Link:  How to Develop a New Driver to Interact with an External Cloud Provider

C12G Labs is pleased to announce that a new stable version of the OpenNebula VMware Addon has been contributed to the OpenNebula Project. The major objective with this release is to provide compatibility, and a much better integration, between the Addon and the new OpenNebula 3.0 and to include several bug fixes.

C12G Labs would like to point out that the OpenNebula Project fully endorses these extensions and supports them through the user mailing list. Moreover, the project ensures its full compatibility with current and upcoming releases of OpenNebula.

After the release of OpenNebula 3.0 (IRIS)C12G Labs is pleased to announce that a development version of the OpenNebula Addons has been contributed to the OpenNebula Project. The major objective with this release is to provide compatiblity between the Addons and the new OpenNebula 3.0. The contributed components are:

  • LDAP Authentication Module that permits users to have the same credentials as in LDAP, so effectively centralizing authentication. Now tested against OpenNebula 3.0.
  • Accounting Toolset that visualizes and reports resource usage data, and allows their integration with chargeback and billing platforms. Now tested against OpenNebula 3.0.

The VMware Driver Addon, which enables the management of an OpenNebula cloud based on VMware ESX and VMware Server hypervisors, has been available since the Beta release of  OpenNebula 3.0.

C12G Labs would like to point out that the OpenNebula Project endorses these extensions and supports them through the user mailing list. Moreover, the project ensures its full compatibility with current and upcoming releases of OpenNebula.

The OpenNebula project is happy to announce the release of a development version of the new plug-ins to build clouds based on Xen Cloud Platform. This new prototype, developed by C12G Labs and first result of the collaboration between OpenNebula and Xen announced last week, allows users to build and manage OpenNebula clouds on XCP.

The new components, which are available for download as a new OpenNebula ecosystem project, bring the rich capabilities of XenAPI to OpenNebula. XCP provides a complete cloud platform to OpenNebula, with enhanced security, storage and network virtualization. Meanwhile, OpenNebula provides cloud orchestration to XCP with adaptable, extensible, proven, and interoperable data center virtualization management.

The OpenNebula project provides support for the deployment and tuning of the new drivers through its ecosystem mailing list.

The Xen.org and OpenNebula.org open source communities are working together to add XCP support to OpenNebula. This collaboration will produce the OpenNebula Toolkit for XCP, which will be hosted as freely available open source project on OpenNebula.org. The XCP project team and Xen.org community will provide technical guidance and assistance to the OpenNebula open-source project.

“We are really excited to collaborate with Xen.org in offering Xen Cloud Platform support. This will be a huge step forward towards achieving a complete open-source stack for cloud infrastructure deployment. We are planning to have a first prototype of the integration by November.” said Ignacio M. Llorente, Director of OpenNebula Project and Chief Executive Advisor at C12G Labs.

“I am really pleased that Xen and OpenNebula are collaborating on a new project, building on a history that goes all the way back to 2008, OpenNebula 1 and Xen 3.1. This renewed collaboration, together with projects such Kronos which will deliver XCP with different Linux distributions, will make building rich Xen based clouds much easier.” said Ian Pratt, Chairman of Xen.org and SVP, Products at Bromium.

OpenNebula is a fully open-source, Apache licensed toolkit for on-premise IaaS cloud computing, offering a comprehensive solution for the management of virtualized data centres to enable private, public and hybrid clouds. OpenNebula interoperability makes cloud an evolution by offering common cloud standards and interfaces, leveraging existing IT infrastructure, protecting existing investments, and avoiding vendor lock-in. OpenNebula is used by many research projects as a powerful tool for innovation and interoperability, and by thousands of organizations to build large-scale production clouds using KVM, Xen and VMware. This new collaboration will extend Xen support in OpenNebula to include XCP, bringing the rich capabilities of XenAPI to OpenNebula.

XCP is an open source, GPLv2 licensed, enterprise-ready server virtualization and cloud computing platform, delivering the Xen Hypervisor with support for a range of guest operating systems including Windows® and Linux® network and storage support, management tools in a single, tested installable image. XCP addresses the needs of cloud providers, hosting services and data centres by combining the isolation and multi-tenancy capabilities of the Xen hypervisor with enhanced security, storage and network virtualization technologies to offer a rich set of virtual infrastructure cloud services. In addition, XCP addresses user requirements for security, availability, performance and isolation across both private and public clouds. The collaboration will add OpenNebula support to the list of Cloud Orchestration stacks that build on top of XCP.

This is excellent news for the community!. You can visit the Xen.org blog for additional information. Stay tuned, the first release will be available in few weeks.

The OpenNebula project is happy to announce the release of a development version of the new plug-ins to build clouds on Microsoft Hyper-V. This new prototype, first result of its collaboration in cloud computing innovation and interoperability with Microsoft, allows users to build and manage OpenNebula clouds on a Hyper-V based virtualization platform. The new components are available for download under the Apache license as a new OpenNebula ecosystem project. The OpenNebula project provides support for the deployment and tuning of the new drivers through its ecosystem mailing list.

The support for Hyper-V consolidates OpenNebula’s position as a fully open-source interoperable and innovative solution for the complete and comprehensive management of virtualized data centers to enable private, public and hybrid clouds. OpenNebula interoperability makes cloud an evolution by offering common cloud standards and interfaces, leveraging existing IT infrastructure, protecting existing investments, and avoiding vendor lock-in. In order to provide the greater flexibility, the integration supports both variants of Hyper-V, namely in Windows Server 2008 and Windows Server 2008 R2 SP1. Moreover the integration will not require the installation of new services in the cloud nodes, making quite simple and rapid to build an OpenNebula cloud on existing Hyper-V deployments.

OpenNebula would like to thank enterprise cloud provider VrStorm for its help in the evaluation of the new plug-ins.

This new contribution to the OpenNebula Ecosystem expands OpenNebula by enabling the use of the well-known hypervisor VirtualBox to create and manage virtual machines.

OneVBox supports the upcoming OpenNebula 3.0 (currently in beta) and VirtualBox 4.0. It is composed of several scripts, mostly written in Ruby, which interpret the XML virtual machine descriptions provided by OpenNebula and perform necessary actions in the VirtualBox node.

OneVBox can deploy but also save, restore and migrate VirtualBox VMs from one physical node to a different one.

Using the new OneVBox driver is very easy and can be done in a few steps:

  1. Download and install the driver. Run from the driver folder:
    user@frontend $> ./install.sh

    Make sure that you have permissions to write in the OpenNebula folders. $ONE_LOCATION can be used to define the self-contained install path, otherwise it will be installed in system-wide mode.

  2. Enable the plugin. Put this in the oned.conf file and start OpenNebula: [shell]
    IM_MAD = [
    name = "im_vbox",
    executable = "one_im_ssh",
    arguments = "-r 0 -t 15 vbox" ]

    VM_MAD = [
    name = "vmm_vbox",
    executable = "one_vmm_exec",
    arguments = "vbox",
    default = "vmm_exec/vmm_exec_vbox.conf",
    type = "xml" ]
    [/shell]

  3. Add a VirtualBox host. For example:
    oneadmin@frontend $> onehost create hostname im_vbox vmm_vbox tm_ssh

    OneVBox also includes ab OpenNebula Sunstone plugin that will enable adding VirtualBox hosts and creating VirtualBox VM templates from the web interface. In order to enable it just add the following lines to etc/sunstone-plugins.yaml:

    [shell]
    – user-plugins/vbox-plugin.js:
    :group:
    :ALL: true
    :user:
    [/shell]

    (Tip: When copy/pasting, avoid using tabs in YAML files, they’re not supported)

For more information, you can visit the OpenNebula Ecosystem page for OneVBox. If you have questions or problems, please let us know on the Ecosystem mailing list or open an issue in the OneVBox github tracker.