Skip to content
ballmüllersolutions logo Send an email Call us

K3 Professional: cloud, quality, DevOps

Run an application securely in Azure: infrastructure as code, CI/CD, observability, messaging and tests that hold up.

Join the waiting list

Who it is for

For developers with .NET experience who want to deliver and run their applications in Azure themselves.

Prerequisites

K2, or a year of professional experience with .NET and the placement test.

Afterward, you can

  • Keep Azure resources, permissions and costs under control
  • Describe and roll out infrastructure with Bicep and azd
  • Run applications without keys in the code, with managed identity and Key Vault
  • Observe applications with OpenTelemetry, Application Insights and KQL
  • Integrate reliably with Service Bus and Event Grid
  • Build pipelines that test, version and deliver only after approval
  • Write tests that hold up, also for time, ports and load
  • Use timeouts, retries, caching and rate limiting the right way
  • Understand Linux, networking, DNS, TLS and mail well enough to clear up incidents
  • Write concurrent and parallel code without race conditions and deadlocks
  • Measure performance and improve it deliberately, up to Native AOT
  • Build serverless flows with Azure Functions and Durable Functions
  • Steer reliability with SLOs, error budgets, runbooks and postmortems

Contents

  1. 3.0

    Infrastructure from the ground up

    Linux and the shell in a container, TCP/IP and ports, DNS, TLS and PKI, proxies and load balancers, firewalls and NSGs, SSH, mail with SMTP, SPF, DKIM and DMARC

    25 h
  2. 3.1

    Azure fundamentals

    subscriptions, resource groups, RBAC, regions and the EU data boundary, costs and budgets

    20 h
  3. 3.2

    Infrastructure as code

    Bicep, azd, environments, what-if and its limits

    25 h
  4. 3.3

    Security in operation

    managed identity, Key Vault, no keys in code or parameters, Front Door and WAF basics, never printing secrets, cryptography (hashing, encryption, signing, keys and PKI in operation), the supply chain with an SBOM and package audits

    28 h
  5. 3.4

    Observability

    OpenTelemetry, Application Insights, KQL, alerts, health checks

    25 h
  6. 3.5

    Messaging and events

    Service Bus, queues, Event Grid, idempotency, dead letters

    25 h
  7. 3.6

    Data in the cloud

    Azure SQL, Blob Storage, an overview of Cosmos DB and PostgreSQL with vectors, backup and restore

    20 h
  8. 3.7

    CI/CD

    Azure Pipelines and GitHub Actions, tests in the build, NuGet feeds and versions, approvals before a deployment

    30 h
  9. 3.8

    Advanced testing

    integration against real dependencies, test data, flaky tests (time, FakeTimeProvider), free ports, load tests

    25 h
  10. 3.9

    Resilience and performance

    timeouts, retries with care, caching, profiling, rate limiting

    20 h
  11. 3.11

    Concurrency and parallelism

    threads and the thread pool, the Task Parallel Library, Parallel.ForEach and PLINQ, async versus parallel, lock, SemaphoreSlim, Interlocked, concurrent collections, channels, race conditions and deadlocks, the memory model, the actor model as the way out

    25 h
  12. 3.12

    Performance in .NET

    BenchmarkDotNet, Span<T> and memory, the garbage collector, allocations, source generators, Native AOT

    15 h
  13. 3.13

    Serverless with Azure Functions

    the isolated worker model, triggers and bindings, Durable Functions, delivery, observability and costs

    15 h
  14. 3.14

    Aspire in depth

    the app model, integrations, the dashboard and service defaults, testing with Aspire, delivery

    15 h
  15. 3.15

    Operations and reliability (SRE)

    SLIs, SLOs and error budgets, on-call and the incident process, postmortems, runbooks, chaos engineering with Azure Chaos Studio

    20 h
  16. 3.10

    Final project

    the Kladde in Azure, delivered fully automatically

    50 h

About 383 hours in all (indicative).

Lessons

You see the text and video of every lesson here on the site after buying the course; the titles and goals are already shown. A self-study course: you work through the lessons in order and check your exercises yourself against the solutions.

You can read the first module (3.0) for free, with text and video, without signing in: so you see how the course works before you buy.

The lessons stand under their modules, in the order of the course. Click a module to open or close its lessons.

3.0 Infrastructure from the ground up

