Feb 24 2011

Running OpenStack under VirtualBox – A Complete Guide (Part 2)

In the previous post, we very simply got OpenStack running under VirtualBox. This next part takes this further by getting multiple compute nodes installed to spread the load of your instances. It also paves the way for Part 3 where we will then start to look at Swift, OpenStack’s storage implementation of S3.

Part 2 – OpenStack on a multiple VirtualBox VMs with OpenStack instances accessible from host

We will be using the same set up as for Part 1.

The proposed environment

OpenStack “Public” Network: 172.241.0.0/25
OpenStack “Private” Network: 10.0.0.0/8
Host has access to its own LAN, separate to this on 192.168.0.0/16 and not used for this guide
One VirtualBox VM running the software needed for the controller
One VirtualBox VM running the software needed for a compute node

This guide will assume you have followed Part 1. We are simply adding in a compute node now, so that will make the virtual machine you created in Part 1 will become the Cloud Controller (CC). Also, OpenStack has been designed so that any part of the environment can run on a separate server. For this guide we will have the following

Cloud Controller running MySQL, RabbitMQ, nova-network, nova-scheduler, nova-objectstore, nova-api, nova-compute
Compute node running: nova-compute

The Guide

Add a new VirtualBox Guest
- Name: cloud2
  - OS Type: Linux
  - Version: Ubuntu (64-Bit)
- 2048Mb Ram
- Boot Hard Disk
  - Dynamically Expanding Storage
  - 8.0Gb
- After this initial set up, continue to configure the guest
  - Storage:
    - Edit the CD-ROM so that it boots Ubuntu 10.10 Live or Server ISO
    - Ensure that the SATA controller has Host I/O Cache Enabled (recommended by VirtualBox for EXT4 filesystems)
  - Network:
    - Adapter 1
      - Host-only Adapter
      - Name: vboxnet0
    - Adapter 2
      - NAT
      - This will provide the default route to allow the VM to access the internet to get the updates, OpenStack scripts and software
  - Audio:
    - Disable (just not required)
- Boot the guest and install Ubuntu as per normal
Assign static IPs to the cloud controller
- Ensure that the Cloud Controller you created in Part 1 has static addresses for eth0 and eth1.
  - For the sake of this guide, I’m assuming you have assigned the following
    - eth0: 172.241.0.101/255.255.255.128. This address is your Cloud Controller address (CC_ADDR) and will be the API interface address you will be communicating on from your host.
    - eth1: stays as dhcp as it is only used for NAT’d access to the real world
- Your compute nodes don’t need to be set statically, but for the rest of this guide it is assumed the addresses are as follows
  - Cloud2
    - eth0: 172.241.0.102/255.255.255.128
    - eth1: stays as dhcp as it is only used for NAT’d access to the real world

Grab this script to install OpenStack
- This will set up a repository (ppa:nova/trunk) and install MySQL server where the information regarding your cloud will be stored
- The options specified on the command line match the environment described above
- ```
wget --no-check-certificate \

https://github.com/uksysadmin/OpenStackInstaller/raw/master/OSinstall.sh
```
Run the script (as root/through sudo) specifying that you want a compute node and that you’ve specified the IP address of the Cloud Controller
- ```
sudo bash ./OSinstall.sh -A $(whoami) -T compute -C 172.241.0.101
```

No further configuration is required.
Once completed, ensure that the Cloud Controller knows about this new compute node
- On the Cloud Controller run the following
  - ```
  mysql -uroot -pnova nova -e 'select * from services;'
```
- ```
sudo nova-manage service list
```
  - You should see your new compute node listed under hosts
  - If you don’t have a DNS server running that resolves these hosts add your new compute node to /etc/hosts
    - ```
    172.241.0.102 cloud2
```
On the new compute node run the following
- ```
sudo nova-manage db sync
```
As you copied your credentials from the cloud controller created in Part 1, you should just be able to continue to use this from your host – but this time you can spin up more guests.
- If you changed the eth0 address of your cloud controller, ensure your cloud/creds/novarc environment file has the correct IP.
Repeat the steps above to create further compute nodes in your environment, scaling seamlessly

Feb 17 2011

Running OpenStack under VirtualBox – A Complete Guide (Part 1)

UPDATE: I’ve been working on a new version of the script which can be used to create an OpenStack host running on Ubuntu 12.04 Precise Pangolin and the Essex release.
I’ve now got a video to accompany this which is recommended over this guide
Head over to ‎http://uksysadmin.wordpress.com/2012/03/28/screencast-video-of-an-install-of-openstack-essex-on-ubuntu-12-04-under-virtualbox/

Running OpenStack under VirtualBox allows you to have a complete multi-node cluster that you can access and manage from the computer running VirtualBox as if you’re accessing a region on Amazon.
This is a complete guide to setting up a VirtualBox VM running Ubuntu, with OpenStack running on this guest and an OpenStack instance running, accessible from your host.

Part 1 – OpenStack on a single VirtualBox VM with OpenStack instances accessible from host

The environment used for this guide

