Guide: OpenStack Python SDK – Basic Usage

This guide provides a quick introduction to managing your bwCloud-OS resources using the OpenStack Python SDK. It covers the most common operations for compute, storage, and networking.

In the following, we demonstrate the routines using an interactive Python shell. In practice, these routines are typically used within Python scripts.

Prerequisites

Install the OpenStack SDK, e.g. for Ubuntu:

sudo apt install python3-openstacksdk 

Alternatively, you can install it via pip (preferably inside a virtual environment):

python3 -m venv openstacksdk_venv
source openstacksdk_venv/bin/activate
pip install openstacksdk

Authentication

You can either:

• source an OpenRC file, or
• use a clouds.yaml file

For details, see the section Create an application credential.

In the following, we use the clouds.yaml method.

Basic Connection

Create a connection in Python:

import openstack
conn = openstack.connect(cloud="openstack")

Compute

Images

List available images:

for image in conn.image.images():
    print(image.name, image.id)

Upload a new image:

image = conn.image.upload_image(
    name="ubuntu-24.04",
    filename="/path/to/images/ubuntu-24.04-server-cloudimg-amd64.img",
    disk_format="qcow2",
    container_format="bare"
)
print(image.id)

Show image details:

image = conn.image.get_image("<IMAGE_ID>")
print(image)

Delete an image:

conn.image.delete_image("<IMAGE_ID_OR_NAME>")

Key Pairs (SSH Access)

Create a key pair:

keypair = conn.compute.create_keypair(name="myKey")
with open("myKey.pem", "w") as f:
    f.write(keypair.private_key)

Set correct permissions (outside Python shell):

chmod 600 myKey.pem

List key pairs:

for kp in conn.compute.keypairs():
    print(kp.name)

Delete a key pair:

conn.compute.delete_keypair("myKey")

Instances

List instances:

for server in conn.compute.servers():
    print(server.name, server.status)

Create an instance (ensure that the specified image, flavor, network, and key pair exist):

image = conn.compute.find_image("ubuntu-24.04")
flavor = conn.compute.find_flavor("p1.tiny")
network = conn.network.find_network("myNet")
server = conn.compute.create_server(
    name="myVM",
    image_id=image.id,
    flavor_id=flavor.id,
    networks=[{"uuid": network.id}],
    key_name="myKey"
)
server = conn.compute.wait_for_server(server)
print("Created:", server.name)

Delete an instance:

server = conn.compute.find_server("myVM")
conn.compute.delete_server(server.id)

Storage

Volumes

List volumes:

for vol in conn.block_storage.volumes():
    print(vol.name, vol.size)

Create a volume (size in GB):

volume = conn.block_storage.create_volume(
    name="myVolume",
    size=10
)

Delete a volume:

volume = conn.block_storage.find_volume("myVolume")
conn.block_storage.delete_volume(volume.id)

Volume Management for Instances

Attach a volume to an instance:

server = conn.compute.find_server("myVM")
volume = conn.block_storage.find_volume("myVolume")
conn.compute.create_volume_attachment(
    server,
    volumeId=volume.id
)

Detach a volume:

attachments = conn.compute.volume_attachments(server)
for att in attachments:
    if att.volume_id == volume.id:
        conn.compute.delete_volume_attachment(att.id, server)

Networking

Networks

List networks:

for net in conn.network.networks():
    print(net.name)

Create a network:

network = conn.network.create_network(name="myNet")

Delete a network:

network = conn.network.find_network("myNet")
conn.network.delete_network(network.id)

Floating IPs

Create a floating IP:

network = conn.network.find_network("provider_default_net")
fip = conn.network.create_ip(floating_network_id=network.id)
print(fip.floating_ip_address)

Associate a floating IP with an instance:

server = conn.compute.find_server("myVM")
conn.compute.add_floating_ip_to_server(server, fip.floating_ip_address)

Disassociate a floating IP:

conn.compute.remove_floating_ip_from_server(server, fip.floating_ip_address)

Delete a floating IP:

conn.network.delete_ip(fip.id)

Security Groups

List security groups:

for sg in conn.network.security_groups():
    print(sg.name)

Create a security group:

sg = conn.network.create_security_group(name="mySecGroup")

Add a rule (HTTP):

conn.network.create_security_group_rule(
    security_group_id=sg.id,
    protocol="tcp",
    port_range_min=80,
    port_range_max=80,
    direction="ingress",
    ethertype="IPv4"
)

Assign security group to an instance:

server = conn.compute.find_server("myVM")
conn.compute.add_security_group_to_server(server, sg.name)

Remove a security group from an instance:

conn.compute.remove_security_group_from_server(server, sg.name)

Delete a security group:

conn.network.delete_security_group(sg.id)