Indicative: 25 hours · 7 lessonsfree to read
  1. Lesson 1 · about 240 minutes

    Linux and the shell in a container

  2. Lesson 2 · about 240 minutes

    TCP/IP, ports and what a connection is

  3. Lesson 3 · about 180 minutes

    DNS

  4. Lesson 4 · about 240 minutes

    TLS and the chain of trust

  5. Lesson 5 · about 180 minutes

    Proxies and load balancers

  6. Lesson 6 · about 180 minutes

    Firewalls, NSGs and SSH

  7. Lesson 7 · about 120 minutes

    Mail: SMTP, SPF, DKIM and DMARC

3.1 Azure fundamentals

Indicative: 20 hours · 6 lessons
  1. Lesson 8 · about 180 minutes

    Azure at a glance

  2. Lesson 9 · about 180 minutes

    Costs first: subscription and budget

  3. Lesson 11 · about 240 minutes

    Who may do what: Entra ID and Azure RBAC

3.2 Infrastructure as code

Indicative: 25 hours · 6 lessons
  1. Lesson 14 · about 180 minutes

    Why infrastructure as code

  2. Lesson 15 · about 240 minutes

    The Bicep language

  3. Lesson 16 · about 240 minutes

    Modules and reuse

  4. Lesson 17 · about 240 minutes

    What-if and its limits

  5. Lesson 18 · about 240 minutes

    azd: the application and its infrastructure

  6. Lesson 19 · about 240 minutes

    Environments

3.3 Security in operation

Indicative: 28 hours · 8 lessons
  1. Lesson 20 · about 240 minutes

    No keys: managed identity

  2. Lesson 21 · about 240 minutes

    Key Vault

  3. Lesson 22 · about 240 minutes

    Never print secrets

  4. Lesson 24 · about 120 minutes

    Least privilege and Defender for Cloud

  5. Lesson 25 · about 180 minutes

    Hashing, encrypting, signing

  6. Lesson 26 · about 180 minutes

    Keys and PKI in operation

  7. Lesson 27 · about 120 minutes

    Securing the supply chain

3.7 CI/CD

Indicative: 30 hours · 7 lessons
  1. Lesson 28 · about 240 minutes

    Continuous integration with GitHub Actions

  2. Lesson 29 · about 240 minutes

    Azure Pipelines

  3. Lesson 30 · about 240 minutes

    Tests in the build

  4. Lesson 31 · about 300 minutes

    Versions and NuGet feeds

  5. Lesson 32 · about 240 minutes

    Delivering without a secret

  6. Lesson 33 · about 240 minutes

    Approvals before the deploy

  7. Lesson 34 · about 180 minutes

    Secure and fast pipelines

3.4 Observability

Indicative: 25 hours · 6 lessons
  1. Lesson 35 · about 240 minutes

    Logs, metrics, traces

  2. Lesson 36 · about 240 minutes

    Application Insights with OpenTelemetry

  3. Lesson 37 · about 240 minutes

    Custom traces and metrics

  4. Lesson 38 · about 300 minutes

    KQL: asking the telemetry questions

  5. Lesson 39 · about 240 minutes

    Health checks and alerts

  6. Lesson 40 · about 120 minutes

    Clearing up an incident

3.6 Data in the cloud

Indicative: 20 hours · 5 lessons
  1. Lesson 41 · about 240 minutes

    Azure SQL

  2. Lesson 43 · about 240 minutes

    Blob Storage

  3. Lesson 45 · about 240 minutes

    Backup and restore

3.5 Messaging and events

Indicative: 25 hours · 7 lessons
  1. Lesson 46 · about 180 minutes

    Why messages

  2. Lesson 47 · about 300 minutes

    Service Bus: queues

  3. Lesson 48 · about 180 minutes

    Topics, subscriptions and sessions

  4. Lesson 49 · about 240 minutes

    Idempotency

  5. Lesson 50 · about 180 minutes

    Dead letters and errors

  6. Lesson 51 · about 180 minutes

    Event Grid

  7. Lesson 52 · about 120 minutes

    Background work in Container Apps

3.8 Advanced testing

Indicative: 25 hours · 6 lessons
  1. Lesson 53 · about 300 minutes

    Integration against real dependencies

  2. Lesson 54 · about 180 minutes

    Test data

  3. Lesson 56 · about 240 minutes

    Flaky tests: time and concurrency

  4. Lesson 57 · about 180 minutes

    Free ports and parallel tests

  5. Lesson 58 · about 300 minutes

    Load tests

