AI curriculum

Course outline for Cloud-Native Engineering for AI Workloads

Package an ordinary HTTP service with Docker, then operate it in a local Kubernetes cluster. Connect services, supply configuration and dummy secrets, set resources, and observe real rollout and failure behavior. Measure scaling against a dependency bottleneck before transferring the same reasoning to AI workers. The final worked map connects these foundations to model serving without requiring a model or GPU.

Cloud-Native Engineering for AI Workloads Course Objectives

  • Write a Dockerfile, build an image, and run a checked ordinary service.
  • Explain process, filesystem, mount, port, and container lifecycle behavior.
  • Deploy Kubernetes workloads with discovery, configuration, secrets, and resource settings.
  • Diagnose real configuration, connectivity, rollout, and process failures.
  • Compare useful throughput and errors at two replica counts.
  • Verify recovery through application requests rather than replica counts alone.
  • Locate gateway, inference engine, storage, and deployment responsibilities in a sourced AI-serving map.

Pre-requisites

  • Run a small application and explain HTTP, files, processes, and ports.
  • Use a terminal, configuration files, and basic cloud responsibilities.
  • Cloud Foundations for AI Engineers or equivalent infrastructure concepts are useful preparation.
  • No container, Kubernetes, AI-service, or cluster-administration experience is required.

Before this course

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

No prerequisite course is required. The entry skills above still apply.

Recommended preparation

Readiness checks

  • Run a small application and explain HTTP, files, processes, and ports.
  • Use a terminal, configuration files, and basic cloud responsibilities.
  • Cloud Foundations for AI Engineers or equivalent infrastructure concepts are useful preparation.
  • No container, Kubernetes, AI-service, or cluster-administration experience is required.

Run a small application and explain HTTP, files, processes, and ports.

Find your place in the learning map

Lab Setup

Delivery requirements: the environment, access, and exercise materials must be prepared and verified before delivery. This outline does not certify that a lab package is ready.

Supported Docker and kubectl, preconfigured local Kubernetes cluster, ordinary HTTP service and client, bounded load driver, dummy secrets, partial manifests, failure hooks, dedicated disposable namespace, and sourced AI-serving manifests. Stable image/platform compatibility, virtualization, memory/disk, resource observations, probe behavior, request checks, and cleanup require verification. No real credentials or paid registry are required.

Detailed Course Outline

Module 1: Build an ordinary service image (2 hours)

  • Containers and virtual machines: Containers versus virtual machines, processes, images, and isolation limits.
  • Docker first run: Docker CLI basics and a first visible container run.
  • Dockerfile and build context: Dockerfile instructions, build context, dependencies, and image layers.
  • Learner-authored image build: Writing and building the supplied HTTP service's Dockerfile.
  • Image identity and non-root operation: Image tags/digests, repeatable inputs, and non-root process identity.
  • Container lifecycle commands: Run, inspect, logs, exit status, stop, and cleanup.
  • Guided-time allocation: 0.75 hours for explanation and a worked example, 0.75 hours for learner practice, 0.25 hours for feedback, and 0.25 hours for questions and contingency.

Practical outcome: Build a learner-authored image and verify actual service output and process behavior.

Module 2: Keep runtime state outside the image (2 hours)

  • Container persistence: Container writable layers, removal, volumes, and bind mounts.
  • External configuration: Environment variables, configuration files, and immutable image inputs.
  • Ports and networking: Port publishing, container networking, and service binding addresses.
  • Read-only mount checks: Read-only inputs and observed denied writes under the chosen configuration.
  • Credentials and image history: Dummy credentials outside builds, image history, and logs.
  • Process recovery checks: Process failure, restart, persistent data, and explicit lifecycle checks.
  • Guided-time allocation: 0.75 hours for explanation and a worked example, 0.75 hours for learner practice, 0.25 hours for feedback, and 0.25 hours for questions and contingency.

Practical outcome: Change configuration without rebuilding and test data survival, denied writes, and container restart.

