Course Syllabus

Module 1: Introduction to MLOps and AWS (4 hours)

This module defines MLOps and its role in operationalizing machine learning. Learners explore the ML lifecycle stages (data, training, deployment, monitoring, retraining) and see how continuous integration/continuous deployment (CI/CD) must extend to ML assets (models and data). We discuss the differences between DevOps and MLOps, and review the key principles (version control, automation, continuous training, and governance) that make ML scalable and repeatable.

We then survey AWS’s MLOps tools. Amazon SageMaker is introduced as the core ML platform – a fully managed service for preparing data, training models, and hosting endpoints. Key SageMaker features (Experiments tracking, Model Registry, Feature Store) are highlighted along with complementary AWS services (CodePipeline for CI/CD, Amazon ECR for containers, Amazon EKS for Kubernetes-based inference, and CloudFormation for IaC). Real-world MLOps use cases (such as fraud detection or product recommendation) illustrate why MLOps pipelines are needed.

• AWS Services Covered: Amazon SageMaker, AWS CodePipeline/CodeCommit, AWS EKS/ECR, AWS CloudFormation, AWS Identity and Access Management (IAM)。
• Hands-on Labs: Explore SageMaker Studio; execute a simple data processing job in AWS Glue.
• Use Case/Project: Case study discussion on deploying a model (e.g. AWS Fraud Detector or SageMaker demo).
• Assessment: Short quiz on MLOps vs. DevOps concepts; a group exercise mapping an example ML workflow to AWS services.

Module 2: AWS Environment Setup & Infrastructure (3 hours)

Learners set up a secure AWS foundation for MLOps. Topics include AWS account best practices (multi-account architecture for dev/test/prod), organization units, and cross-account roles. We cover IAM roles and policies needed for ML pipelines (e.g. roles for SageMaker, CodePipeline, Lambda). Basic networking concepts (VPC, subnets, security groups, endpoints for S3) are reviewed to host ML workflows in a secured VPC.

Next, we introduce Infrastructure as Code (IaC). Using AWS CloudFormation (or CDK), students define and deploy the necessary resources: S3 buckets for data and models, ECR repositories for Docker images, IAM roles, and compute resources. This ensures reproducibility of environments. We also install and configure the AWS CLI and SDKs on local machines for interaction and automation.

• AWS Services Covered: AWS CloudFormation/CDK, AWS Organizations, IAM, Amazon ECR, Amazon S3, VPC, AWS CLI.
• Hands-on Labs: Write and deploy a CloudFormation stack that creates S3 buckets, an ECR repo, and IAM roles for SageMaker and CodePipeline.
• Use Case/Project: Practice creating a project environment (Dev, Test, Prod accounts) to mirror a corporate MLOps setup.
• Assessment: Interactive quiz on AWS IAM roles and network security options.

Module 3: Data Engineering for ML Pipelines (4 hours)

This module focuses on preparing and managing data for machine learning. We cover data ingestion and storage patterns: sources (e.g. databases, streams, files) and durable storage on S3. AWS Glue is introduced as an ETL service: learners create Glue Jobs and Crawlers to catalog and transform raw data into clean, analysis-ready form. We discuss Glue workflows and triggers for automation. Other tools like AWS Athena (interactive queries) and Glue DataBrew (visual data preparation) are mentioned.

Students also learn about data versioning and feature storage. The Amazon SageMaker Feature Store is covered for storing and retrieving features. We emphasize best practices: data partitioning in S3, data validation, and lineage tracking. Real-time data pipelines (e.g. using AWS Kinesis or Lambda with S3) versus batch pipelines are compared.

• AWS Services Covered: AWS Glue (ETL, Workflows, Crawlers), Amazon S3, AWS Glue Data Catalog, AWS Athena, AWS Kinesis (optional), SageMaker Feature Store.
• Hands-on Labs: Build a Glue ETL job that reads raw CSV from S3, cleans it (remove nulls, encode labels), and writes features to a processed S3 bucket.
• Use Case/Project: Create a data pipeline that ingests customer transaction data, transforms it via Glue, and stores features in SageMaker Feature Store for training.
• Assessment: Lab assignment submission (validated pipeline success), quiz on data partitioning and Glue components.

Module 4: Model Development with SageMaker (5 hours)

In this hands-on module, participants use Amazon SageMaker to develop and train ML models. We start with SageMaker Studio and Notebook Instances for interactive development. Students practice using SageMaker Python SDK, container images, and built-in algorithms. SageMaker Experiments are introduced to track hyperparameters, metrics, and model artifacts.