3.9 Resilience and performance

Indicative: 20 hours · 5 lessons
  1. Lesson 59 · about 180 minutes

    Timeouts and honest errors

  2. Lesson 60 · about 240 minutes

    Retrying with care

  3. Lesson 61 · about 240 minutes

    Caching

  4. Lesson 62 · about 180 minutes

    Rate limiting

  5. Lesson 63 · about 240 minutes

    Measuring instead of guessing: profiling

3.11 Concurrency and parallelism

Indicative: 25 hours · 8 lessons
  1. Lesson 64 · about 180 minutes

    Threads and the thread pool

  2. Lesson 65 · about 180 minutes

    Async is not parallel

  3. Lesson 66 · about 180 minutes

    Task Parallel Library, Parallel and PLINQ

  4. Lesson 68 · about 180 minutes

    Concurrent collections and channels

  5. Lesson 70 · about 120 minutes

    The .NET memory model in plain words

  6. Lesson 71 · about 120 minutes

    The way out: the actor model

3.12 Performance in .NET

Indicative: 15 hours · 5 lessons
  1. Lesson 72 · about 180 minutes

    Measuring right with BenchmarkDotNet

  2. Lesson 73 · about 180 minutes

    Span<T>, Memory<T> and fewer allocations

  3. Lesson 74 · about 180 minutes

    The garbage collector

  4. Lesson 75 · about 180 minutes

    Source generators instead of reflection

  5. Lesson 76 · about 120 minutes

    Native AOT

3.13 Serverless with Azure Functions

Indicative: 15 hours · 4 lessons
  1. Lesson 77 · about 180 minutes

    Serverless and the isolated worker model

  2. Lesson 78 · about 240 minutes

    Triggers and bindings

  3. Lesson 79 · about 240 minutes

    Durable Functions

  4. Lesson 80 · about 120 minutes

    Delivering, observing and costing Functions

3.14 Aspire in depth

Indicative: 15 hours · 5 lessons
  1. Lesson 81 · about 180 minutes

    The app model

  2. Lesson 82 · about 180 minutes

    Integrations: hosting and client

  3. Lesson 83 · about 180 minutes

    Dashboard and service defaults

  4. Lesson 84 · about 180 minutes

    Testing with Aspire

3.15 Operations and reliability (SRE)

Indicative: 20 hours · 6 lessons
  1. Lesson 86 · about 240 minutes

    SLIs and SLOs

  2. Lesson 87 · about 180 minutes

    Error budgets

  3. Lesson 88 · about 180 minutes

    On-call and the course of an incident

  4. Lesson 89 · about 180 minutes

    Blameless postmortems

  5. Lesson 90 · about 180 minutes

    Runbooks

  6. Lesson 91 · about 180 minutes

    Chaos engineering with Azure Chaos Studio

3.10 Final project

Indicative: 50 hours · 12 lessons
  1. Lesson 92 · about 180 minutes

    Planning and estimating

  2. Lesson 93 · about 300 minutes

    The empty subscription

  3. Lesson 94 · about 300 minutes

    The pipeline from scratch

  4. Lesson 95 · about 300 minutes

    The application without keys

  5. Lesson 96 · about 300 minutes

    The import via Service Bus

  6. Lesson 97 · about 300 minutes

    Observation and alerts

  7. Lesson 98 · about 300 minutes

    Resilient under load

  8. Lesson 99 · about 180 minutes

    Recovery rehearsed

  9. Lesson 100 · about 240 minutes

    Teardown and rebuild

  10. Lesson 101 · about 240 minutes

    Review and operations manual

  11. Lesson 102 · about 180 minutes

    Incident drill

  12. Lesson 103 · about 180 minutes

    Wrapping up

Final project: the Kladde

What the Kladde can do after this course

In Azure, delivered fully automatically: Bicep and azd, a pipeline with tests, Key Vault and managed identity, OpenTelemetry, an import through Service Bus and a rehearsed restore.

The pipeline and the infrastructure run from an empty subscription. At the end you clear up an incident from the logs and write it up in a postmortem that you check yourself against a checklist.

More about the Kladde

Certifications

An offer, never a requirement: these Microsoft exams fit this stage. You take them at Microsoft; we are not a Microsoft training partner.

Keep learning with Microsoft Learn

Microsoft's learning paths and documentation that go with this course.

All courses at a glance