A 64-Bit Intel Core i7 Laptop, 8Gb Ram.
Ubuntu 10.10 Maverick AMD64 (The “host”)
VirtualBox 4
Access from host running VirtualBox only (so useful for development/proof of concept)

The proposed environment

OpenStack “Public” Network: 172.241.0.0/25
OpenStack “Private” Network: 10.0.0.0/8
Host has access to its own LAN, separate to this on 192.168.0.0/16 and not used for this guide

The Guide

Download and install VirtualBox from http://www.virtualbox.org/
Under Preferences… Network…
Add/Edit Host-only network so you have vboxnet0. This will serve as the “Public interface” to your cloud environment
- Configure this as follows
  - Adapter
    - IPv4 Address: 172.241.0.100
    - IPv4 Network Mask: 255.255.255.128
  - DHCP Server
    - Disable Server
- On your Linux host running VirtualBox, you will see an interface created called ‘vboxnet0′ with the address specified as 172.241.0.100. This will be the IP address your OpenStack instances will see when you access them.
- Create a new Guest
  - Name: Cloud1
    - OS Type: Linux
    - Version: Ubuntu (64-Bit)
  - 1024Mb Ram
  - Boot Hard Disk
    - Dynamically Expanding Storage
    - 8.0Gb
  - After this initial set up, continue to configure the guest
    - Storage:
      - Edit the CD-ROM so that it boots Ubuntu 10.10 Live or Server ISO
      - Ensure that the SATA controller has Host I/O Cache Enabled (recommended by VirtualBox for EXT4 filesystems)
    - Network:
      - Adapter 1
        
        Host-only Adapter
        
        Name: vboxnet0
      - Adapter 2
        
        NAT
        
        This will provide the default route to allow the VM to access the internet to get the updates, OpenStack scripts and software
    - Audio:
      - Disable (just not required)
- Power the guest on and install Ubuntu
- For this guide I’ve statically assigned the guest with the IP: 172.241.0.101 for eth0 and netmask 255.255.255.128. This will be the IP address that you will use to access the guest from your host box, as well as the IP address you can use to SSH/SCP files around.
- Once installed, run an update (sudo apt-get update&&sudo apt-get upgrade) then reboot
- If you’re running a desktop, install the Guest Additions (Device… Install Guest Additions, then click on Places and select the VBoxGuestAdditions CD and follow the Autorun script), then Reboot
- Install openssh-server
  - ```
  sudo apt-get -y install openssh-server
```
- Grab this script to install OpenStack
  - This will set up a repository (ppa:nova/trunk) and install MySQL server where the information regarding your cloud will be stored
  - The options specified on the command line match the environment described above
  - ```
  wget https://github.com/uksysadmin/OpenStackInstaller/raw/master/OSinstall.sh
```
- Run the script (as root/through sudo)
  - ```
  sudo bash ./OSinstall.sh -A $(whoami)
```
- Run the post-configuration steps
  - ```
  ADMIN=$(whoami)
  sudo nova-manage user admin ${ADMIN}
  sudo nova-manage role add ${ADMIN} cloudadmin
  sudo nova-manage project create myproject ${ADMIN}
  sudo nova-manage project zipfile myproject ${ADMIN}
  mkdir -p cloud/creds
  cd cloud/creds
  unzip ~/nova.zip
  . novarc
  cd
  euca-add-keypair openstack > ~/cloud/creds/openstack.pem
  chmod 0600 cloud/creds/*
```
Congratulations, you now have a working Cloud environment waiting for its first image and instances to run, with a user you specified on the command line (yourusername), the credentials to access the cloud and a project called ‘myproject’ to host the instances.
- You now need to ensure that you can access any instances that you launch via SSH as a minimum (as well as being able to ping) – but I add in access to a web service and port 8080 too for this environment as my “default” security group.
  - ```
  euca-authorize default -P tcp -p 22 -s 0.0.0.0/0
  euca-authorize default -P tcp -p 80 -s 0.0.0.0/0
  euca-authorize default -P tcp -p 8080 -s 0.0.0.0/0
  euca-authorize default -P icmp -t -1:-1
```
- Next you need to load a UEC image into your cloud so that instances can be launched from it
  - ```
  image="ttylinux-uec-amd64-12.1_2.6.35-22_1.tar.gz"
  wget http://smoser.brickies.net/ubuntu/ttylinux-uec/$image
  uec-publish-tarball $image mybucket
```
- Once the uec-publish-tarball command has been run, it will present you with a line with emi=, eri= and eki= specifying the Image, Ramdisk and Kernel as shown below. Highlight this, copy and paste back in your shell
```
Thu Feb 24 09:55:19 GMT 2011: ====== extracting image ======
kernel : ttylinux-uec-amd64-12.1_2.6.35-22_1-vmlinuz
ramdisk: ttylinux-uec-amd64-12.1_2.6.35-22_1-initrd
image  : ttylinux-uec-amd64-12.1_2.6.35-22_1.img
Thu Feb 24 09:55:19 GMT 2011: ====== bundle/upload kernel ======
Thu Feb 24 09:55:21 GMT 2011: ====== bundle/upload ramdisk ======
Thu Feb 24 09:55:22 GMT 2011: ====== bundle/upload image ======
Thu Feb 24 09:55:25 GMT 2011: ====== done ======
emi="ami-fnlidlmq"; eri="ami-dqliu15n"; eki="ami-66rz6vbs";
```
- To launch an instance
  - ```
  euca-run-instances $emi -k openstack -t m1.tiny
```
- To check its running
  - ```
  euca-describe-instances
```
- You will see the Private IP that has been assigned to this instance, for example 10.0.0.3
- To access this via SSH
  - ```
  ssh -i cloud/creds/openstack.pem root@10.0.0.3
```
- (To log out of ttylinux, type: logout)
- Congratulations, you now have an OpenStack instance running under OpenStack Nova, running under a VirtualBox VM!
- To access this outside of the VirtualBox environment (i.e. back on your real computer, the host) you need to assign it a “public” IP
  - Associate this to the instance id (get from euca-describe-instances and will be of the format i-00000000)
    - ```
    euca-allocate-address
```
- This will return an IP address that has been assigned to your project so that you can now associate to your instance, e.g. 172.241.0.3
- ```
euca-associate-address -i i-00000001 172.241.0.3
```
  - Now back on your host (so outside of VirtualBox), grab a copy of cloud/creds directory
    - ```
    scp -r user@172.241.0.101:cloud/creds .
```
- You can now access that host using the Public address you associated to it above
  - ```
  ssh -i cloud/creds/openstack.pem root@172.241.0.3
```
CONGRATULATIONS! You have now created a complete cloud environment under VirtualBox that you can manage from your computer (host) as if you’re managing services on Amazon. To demonstrate this you can terminate that instance you created from your computer (host)
- ```
sudo apt-get install euca2ools
. cloud/creds/novarc
euca-describe-instances
euca-terminate-instances i-00000001
```
Credits