Key capabilities covered: Automatic model tuning (Hyperparameter Optimization), SageMaker Autopilot for AutoML, and JumpStart for pre-built models. We demonstrate distributed training (GPU/CPU, spot instances) and explain cost controls. Participants will train a model (e.g., a classification problem) end-to-end. The SageMaker Model Registry is covered: how to register models with metadata for versioning and approval.

• AWS Services Covered: Amazon SageMaker (Studio, Notebooks, Experiments, Tuning, Model Registry), AWS ECR (for custom containers), AWS S3 (for training data and model artifacts).
• Hands-on Labs: Train a machine learning model in SageMaker (e.g. XGBoost or a deep learning model), tune its hyperparameters with SageMaker Tuning Jobs, and register the best model in the SageMaker Model Registry.
• Use Case/Project: Develop a model for a sample dataset (e.g. image classification or tabular prediction), tracking experiments and selecting the best model version.
• Assessment: Completion of a lab report detailing experiment tracking outcomes; multiple-choice quiz on SageMaker components.

Module 5: CI/CD and Containerization for ML (5 hours)

This module teaches how to integrate ML workflows with DevOps pipelines. We cover source control (Git, CodeCommit) and explain how every code change or data change can trigger a pipeline. AWS CodePipeline and CodeBuild are used to automate building and deploying ML components. In hands-on exercises, students containerize a training or inference application using Docker and push images to Amazon ECR.

We then build a simple CI pipeline: on code commit, CodeBuild creates a Docker image and stores it in ECR. Next, infrastructure as code using CloudFormation or the AWS CDK is triggered to create/ update SageMaker training jobs or endpoints with the new model. We show how AWS CodeDeploy (or custom scripts) can automate model deployment to endpoints or EKS services. Best practices like pipeline-as-code and rollback strategies are discussed.

• AWS Services Covered: AWS CodeCommit/CodePipeline/CodeBuild/CodeDeploy, Amazon ECR, AWS CloudFormation (or CDK), AWS Lambda (for custom pipeline actions), AWS CloudWatch Events (or EventBridge for triggers).
• Hands-on Labs: Set up a CodePipeline that builds a Docker image for a SageMaker training job or Lambda inference function and deploys it to an endpoint.
• Use Case/Project: Create a CI/CD pipeline that automatically retrains and deploys a model whenever training code or data is updated. For example, integrate GitHub with CodeBuild/CodePipeline and SageMaker.
• Assessment: Quiz on CI/CD concepts for ML (e.g. blue/green deployment, canary models); review of pipeline logs for troubleshooting.

Module 6: MLOps Pipelines & Workflow Orchestration (5 hours)

Here we delve into orchestrating complex ML workflows. Amazon SageMaker Pipelines is introduced as a purpose-built service for ML pipelines. Students design and create multi-step pipelines (using the SageMaker SDK or JSON) that string together processing, training, evaluation, and deployment steps. The advantages of SageMaker Pipelines (serverless scaling, integration with SageMaker jobs, and ML lineage tracking) are demonstrated.

We compare SageMaker Pipelines to other orchestration tools like AWS Step Functions and open-source alternatives (e.g. Kubeflow). A lab shows how Step Functions can coordinate AWS Lambda, Glue, and SageMaker steps in a pipeline. Students learn to trigger pipelines via events (e.g. new data arrival) and to handle conditional steps (e.g. only deploy if accuracy exceeds a threshold). The concept of Pipeline as Code and version control is reinforced.

• AWS Services Covered: SageMaker Pipelines, AWS Step Functions, AWS Lambda (for custom logic), Amazon EventBridge (for scheduled or event triggers), SageMaker Feature Store (integrated in pipelines).
• Hands-on Labs: Build a SageMaker Pipeline that automates data preprocessing (SageMaker Processing), model training, evaluation, and conditional registration in the Model Registry.
• Use Case/Project: Implement an end-to-end retraining pipeline that is triggered weekly or on new data. Use EventBridge to schedule the pipeline.
• Assessment: Students present their pipeline DAG and discuss how it ensures repeatability; quiz on pipeline orchestration concepts.

Module 7: Model Deployment & Serving (4 hours)

This module covers strategies for serving models in production. We contrast real-time inference (HTTP endpoints) vs. batch inference. For real-time, we demonstrate deploying models as SageMaker Endpoints (single-model and multi-model endpoints) and explain autoscaling settings. We also explore serverless inference with SageMaker’s on-demand API or AWS Lambda for lightweight models.

