← Back to all projects

LEARN OPENSTACK AND OPENSHIFT

Learn OpenStack and OpenShift: From IaaS to PaaS Mastery

Goal: To gain a deep, hands-on understanding of the cloud-native stack by learning OpenStack (the Infrastructure as a Service layer that provisions the “cloud”) and OpenShift (the Platform as a Service layer that runs applications on the cloud).

Why Learn OpenStack and OpenShift Together?

OpenStack and OpenShift are two sides of the same cloud coin. They answer two different, but related, questions:

  1. OpenStack (IaaS): “How do I create and manage a cloud? How do I provision virtual machines, networks, and storage on-demand from a pool of physical hardware?”
  2. OpenShift (PaaS): “Now that I have a cloud (which could be OpenStack, AWS, Azure, etc.), how do I easily deploy, scale, and manage containerized applications on it?”

Learning them together provides a complete picture, from the bare metal up to the running application. You’ll understand the roles and responsibilities at each layer of the cloud.

The Cloud Stack You Will Master

┌─────────────────────────────────────────────────────────────────────────┐
│                           Your Application                              │
│                (e.g., a multi-tier web service)                         │
├───────────────────────────────────┬─────────────────────────────────────┤
│        ▲                          │         ▲                           │
│  Runs inside a Container          │   Managed by a Pod                  │
├───────────────────────────────────┴─────────────────────────────────────┤
│                       Part 2: OpenShift (PaaS)                          │
│     (Manages Containers, Provides Developer Tools, Routing, S2I)        │
│                                                                         │
│   ┌─────────────┐   ┌─────────────┐   ┌─────────────┐                   │
│   │  Worker Node  │   │  Worker Node  │   │ Master Node   │ (These are VMs) │
│   └─────────────┘   └─────────────┘   └─────────────┘                   │
├───────────────────────────────────┬─────────────────────────────────────┤
│        ▲                          │          ▲                          │
│  Runs on Virtual Machines         │   Provided by IaaS                  │
├───────────────────────────────────┴─────────────────────────────────────┤
│                        Part 1: OpenStack (IaaS)                         │
│ (Manages VMs, Virtual Networks, Block Storage, Load Balancers, etc.)    │
└─────────────────────────────────────────────────────────────────────────┘

This learning plan is divided into two parts, followed by a capstone project.

Part 1: Learning OpenStack (The IaaS Foundation)

OpenStack is a collection of open-source software projects that let you build and manage your own private or public cloud. It’s the engine that provides virtual machines, networking, and storage.

Key OpenStack Services You Will Learn

  • Keystone: Identity service (Auth/Authz). The gatekeeper.
  • Glance: Image service. Stores the templates for your VMs (e.g., Ubuntu, CentOS images).
  • Nova: Compute service. The heart of OpenStack, responsible for creating and managing VMs.
  • Neutron: Networking service. Manages virtual networks, subnets, routers, and firewalls.
  • Cinder: Block Storage service. Provides persistent “hard drives” (volumes) for your VMs.
  • Horizon: The web dashboard that provides a GUI for all these services.

Project 1: Deploy a Single-Node OpenStack with DevStack

  • File: LEARN_OPENSTACK_AND_OPENSHIFT.md
  • Main Technology: DevStack
  • Coolness Level: Level 3: Genuinely Clever
  • Business Potential: 1. The “Resume Gold”
  • Difficulty: Level 2: Intermediate
  • Knowledge Area: Cloud Infrastructure / IaaS
  • Main Resource: The official DevStack documentation.

What you’ll build: A complete, all-in-one OpenStack cloud running on a single machine (either a powerful laptop or a cloud server).

Why it teaches OpenStack: DevStack is the fastest way to get a working OpenStack environment. It forces you to see how all the core services are installed and configured to work together. It’s the “Hello, World!” of OpenStack administration.

Core challenges you’ll face:

  • Hardware Requirements → maps to understanding that running a cloud is resource-intensive (at least 16GB RAM recommended)
  • Configuration (local.conf) → maps to learning to set passwords, IP ranges, and enable services
  • The Install Process (stack.sh) → maps to watching how the services are cloned, installed, and started in order
  • First Login → maps to using the Horizon dashboard and getting your openrc file for CLI access

Difficulty: Intermediate (due to hardware/networking setup) Time estimate: Weekend Prerequisites: A fresh installation of Ubuntu/CentOS on a machine with significant RAM. Basic Linux and networking knowledge.

Real world outcome: A running OpenStack dashboard in your browser. You will be able to log in, see the service catalog, and use the OpenStack CLI (openstack server list) to communicate with your own private cloud. You will then launch your first tiny VM using the “CirrOS” test image.

Implementation Hints:

  1. Get a dedicated machine or a large VM (e.g., from Hetzner or OVH). Do not run this on your personal machine’s main OS.
  2. Follow the official DevStack quick-start guide carefully.
  3. Your main configuration will be in a file named local.conf. This is where you’ll set your admin password, IP version, and which services to enable.
  4. Run ./stack.sh. This will take a long time. Read the output as it scrolls by to see the services being set up.
  5. If it fails (it often does on the first try), read the error, clean up with ./unstack.sh && ./clean.sh, fix the issue (often network-related), and try again.

