AI curriculum

Course outline for Cloud-Native Engineering for AI Workloads

Adding agent-worker replicas can increase a model API's throttling and grow the queue instead of completing more work. Package a supplied mock model gateway and worker service with explicit configuration and resource limits. Inspect Kubernetes reconciliation, cancellation, and queue behavior under a rate-limited synthetic dependency.

About Cloud-Native Engineering for AI Workloads

Adding agent-worker replicas can increase a model API's throttling and grow the queue instead of completing more work. Package a supplied mock model gateway and worker service with explicit configuration and resource limits. Inspect Kubernetes reconciliation, cancellation, and queue behavior under a rate-limited synthetic dependency.

Cloud-Native Engineering for AI Workloads Course Objectives

  • Package a mock model gateway and worker with reproducible container builds.
  • Declare Kubernetes workloads, discovery, resource limits, and queue capacity.
  • Separate provider settings and dummy credentials from images and logs.
  • Test read-only inputs and document remaining execution authority.
  • Compare worker scaling against downstream model-service rate limits.
  • Inspect cancellation and isolated-workspace cleanup using supplied fixtures.

Pre-requisites

  • Basic Linux, application deployment, networking, and command-line skills.
  • Understanding of cloud compute, storage, and identity responsibilities.

Before this course

Complete the required courses or bring equivalent experience. Recommended courses add useful depth; they are not enrolment gates.

Required preparation

Recommended preparation

Understands infrastructure roles and has basic Linux/deployment skills before packaging and operating containers and Kubernetes workloads.

Find your place in the learning map

Lab Setup

  • Docker or compatible runtime, a preconfigured local Kubernetes cluster, and tested mock gateway/worker manifests.
  • Supplied queue/cancellation scaffold, disposable workspaces, bounded synthetic load, read-only inputs, and dummy provider credentials.
  • No live model, GPU scheduling, cloud account, authenticated personal tools, or production cluster is required.

Detailed Course Outline

Module 1: Package a mock AI gateway and worker

  • Containers: Package mock model gateway and agent-worker dependencies with separate runtime settings and disposable workspaces; distinguish packaging from a complete execution-security boundary.
  • Docker: Build reproducible mock AI service images; keep provider configuration, dummy credentials, and mutable task state outside image layers.
  • Kubernetes: Declare prepared gateway and worker workloads with resource limits; distinguish replica reconciliation from recovery or completion of an agent task.

Practical outcome: Build the supplied service image and deploy prepared gateway/worker manifests with resource limits; compare desired and observed replicas.

Module 2: Configure AI workload boundaries

  • Service discovery: Connect workers to a mock model gateway through declared discovery; verify request routing without relying on fixed pod addresses.
  • Configuration: Manage provider endpoints, timeouts, concurrency, and queue limits outside images; diagnose bad settings and verify protected input mounts reject writes.
  • Secrets: Supply dummy model-provider credentials outside images and logs; distinguish credential storage from least-privilege access and complete encryption guarantees.

Practical outcome: Connect workers to a mock model gateway, mount read-only inputs, and supply dummy provider credentials and bounded queue settings outside images and logs.

Module 3: Investigate worker capacity and lifecycle

  • Scaling: Compare worker throughput, throttling, and queue depth at two replica counts; choose bounded concurrency from downstream model-service capacity rather than worker availability.
  • Networking: Map gateway, worker, and mock-tool connectivity; document remaining outbound authority without assuming read-only files also restrict network actions.
  • Observability: Record replica, queue, throttling, cancellation, and workspace-cleanup evidence; distinguish stopping pending tasks from reversing already committed effects.

Practical outcome: Compare two worker replica counts against a rate-limited mock model service; inspect throttling, queue depth, cancellation, and supplied workspace-cleanup evidence.

Practical exercise

  • Produce a service image, local gateway/worker manifests, configuration inventory, and timestamped operational evidence using the supplied scaffold.
  • Verify connectivity; inject bad provider configuration and demonstrate a denied write to a read-only input mount without exposing dummy credentials.
  • Remove a worker replica and observe reconciliation; inspect cancellation before and after a mock task effect, and verify the scaffold's disposable-workspace cleanup.
  • Compare two replica counts under bounded load; measure throughput, queue depth, throttling, and errors and justify a concurrency limit rather than assuming more replicas help.

What you will produce

Deploy and diagnose mock AI gateway/worker workloads with tested configuration, resource, queue, and lifecycle boundaries.

How the work is checked

  • The build and manifests reproduce the expected local service.
  • Valid connectivity succeeds, bad configuration is diagnosed, and the protected mount denies writes.
  • Desired/observed state records show the supplied reconciliation behavior.
  • Scaling results distinguish worker capacity from model-service throttling; cancellation and workspace-cleanup evidence state their limits and avoid credential leakage.

Six-hour local Kubernetes lab using prepared mock AI gateway, queue, and worker scaffolds. Compare timestamped reconciliation states. Cancellation does not undo committed effects, and cleanup checks cover only the supplied workspace. Kubernetes Secrets are not inherently encrypted; containers do not establish complete isolation. Production inference, autoscaling, and agent sandbox design follow elsewhere.

When another approach is better

  • Use a simpler service deployment when Kubernetes adds more operating burden than coordination benefit.
  • Do not increase replicas when a downstream limit is the actual bottleneck.

How we train

Contact us for full course details, including duration, delivery options and lab requirements.

Ask about exercises, instructor feedback and the prior knowledge you need. Tool-specific courses marked provisional may become modules in a broader course.

Discuss your learning goals