Compute Examples

Example: Creating a Node

from libcloud.compute.types import Provider
from libcloud.compute.providers import get_driver

RACKSPACE_USER = 'your username'
RACKSPACE_KEY = 'your key'

Driver = get_driver(Provider.RACKSPACE)
conn = Driver(RACKSPACE_USER, RACKSPACE_KEY)

# retrieve available images and sizes
images = conn.list_images()
# [<NodeImage: id=3, name=Gentoo 2008.0, driver=Rackspace  ...>, ...]
sizes = conn.list_sizes()
# [<NodeSize: id=1, name=256 server, ram=256 ... driver=Rackspace ...>, ...]

# create node with first image and first size
node = conn.create_node(name='test', image=images[0], size=sizes[0])
# <Node: uuid=..., name=test, state=3, public_ip=['1.1.1.1'],
#   provider=Rackspace ...>

Example: List Nodes Across Multiple Providers

from libcloud.compute.types import Provider
from libcloud.compute.providers import get_driver

EC2_ACCESS_ID = 'your access id'
EC2_SECRET_KEY = 'your secret key'
RACKSPACE_USER = 'your username'
RACKSPACE_KEY = 'your key'

EC2Driver = get_driver(Provider.EC2)
RackspaceDriver = get_driver(Provider.RACKSPACE)

drivers = [EC2Driver(EC2_ACCESS_ID, EC2_SECRET_KEY),
           RackspaceDriver(RACKSPACE_USER, RACKSPACE_KEY)]

nodes = []
for driver in drivers:
    nodes += driver.list_nodes()
print nodes
# [ <Node: provider=Amazon, status=RUNNING, name=bob, ip=1.2.3.4.5>,
#   <Node: provider=Rackspace, status=REBOOT, name=korine, ip=6.7.8.9>, ... ]

# Reboot all nodes named 'test'
[node.reboot() for node in nodes if node.name == 'test']

Example: Bootstrapping Puppet on a Node

from __future__ import with_statement

import os

from libcloud.compute.types import Provider
from libcloud.compute.providers import get_driver
from libcloud.compute.deployment import MultiStepDeployment
from libcloud.compute.deployment import ScriptDeployment, SSHKeyDeployment

# Path to the public key you would like to install
KEY_PATH = os.path.expanduser('~/.ssh/id_rsa.pub')

# Shell script to run on the remote server
SCRIPT = '''#!/usr/bin/env bash
apt-get -y update && apt-get -y install puppet
'''

RACKSPACE_USER = 'your username'
RACKSPACE_KEY = 'your key'

Driver = get_driver(Provider.RACKSPACE)
conn = Driver(RACKSPACE_USER, RACKSPACE_KEY)

with open(KEY_PATH) as fp:
    content = fp.read()

# Note: This key will be added to the authorized keys for the root user
# (/root/.ssh/authorized_keys)
step_1 = SSHKeyDeployment(content)

# A simple script to install puppet post boot, can be much more complicated.
step_2 = ScriptDeployment(SCRIPT)

msd = MultiStepDeployment([step_1, step_2])

images = conn.list_images()
sizes = conn.list_sizes()

# deploy_node takes the same base keyword arguments as create_node.
node = conn.deploy_node(name='test', image=images[0], size=sizes[0],
                        deploy=msd)

Create an OpenStack node using trystack.org provider

trystack.org allows users to try out OpenStack for free. This example demonstrates how to launch an OpenStack node on the trystack.org provider using a generic OpenStack driver.

from libcloud.compute.types import Provider
from libcloud.compute.providers import get_driver

import libcloud.security

# At the time this example was written, https://nova-api.trystack.org:5443
# was using a certificate issued by a Certificate Authority (CA) which is
# not included in the default Ubuntu certificates bundle (ca-certificates).
# Note: Code like this poses a security risk (MITM attack) and that's the
# reason why you should never use it for anything else besides testing. You
# have been warned.
libcloud.security.VERIFY_SSL_CERT = False

OpenStack = get_driver(Provider.OPENSTACK)

driver = OpenStack('your username', 'your password',
                   ex_force_auth_url='https://nova-api.trystack.org:5443',
                   ex_force_auth_version='2.0_password')

nodes = driver.list_nodes()

images = driver.list_images()
sizes = driver.list_sizes()
size = [s for s in sizes if s.ram == 512][0]
image = [i for i in images if i.name == 'natty-server-cloudimg-amd64'][0]

node = driver.create_node(name='test node', image=image, size=size)

Create an OpenStack node using a local OpenStack provider

This example shows how to create a node using a local OpenStack installation. Don’t forget to replace your_auth_username, your_auth_password and ex_force_auth_url with the correct values specific to your installation.

Note

This example works with Libcloud version 0.9.0 and above.

from libcloud.compute.types import Provider
from libcloud.compute.providers import get_driver

import libcloud.security