This guide is based on Thierry Carrez’ blog @ http://fnords.wordpress.com/2010/12/02/bleeding-edge-openstack-nova-on-maverick/
Next: Part 2 – OpenStack on a multiple VirtualBox VMs with OpenStack instances accessible from host

Feb 15 2011

Running OpenStack under VirtualBox

This page has been superseded by Running OpenStack under VirtualBox – A Complete Guide.

(There’s still some good things on here though)

Running OpenStack under VirtualBox is detailed on many pages on the internet. The Wiki at OpenStack.org has an intro on getting this going and why you would want to do this. One big reason is that getting this great cloud software running under virtual hardware means you can set up multi-node clusters without a big outlay in hardware. This allows you to develop your cloud environment under the safety and convenience of your own machine.

The steps below are a mixture of instructions from http://fnords.wordpress.com/2010/12/02/bleeding-edge-openstack-nova-on-maverick/ and http://wiki.openstack.org/NovaInstall/.

What you will be setting up

VirtualBox from http://www.virtualbox.org/
Ubuntu 10.10 (Maverick) http://www.ubuntu.com/
OpenStack from Developer’s trunk (Bleeding edge code)

Instructions

Install VirtualBox
Create a Ubuntu 64 Guest
- 1vCPU
- 1024Mb Ram
- 8Gb Disk
- Enable Hardware VT-x/AMD-V if available
- Add in an extra NIC, Host-only Adapter
Once installed, run the updates (and optionally install the Guest Additions if you’re running the desktop version) and reboot.
Assign a static IP to your eth1 interface (Host-only) – you will use this to access the guest from your host.
To install OpenStack follow the instructions http://fnords.wordpress.com/2010/12/02/bleeding-edge-openstack-nova-on-maverick/

Warning for nested virtualization

Since you are running virtualization software under virtualization software (nested virtualization) some words of warning:

Intel VT-x: KVM does NOT currently support nested virtualization

To run instances under OpenStack under VirtualBox, you must specify that software emulation be used

sudo apt-get install qemu

Edit /etc/nova/nova.conf to enable qemu (software virtualization) support

--libvirt_type=qemu

AMD-V: Enable nested KVM virtualization support

To enable AMD’s KVM support create a file /etc/modprobe.d/kvm_amd.conf with the following in

options kvm_amd nested=1

And restart all the OpenStack services

service libvirt-bin restart; service nova-network restart; service  nova-compute restart; service nova-api restart; service nova-objectstore  restart; service nova-scheduler restart

Known Issues

Currently, at the time of writing, there is a bug in some of the Python scripts used to launch instances that may cause the following error to be thrown: KeyError: ‘imageId’ when creating instance with EC2/S3. A patch is available.

wget http://launchpadlibrarian.net/64364074/x.patch -O /tmp/KeyError_imageId.patch
cd /usr/lib/pymodules/python2.6
sudo patch -p0 < /tmp/KeyError_imageId.patch
service libvirt-bin restart; service nova-network restart; service   nova-compute restart; service nova-api restart; service nova-objectstore   restart; service nova-scheduler restart