Project 2: Manual Infrastructure Provisioning

  • File: LEARN_OPENSTACK_AND_OPENSHIFT.md
  • Main Technology: OpenStack CLI & Horizon Dashboard
  • Difficulty: Level 2: Intermediate
  • Knowledge Area: Cloud Networking / Virtualization
  • Main Resource: OpenStack End User Guide.

What you’ll build: Inside your DevStack cloud, you will manually provision a complete, isolated tenant network and launch a virtual machine on it that can access the internet.

Why it teaches OpenStack: This teaches the core workflow of a cloud user. You will act as your own tenant, creating virtual resources just as you would on a public cloud. It forces you to understand how Neutron networking (routers, networks, security groups) and Nova compute interact.

Core challenges you’ll face:

  • Creating a Network and Subnet → maps to defining your private IP space
  • Creating a Router → maps to connecting your private network to the “external” public network
  • Managing Security Groups → maps to creating firewall rules to allow SSH and ICMP (ping)
  • Launching a VM → maps to associating a VM with a network, keypair, and security group
  • Floating IPs → maps to assigning a public IP to your VM to access it from the outside

Real world outcome: You will be able to SSH into a virtual machine that is running inside your OpenStack cloud, from your own computer. You’ll be able to prove it has internet access by pinging an external address like 8.8.8.8 from inside the VM.

Project 3: Automating with Infrastructure-as-Code (Heat)

  • File: LEARN_OPENSTACK_AND_OPENSHIFT.md
  • Main Technology: OpenStack Heat
  • Difficulty: Level 3: Advanced
  • Knowledge Area: Infrastructure as Code (IaC) / Orchestration
  • Main Resource: OpenStack Heat documentation and tutorials.

What you’ll build: An OpenStack Heat template (in YAML) that declaratively defines and orchestrates everything you built manually in Project 2.

Why it teaches OpenStack: This teaches the principles of cloud automation. Manually clicking in a UI is slow and error-prone. Heat introduces you to IaC, where your infrastructure is defined in code. This is the foundation for repeatable, scalable cloud deployments.

Core challenges you’ll face:

  • Writing a HOT (Heat Orchestration Template) → maps to learning the YAML syntax for defining resources, parameters, and outputs
  • Defining Resource Dependencies → maps to telling Heat the order of creation (e.g., create a network before creating a port on it)
  • Using the Heat CLI → maps to launching your infrastructure with openstack stack create and deleting it cleanly with openstack stack delete

Real world outcome: A single YAML file and a single CLI command that can create (and destroy) a whole virtual data center: network, subnet, router, security group, and VM.

Part 2: Learning OpenShift (The PaaS Application Platform)

OpenShift is Red Hat’s enterprise Kubernetes platform. It takes a Kubernetes core and adds a huge number of developer-centric and security-focused features, making it a true Platform as a Service.

Key OpenShift Concepts You Will Learn

  • Kubernetes Core: Pods, Deployments, Services, Persistent Volumes.
  • Routes: An improvement on Kubernetes Ingress for exposing applications to the web.
  • Source-to-Image (S2I): A powerful tool to build container images directly from your source code without a Dockerfile.
  • Developer and Admin Consoles: Rich web UIs for managing the platform and applications.
  • Operators: The preferred way to manage complex applications on the platform.
  • Security Context Constraints (SCCs): OpenShift’s strict, security-first permissions model.

Project 4: Local OpenShift with CodeReady Containers (CRC)

  • File: LEARN_OPENSTACK_AND_OPENSHIFT.md
  • Main Technology: CodeReady Containers (CRC) / OpenShift Local
  • Difficulty: Level 2: Intermediate
  • Knowledge Area: Kubernetes / PaaS
  • Main Resource: Red Hat’s official CRC documentation.

What you’ll build: A single-node OpenShift cluster running on your local machine.

Why it teaches OpenShift: CRC is the DevStack equivalent for OpenShift. It provides a fully-featured local cluster, including the web console, operator hub, and oc CLI. It’s the best way to get a feel for the OpenShift environment.

Core challenges you’ll face:

  • Hardware Virtualization → maps to ensuring your machine has virtualization enabled in the BIOS
  • Installation and Setup → maps to running crc setup and crc start
  • Using the oc CLI → maps to logging in and interacting with your cluster from the command line (oc whoami, oc get projects)
  • Navigating the Web Console → maps to exploring the developer and administrator perspectives in the GUI

Difficulty: Intermediate Time estimate: A few hours Prerequisites: A modern laptop with 16GB+ RAM and virtualization support.

Real world outcome: A running OpenShift web console accessible at https://console-openshift-console.apps-crc.testing. You will be able to log in as both a developer and an administrator (kubeadmin).

Project 5: Deploying an App with Source-to-Image (S2I)

  • File: LEARN_OPENSTACK_AND_OPENSHIFT.md
  • Main Technology: OpenShift S2I, oc CLI
  • Difficulty: Level 2: Intermediate
  • Knowledge Area: Application Deployment / CI/CD
  • Main Resource: OpenShift S2I documentation.