# This assumes you don't have SSL set up.
# Note: Code like this poses a security risk (MITM attack) and
# that's the reason why you should never use it for anything else
# besides testing. You have been warned.
libcloud.security.VERIFY_SSL_CERT = False

OpenStack = get_driver(Provider.OPENSTACK)
driver = OpenStack('your_auth_username', 'your_auth_password',
                   ex_force_auth_url='http://192.168.1.101:5000',
                   ex_force_auth_version='2.0_password')

Create a VMware vCloud v1.5 node using generic provider

This example demonstrates how to launch a VMware vCloud v1.5 node on a generic provider such as a test lab

Note

This example works with Libcloud version 0.10.1 and above.

from libcloud.compute.types import Provider
from libcloud.compute.providers import get_driver

import libcloud.security

# Skip this step if you are launching nodes on an official vCloud
# provider. It is intended only for self signed SSL certs in
# vanilla vCloud Director v1.5 test deployments.
# Note: Code like this poses a security risk (MITM attack) and
# that's the reason why you should never use it for anything else
# besides testing. You have been warned.
libcloud.security.VERIFY_SSL_CERT = False

vcloud = get_driver(Provider.VCLOUD)

driver = vcloud('you [email protected]', 'your password',
                host='vcloud.local', api_version='1.5')

# List all instantiated vApps
nodes = driver.list_nodes()
# List all VMs within the first vApp instance
print nodes[0].extra['vms']

# List all available vApp Templates
images = driver.list_images()
image = [i for i in images if i.name == 'natty-server-cloudimg-amd64'][0]

# Create node with minimum set of parameters
node = driver.create_node(name='test node 1', image=image)
# Destroy the node
driver.destroy_node(node)

# Create node without deploying and powering it on
node = driver.create_node(name='test node 2', image=image, ex_deploy=False)

# Create node with custom CPU & Memory values
node = driver.create_node(name='test node 3', image=image, ex_vm_cpu=3,
                          ex_vm_memory=1024)

# Create node with customised networking parameters (eg. for OVF
# imported images)
node = driver.create_node(name='test node 4', image=image,
                          ex_vm_network='your vm net name',
                          ex_network='your org net name',
                          ex_vm_fence='bridged', ex_vm_ipmode='DHCP')

# Create node in a custom virtual data center
node = driver.create_node(name='test node 4', image=image,
                          ex_vdc='your vdc name')

# Create node with guest OS customisation script to be run at first boot
node = driver.create_node(name='test node 5', image=image,
                          ex_vm_script='filesystem path to your script')

Create EC2 node using a provided key pair and security groups

Note

This example assumes the provided key pair already exists. If the key pair doesn’t exist yet, you can create it using AWS dashboard, or ex_import_keypair() driver method.

This example demonstrates how to create an EC2 node using an existing key pair. Created node also gets added to the provided security groups.

from libcloud.compute.types import Provider
from libcloud.compute.providers import get_driver

ACCESS_ID = 'your access id'
SECRET_KEY = 'your secret key'

SIZE_ID = 't1.micro'

# Name of the existing keypair you want to use
KEYPAIR_NAME = 'keypairname'

# A list of security groups you want this node to be added to
SECURITY_GROUP_NAMES = ['secgroup1', 'secgroup2']

cls = get_driver(Provider.EC2)
driver = cls(ACCESS_ID, SECRET_KEY)

sizes = driver.list_sizes()
images = driver.list_images()
size = [s for s in sizes if s.id == 't1.micro'][0]
image = images[0]

node = driver.create_node(name='test-node-1', image=image, size=size,
                          ex_keyname=KEYPAIR_NAME,
                          ex_securitygroup=SECURITY_GROUP_NAMES)

As noted in the example, you use ex_keyname argument to specify key pair name and ex_securitygroup to specify a name of a single (str) or multiple groups (list) you want this node to be added to.

Create EC2 node using a custom AMI

This examples demonstrates how to create an EC2 node using a custom AMI (Amazon Machine Image).

AMI’s are region specific which means you need to select AMI which is available in the region of an EC2 driver you have instantiated.

In Libcloud 0.13.0 and lower, region is determined based on the provider constant (us-east-1 is available as Provider.EC2_US_EAST, us-west-1 is available as Provider.EC2_US_WEST and so on). For a full list of supported providers and provider constants, see supported providers page

from libcloud.compute.types import Provider
from libcloud.compute.providers import get_driver
from libcloud.compute.base import NodeImage

ACCESS_ID = 'your access id'
SECRET_KEY = 'your secret key'

# Image with Netflix Asgard available in us-west-1 region
# https://github.com/Answers4AWS/netflixoss-ansible/wiki/AMIs-for-NetflixOSS
AMI_ID = 'ami-c8052d8d'

SIZE_ID = 't1.micro'

# 'us-west-1' region is available in Libcloud under EC2_US_WEST provider
# constant
cls = get_driver(Provider.EC2_US_WEST)
driver = cls(ACCESS_ID, SECRET_KEY)

