Documentation
System StatusPortal Login

Rackspace Flex Cloud: Components

A brief summary of Flex Cloud's components and some potential uses.

Suggest Edits

This document provides a brief explanation of the primary Rackspace Flex Cloud components which are all based on Openstack. It is intended to provide a very quick overview of their purpose, use cases, and upstream OpenStack name. Since Rackspace Flex Cloud is all based on upstream OpenStack, users can leverage substantial existing knowledge from across the web.

COMPUTE

These components are primarily responsible for creating, managing, and interacting with virtual machines (VMs) in OpenStack.

Instances

  • What it is: Instances are virtual machines (VMs) created on demand in OpenStack. Each instance is a fully isolated environment where you can run operating systems, applications, and databases.
  • Use Case: If you're running a web application, you would create an instance to host the application. The term instance interchangeable with virtual server or VM.
  • OpenStack Service: Nova

Instance Snapshots

  • What it is: A snapshot captures the state of an instance at a specific point in time, including the operating system and application state. This allows you to save and restore the instance later.

WARNING: Instance Snapshots only capture the local disk. They will NOT capture ephemeral disks or attached volumes.

  • Use Case: Before making significant changes to a server, you can take a snapshot so you can roll back if something goes wrong.
  • OpenStack Service: Nova

Flavors

  • What it is: Flavors define the computational resources (like CPU, RAM, disk) allocated to an instance. They essentially dictate the specs such as size and capacity of a virtual machine.
  • Use Case: You choose a flavor when you create an instance depending on the workload. For example, a small web server might use a smaller flavor, while a high-performance database server might use a larger one.
  • OpenStack Service: Nova

NOTE: For more information on the available flavors in Rackspace Flex Cloud and their specifications, see here:

Server Groups

  • What it is: Server groups allow instances to be grouped together based on scheduling policies, such as ensuring they are placed on the same host or distributed across multiple hosts.
  • Use Case: If you're deploying a web application with multiple backend services, you might want to group instances based on their role (e.g., web servers in one group and database servers in another).
  • OpenStack Service: Nova

Images

  • What it is: Images are templates used to create instances. They typically contain a pre-configured operating system, software stack, or configuration that instances can be launched from.
  • Use Case: If you need multiple instances to have the same OS configuration or software pre-installed, you create or use an existing image.
  • OpenStack Service: Glance

Key Pairs

  • What it is: Key pairs are used for SSH authentication to instances. As an alternative to using a password, you can associate a public SSH key with an instance, allowing you to securely access it.
  • Use Case: When you launch an instance, you can provide a key pair that allows secure access, ensuring that only authorized users can log in.
  • OpenStack Service: Nova

STORAGE

These components handle persistent data storage in OpenStack, from block storage volumes to object storage.

Volumes

  • What it is: Volumes are block-level storage devices that can be attached to instances. They behave like hard drives for virtual machines and can be detached and reattached to different instances. You can also boot VMs from volumes if they are bootable and outfitted with an OS from an image.
  • Use Case: If your instance needs additional storage beyond what’s available on the root disk, you would create a volume and attach it to your instance.
  • OpenStack Service: Cinder

Volume Backups

  • What it is: Backups allow you to create an image of a volume, which can be restored if the volume is lost or corrupted.
  • Use Case: Performing regular backups of your database volumes to ensure data safety in case of failure.

IMPORTANT: The backup can only capture the data that has been written to the volume at the beginning of the backup task, excluding the data in the cache at that time. To ensure the integrity of the data, it is recommended that you suspend the write operation of all files when creating a backup.

  • OpenStack Service: Cinder

Volume Snapshots

  • What it is: Snapshots are point-in-time copies of volumes, similar to backups, but typically used for faster restoration or creating new volumes.
  • Use Case: If you're upgrading a database and want to ensure you can restore it quickly, you take a snapshot of the volume before making changes.
  • OpenStack Service: Cinder

Object Storage

  • What it is: Object storage is an unstructured data storage system (similar to cloud storage like Rackspace Cloud Files or AWS S3) that stores files, backups, logs, and images. Objects are stored with metadata and are accessed via APIs.
  • Use Case: Storing large files such as user-uploaded content, backups, or log data. Object storage is optimized for scalability and durability.

