View source for 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 basic authentication and common operations for compute, storage, and networking.


<nowiki>__TOC__</nowiki>

== Prerequisites ==
Install the OpenStack SDK (Ubuntu example):<pre>
sudo apt update
sudo apt install python3-openstacksdk -y
</pre>Alternatively (if not available via apt), you can install it via pip:<pre>
pip install openstacksdk
</pre>

== Authentication ==
The SDK uses the same configuration as the OpenStack CLI.

You can either:

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

Example (clouds.yaml):<pre>
clouds:
  openstack:
    auth:
      auth_url: https://your-auth-url:5000/v3
      application_credential_id: "YOUR_ID"
      application_credential_secret: "YOUR_SECRET"
    region_name: "RegionOne"
    interface: "public"
    identity_api_version: 3
    auth_type: "v3applicationcredential"
</pre>

== Basic Connection ==
Create a connection in Python:<pre>
import openstack

conn = openstack.connect(cloud="openstack")
</pre>

== Compute ==

=== Instances ===
List instances:<pre>
for server in conn.compute.servers():
    print(server.name, server.status)
</pre>Create an instance:<pre>
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)
</pre>Delete an instance:<pre>
server = conn.compute.find_server("myVM")
conn.compute.delete_server(server.id)
</pre>

=== Images ===
List images:<pre>
for image in conn.compute.images():
    print(image.name)
</pre>

== Storage ==

=== Volumes ===
List volumes:<pre>
for vol in conn.block_storage.volumes():
    print(vol.name, vol.size)
</pre>Create a volume:<pre>
volume = conn.block_storage.create_volume(
    name="myVolume",
    size=10
)
</pre>Delete a volume:<pre>
volume = conn.block_storage.find_volume("myVolume")
conn.block_storage.delete_volume(volume.id)
</pre>

=== Volume Management for Instances ===
Attach a volume to an instance:<pre>
server = conn.compute.find_server("myVM")
volume = conn.block_storage.find_volume("myVolume")

conn.compute.create_volume_attachment(
    server,
    volumeId=volume.id
)
</pre>Detach a volume:<pre>
attachments = conn.compute.volume_attachments(server)
for att in attachments:
    if att.volume_id == volume.id:
        conn.compute.delete_volume_attachment(att.id, server)
</pre>

== Networking ==

=== Networks ===
List networks:<pre>
for net in conn.network.networks():
    print(net.name)
</pre>Create a network:<pre>
network = conn.network.create_network(name="myNet")
</pre>Delete a network:<pre>
network = conn.network.find_network("myNet")
conn.network.delete_network(network.id)
</pre>

=== Floating IPs ===
Create a floating IP:<pre>
fip = conn.network.create_ip(floating_network_id="provider_default_net")
print(fip.floating_ip_address)
</pre>Associate a floating IP with an instance:<pre>
server = conn.compute.find_server("myVM")
conn.compute.add_floating_ip_to_server(server, fip.floating_ip_address)
</pre>Disassociate a floating IP:<pre>
conn.compute.remove_floating_ip_from_server(server, fip.floating_ip_address)
</pre>Delete a floating IP:<pre>
conn.network.delete_ip(fip.id)
</pre>

=== Security Groups ===
List security groups:<pre>
for sg in conn.network.security_groups():
    print(sg.name)
</pre>Create a security group:<pre>
sg = conn.network.create_security_group(name="mySecGroup")
</pre>Add a rule (HTTP):<pre>
conn.network.create_security_group_rule(
    security_group_id=sg.id,
    protocol="tcp",
    port_range_min=80,
    port_range_max=80,
    direction="ingress"
)
</pre>Assign security group to an instance:<pre>
server = conn.compute.find_server("myVM")
conn.compute.add_security_group_to_server(server, sg.name)
</pre>Remove a security group from an instance:<pre>
conn.compute.remove_security_group_from_server(server, sg.name)
</pre>Delete a security group:<pre>
conn.network.delete_security_group(sg.id)
</pre>