# Here we select
sizes = driver.list_sizes()
size = [s for s in sizes if s.id == 't1.micro'][0]
image = NodeImage(id=AMI_ID, name=None, driver=driver)

node = driver.create_node(name='test-node', image=image, size=size)

Create EC2 node using an IAM Profile

Note

This example assumes the IAM profile already exists. If the key pair doesn’t exist yet, you must create it manually.

from libcloud.compute.types import Provider
from libcloud.compute.providers import get_driver

ACCESS_ID = 'your access id'
SECRET_KEY = 'your secret key'
IAM_PROFILE = 'your IAM profile arn or IAM profile name'

IMAGE_ID = 'ami-c8052d8d'
SIZE_ID = 't1.micro'
cls = get_driver(Provider.EC2_US_WEST)
driver = cls(ACCESS_ID, SECRET_KEY)

# Here we select size and image
sizes = driver.list_sizes()
images = driver.list_images()

size = [s for s in sizes if s.id == SIZE_ID][0]
image = [i for i in images if i.id == IMAGE_ID][0]

node = driver.create_node(name='test-node', image=image, size=size,
                          ex_iamprofile=IAM_PROFILE)

Create a node on a CloudStack provider using a provided key pair and security groups

Note

This example assumes the provided key pair already exists. If the key pair doesn’t exist yet, you can create it using the provider’s own UI, or ex_create_keypair() driver method. This functionality is only available in Libcloud 0.14.0 and above.

This example demonstrates how to create a node using an existing key pair. Created node also gets added to the provided security groups.

from libcloud.compute.types import Provider
from libcloud.compute.providers import get_driver

ACCESS_ID = 'your access id'
SECRET_KEY = 'your secret key'
HOST = 'hostname or ip address of your management server'
PATH = 'path to the api endpoint, e.g: /client/api'

SIZE_ID = 'id of the computer offering you want to use'
IMAGE_ID = 'id of the template you want to use'

# Name of the existing keypair you want to use
KEYPAIR_NAME = 'keypairname'

# The security groups you want this node to be added to
SECURITY_GROUP_NAMES = ['secgroup1', 'secgroup2']

cls = get_driver(Provider.CLOUDSTACK)
driver = cls(key=ACCESS_ID, secret=SECRET_KEY, secure=True,
             host=HOST, path=PATH)

sizes = driver.list_sizes()
images = driver.list_images()
size = [s for s in sizes if s.id == SIZE_ID][0]
image = [i for i in images if i.id == IMAGE_ID][0]

node = driver.create_node(name='test-node-1', image=image, size=size,
                          ex_security_groups=SECURITY_GROUP_NAMES,
                          ex_keyname=KEYPAIR_NAME)

Create floating IP and attach it to a node using a local OpenStack provider

This example demonstrates how to use OpenStack’s floating IPs.

from libcloud.compute.types import Provider
from libcloud.compute.providers import get_driver

import libcloud.security

# This assumes you don't have SSL set up.
# Note: Code like this poses a security risk (MITM attack) and
# that's the reason why you should never use it for anything else
# besides testing. You have been warned.
libcloud.security.VERIFY_SSL_CERT = False

OpenStack = get_driver(Provider.OPENSTACK)
driver = OpenStack('your_auth_username', 'your_auth_password',
                   ex_force_auth_url='http://10.0.4.1:5000',
                   ex_force_auth_version='2.0_password',
                   ex_tenant_name='your_tenant')

# get the first pool - public by default
pool = driver.ex_list_floating_ip_pools()[0]

# create an ip in the pool
floating_ip = pool.create_floating_ip()

# get the node, note: change the node id to the some id you have
node = driver.ex_get_node_details('922a4381-a18c-487f-b816-cc31c9060853')

# attach the ip to the node
driver.ex_attach_floating_ip_to_node(node, floating_ip)

# remove it from the node
driver.ex_detach_floating_ip_from_node(node, floating_ip)

# delete the ip
floating_ip.delete()

Create an IBM SCE Windows node using generic provider

Note

ex_configurationData is the key component of this example.

This example shows how to create a Windows node using IBM SmartCloud Enterpiese.

from libcloud.compute.types import Provider
from libcloud.compute.providers import get_driver

Driver = get_driver(Provider.IBM)
conn = Driver("[email protected]", "ibm_sce_password")

images = conn.list_images()
image = [i for i in images if i.id == '20014110'][0]

locations = conn.list_locations()
location = [l for l in locations if l.id == '82'][0]

sizes = conn.list_sizes()
size = [s for s in sizes if s.id == 'COP32.1/2048/60'][0]

node = conn.create_node(name="windows box",
                        image=image,
                        size=size,
                        ex_configurationData={
                            'UserName': 'someone',
                            'Password': 'Wind0wsPass'},
                        location=location)
print(conn.list_nodes())