Module 3: Declare and discover a Kubernetes service (2 hours)

  • Cluster and kubectl foundations: Cluster, node, control plane, API, and kubectl basics.
  • Deployment reconciliation: Pods, Deployments, replicas, labels, and desired-state reconciliation.
  • Actual deployment manifests: Applying and inspecting a learner-completed deployment manifest.
  • Service discovery: Services, selectors, endpoints, and cluster DNS identities.
  • Frontend-to-service requests: Actual frontend-to-service requests without fixed pod addresses.
  • Selector and endpoint diagnosis: Wrong selectors, empty endpoints, pod replacement, and diagnostic commands.
  • Guided-time allocation: 0.75 hours for explanation and a worked example, 0.75 hours for learner practice, 0.25 hours for feedback, and 0.25 hours for questions and contingency.

Practical outcome: Deploy the ordinary service and repair a discovery failure using actual cluster state.

Module 4: Configure access and resources deliberately (2 hours)

  • ConfigMap configuration: ConfigMaps and environment/file configuration outside images.
  • Secret references: Secret references, dummy values, and sensitive-output avoidance.
  • Encoding and encryption: Secret encoding versus encryption and least-privilege responsibility.
  • Resource requests and limits: CPU/memory requests, limits, scheduling, and bounded failure observations.
  • Network reachability: Service paths, ports, DNS, and explicit network reachability tests.
  • Probe meanings: Readiness, startup, liveness, and distinct failure meanings.
  • Guided-time allocation: 0.75 hours for explanation and a worked example, 0.75 hours for learner practice, 0.25 hours for feedback, and 0.25 hours for questions and contingency.

Practical outcome: Configure a working deployment and diagnose bad configuration and an unschedulable resource request.

Module 5: Roll out changes and prove recovery (2 hours)

  • Image rollout: Image updates, rollout status, readiness, and revision history.
  • Broken rollout observations: Broken image/configuration rollout with actual request observations.
  • Rollback and independent checks: Rollback to a known image/configuration and independent response checks.
  • Replacement versus restart: Pod deletion, process crash, restart, and controller replacement.
  • Diagnostic evidence: Logs, prior-container logs, events, timestamps, and application counters.
  • Replica and data recovery: Recovered replicas versus recovered data and completed work.
  • Guided-time allocation: 0.75 hours for explanation and a worked example, 0.75 hours for learner practice, 0.25 hours for feedback, and 0.25 hours for questions and contingency.

Practical outcome: Inject a rollout/process failure, diagnose it, and demonstrate actual application recovery.

Module 6: Scale useful work rather than replica counts (2 hours)

  • Bounded workload measures: Bounded load, latency, useful throughput, errors, and dependency capacity.
  • Replica experiment: Actual one-replica versus multi-replica ordinary-service experiment.
  • Dependency capacity: Continuing requests, downstream saturation, queues, and retry amplification.
  • Local-cluster evidence limits: Resource observations, measurement windows, and local-cluster limits.
  • Dummy AI-worker transfer: AI-worker transfer with a rate-limited dummy dependency, not live inference.
  • Scaling choice and cleanup: Concurrency choice, simpler deployment option, and full lab cleanup.
  • Guided-time allocation: 0.75 hours for explanation and a worked example, 0.75 hours for learner practice, 0.25 hours for feedback, and 0.25 hours for questions and contingency.

Practical outcome: Measure two scaling configurations and justify a bounded replica/concurrency choice from actual observations.

Module 7: Map a model service onto the same foundations (2 hours)

  • Serving request path: Client, policy gateway, inference engine, model files, and storage boundaries.
  • vLLM and Kubernetes roles: vLLM inside a container versus Kubernetes deployment and service ownership.
  • GPU scheduling dependencies: GPU device plugins, advertised resources, scheduling, and absent-device Pending diagnosis.
  • Model startup and cache: Model download, cache persistence, startup probes, and ready-to-infer checks.
  • Replicas versus batching: Replica scaling versus request batching and GPU-memory capacity limits.
  • KServe and Kubeflow roles: KServe control layer and Kubeflow lifecycle roles without mandatory installation.
  • Guided-time allocation: 0.75 hours for explanation and a worked example, 0.75 hours for learner practice, 0.25 hours for feedback, and 0.25 hours for questions and contingency.

