This course teaches the cloud as a profession, not as one provider's catalogue. You first learn the mechanisms shared by every cloud: why a machine costs what it costs, why a badly split network is still being paid for two years later, and why an overly broad permission always ends up being used. You then apply them, with no account and no credit card, on an emulator and local tools. The audience runs from the beginner who has never created a virtual machine to the administrator who wants to give structure to what they already practise. Only basic Linux administration and a few networking notions are expected at the start.
What you will learn
- Choose a service and deployment model for a workload (an application and its data), and say who is responsible for what.
- Estimate the monthly cost of an architecture before deploying it, outbound transfers included.
- Build a private network, from the addressing plan to the exit to the Internet.
- Bootstrap a machine with no manual intervention and no public address.
- Control who can access what, without repeating the classic mistakes.
- Operate over time: resilience, restored backups, rebuilding from code, verified destruction.
- Transfer the same knowledge from one provider to another, because the vocabulary changes more than the concepts.
How the course is organised
The course separates what is universal from what belongs to one provider. This is the most useful distinction you can take away: it keeps you from mistaking a transferable skill for a reflex that only works in one console.
The common core explains the mechanisms. A subnet, an access policy, a cold storage class, a billed outbound transfer: these notions exist everywhere, under different names. The pages of the common core depend on no provider to explain a concept, and when an implementation helps understanding, they show several.
The provider tracks apply these mechanisms to one specific cloud, with its names, its limits and its traps: OUTSCALE and Scaleway each have their own course, and AWS, Azure and GCP have one optional lesson each at the end of the course. You follow only one, the one you use. The others stay readable the day you switch.
What are the three tracks of the course?
The course offers three overlapping tracks: Cloud Essentials, Cloud Engineer and Cloud Architect. A track only filters which programme the My path page displays. Your progress is tracked across the whole course, and switching track loses nothing.
| Track | Who it is for | What it covers | Practice and proof |
|---|---|---|---|
| Cloud Essentials | Anyone who must understand and explain a cloud architecture | The concepts, the bill, then the lessons on networking, compute, storage, data, identities, exposure, resilience, governance and sovereignty that can be understood without practising; no practice, no automation, no operations, no migration, no final project; optionally, the three discovery lessons on AWS, Azure and GCP | Reading the lessons, no account, no practical proof |
| Cloud Engineer | Anyone who builds and operates an environment | The modules from the introduction to operations, plus the local work packages of the final project; optionally, the lesson on threats and detection and the three provider lessons | No account and no credit card: local labs, four labs verified by dsoxlab |
| Cloud Architect | Anyone who assesses an existing architecture, compares and decides, designs identities and continuity, governs and defends an architecture in review | The whole course: the build lessons as a base, then the lessons specific to the Architect (analyse an unknown architecture, compare and decide, recommend changes, hybrid networking, governance, migration, sovereignty, architecture review); optionally, the Engineer's lessons (threats and detection, the major providers), plus Pépin and how to read its results | A written assessment, the analysis of an unknown architecture: brief and grid online, with no account and no imposed provider. The site does not collect submissions: the grid is there to assess your own |
The track selector is on the My path page: it shows only the lessons of the chosen track. Optional lessons, such as opening an account with a provider, block no track. The following are also optional: the lesson on threats and detection (in French) in the "Operate" module, Pépin and how to read its results in the "Govern and optimise" module, and the "The major providers (optional)" module.
The common core
Fundamentals
These are the cloud mechanisms, independent of any provider: what you really buy, how it is billed, and what you give up in exchange. The entry point is the NIST definition (in French), the first lesson after this introduction. NIST is the American standards institute that fixed the cloud vocabulary. Then come the IaaS, PaaS and SaaS models, shared responsibility and regions and availability zones (in French), which decide your resilience. The fundamental everything is an API (in French) explains why a cloud is driven by code, which the module on rebuilding from code puts into practice.
Reading the cloud as a bill
Four lessons teach you to put a price on things before you deploy: CAPEX and OPEX (in French), the pay-as-you-go pricing models, the TCO method (in French) and the cost of outbound transfer, the line of the bill that nobody anticipates.
Security and identities
This is a domain not to put off, even though the course plan teaches it after networking and compute: an overly broad permission stays invisible until it is used. You start with identities through IAM, continue with what is reachable without authentication, and log before you need the logs. The entry point is Cloud security (in French), complemented by encryption at rest and in transit (in French).
Compute, networking, storage and data
This covers what you buy when you create a machine, how to size it without paying for nothing, and what keeps being billed after shutdown: see Choosing and sizing a machine (in French) and elasticity and scalability.
Networking has its own series, from addressing to architectures: the networking course (in French), then the private network and its subnets (in French) and network security (in French). To expose an application, CDN, WAF and private links (in French) say what each edge service really protects.
On the data side, managed databases, caches and queues and the three storage families (in French) (blocks, files, objects) detail what each choice implies for performance and for the bill: storage is the item that grows on its own, and the hardest one to correct after the fact.
Operations, governance and sovereignty
Keep the environment running over the long term, then know who spends what and set guardrails that nobody bypasses: imposed maintenance, quotas and capacity, then account hierarchy, guardrails and tagging (in French). Location, jurisdiction and technological dependence are three distinct questions, covered in the technological sovereignty of the stack (in French).
How do you practise without opening an account?
The first obstacle to learning the cloud is not difficulty, it is the credit card. A handling mistake on a real account is paid for immediately, and the fear of the bill keeps people from experimenting, and therefore from learning. The Engineer track is therefore played without a cloud account or a credit card.
The Feint emulator answers this problem: it serves the APIs of several European clouds locally, so you can replay operations, get them wrong, and start again without any resource being billed. What it emulates and, just as important, what it does not emulate, is spelled out in What Feint proves: no prices, no quotas, no permissions, no object storage, no real traffic.
No account does not mean no machine. The labs that only need Feint and local tools, a disk and an object storage test bench under Docker or Podman, run on an ordinary workstation. The labs that run real machines require a Linux host able to virtualise (KVM or Incus) and dsoxlab, the site's tool for verifiable labs. The installation pages are KVM (in French), Incus and dsoxlab. Without such a host, you follow the lessons and the Feint labs, but not the machine labs.
A real account remains possible, as an option: the lesson on the practice environment (in French) explains how to open a dedicated project with a provider, with short-lived credentials, a budget alert and a verified teardown.
What is the final project?
The whole course converges on a single project: deploy a three-tier application, secure it, back it up, then verify each requirement with a command rather than an impression. The final project (in French) is split into work packages. The "build and operate" packages are played locally, with no account, and carry validation criteria that you check yourself, against the state of your environment and never against the commands you typed. The written architecture review, which only a human reads, belongs to the Architect track, which defends it in review.
Each lesson ends with a quiz, except the introduction, the Feint presentation (a page of landmarks, with no exercise to check), the final project and the assessment on analysing an unknown architecture, which is validated on a submission. This quiz usually draws six questions from its bank (the IAM lesson draws eight) and checks what the page has just taught.
A stance, stated frankly
The course is neutral on concepts, and it is not neutral on choices. The two are different, and confusing them produces lukewarm courses that help nobody decide.
Neutral on concepts: a subnet, an access policy or a storage class can be explained without naming a provider, and nothing here requires you to hold an account anywhere to be understood. You will never have to choose a cloud to follow a lesson of the common core.
Not neutral on choices: I have an openly declared preference for European and sovereign clouds, and you will see it in the examples, in the comparisons and in the most developed tracks. It rests on three arguments that the course spells out rather than hammers home.
- Jurisdiction is chosen in advance or endured. Hosting in Europe with a provider subject to extraterritorial legislation does not protect you from that legislation. It is a matter of law, not geography, and it is settled before the migration.
- Reversibility is a technical criterion. The exit cost is built the day you adopt a proprietary managed service, not the day you want to leave. Billed outbound traffic is its visible form; dependence on an API is less visible.
- Sovereignty is not a single label. "European cloud", "sovereign cloud", "SecNumCloud" and "data hosted in France" designate four distinct things, and the course separates them instead of stacking them.
That said, nothing here pushes you to leave an American cloud. If you work on AWS, Azure or GCP, the mechanisms taught are exactly the same, the examples cite them, and you will be better equipped to discuss the trade-offs with your management. A course that refused to talk about the three biggest providers in the world would do you a disservice.
Which provider tracks exist?
Choose the cloud you use, or the one you must assess. OUTSCALE and Scaleway are full courses in their own right. AWS, Azure and GCP make up the "The major providers (optional)" module, at the end of the course, with one lesson each. The table below gives the size of each track before you open it.
| Track | Scope | What you will find |
|---|---|---|
| OUTSCALE (in French) | Extensive (about fifty pages) | Foundations, networking, storage, IaC, Well-Architected and final project |
| Scaleway (in French) | Extensive (about fifty pages) | Getting started, foundations, networking, IaC, containers, data, observability and security, with labs that build, verify, then destroy each brick |
| AWS (in French) | One optional lesson | Mapping to the notions of the course, account organisation, IAM Identity Center and first steps with the AWS CLI; the guide to the command line (in French) and the Floci local emulator remain separate guides |
| Azure (in French) | One optional lesson | Resource hierarchy, key services, regions and first steps with az |
| GCP (in French) | One optional lesson | Key services, project and first steps with gcloud; the concepts of the common core apply there |
Where should you start?
There are four entry points, depending on what you already know and what you want to do first: the concepts, the subjects that are expensive when done badly, hands-on practice right away, or directly your provider. Open the tab that looks like you.
Start with the NIST definition (in French), the first lesson after this introduction. The fundamentals answer the question nobody dares to ask once they are in a job: what exactly do you buy when you "take a machine in the cloud", and which responsibility do you hand over to whom.
If IaaS, PaaS and SaaS already mean something to you, go straight to what costs the most when done badly: access management (IAM) and the bill (the cost of outbound transfer), the line that surprises teams at the end of the first month.
Set up a local environment, with no account and no credit card, and make your first mistakes there at no cost: install Feint, plug in the official CLIs, then read what it proves.
Go straight to its track, OUTSCALE (in French) or Scaleway (in French). For AWS, Azure or GCP, open the matching optional lesson, AWS (in French), Azure (in French) or GCP (in French): it translates the vocabulary of the course into that of the provider. The common core remains useful afterwards, when a notion resists or when you need to compare.
Key takeaways
- Concepts are transferable, consoles are not. Learn the mechanism; a provider's vocabulary takes a day to pick up.
- Three subjects decide the real cost of an infrastructure: sizing, storage and outbound transfer. They are more expensive to fix once the architecture is frozen (sizing can be readjusted, a storage or transfer layout much less so).
- An overly broad permission always ends up being used. Least privilege is not a theoretical principle, it is what limits the scale of an incident.
- Practise before you pay. The Engineer track is played without a cloud account or a credit card, but not without a machine: the machine labs require a Linux host that can virtualise, and dsoxlab.
- The cloud does not stop at going live. Imposed maintenance, quotas reached, forced version upgrades and restores that were never tested account for most of the nasty surprises.
- A provider track is not official documentation. It reflects an experience, and the vendor's documentation remains the reference source.