5.2. Installer-Provisioned Infrastructure
Table of Contents
What “Installer-Provisioned Infrastructure” Means in OpenShift
In the Installer-Provisioned Infrastructure (IPI) model, the OpenShift installer not only deploys the cluster components, but also creates and manages most of the underlying infrastructure on a supported cloud or virtualization platform.
In practice, this means:
- You provide high-level inputs (platform, region, base domain, credentials).
- The installer creates:
- Network components (VPC/VNet, subnets, security groups, load balancers).
- Compute (control plane and worker VMs/instances).
- Storage integrations for default storage classes.
- DNS records for cluster endpoints (where supported).
- You get a fully functioning, production-grade cluster with minimal manual infra work.
This is in contrast to User-Provisioned Infrastructure (UPI), where you build and wire most of the infrastructure yourself and the installer only lays down OpenShift on top of it.
When to Choose IPI
IPI is best suited for situations where:
- You are deploying on a supported public cloud or virtualization platform:
- Common examples: AWS, Azure, GCP, vSphere, IBM Cloud, bare metal with specific integrations.
- You want a fast, opinionated, automated deployment.
- You accept the default reference architecture provided by OpenShift for that platform (network layout, LB type, etc.).
- You prefer less manual work and more day-2 automation via Cluster API and MachineSets.
You might not choose IPI if:
- Your organization has strict infrastructure standards (custom networking, security zoning, IPAM, etc.) that deviate from the installer’s defaults.
- The platform is not supported by IPI.
- You need fine-grained control over every infrastructure component (then UPI or a managed service may fit better).
Core Concepts in IPI
Cluster Manifest Generation
IPI begins with creating an install-config.yaml that describes how the installer should build the cluster. The installer uses it to generate full cluster manifests and a set of infrastructure creation templates.
Typical fields in install-config.yaml:
- Cluster identity:
metadata.namebaseDomain- Platform-specific configuration:
- e.g.,
platform.aws.region,platform.azure.region, etc. - Network configuration:
networking.machineNetworknetworking.clusterNetworknetworking.serviceNetwork- Network type (e.g.,
OpenShiftSDNin older versions,OVNKubernetes). - Machine pools:
- Control plane:
controlPlane(replicas, instance type, platform settings). - Workers:
computesections (MachinePools).
The installer consumes this file and, in IPI, does not require you to define low-level infrastructure details (subnets, LB names, etc.)—it derives and creates them.
Machine API, MachineSets, and Scaling
In IPI clusters, the Machine API is central:
- Machines represent VMs/instances managed by the cluster itself.
- MachineSets define groups of Machines with a shared template:
- Similar in spirit to Kubernetes
ReplicaSet, but for nodes. - Specify instance types, images, labels, and availability zone details.
- OpenShift’s autoscaling and day-2 scaling can act directly on MachineSets:
- You scale workers by changing
spec.replicason a MachineSet (or using an autoscaler). - The Machine API then creates or deletes the underlying instances.
With IPI, MachineSets are automatically created for the initial workers (and often for control plane, depending on platform), giving you immediate cloud-native scaling capabilities.
Integration With Cloud Provider APIs
IPI clusters are wired to the cloud provider from day 1:
- Cloud-specific controllers are configured to:
- Attach volumes and expose cloud storage as PersistentVolumes.
- Create and manage load balancers, health checks, and node membership.
- Manage DNS entries for cluster endpoints (where supported).
- Service types like
LoadBalancerleverage the underlying platform’s native LB.
Because the installer created the infra, these controllers are configured in a known-good, supported way without manual wiring.
Typical IPI Workflow
Although details vary by platform, an IPI deployment usually follows a similar pattern.
1. Prepare Prerequisites
Typical prerequisites:
- Access to a supported platform account (e.g., AWS, Azure).
- Adequate IAM/role permissions allowing:
- Creating VMs/instances.
- Managing networking (VPC/VNet, subnets, security groups, LBs).
- Managing storage and DNS (as applicable).
- A pull secret from Red Hat.
- SSH key for node access (optional but recommended).
- Sizing decisions for control plane and workers:
- Instance types.
- Number of nodes and zones.
These prerequisites are usually validated by the installer early in the process.
2. Create the Install Configuration
You run openshift-install create install-config and answer prompts (or supply a pre-written install-config.yaml) specifying:
- Platform (e.g.,
aws,azure,gcp,vsphere). - Region, base domain, cluster name.
- Pull secret and SSH key.
- Basic networking information if needed.
The installer stores install-config.yaml in the working directory. In IPI, this file is the primary input; you rarely need to edit low-level infra definitions.
3. Generate Manifests (Optional Customization)
Optionally, you can:
- Run
openshift-install create manifeststo generate cluster manifests. - Make limited adjustments to cluster-level resources before install:
- Additional MachinePools.
- Tweaks to some operator configurations.
For most beginner IPI deployments, you skip detailed manifest edits and go directly to cluster creation.
4. Create the Cluster and Infrastructure
Running openshift-install create cluster starts the full IPI process:
- The installer:
- Creates platform-specific infra components (VPC/VNet, subnets, security groups, LBs, DNS records, etc.).
- Boots bootstrap, control plane, and worker nodes.
- The bootstrap node:
- Temporarily controls initial configuration of the control plane.
- Once the control plane is healthy, it is destroyed (except on some bare-metal or specialized flows).
You monitor progress:
- Via console output from the installer.
- Using
ocand thekubeconfigit writes once API is up. - Sometimes via cloud console to see created resources.
Upon completion, you receive:
kubeconfigfor cluster access.- Web console URL and credentials (or instructions to set up IDP).
5. Day-2 Operations on IPI
For daily operation, IPI clusters emphasize:
- Machine API–driven node management:
- Add more worker capacity by cloning or editing MachineSets.
- Configure cluster autoscaler to scale MachineSets automatically.
- Platform integration:
- Use cloud-native constructs (e.g., cloud load balancers, cloud storage).
- Cluster lifecycle:
- Keep in mind that the installer “owns” much of the initial infra shape. Major topology changes (e.g., redesigning VPC) may require redeployment or moving toward a more customized model.
Platform-Specific Characteristics (High-Level)
Detail belongs in platform-specific material, but some key differences are important to understand conceptually.
Public Clouds (AWS, Azure, GCP)
Typical IPI behavior:
- Creates:
- VPC/VNet (or uses an existing one if configured that way).
- Public/private subnets.
- Security groups / network rules.
- External and internal load balancers for API and Ingress.
- DNS records for
api.<cluster>.<domain>and wildcard apps. - Sets up:
- Platform-specific images (AMIs, images, templates).
- MachineSets across multiple availability zones.
This often results in:
- Highly integrated cluster with native cloud services.
- Good defaults for availability and resiliency (multi-AZ deployments when requested).
Virtualization Platforms (e.g., vSphere)
In vSphere IPI:
- You typically prepare:
- vSphere cluster/datastores/networks.
- A base template or image.
- The installer:
- Clones VMs for bootstrap, control plane, and workers.
- Creates MachineSets tied to vSphere templates.
- Networking and load balancing:
- May use NSX-T or external load balancers depending on configuration.
- Some components (like DNS) might still require external setup.
The principle remains: the installer orchestrates VM creation and wiring, but exact capabilities depend on the virtualization platform’s integration.
Bare Metal IPI (and Similar)
Bare-metal IPI is more constrained and specialized:
- Uses components like the Bare Metal Operator and Ironic.
- Requires detailed host inventory (BMC addresses, credentials).
- The installer:
- Automates provisioning of physical nodes.
- Manages them as Machines.
Although still “installer-provisioned,” bare metal usually demands more initial prep and familiarity with hardware provisioning compared to cloud-based IPI.
Advantages and Trade-Offs of IPI
Advantages
- Speed to value: Fast path to a functioning cluster with minimal manual infra work.
- Reduced complexity for beginners:
- No need to handcraft every network or instance.
- Supported design:
- Uses reference architectures validated by Red Hat on that platform.
- Tight integration with Machine API and cloud provider:
- Easier scaling.
- Seamless load balancers and storage classes.
Trade-Offs
- Less flexibility:
- Network layout, security groups, and certain infra choices follow Red Hat’s reference design.
- Infra ownership:
- The cluster lifecycle is closely tied to how the installer created infrastructure.
- Deep changes to underlying infra may be harder than in a fully custom UPI model.
- Platform dependency:
- Only works on supported platforms with required APIs.
Common Beginner Scenarios with IPI
Quick Lab or Test Cluster
- Use IPI on a public cloud sandbox subscription.
- Provide simple
install-config.yamlwith minimal customization. - Get a working cluster quickly for:
- Learning
ocand the web console. - Trying deployment patterns and Operators.
Small Production Cluster in Cloud
- Use IPI to create a small multi-AZ cluster on a supported cloud.
- Accept default network layout.
- Focus operational effort on:
- Application deployment.
- Security, monitoring, and CI/CD.
- Scale workers via MachineSets as workloads grow.
Transition to More Advanced Models
- Start with IPI to learn:
- Cluster behavior.
- Machine API concepts.
- Platform integration.
- Over time, if requirements outgrow defaults:
- Consider:
- More advanced IPI tuning (custom MachinePools, pre-existing VPCs).
- Or switching to UPI / managed OpenShift offerings for stricter control.
Practical Tips for Working With IPI
- Keep your
install-config.yamlversioned: - Helps reproduce or adjust clusters consistently.
- Understand what the installer creates:
- Explore cloud console to see VPCs, subnets, LBs, and instances.
- This is valuable for troubleshooting and cost estimation.
- Monitor resource limits and quotas:
- IPI may fail if the account runs out of:
- VM quotas.
- IP addresses.
- Load balancer or disk quotas.
- Use labels and MachineSets wisely:
- Group workers by role (e.g., “infra”, “app”, “batch”) via separate MachineSets.
- This improves placement and scaling policies.
- Plan for deprovisioning:
openshift-install destroy clustercan remove infra created by IPI.- Use it carefully, especially in shared accounts.
How IPI Fits into the Broader Deployment Landscape
Within the overall OpenShift deployment options:
- IPI sits between:
- Managed services (where the provider manages infra and cluster for you).
- UPI (where you fully manage infra and then install OpenShift).
- It is particularly attractive for:
- New teams getting started with OpenShift.
- Environments where cloud-native automation aligns with organizational practices.
- For HPC and specialized workloads:
- IPI gives a straightforward way to stand up clusters that can then be tailored for compute-heavy or GPU-based workloads, as long as the underlying platform and instance types support them.
Understanding IPI prepares you to:
- Quickly stand up clusters for experimentation and early production.
- Grasp how OpenShift interacts with underlying platforms.
- Compare it to other deployment models and pick the right one for each use case.
Views: 0
Where to Move
Move chapter:
- ☰ 1. Course Overview
- ☰ 1.1. What is OpenShift
- ☰ 1.2. Why OpenShift is used in modern IT and cloud environments
- ☰ 1.3. OpenShift vs Kubernetes
- ☰ 1.4. Typical OpenShift use cases
- ☰ 1.5. Structure and goals of the course
-
- ☰ 2. Containers and Cloud-Native Fundamentals
- ☰ 2.1. What is a container
- ☰ 2.2. Containers vs virtual machines
- ☰ 2.3. Introduction to Docker and container images
- ☰ 2.4. Container registries
- ☰ 2.5. Basics of cloud-native applications
-
- ☰ 3. Kubernetes Fundamentals
- ☰ 3.1. What is Kubernetes
- ☰ 3.2. Kubernetes architecture
- ☰ 3.3. Control plane components
- ☰ 3.4. Worker node components
- ☰ 3.5. Kubernetes objects and resources
- ☰ 3.6. Declarative configuration model
-
- ☰ 4. OpenShift Architecture
- ☰ 4.1. Overview of OpenShift architecture
- ☰ 4.2. Control plane in OpenShift
- ☰ 4.3. Nodes and machine roles
- ☰ 4.4. OpenShift Operators
- ☰ 4.5. OpenShift networking model
- ☰ 4.6. OpenShift storage model
-
- ☰ 5. OpenShift Installation and Deployment Models
- ☰ 5.1. OpenShift deployment options
- ☰ 5.2. Installer-Provisioned Infrastructure
- ☰ 5.3. User-Provisioned Infrastructure
- ☰ 5.4. Managed OpenShift services
- ☰ 5.5. Single-node OpenShift
- ☰ 5.6. Cluster lifecycle management
-
- ☰ 6. Accessing and Using OpenShift
- ☰ 6.1. OpenShift web console
- ☰ 6.2. OpenShift CLI (oc)
- ☰ 6.3. Authentication and authorization
- ☰ 6.4. Projects and namespaces
- ☰ 6.5. Resource quotas and limits
-
- ☰ 7. Building and Deploying Applications
- ☰ 7.1. Application deployment concepts
- ☰ 7.2. Source-to-Image (S2I)
- ☰ 7.3. Container-based deployments
- ☰ 7.4. DeploymentConfigs and Deployments
- ☰ 7.5. Rolling updates and rollbacks
-
- ☰ 8. Networking in OpenShift
- ☰ 8.1. Services and service discovery
- ☰ 8.2. Routes and ingress
- ☰ 8.3. Network policies
- ☰ 8.4. Load balancing
- ☰ 8.5. External access to applications
-
- ☰ 9. Storage in OpenShift
- ☰ 9.1. Persistent storage concepts
- ☰ 9.2. Persistent Volumes
- ☰ 9.3. Persistent Volume Claims
- ☰ 9.4. StorageClasses
- ☰ 9.5. Dynamic provisioning
- ☰ 9.6. Stateful applications
-
- ☰ 10. Configuration and Secrets Management
- ☰ 10.1. ConfigMaps
- ☰ 10.2. Secrets
- ☰ 10.3. Environment variables
- ☰ 10.4. Managing sensitive data
- ☰ 10.5. Best practices for configuration
-
- ☰ 11. Scaling and High Availability
- ☰ 11.1. Horizontal pod autoscaling
- ☰ 11.2. Vertical scaling
- ☰ 11.3. Self-healing and pod restarts
- ☰ 11.4. High availability concepts
- ☰ 11.5. Multi-zone and multi-region clusters
-
- ☰ 12. Monitoring, Logging, and Observability
- ☰ 12.1. Built-in monitoring stack
- ☰ 12.2. Metrics and alerts
- ☰ 12.3. Logging architecture
- ☰ 12.4. Distributed tracing
- ☰ 12.5. Troubleshooting applications
-
- ☰ 13. Security in OpenShift
- ☰ 13.1. Security model overview
- ☰ 13.2. Role-Based Access Control
- ☰ 13.3. Security Context Constraints
- ☰ 13.4. Image security and scanning
- ☰ 13.5. Network security
- ☰ 13.6. Compliance and auditing
-
- ☰ 14. CI/CD and DevOps with OpenShift
- ☰ 14.1. DevOps concepts
- ☰ 14.2. CI/CD pipelines overview
- ☰ 14.3. OpenShift Pipelines (Tekton)
- ☰ 14.4. GitOps with Argo CD
- ☰ 14.5. Integrating OpenShift with external CI tools
-
- ☰ 15. Operators and Platform Services
- ☰ 15.1. What are Operators
- ☰ 15.2. Operator Lifecycle Manager
- ☰ 15.3. Installing and managing Operators
- ☰ 15.4. Common platform Operators
- ☰ 15.5. Custom Operators
-
- ☰ 16. Upgrades, Maintenance, and Operations
- ☰ 16.1. OpenShift upgrade process
- ☰ 16.2. Backup and restore
- ☰ 16.3. Node maintenance
- ☰ 16.4. Cluster troubleshooting
- ☰ 16.5. Capacity planning
-
- ☰ 17. OpenShift on HPC and Specialized Workloads
- ☰ 17.1. Running batch workloads on OpenShift
- ☰ 17.2. OpenShift and GPUs
- ☰ 17.3. MPI and parallel workloads in containers
- ☰ 17.4. Hybrid HPC and cloud workflows
-
- ☰ 18. OpenShift in Practice
- ☰ 18.1. Typical OpenShift workflows
- ☰ 18.2. Development to production lifecycle
- ☰ 18.3. Case studies from industry
- ☰ 18.4. Common pitfalls and best practices
-
- ☰ 19. Future Directions and Ecosystem
- ☰ 19.1. Kubernetes ecosystem overview
- ☰ 19.2. OpenShift roadmap
- ☰ 19.3. Serverless and event-driven workloads
- ☰ 19.4. AI and data platforms on OpenShift
-
- ☰ 20. Final Project and Hands-On Exercises
- ☰ 20.1. Deploying a containerized application
- ☰ 20.2. Implementing CI/CD with OpenShift
- ☰ 20.3. Securing and scaling an application
- ☰ 20.4. Monitoring and troubleshooting report
-
Comments
Please login to add a comment.
Don't have an account? Register now!