Practical outcome: Annotate a sourced serving deployment map and predict a new startup or scheduling failure.

Practical exercise

  • Planned supplied assets are an ordinary booking-status HTTP service, a second client/dependency component, tests, bounded load driver, cluster startup, partial manifests, and fault hooks. Learners write the Dockerfile, complete workload and Service manifests, add configuration/secret/resource/probe settings, and author an independent request check. They must build, run, deploy, change, and diagnose the system, not only inspect prepared lifecycle records.
  • Build the image, verify service output, change an environment setting, inspect logs, and stop/restart the container. Compare transient container state with a mounted volume. Attempt a write against the actual protected input mount and record the result. Do not infer complete sandbox isolation or blocked outbound network access from a denied filesystem write.
  • Deploy to the preconfigured local cluster. Send actual requests through a Service and DNS name. Break a selector, inspect endpoints, repair it, and verify the application result. Supply a ConfigMap and dummy Secret outside the image. Check that selected image history and captured logs omit the dummy value. This is a bounded leak check, not a full credential audit. Kubernetes Secrets are not automatically an encryption guarantee.
  • Set resource requests and limits. Make one safely excessive request, observe Pending/scheduling events, correct it, and rerun. Inject an invalid application setting and a broken rollout. Observe readiness, logs, events, and actual HTTP failures. Roll back and check the response body independently. Delete a pod and crash a process to distinguish replacement from restart. Do not claim either restores lost application data or reverses committed work.
  • Apply the same bounded synthetic load at one and several replicas, with a known dependency limit. Measure successful responses per interval, latency, errors, and dependency saturation. More replicas need not improve useful throughput. Transfer the result to a dummy AI-worker dependency only after the ordinary service works. No model account is required. Preserve a new failure/scaling prediction for independent diagnosis before feedback. Clean only the dedicated namespace, containers, images, and volumes identified by the lab inventory.
  • Keep the ordinary service and dummy AI dependency as the complete runnable baseline. Then follow one request through a worked client → gateway → Service → model-server Pod map. Show where vLLM executes tokens and where Kubernetes schedules and replaces processes. Explain a sourced GPU-resource manifest, device-plugin dependency, model cache mount, startup probe, and application readiness check. Predict why a GPU request without an advertised device remains Pending. This is sourced manifest inspection, not an executed GPU deployment. Distinguish KServe's serving controller from Kubeflow's wider lifecycle tools. Assess a new missing-cache or readiness condition before feedback. Keep actual container, networking, scaling, failure, and recovery observations from Modules 1–6 as the primary evidence.

Delivery and timing

  • Guided hours include teaching, demonstrations, learner practice, feedback, questions, and contingency as allocated above. Breaks, bulk downloads, account approval, and prerequisite setup are additional. Allocations need a timed learner pilot before delivery; they are not measured completion times.

What you will produce

Build and operate a containerized service on Kubernetes, diagnose failures, and explain the extra needs of AI serving.

How the work is checked

  • A learner-authored Dockerfile builds and the actual service runs correctly.
  • Container lifecycle and mount/configuration observations match the explanation.
  • Actual Kubernetes workloads communicate through the declared Service and DNS path.
  • Configurations, dummy secrets, resource settings, and probes have observable effects.
  • Real injected failures produce diagnosis and verified application recovery.
  • Two replica tests measure useful work and expose the dependency bottleneck.
  • The independent task is attempted before feedback and cleanup is checked.
  • A sourced AI-serving map assigns each failure to its actual layer without claiming model operation.

14 guided hours. Ordinary Docker and Kubernetes operation is the required foundation. Actual configuration, networking, scaling, failures, and recovery precede an AI-serving deployment map. vLLM, GPU device plugins, KServe, and Kubeflow are sourced comparisons here, not additional running platforms. No GPU, model account, cloud cluster, production cluster administration, autoscaling, network-policy certification, or multi-node resilience claim is required.

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