Open-source clouds: OpenStack, CloudStack and Eucalyptus
Comparison and study notes on three popular open-source IaaS clouds — OpenStack, CloudStack and Eucalyptus — their architectures, components, common commands and exam-style examples.
Drafted with Aria, reviewed by the AiCanCode.org team · Updated . How we write and check our notes. Spotted an error? Use Give Feedback at the bottom of the page.
Why it matters
Open-source cloud platforms are used by engineers to build private and hybrid Infrastructure-as-a-Service (IaaS) clouds. Knowing OpenStack, CloudStack and Eucalyptus helps you design, deploy and debug clouds, choose the right platform for requirements, and answer architecture and deployment questions in exams.
Key ideas
Start from first principles: a cloud provides virtual resources on demand. Important words defined before use.
- Cloud: a set of networked hardware and software that provides resources (compute, storage, network) to users on demand with some automation.
- IaaS (Infrastructure as a Service): a service model that provides virtual machines, block and object storage, and basic networking as managed services to users.
- Open-source cloud: a cloud stack whose source code is available and modifiable under an open-source licence.
Common IaaS building blocks (define before platform mapping):
- Compute: virtual machines provided by a hypervisor on physical servers.
- Block storage: storage volumes that attach to VMs (like a virtual disk).
- Object storage: storage for files/objects accessed via HTTP APIs (good for large unstructured data).
- Networking: virtual networks, IP addressing, security groups and routing.
- Identity and authentication: service that manages users, projects (tenants) and credentials.
- Image service: stores VM images (OS images) for launching instances.
Exact, exam-style definitions of the three platforms (state and assumptions):
OpenStack (definition): an open-source IaaS cloud platform composed of loosely coupled services (each service provides a specific function) communicating through REST APIs and a message queue. Assumes a Linux environment, common choices of hypervisors (KVM, QEMU), and middleware components (RabbitMQ, MySQL/MariaDB).
OpenStack core services (list — memorize names and short role):
- Nova: compute service that controls lifecycle of VMs.
- Neutron: networking service providing virtual networks, routers and security groups.
- Cinder: block storage service (volumes attached to VMs).
- Swift: object storage service (HTTP API, eventually consistent, replicated).
- Glance: image service (stores VM images)
- Keystone: identity, authentication and service catalog.
- Horizon: web dashboard (UI) for users and admins.
- Heat: orchestration service (stacks, templates for resource composition).
- Ceilometer / Aodh / Gnocchi: telemetry, metering and alarming (names vary by deployment).
- Placement: resource inventory and scheduling constraints service required by Nova.
Architecture to draw (describe exactly): draw one large rectangle labelled "Controller Node(s)" and place inside boxes for Keystone, Glance, Nova API (Controller), Neutron server, Cinder API, Horizon, RabbitMQ, and SQL DB. To the right draw 2–3 smaller rectangles labelled "Compute Node" each with a hypervisor (KVM) and nova-compute agent. Below draw a rectangle labelled "Storage Node" with Swift (object) or Cinder backend. Between controller and compute label arrows: "RPC (RabbitMQ)" and between controller and storage label "API calls" and between users and controller label "REST API / Horizon". This is the diagram examiners expect.
CloudStack (definition): an open-source IaaS platform with a monolithic management server that controls hypervisors and network services. Assumes a central Management Server, database, and agent-based communication to hypervisor hosts; uses system VMs for storage, console proxy, and networking services.
CloudStack components (memorize):
- Management Server: central component (API, UI, scheduler).
- Database: Stores configuration and state (MySQL typical).
- CloudStack System VMs: SSVM (Secondary Storage VM) and CPVM (Console Proxy VM) that provide storage and console proxy services in each zone. Also include the Virtual Router (VR), which provides DHCP, DNS, NAT, and load balancing for guest networks (especially in Advanced networking).
- Hypervisor Hosts: run KVM, XenServer or VMware hypervisors controlled by agent.
- Zones, Pods, Clusters: hierarchical deployment units (zone → pod → cluster → host → VM).
Draw for exam: draw a top box "Management Server + DB" with arrows to multiple "Zone" boxes. In each zone box draw a SSVM and CPVM, and a cluster of hosts. Label network type options: "Basic" and "Advanced" (Basic = single shared network with security groups; Advanced = isolated, user-defined networks with Virtual Router services and VLAN-based segmentation).
Eucalyptus (definition): an open-source IaaS platform that provides AWS-compatible APIs (EC2 and S3 equivalents) and is designed for private cloud deployments. Assumes AWS-compatible client tooling and components that mirror AWS architecture.
Eucalyptus components (memorize):
- Cloud Controller (CLC): top-level entry point (API, scheduling).
- Walrus: object storage service (S3-like; deprecated in later releases in favor of the Object Storage Gateway).
- Cluster Controller (CC): manages a cluster's network and scheduling.
- Storage Controller (SC): provides block storage volumes.
- Node Controller (NC): runs VMs on hypervisors and manages VM lifecycle.
Diagram to draw: central CLC box connected to Walrus and cluster boxes; each cluster box contains a CC and SC and multiple NCs; label AWS API compatibility.
Design and operational differences (important exam comparisons):
- OpenStack: modular microservices, large ecosystem, steep learning curve, flexible network models (Neutron), native services for both block and object storage. Good for complex clouds and public/private hybrid designs.
- CloudStack: simpler central management, fewer moving services, easier to install and operate in smaller teams, opinionated network models.
- Eucalyptus: focused on AWS API compatibility (good for private-to-AWS hybrid), fewer community contributions in recent years, smaller feature set compared to OpenStack.
Assumptions behind each statement: differs by release and distribution; names and modules evolve. Where uncertain I note in the verify list.
Formulas
For this topic, remember the key command syntax patterns used in exam practicals and scripts.
openstack server create --image <IMAGE> --flavor <FLAVOR> --network <NETWORK> --security-group <SECGRP> <NAME> — Create a VM in OpenStack; replace angle-bracketed tokens.
openstack volume create --size <GB> --type <TYPE> <VOLUME_NAME> — Create a Cinder volume size in GB.
glance image-create --name <NAME> --disk-format qcow2 --container-format bare --file <FILE> — Upload image to Glance (older syntax; recent OpenStack uses openstack image create).
euca-bundle-image -i <IMAGE_FILE> -r <ARCH> --kernel <KERNEL_ID> --manifest <MANIFEST> — Eucalyptus image bundle step (then upload and register).
cloudmonkey sync — CloudStack CLI tool syncs API; listVirtualMachines is an example API call (via cloudmonkey or API endpoint).
Always replace tokens with real values. Command sets and flags vary by version — verify in your lab environment.
Worked examples
Example 1 — Launch a simple VM in OpenStack (exam-style step-by-step) Given: image "ubuntu-20.04", flavor "m1.small" (1 vCPU, 2 GB RAM), network "private-net", security group "default". Steps:
- Authenticate: source an OpenStack RC file (e.g.,
source project-openrc.sh) or set environment variables (OS_USERNAME, OS_PASSWORD, OS_PROJECT_NAME, OS_AUTH_URL, plus domain variables for Keystone v3 such as OS_USER_DOMAIN_NAME and OS_PROJECT_DOMAIN_NAME). - Create server:
- Formula (command):
openstack server create --image ubuntu-20.04 --flavor m1.small --network private-net --security-group default myVM
- Formula (command):
- Expected outputs (what exam expects you to state): a JSON or table showing ID, name myVM, status BUILD then ACTIVE, addresses mapping the VM to an IP on private-net.
- Attach a volume if needed:
openstack volume create --size 10 --type standard myVolthenopenstack server add volume myVM myVol. Final result: myVM is ACTIVE and reachable on assigned IP if networking and security rules allow.
Example 2 — Storage capacity calculation (object vs block, numerical) Question: You have 30 TB of raw disk storage and will use Swift with a replication factor of 3. What is usable capacity? If you need 8 TB usable, is this raw storage enough? Steps and calculation:
- Swift usable capacity = raw_capacity / replication_factor.
- Compute:
30 TB / 3 = 10 TB. - Compare with requirement: 10 TB usable >= 8 TB required, so raw 30 TB is enough. Final answer: Usable = 10 TB; 30 TB raw is sufficient. (Note: some deployments use erasure coding instead; replication factor and usable formula change.)
Example 3 — Register an image in Eucalyptus (exam-style command sequence)
Given: local image file centos.qcow2, architecture x86_64.
Steps:
- Bundle image:
euca-bundle-image -i centos.qcow2 -r x86_64 --manifest centos.manifest(use--kernel <EKI-ID>only if you need to associate a separate kernel image). - Upload bundle to Walrus (or S3 backend):
euca-upload-bundle -b mybucket -m centos.manifest -a <ACCESS_KEY> -s <SECRET_KEY>. - Register image:
euca-register mybucket/centos.manifest. - Launch:
euca-run-instances -k mykey -t m1.small <IMAGE_ID>. Final: VM appears and can be managed using Eucalyptus EC2-compatible commands.
Common mistakes
- Forgetting to mention Keystone (identity) when asked for authentication in OpenStack.
- Mixing CloudStack SSVM/CPVM roles: SSVM is secondary storage helper; CPVM is console proxy — name them correctly.
- Using
glance image-createsyntax from an older release without noting that newer CLI usesopenstack image create. - Assuming replication factor is always 3 — some systems use erasure coding; state assumptions in answers.
For your exam
Typical question types:
- Definitions: define OpenStack, CloudStack, Eucalyptus, and services like Nova, Neutron, Cinder, Swift, Walrus.
- Short notes: compare OpenStack vs CloudStack vs Eucalyptus (architecture, deployment, network models, AWS-compatibility).
- Diagrams: draw OpenStack architecture and label Controller/Compute/Storage nodes and message flows.
- Commands/practicals: steps to launch a VM, register an image, or create a volume (show key CLI commands).
- Numerical: capacity planning with replication; compute usable capacity given replication factor.
What a full-marks answer includes:
- Clear definition with bold terms (IaaS, object/block storage), a labelled diagram where required, list of components with roles, and mention of assumptions (version, hypervisor). For comparison questions include at least 3 clear points of difference and practical implications.
Quick check
- Name the OpenStack service that provides virtual networking.
- In CloudStack what are SSVM and CPVM used for (short)?
- If Swift uses replication factor 3 and you have 12 TB raw, what is usable capacity?
Answers: Neutron; SSVM = secondary storage service helper, CPVM = console proxy VM; 4 TB.
Finished this topic? Mark it so your progress, study plan and readiness keep up.
Stuck on something here?