OpenStack Academy: How to Train a Cloud Operator in Nine Weeks

Not through a course. Through a cloud you build, operate, break, and repair with your own hands.

Cloud computing is usually taught through presentations: architectures, diagrams, definitions. The problem is that no one has ever kept a cloud up and running by looking at a diagram.

That is why, in September, we launched an internal academy based on a different premise — you learn OpenStack exactly the way you will use it: by working hands-on with real infrastructure, from the first day to the last.

What It Is, in Short

A hands-on, eight-module program lasting approximately nine weeks, part-time.

By the end, each participant will have installed OpenStack from scratch twice — once entirely by hand, to see every individual piece, and once using the tool currently used in production.

They will operate it day to day, deliberately break it and repair it without reinstalling it, recreate it through code, and, in the end, place it behind a firewall they configured themselves.

Everything takes place on a real cluster, with dedicated servers — not on a simulator and not in a “toy” environment. Each participant gets an entire server, with production-grade resources at their disposal.

The Journey

The journey starts from the ground up, with the fundamentals — Linux, networking, and Ansible — where each participant builds the lab network they will use throughout the rest of the program.

Only after the groundwork is in place do they move into the OpenStack architecture: what components exist and, more importantly, which components talk to one another and why.

The first installation comes next, done entirely by hand, with no automation whatsoever — a mini-cloud built piece by piece, specifically so that nothing remains a black box.

That understanding then becomes the foundation for the real, multi-node deployment with Kolla-Ansible, the tool currently used in production.

With the cluster up and running, the program continues with day-to-day operations — projects, quotas, volumes, backup and restore — followed by the academy’s core module: troubleshooting.

Toward the end, everything is recreated through code using Ansible and Terraform, and the final piece adds a security perimeter around the infrastructure, configured with pfSense.

The eight modules are not independent: each one builds on what the previous one produced, and nothing is discarded along the way.

The router you build manually in the first week is the very gateway through which OpenStack is installed later — and the exact component you replace with a professional firewall at the end.

That is precisely why the exercises cannot be reordered at will: each one carries an explicit dependency on those that came before it.

The Philosophy: No Step Comes Pre-Written

The essential difference from a tutorial is that the exercise sheets never give you the finished configuration.

They tell you what needs to be achieved and where to look — the rest you have to figure out yourself.

It is the only way an exercise truly builds a skill rather than simply producing a successful copy.

When you get stuck, you are not given the solution, but a question that narrows your search.

It is slower, and that is exactly the point.

The Core Module: Troubleshooting

The part I am most proud of as a mentor is the troubleshooting module.

We deliberately “break” each participant’s own cluster in a controlled way — without telling them where or what was changed — and they have to work from symptom to root cause and prove the fix, exactly as they would during a real overnight incident.

It does not matter that they guessed which file was changed; what matters is that they understand the mechanism and can demonstrate, through a clear verification, that they fixed it.

Every fault is repaired live, without reinstalling — because in production, you never have the luxury of starting everything over from scratch.

What I Believe Matters Most

After all these modules, my conviction is simple: infrastructure can only be learned by working with it hands-on.

A cloud you have built yourself, broken, and brought back to life teaches you in a few weeks what a year of theory could not.

Beyond the technical side, the academy also builds a reflex that stays with you for life: the discipline of always working with a safety net.

You verify before you make a claim, you always have a way back, and you never cut off the branch you are sitting on.

These are not OpenStack lessons — they are engineering lessons.

OpenStack is simply the ground on which you practice them.