For custom deployment, we cover AWS EKS/ECS: packaging models in Docker and deploying them behind a Kubernetes or ECS service, potentially with KServe or Triton. Students learn how to expose models via AWS API Gateway. We also discuss edge deployment (e.g. SageMaker Neo or Lambda@Edge) in brief. AWS Best Practices for hosting (high availability, security) are reviewed.

• AWS Services Covered: Amazon SageMaker Endpoints (real-time & batch), AWS Lambda, Amazon EKS/ECS, Amazon API Gateway, SageMaker Serverless Inference.
• Hands-on Labs: Deploy a trained model as a SageMaker real-time endpoint; test it with sample inputs. Then containerize a model and deploy it on an EKS cluster.
• Use Case/Project: Compare performance and cost of SageMaker endpoint vs. Lambda hosting for an image classification model.
• Assessment: Review of endpoint logs and metrics; exercise configuring endpoint autoscaling.

Module 8: Monitoring, Logging & Governance (4 hours)

Once models are deployed, continuous monitoring is essential. We cover CloudWatch for logging and metrics (latency, invocations, errors) on endpoints. Amazon SageMaker Model Monitor is introduced to detect data quality and model performance drift. Students set up Model Monitor jobs to track statistics on input features and prediction quality, and configure alerts for threshold violations.

We also cover application monitoring with AWS X-Ray (for tracing multi-step inference), and log aggregation practices. The SageMaker Model Registry and its approval workflows are revisited for model governance. We discuss ML lineage and auditing: how tools like SageMaker Lineage Tracking help trace models back to datasets and code. Best practices for experimentation governance (tracking experiments, artifact versioning) are emphasized.

• AWS Services Covered: Amazon CloudWatch (Logs, Metrics, Dashboards), AWS X-Ray, Amazon SageMaker Model Monitor (Data and Model Quality), SageMaker Model Registry.
• Hands-on Labs: Configure a Model Monitor baseline on a deployed endpoint; simulate data drift and observe alert notifications.
• Use Case/Project: Implement a monitoring dashboard in CloudWatch that shows model inference metrics and drift alerts for a sample model.
• Assessment: Quiz on distinguishing data drift vs. concept drift; scenario analysis on alerting and retraining triggers.

Module 9: Security, Compliance & Best Practices (3 hours)

This module emphasizes securing the MLOps pipeline. Topics include IAM and roles best practices (least privilege for ML workflows) and using AWS KMS for encrypting data at rest (S3, model artifacts) and in transit. We cover network security: deploying SageMaker in VPC-only mode, using VPC endpoints for S3, and securing EKS clusters with pod security policies.

We discuss data privacy and compliance: handling PII with AWS Macie or custom rules, and complying with regulatory requirements (auditing pipelines with AWS Config, tagging resources for compliance). Cost optimization tips (instance selection, spot instances, workload scheduling) are also provided. Finally, we review AWS Well-Architected Framework considerations specific to ML.

• AWS Services Covered: AWS IAM, AWS KMS, AWS Config, AWS CloudTrail, Amazon SageMaker VPC endpoints, AWS Macie (optional).
• Hands-on Labs: Set up encryption for S3 buckets and ECR repos; enforce IAM policies so that only authorized roles can access model data.
• Use Case/Project: Conduct a security review of a deployed MLOps pipeline, identify gaps, and implement fixes.
• Assessment: Quiz on IAM policies and encryption; group discussion on ethical considerations and fairness in ML.

Module 10: Capstone Project & Case Studies (4 hours)

In the final module, learners apply all concepts in an end-to-end capstone project. For example, teams might build an MLOps pipeline for a predictive maintenance use case: ingest sensor data, train models, and deploy an inference service with monitoring. They will define the pipeline, implement infrastructure as code, train and deploy a model, and set up monitoring.

We also review real-world case studies of MLOps on AWS (e.g. recommender systems in e‑commerce, demand forecasting) to reinforce lessons learned. Each team presents their solution, highlighting AWS services used, pipeline design, and challenges faced. Finally, a comprehensive assessment (written/oral exam or project deliverable) ensures understanding of key topics.

• AWS Services Covered: Integrates all previously covered services in a complete workflow (e.g. S3, Glue, SageMaker, CodePipeline, etc.).
• Capstone Lab: Build, run, and demonstrate a full MLOps pipeline for a chosen problem.
• Use Case/Project: End-of-course project as described above.
• Assessment: Final project presentation and peer review; written exam covering MLOps concepts and AWS tools.