Orchestration on serverplus: infrastructure as code (Heat)

Orchestration is a way to describe an entire infrastructure as text (in a template) and deploy it with one click. Instead of manually creating a server, then a network, a disk, an IP and rules one by one, you describe the whole set in a single file — and the cloud brings up all the resources in the right order itself.

Technically the section is powered by OpenStack Heat — an "infrastructure as code" (IaC) engine. One such deployed set of resources is called a stack.

The section is split into three tabs: Stacks, Resource types and Template versions.

Why you need it

• Reproducibility. The same template deploys identical infrastructure any number of times — dev, staging, prod come out the same.
• Speed. A set of dozens of resources comes up in a single run, not by clicking each one.
• Order and links. Heat understands dependencies itself: first the network and subnet, then a server in that network, then an IP on the server.
• Manageability. The whole group of resources can be updated or deleted as a single whole (the stack).
• Versioning. A template is text: convenient to keep in git, review and roll back.

The "Stacks" tab

A stack is a deployed instance of a template: a specific set of resources created from the description. Here you create stacks, watch their status and delete them. While there are no stacks, the tab is empty with a Create stack button.

How to create a stack

Click Create stack and fill in the form:

• Location — the region (uz-tas1 / RegionOne).
• Stack Name — the stack name, for example web-prod.
• Creation Timeout (minutes) — how long to wait for deployment before cancelling (default 60).
• Rollback On Failure — if enabled, on an error Heat rolls back the already-created resources, leaving no "half-built" stack.
• Template Source — where to take the template from: File (upload a file), Direct Input (paste text) or URL (by a link).
• Environment Source (optional) — an environment file that overrides parameters, the same way: File / Direct Input / URL.

After filling it in, click + Create stack — Heat starts deploying the resources.

The template (HOT): what it consists of

A Heat template (the HOT format, usually YAML) describes what to create and with which parameters. The main sections:

• heat_template_version — the template format version (see the "Template versions" tab).
• description — a description of what the template is for.
• parameters — input parameters (for example server size, network name) set at launch time.
• resources — the resources themselves: servers, networks, disks, IPs, etc.
• outputs — what to return after deployment (for example the server's public IP).

A minimal example — one server with a size parameter:

heat_template_version: 2021-04-16 description: One cloud server parameters:  flavor:    type: string    default: s1-1 resources:  web_server:    type: OS::Nova::Server    properties:      name: web-1      flavor: { get_param: flavor }      image: Ubuntu 24.04 outputs:  server_name:    value: { get_attr: [web_server, name] }

The "Resource types" tab

This is a catalog of all resources you can use in a template. Each type is a "building block" of infrastructure. Two groups of names are supported:

• OS::… — the "native" OpenStack resources: OS::Nova::Server (a server), OS::Neutron::Net (a network), OS::Neutron::Subnet (a subnet), OS::Cinder::Volume (a disk), OS::Neutron::FloatingIP and others.
• AWS::… — types compatible with AWS CloudFormation (AWS::EC2::Instance, AWS::AutoScaling::AutoScalingGroup, etc.), so you can port familiar templates.

From a resource type you can see which properties it accepts — a hint when writing a template.

The "Template versions" tab

A list of supported template format versions. The heat_template_version line in your template must be from this list. Types:

• hot — the modern Heat format (heat_template_version.2013-05-23 … 2021-04-16), with clear aliases by OpenStack releases: newton, ocata, pike, queens, rocky, wallaby.
• cfn — the format compatible with AWS CloudFormation (AWSTemplateFormatVersion.2010-09-09, HeatTemplateFormatVersion.2012-12-12).

Tip. Use a newer version (for example 2021-04-16) — it has more functions and resources available. Older versions are needed mainly for compatibility with old templates.

Typical scenarios

• A ready "turnkey" environment. A template that brings up a network + server + disk + IP + rules — as one stack for a new project or client.
• Identical environments. Dev / staging / prod from one template with different parameters — without "configured differently" discrepancies.
• Autoscaling. A group of servers (an AutoScalingGroup) that grows and shrinks with the load.
• Infrastructure updates. You change the template → update the stack; Heat recreates only what changed.

Orchestration, Kubernetes and manual creation — the difference

• Manual creation in the panel is convenient for one or two servers, but is not reproducible and it is easy to forget a step.
• Orchestration (Heat) manages cloud infrastructure: servers, networks, disks, IPs as a single stack.
• Kubernetes manages containers inside a cluster. These are different levels: Heat can deploy the cluster/servers themselves, and Kubernetes — the containerized applications on them.

FAQ

Do I need to know programming to use orchestration?

Programming — no, but you need to learn the HOT template format (YAML) and know the needed resource types. It is closer to "describing by example" than to development. The easiest is to start with a small ready template and refine it.

What is a stack in simple terms?

A stack is a "package" of resources created from one template and managed as a whole. Delete a stack — all resources in it are deleted; update it — they update consistently.

How do Template Source File / Direct Input / URL differ?

It is just a way to supply the same template: File — upload a file from your computer, Direct Input — paste the text directly into the field, URL — provide a link to download it from.

Why is Rollback On Failure needed?

So that an error in the middle of deployment does not leave "garbage" from half-created resources. With rollback enabled, Heat deletes everything it managed to create and returns a clean state.

What is an Environment?

A separate file that overrides a template's parameters and settings for a specific launch — handy when one template is used for different environments with different values.