Installing Openstack on Openshift - The Process

So you're convinced that running Openstack on Openshift is a good idea? Great! Let's walk through how you actually get this thing up and running.

Prerequisites - The Boring But Important Stuff

First things first, you'll need an Openshift cluster that's already running. Obviously! You can't install Openstack on something that doesn't exist. Your cluster needs to be version 4.18 or newer - that's when the Openstack operator became available.

You'll also need storage. Lots of it. Openstack's control plane services need persistent storage for their databases and configuration. Make sure your cluster has a decent storage class configured.

The Operator Installation

Here's where it gets interesting. Remember how I mentioned that operators manage everything in Openshift? Well, first we need to install the Openstack operator itself.

Head over to the OperatorHub in your Openshift web console. Search for "Red Hat Openstack Services" or just "RHOSO" if you're feeling lazy. Click install and let Openshift do its magic.

The operator will deploy into its own namespace and start watching for Openstack custom resources. Think of it as hiring a very competent robot butler to manage your Openstack deployment.

Creating Your Openstack Instance

Now comes the fun part! With the operator installed, you create what's called a "custom resource" that describes your Openstack deployment. This is just a YAML file that tells the operator "hey, I want Openstack with these specific services enabled."

apiVersion: core.openstack.org/v1beta1
kind: OpenStackControlPlane
metadata:
  name: my-openstack
spec:
  # Your configuration goes here

Deploy this YAML and watch as the operator springs into action, spinning up containers for Nova, Neutron, Cinder, Glance - all the usual suspects. But now they're running as pods in your Openshift cluster!

The Magic Happens

The really cool thing? The operator handles all the interconnections between services. No more manually editing configuration files or wondering if service A can talk to service B. The operator knows how to wire everything together correctly.

And remember that upgrade problem I mentioned? When a new version comes out, you just update your custom resource and the operator handles the rolling upgrade. No more weekend maintenance windows that turn into all-nighters!

Complicated? Not really. Different? Absolutely. But different in a "why didn't we do this years ago" kind of way.

Getting Your Hands Dirty - The Technical Steps

Alright, enough theory! Let's actually get this thing installed. Here's the step-by-step process to get Openstack running on your Openshift cluster.

Step 1: Prepare Your Openshift Cluster

First things first - make sure you've got the prerequisites sorted:

# Check your Openshift version
oc version

# Make sure you're cluster-admin
oc whoami
oc auth can-i '*' '*'

You need Openshift 4.18 or later and cluster-admin privileges. No shortcuts here!

Step 2: Install the RHOSO Operator

Navigate to your Openshift web console and head to Operators > OperatorHub. Search for "Red Hat OpenStack Services" and click install.

Or if you're a command line person like me:

# Create the operator subscription
cat <<EOF | oc apply -f -
apiVersion: operators.coreos.com/v1alpha1
kind: Subscription
metadata:
  name: openstack-operator
  namespace: openstack-operators
spec:
  channel: stable
  name: openstack-operator
  source: redhat-operators
  sourceNamespace: openshift-marketplace
EOF

Wait for the operator to install. You can check its status:

oc get csv -n openstack-operators

Step 3: Create Your Infrastructure Namespace

The Openstack services need somewhere to live:

# Create the namespace
oc create namespace openstack

# Label it for proper networking
oc label namespace openstack security.openshift.io/scc.podSecurityLabelSync=false
oc label namespace openstack pod-security.kubernetes.io/enforce=privileged

Step 4: Set Up Storage Classes

Openstack needs persistent storage. Make sure you have storage classes available:

# Check available storage classes
oc get storageclass

# If you need to create one (example for local storage)
cat <<EOF | oc apply -f -
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: local-storage
provisioner: kubernetes.io/no-provisioner
volumeBindingMode: WaitForFirstConsumer
EOF

Step 5: Deploy Your OpenStack Control Plane

Now for the main event! Create your OpenStackControlPlane custom resource:

apiVersion: core.openstack.org/v1beta1
kind: OpenStackControlPlane
metadata:
  name: openstack-control-plane
  namespace: openstack
spec:
  storageClass: local-storage
  
  # Database configuration
  galera:
    enabled: true
    templates:
      openstack:
        storageRequest: 500Gi
        
  # Message queue
  rabbitmq:
    templates:
      rabbitmq:
        storageRequest: 10Gi
        
  # Core OpenStack services
  keystone:
    enabled: true
    template:
      databaseInstance: openstack
      
  glance:
    enabled: true
    template:
      databaseInstance: openstack
      storageRequest: 10Gi
      
  nova:
    enabled: true
    template:
      cellTemplates:
        cell0:
          conductorServiceTemplate:
            replicas: 1
        cell1:
          conductorServiceTemplate:
            replicas: 1
            
  neutron:
    enabled: true
    template:
      databaseInstance: openstack
      
  cinder:
    enabled: true
    template:
      databaseInstance: openstack

Deploy it:

oc apply -f openstack-control-plane.yaml

Step 6: Watch the Magic Happen

The operator will start deploying services. You can watch the progress:

# Watch pods being created
oc get pods -n openstack -w

# Check the control plane status
oc get openstackcontrolplane -n openstack

# Get detailed status
oc describe openstackcontrolplane openstack-control-plane -n openstack

This will take a while - the operator needs to deploy databases, message queues, and all the OpenStack services. Go grab a coffee!

Step 7: Verify Your Deployment

Once everything's running, you should see something like:

# All pods should be Running
oc get pods -n openstack

# Services should be ready
oc get svc -n openstack

# Your control plane should show as Ready
oc get openstackcontrolplane -n openstack

Step 8: Access Your OpenStack

The operator will create routes for the OpenStack APIs. Find your endpoint:

# Get the keystone public endpoint
oc get route -n openstack | grep keystone

# Get admin credentials (they're stored in a secret)
oc get secret -n openstack | grep admin

And that's it! You now have OpenStack running as containers in your Openshift cluster. The operator is managing everything - databases, services, networking, the whole shebang.

Pretty straightforward, right? No more wrestling with configuration files or hoping services start in the right order. The operator handles all that complexity for you!