What you’ll build: You will take a simple Node.js or Python application without a Dockerfile and deploy it directly from its source code repository on GitHub.

Why it teaches OpenShift: This highlights a key feature that makes OpenShift so developer-friendly. You will see how the platform can abstract away the complexity of containerization, automatically detecting your language, building a container image, pushing it to the integrated registry, and deploying it.

Core challenges you’ll face:

  • Using oc new-app → maps to the core command for creating applications
  • Understanding BuildConfigs and ImageStreams → maps to the OpenShift objects that manage the S2I build process and resulting images
  • Exposing the Service with a Route → maps to making your running application accessible from your browser
  • Watching the Build Logs → maps to seeing the platform clone your repo, install dependencies, and build the image

Real world outcome: A publicly accessible URL on your CRC cluster that serves your live application, which was deployed without you ever writing docker build.

Implementation Hints:

  1. Create a new project: oc new-project my-s2i-app
  2. Deploy from GitHub: oc new-app https://github.com/sclorg/nodejs-ex.git (using the official example)
  3. Watch the build: oc logs -f bc/nodejs-ex
  4. Expose the service: oc expose svc/nodejs-ex
  5. Find the URL: oc get route nodejs-ex

Project 6: Deploying a Multi-Tier Application (WordPress)

  • File: LEARN_OPENSTACK_AND_OPENSHIFT.md
  • Main Technology: Kubernetes concepts (Deployments, Services, PVCs)
  • Difficulty: Level 3: Advanced
  • Knowledge Area: State management in containers
  • Main Resource: OpenShift documentation on deploying stateful applications.

What you’ll build: A fully functional WordPress site on your CRC cluster, with a PHP frontend and a MySQL database backend.

Why it teaches OpenShift: This teaches you how to manage a stateful application. The WordPress container is ephemeral, but the database needs to store its data persistently. You will learn how to connect different application tiers using internal Services and provide persistent storage using PersistentVolumeClaims.

Core challenges you’ll face:

  • Deploying from a template → maps to using OpenShift’s built-in templates to deploy common applications like WordPress
  • Persistent Storage → maps to understanding PersistentVolume (PV) and PersistentVolumeClaim (PVC) to give your database a stable place to store its files
  • Internal Networking → maps to understanding how the WordPress frontend pod finds and connects to the MySQL pod using a Kubernetes Service name
  • Managing Secrets → maps to securely providing the database password to the WordPress pod without hardcoding it in the image

Real world outcome: A running WordPress site on your OpenShift cluster. You can go through the WordPress setup, write a blog post, restart the pods, and see that your post is still there because the database was using persistent storage.

Part 3: Capstone Project

Project 7: Deploying OpenShift on OpenStack

  • File: LEARN_OPENSTACK_AND_OPENSHIFT.md
  • Difficulty: Level 5: Master
  • Knowledge Area: Full-Stack Cloud Architecture
  • Main Resource: OpenShift IPI/UPI on OpenStack installation guides.

What you’ll build: Using your OpenStack cloud (from Part 1) as the infrastructure provider, you will deploy a multi-node OpenShift cluster (from Part 2).

Why it’s the capstone: This project ties everything together. You will see firsthand how the IaaS layer you built provides the VMs, networking, and storage that the PaaS layer needs to function. You will use the OpenStack CLI to prepare the infrastructure and the OpenShift installer to deploy the cluster, bridging the two worlds.

Core challenges you’ll face:

  • Preparing the OpenStack environment → maps to creating specific networks, security groups, and Glance images required by the OpenShift installer
  • Running the OpenShift Installer → maps to using the openshift-install binary to provision the VMs on OpenStack and bootstrap the cluster
  • Troubleshooting Both Layers → maps to debugging problems that could be in your OpenStack network configuration OR your OpenShift deployment configuration
  • DNS and Networking Integration → maps to making sure your OpenShift cluster’s services can be resolved and accessed correctly

Real world outcome: A fully functional, multi-node OpenShift cluster where the master and worker nodes are virtual machines running on your own OpenStack cloud. You have built your own private cloud from the hardware up to the application platform.

Summary

Project Focus Key Technology Difficulty Goal
Part 1: OpenStack        
1. Deploy DevStack IaaS Installation DevStack Intermediate Get a working OpenStack cloud.
2. Manual Provisioning IaaS User Workflow Horizon/CLI Intermediate Create a VM with network access.
3. Automate with Heat IaC Principles OpenStack Heat Advanced Define infrastructure in code.
Part 2: OpenShift        
4. Deploy CRC PaaS Installation CodeReady Containers Intermediate Get a working OpenShift cluster.
5. S2I Deployment Developer Workflow Source-to-Image Intermediate Deploy an app from source code.
6. Stateful App PaaS Application Mgmt K8s Primitives Advanced Deploy a database-backed app.
Part 3: Capstone        
7. OpenShift on OS Full Stack Integration IPI Installer Master Deploy PaaS on top of your IaaS.