Unit 1.3: Designing Around Platform Boundaries: The Native-Substitution Model
Introduction
Architects who arrive from a hyperscaler often start a design with a product name: "we need a gateway", "we need read replicas", "we need a failover service". On IONOS CLOUD, the more productive starting point is the capability. Name what the requirement actually needs, such as routing by path, reads that scale, or traffic that moves when a site fails, and then compose it from the products the platform does offer.
This course calls that habit the native-substitution model. It is not a workaround mindset. Each substitution has a clear owner, a known failure mode and a cost, and you can reason about all three. This unit introduces the six substitutions that recur through the course and points to the unit that builds each one.
1. The Model: Capability First, Then Composition
1.1 How to Apply It
The model has three steps. First, state the capability in neutral terms, without a product name. Second, find the platform primitives that deliver it and draw where they sit on the layered shape from Unit 1.2. Third, write down what you now own: the configuration, the monitoring and the runbook that the composition needs.
That third step is where the design work lives. A composed capability is usually more transparent than a packaged one, because you can see every part. It also means that responsibility for the glue is yours, and the glue must be designed, tested and monitored like any other component.
1.2 The Six Substitutions
The following table summarises the substitution set. Sections 1.3 to 1.8 explain each one.
| Capability you need | Composed from | What you own | Designed or built in |
|---|---|---|---|
| Content routing for APIs | Managed Application Load Balancer forwarding rules plus an ingress controller inside Managed Kubernetes | Rule design, ingress controller lifecycle | Units 3.3, 6.1, 6.2 |
| Read scaling for a relational database | DBaaS for In-Memory DB as a cache plus the managed connection pooler of DBaaS for PostgreSQL | Cache-aside logic, invalidation, pool sizing | Units 5.3, 5.5 |
| Automated failover | Load balancer health checks, IP failover groups, cluster-internal promotion, and Cloud DNS records updated through the API | The failure detection and the record change across sites | Units 3.5, 3.7, 7.1 |
| Change-data-capture | Application-level event publishing to Event Streams for Apache Kafka | Event schema, publish-on-write discipline | Unit 5.6 |
| VM import | Image conversion and upload into Images & Snapshots, or VMware-native replication into Private Cloud | Guest preparation, boot mode, drivers | Units 4.2, 7.4 |
| Access control | Identity and Access Management groups with per-resource grants | Group design, joiner, mover and leaver runbook | Unit 2.2 |
1.3 Content Routing via Load-Balancer Rules and In-Cluster Ingress
The Managed Application Load Balancer (ALB) routes on header, path, query, method, host, cookie or source IP, and it supports TLS offloading. For API traffic, these forwarding rules carry the coarse routing: one host or path prefix per backend service.
Inside a Managed Kubernetes cluster, the fine-grained routing belongs to an ingress controller. A Service of type LoadBalancer does not deploy a true load balancer in front of the cluster. The platform allocates a static IP address and assigns it to one node as an additional address, and that node acts as the ingress node. The usual practice is therefore to expose only the ingress controller service as type LoadBalancer and let the controller distribute traffic inside the cluster. The composition is ALB rules at the edge, ingress rules inside the cluster, and a clear split between the two. Keep the ALB rule set lean; Unit 3.3 explains the cost pressure.
1.4 Read Scaling via Cache and Connection Pooling
In a multi-node DBaaS for PostgreSQL cluster, standby nodes currently operate in warm standby mode and do not serve read requests. They exist for resilience: if the primary fails, a standby is promoted. Adding nodes therefore buys availability, not read capacity.
Read capacity comes from two other places. DBaaS for In-Memory DB, a key-value store compatible with the Redis OSS API, fits frequently accessed data that rarely changes, and using it as a cache reduces the queries that reach the database. The managed connection pooler (pgbouncer) of DBaaS for PostgreSQL, in transaction or session mode, lets many application connections share fewer database connections. Together they are the read-scaling layer. Note the scope: this boundary is about PostgreSQL. MongoDB Enterprise lets you add up to five secondary members to a replica set, for a total of seven nodes (Unit 5.4).
1.5 Automated Failover via Health Checks and DNS
Failover is composed in layers. Within a site, the managed load balancers run health checks and send traffic only to healthy targets, and a DBaaS for PostgreSQL cluster promotes a standby when the primary fails. For active-passive VM pairs, IP failover groups reassign a public IP address to the standby VM automatically. An IP failover group needs a reserved IP address, works on a public LAN only and supports IPv4 only. It is also not a failover mechanism on its own: the high-availability setup, such as the cluster software in the guests, must be fully installed on your VMs.
Across sites, the steering layer is DNS. The Cloud DNS API lets you create, update and delete records programmatically, so your own monitoring can move a record to the surviving endpoint. The record time to live (TTL) then bounds how quickly clients follow: Cloud DNS accepts TTLs down to 60 seconds and defaults to 3600 seconds. DNS changes steer new connections only, which is one more reason the compute tier must be stateless. Units 3.7 and 7.1 design this layer.
1.6 Change-Data-Capture via Application-Level Events
When downstream systems need a feed of database changes, design the application to publish each business change as an event when it writes to the database. Event Streams for Apache Kafka, a fully managed Apache Kafka service with automatic failover and TLS-encrypted endpoints, carries those events to every consumer. The trade-off is discipline: the event and the database write must stay consistent, which is an application design concern. Unit 5.6 covers partitioning and ordering.
1.7 VM Import via Image Conversion
You bring a VM onto VDC compute as a disk image. Uploads go to the upload servers for each data center location, over FTP with optional TLS. The supported HDD formats are vmdk (VMware), vhd and vhdx (HyperV), cow, qcow and qcow2 (Qemu), raw (binary), vpc (VirtualPC) and vdi (VirtualBox). An image is converted to RAW after upload, so a dynamic disk is always used at its maximum size.
Guest preparation is part of the work. The Intel Sierra Forest and AMD EPYC Turin CPU families require UEFI for booting, and Windows guests need the VirtIO drivers. For workloads that must keep their VMware operating model, the alternative path is VMware Cloud Director Availability (VCDA) into Private Cloud, which replicates, migrates and fails over virtual machines. Unit 7.4 compares the paths and their downtime.
1.8 Access Control via Group-and-Grant
Identity and Access Management (IAM) assigns rights through groups. A group holds users, and you grant the group Read, Edit or Sharing on individual resources such as VDCs, snapshots, images, IP blocks, backup units and Kubernetes clusters. Read is implicit as soon as a group is assigned to a resource. Contract Owner and Administrator accounts are exempt from group management because they have access to all contracted resources. Least privilege is therefore a design of groups and grants, plus a short list of administrators.
Federation follows the same model. A federated login links to an existing user, and the platform does not provision users just in time. Your joiner, mover and leaver process creates, changes and removes users and their group memberships. Unit 2.2 builds this.
2. Trade-offs and the FinCorp Slice
2.1 What Each Substitution Moves to You
| Substitution | Advantages | Disadvantages | Best for |
|---|---|---|---|
| ALB rules plus in-cluster ingress | Each layer is visible and independently testable | Two rule sets to keep consistent | Containerised APIs behind a public edge |
| Cache plus pooling | Read load drops without changing the database cluster | Cache invalidation is application logic | Read-heavy services with stable hot data |
| Health checks plus DNS records | Each layer fails over on its own signal | Cross-site detection and record change are yours | Two-site designs with stateless front ends |
| Application events to Kafka | Consumers decouple from the database schema | Write-and-publish consistency is yours | Integration feeds and the AI ingestion spine |
| Image conversion or VCDA | Clear per-path mechanics | Guest preparation and testing per VM family | Planned migration waves |
| Group-and-grant | Simple to audit per resource | Manual lifecycle for federated users | Small administrator sets, clear resource ownership |
2.2 FinCorp Applies the Model
FinCorp's architects receive six requirements in one workshop. Their API team wants a gateway in front of microservices; the composition is ALB host and path rules into an ingress controller. The portal team expects read replicas for the customer database; the composition is DBaaS for In-Memory DB for account summaries plus the PostgreSQL connection pooler. The risk office demands automated failover between two VDCs; the composition is health-checked load balancers in each VDC and a monitored Cloud DNS record with a short TTL. The data team wants change-data-capture for the AI pipeline; the portal publishes account events to Event Streams for Apache Kafka. The migration team needs to import VMware VMs; it splits the estate between image conversion and VCDA into Private Cloud. Security wants role-based access; the answer is IAM groups per team and environment, with a written leaver runbook.
Each answer is recorded with what FinCorp now owns. That list becomes the operational backlog that Module 7 works through.
Decision Summary
| Requirement phrased as | Restate as capability | Compose from | Decided in |
|---|---|---|---|
| "API gateway" | Route by host or path, terminate TLS | ALB forwarding rules, in-cluster ingress controller | Units 3.3, 6.2 |
| "Read replicas" (PostgreSQL) | Scale reads without loading the primary | DBaaS for In-Memory DB, PostgreSQL connection pooler | Units 5.3, 5.5 |
| "Failover service" | Move traffic when a target or site fails | Load balancer health checks, IP failover, Cloud DNS API with low TTL | Units 3.5, 3.7, 7.1 |
| "Change-data-capture" | Feed changes to consumers | Application events to Event Streams for Apache Kafka | Unit 5.6 |
| "Import my VMs" | Run the same workload on the platform | Image upload with guest preparation, or VCDA into Private Cloud | Units 4.2, 7.4 |
| "Policy-based roles" | Grant least privilege per resource | IAM groups with Read, Edit or Sharing grants | Unit 2.2 |
Summary
The native-substitution model turns product-shaped requirements into capabilities and composes each one from platform primitives. The six recurring cases are API routing, read scaling, failover, change-data-capture, VM import and access control. Each composition is sound and transparent, and each hands your team a specific piece of glue to design, monitor and run. Later modules build every one of them.
Key Points:
- Start from the capability, not the product name; then compose and record what you own.
- PostgreSQL standby nodes do not serve read requests; scale reads with DBaaS for In-Memory DB and the connection pooler.
- A Kubernetes LoadBalancer Service is a static IP on one node; route APIs with ALB rules plus an in-cluster ingress controller.
- Cross-site failover is driven by your monitoring changing Cloud DNS records; the TTL bounds how fast clients follow.
- IAM grants Read, Edit or Sharing per resource through groups, and federated users must already exist.