NOTE: Rackspace Flex Cloud's Object Storage does not incorporate the CDN functionality that Rackspace Cloud Files has. Object Storage on Flex Cloud is pure object storage.

  • OpenStack Service: Swift

NETWORK

These components manage how instances and other resources communicate with each other and the outside world.

Networks

  • What it is: Networks define logical segments within OpenStack to allow instances to communicate. Networks can be private or public.
  • Use Case: You would create a private network for your database instances to prevent them from being publicly accessible, and associate the public network with your web servers through a floating IP.
  • OpenStack Service: Neutron

Ports

  • What it is: Ports are the virtual network interfaces that are attached to instances. Each port is linked to a specific network and allows the instance to send and receive traffic.
  • Use Case: When you connect an instance to a network, you assign it a port. If you want the instance to communicate over a different network, you would configure additional ports.
  • OpenStack Service: Neutron

QoS Policies

  • What it is: QoS (Quality of Service) policies allow you to define performance requirements for network traffic, such as maximum bandwidth or latency guarantees.
  • Use Case: For real-time applications like VoIP or video streaming, you would use QoS policies to ensure these services receive higher priority over less time-sensitive traffic.
  • OpenStack Service: Neutron

Routers

  • What it is: Routers manage the flow of traffic between different networks. For example, a router can allow communication between a public and private network.
  • Use Case: If you have a private network for your application servers and a public network for your web servers, a router allows them to communicate without exposing your internal systems directly to the internet.
  • OpenStack Service: Neutron

Floating IPs

  • What it is: Floating IPs are public IP addresses that you can assign to instances, making them accessible from the internet.
  • Use Case: You would assign a floating IP to a web server instance that needs to be accessible to users on the internet.
  • OpenStack Service: Neutron

Topology

  • What it is: Topology represents the graphical representation of your network setup. It shows how your instances, networks, and routers are connected.
  • Use Case: Topology helps visualize and manage your network’s architecture, especially in complex environments.
  • OpenStack Service: Neutron

Load Balancers

  • What it is: Load balancers distribute incoming network traffic across multiple instances to ensure high availability and performance by preventing any single instance from becoming overwhelmed.
  • Use Case: If you’re running a highly trafficked website, a load balancer can distribute requests evenly across multiple web server instances to avoid bottlenecks.
  • OpenStack Service: Octavia

Certificates

  • What it is: Certificates are used to secure communications between clients and OpenStack services. They enable encryption (HTTPS) and verify the identity of services.
  • Use Case: If your application handles sensitive data (e.g., payments), you would use certificates to ensure secure communication between the client and the server.
  • OpenStack Service: Barbican (Key management service) or external management.

Security Groups

  • What it is: Security groups are virtual firewalls for instances. They control the inbound and outbound traffic to your instances, based on rules you set (e.g., allow HTTP traffic, block SSH from outside).
  • Use Case: You could configure a security group that allows only HTTP/HTTPS traffic to a web server and restricts all other traffic.
  • OpenStack Service: Neutron

ORCHESTRATION

Orchestration helps automate the deployment and management of resources, reducing manual effort and error.

Stacks

  • What it is: A stack is a collection of resources, like instances, networks, and storage, that can be managed as a single unit. Stacks are defined by templates and are typically created using the Heat orchestration service.
  • Use Case: If you're deploying a complex application, you can use a stack to manage all resources (web servers, databases, networking) together. Stacks are deployed using yaml templates. Changes to the stack are automatically applied to all resources.
  • OpenStack Service: Heat

CONTAINER

These components are designed for managing containerized applications, which are lightweight compared to virtual machines and are commonly used in microservices architectures.

Clusters

  • What it is: A cluster is a group of nodes (physical or virtual machines) that work together to run containers. Kubernetes is often used for managing container clusters.
  • Use Case: If you're running a microservices-based application, you might deploy containers on a Kubernetes cluster for better scalability and management.
  • OpenStack Service: Magnum

Cluster Templates

  • What it is: Cluster templates are predefined configurations for clusters. They specify the number of nodes, their roles, and other settings that make it easier to deploy multiple clusters with similar configurations.
  • Use Case: If you need to set up multiple clusters with similar configurations, cluster templates simplify the process by automating cluster creation.
  • OpenStack Service: Magnum

Additional Documentation:

Updated 1 day ago