---
title: "Cloud-Native Architecture: Containers, Schedulers and the Control Loop"
description: "A deployment is described as a desired state and a controller works continuously to close the gap. Containers make a process portable, a scheduler decides where it runs, and the control loop is what t"
canonical: https://lightmysky.com/learn/computing/cloud-native-architecture-containers-schedulers-and-the-control-loop-mt_nV1LgSRsh_
source: https://lightmysky.com/learn/computing/cloud-native-architecture-containers-schedulers-and-the-control-loop-mt_nV1LgSRsh_.md
retrieved: 2026-09-12
---

> **Agent view.** This is the Markdown twin of the page, for tools and assistants.
> When to use this site, and the call that answers each job: https://lightmysky.com/agent-instructions.md
> API description (OpenAPI 3.1): https://lightmysky.com/openapi.json · Authentication: https://lightmysky.com/auth.md
> Pricing: https://lightmysky.com/pricing.md · Catalog: https://lightmysky.com/llms.txt · Full catalog: https://lightmysky.com/llms-full.txt
> Every machine-readable file on this domain: https://lightmysky.com/.well-known/ai-catalog.json
> Ask for Markdown with `Accept: text/markdown`, a `.md` address, or `?mode=agent`.

# Cloud-Native Architecture: Containers, Schedulers and the Control Loop

A deployment is described as a desired state and a controller works continuously to close the gap. Containers make a process portable, a scheduler decides where it runs, and the control loop is what turns a crashed replica into a replaced one with nobody being paged.

Subject: Computing · Area: Computer Systems · Ages 23 to 24
Page: https://lightmysky.com/learn/computing/cloud-native-architecture-containers-schedulers-and-the-control-loop-mt_nV1LgSRsh_

## Ready when they can

- Say what a container isolates and what it shares with the host
- Describe the reconcile loop and why it is written to be safe to run repeatedly
- Explain why declaring the desired state beats issuing the steps to reach it

## Lesson: Declare the state, let the loop converge

Cloud-native programs split work into microservices: many small services that each do one job and talk over the network. That is the opposite of a monolith, where every feature lives in one big codebase. Each small service can be copied, moved, or restarted alone, which fits a cloud of replaceable machines.

Containers make a process portable by isolating it while still sharing the host underneath. A scheduler then decides where copies run, placing them wherever room and rules allow. When load shifts or a machine dies, placement simply changes instead of the service dying with its box.

**Example.** A deployment is described as a desired state, and a controller works continuously to close the gap. If a node dies, the loop notices a missing replica and starts a replacement with nobody being paged. Declaring the end state beats issuing steps, because the loop re-derives the steps every round.

**Tip.** Write your reconcile loop so repeats do no harm. Each pass should compare actual against declared state and nudge only the difference. A loop safe to rerun heals crashes, absorbs moved copies, and survives its own retries.

**Recap.** Split into services, declare the desired state, and let a repeat-safe loop enforce it.

## Practice

8 questions on this page, each with its working shown.

## Needs first

- [Software Architecture: Layers, Services and Their Trade-offs](https://lightmysky.com/learn/computing/software-architecture-layers-services-and-their-trade-offs-mt_uz_OkFgysJ)
- [Continuous Integration and the Build Pipeline](https://lightmysky.com/learn/computing/continuous-integration-and-the-build-pipeline-mt_z__G4nfjwh)

## Opens up

- [Observability and Tail Latency Across Services](https://lightmysky.com/learn/computing/observability-and-tail-latency-across-services-mt_NT5tmumdfA)