Ultimate DevOps to MLOps Bootcamp - Build ML CI/CD Pipelines

Clarify MLOps and its role in bridging data science and production by standardizing the ML lifecycle, applying revision control for code, data, and models, and automating end-to-end CI/CD pipelines.

Trace the evolution from ML to LLMs and autonomous AI ops, and explore how MLOps, LM ops, prompts, embeddings, and vector databases reshape AI infrastructure.

Compare ml ops, lm ops, and agent ai ops to decide when to use each for structured data, prompts, and multi-step automation; learn core components, use cases, and starter steps.

Explore MLOps case studies from Netflix, Uber, OpenAI, and Anthropic, showing how Metaflow, Michelangelo, and RLHF address deployment, environment consistency, and scalable inference.

Compare DevOps and MLOps by highlighting data dependency, model drift, and experiments, and learn how MLOps adds data, model versioning, and monitoring to the traditional DevOps lifecycle.

Explore the emergence of ml ops engineers and two streams: ml ops practitioners and ai platform engineers, driving data, model production, and scalable ml pipelines.

Set up a practical MLOps environment, explore a relatable use case with a simple web UI, and build foundational MLOps practices using minimal hardware and a GitHub workflow.

Define features such as square footage, bedrooms, bathrooms, location, age, and condition to predict house prices, and build an end-to-end mlops pipeline with data engineering and model inference.

Explore end-to-end ml practices from data engineering and EDA to feature engineering, training, and deployment, with CI/CD, Docker, Kubernetes, and monitoring using Prometheus and Grafana.

Set up the dev environment with hardware basics, docker or podman, and mlflow. Prepare a docker-compose stack with streamlit and fastapi, and review kubernetes basics and vscode usage.

Learn to set up Docker or Podman with Compose, create a Docker Hub account, and validate a working environment for packaging models, MLflow, and deploying with Kubernetes.

Launch MLflow for experiment tracking by deploying a dockerized setup with Docker compose, then explore model performance and comparisons across algorithms.

Understand the ML project scaffold from raw data and notebooks to scripts, model training, and fastapi deployment, plus CI/CD and pipeline orchestration.

Set up a lightweight Python virtual environment with UV to manage ML notebooks, data processing, and plotting libraries. Activate, install dependencies from requirements.txt, and lock the desired Python version.

Set up a virtual environment, install and launch Jupyter Lab, and explore notebooks in VS Code or browser, executing multi-language cells for python, r, and shell in data engineering.

Set up the MLOps environment with Docker or Podman, configure MLflow via Docker Compose, and prepare a virtual environment to run notebooks in VS Code, enabling data science workflows.

Explore how devops and mlops teams collaborate with data scientists and data engineers to understand applications, notebooks, and workflows, then build ml ci/cd pipelines with feature engineering and experimentation.

Data engineers convert raw data into clean, processed inputs by cleaning, handling missing values and outliers, and scripting data pipelines for ml models in a cross-functional setting.

Explore exploratory data analysis from a data scientist's perspective using Jupyter Lab notebooks. Analyze house price data with visualizations and correlations to identify key features and future feature engineering.

Explore feature engineering, creating features such as price per square foot, property age, bed-bath ratio, and splitting addresses, which help predict the target variable, plus encodings for training and inference.

Engineer new features from the house price dataset—such as age of the house, price per square foot, and bedroom to bathroom ratio—and visualize their distributions to support model experiments.

Prepare for model experimentation by setting up MLflow for experiment tracking, verifying docker deployment, and analyzing data splits while exploring multiple models with scikit-learn and XGBoost.

Split data into x_train, y_train, x_test, and y_test from a csv to train and validate a model, using an 80/20 split of features and target with random_state.

Set up MLflow to record experiments, compare linear regression, random forest, gradient boosting, and XGBoost via grid search with cross-validation, tuning hyperparameters to identify and validate the best regression model.

Run a hyperparameter grid across linear regression, gradient boosting, XGBoost, and random forest to compare performance, then select gradient boosting as the best model with optimized configurations tracked in mlflow.

Transition from data science to ml ops by mastering containerization, ci/cd, cloud and Kubernetes, with experimentation tracking, hyperparameter tuning, and monitoring for productionizing models.

Understand how a model is an algorithm trained from data using features and hyperparameters to infer on new data. Get an overview of key algorithms with simple analogies.

Learn linear regression as a regression method to predict house prices using square footage, bedrooms, and age.

Explore logistic regression for disease diagnosis by predicting yes/no outcomes from factors, using a 0–1 probability and a 0.5 decision boundary; apply to spam filtering, credit approval, and fraud detection.

Explore how the decision tree algorithm works for on-the-spot loan decisions. See income, debt-to-income ratio, and credit score map to a simple, explainable flowchart.

Explore how random forest uses many decision trees and majority voting to reach outcomes, reducing biases, for fraud detection, credit risk, and spam detection, with experimentation across features and hyperparameters.

Explore how SVMs create an optimal decision boundary with a margin to separate ripe from unripe fruits using color and weight.

Explore how neural networks mimic brains to recognize handwritten digits, detect features across multiple layers, and predict outcomes with accuracy in image and language tasks, including large language models.

Explore boosting algorithms like gradient boosting, XGBoost, and LightGBM through an IPL player auction price example, showing how ensemble trees combine performance data to improve predictions in MLOps pipelines.

Gain a high-level, conceptual overview of why these models matter and how they work for ML AI engineers and ML ops, and explore the MLOps track and mini degree.

Package the model into a container image with Docker and Docker Compose, wrap it with FastAPI or Streamlit, and prototype or containerize an app for production deployment.

Learn how data scientists hand over model configurations and notebooks, convert them into scripts, wrap models into RESTful APIs, and containerize with Docker for CI pipelines.

Convert notebooks into executable feature engineering and preprocessing scripts, generate features like house age and price per square foot, and integrate a preprocessor into a CI/CD pipeline for inference.

Experiment with multiple models, evaluate performance, and select the best using a model config; train the final model with MLflow tracking and prepare a pickle file and pre-processor.

Wrap the model and preprocessor into a FastAPI restful service with health, predict, and batch endpoints for inference, and connect a Streamlit UI for input and visualization.

Write a dockerfile at the repository root to containerize a fastapi app, copying app code and models, installing requirements, and running on uvicorn port 8000.

Troubleshoot dockerized FastAPI apps by inspecting logs, using interactive containers, and addressing version mismatches between model build and runtime; update NumPy, scikit-learn, and Joblib, rebuild, and validate via uvicorn docs.

package and containerize a streamlit app by writing a dockerfile, copying app.py and requirements.txt, installing dependencies, exposing port 8501, building and publishing to Docker Hub, and using docker compose.

Integrate dockerfiles for fast API and Streamlit with Docker Compose to launch interconnected containers, configure environment variables, and test end-to-end ML serving in a reproducible dev environment.

Bridge devops to mlops by building ml ci/cd pipelines, packaging models as fast API microservices, containerizing them, and automating data processing, feature engineering, and deployment with GitHub Actions.

Explore a simple MLOps ci workflow with GitHub actions to automate build, test, package, and publish container images to a registry.

Understand an end-to-end ML workflow from raw data ingestion and feature engineering to model training, packaging, and deployment using DAG-based workflows and GitHub Actions for CI/CD.

Understand GitHub actions syntax to build a single MLOps CI workflow with events, runners, jobs, and steps. Map stages like data processing, feature engineering, model training, and publishing.

Create a GitHub workflows directory and a mlops ci workflow yaml, activated on main pushes. Commit and push to trigger the action, scaffold with setup python and install dependencies.

launch mlflow in a container using docker run, map port 5000, and translate docker compose steps into a run workflow; train, generate a pickle, and prepare packaging and cleanup.

Add container image build and publish steps using a docker build action in GitHub Actions, including login, build context, dockerfile path, and tagging with the commit hash for Docker Hub.

Configure docker hub credentials by setting repository variables and secrets, generate a personal access token, and publish the model image through an end-to-end ml ops workflow with build and push.

Showcases a modular, three-stage MLOps CI workflow that processes data, trains models, and packages artifacts into a docker image for publishing.

Build a realistic MLOps CI workflow using GitHub Actions, with triggers, jobs, runners, and modular multi-stage steps, preparing for deployment with Docker Hub and Kubernetes.

Deploy a packaged model as a container to a scalable inference infrastructure using Kubernetes, integrating with a Streamlit app and existing pipelines for reliable production serving.

Design scalable inference infrastructure with Kubernetes, deploying model and API wrapper, enabling horizontal scaling, load balancing, and canary or blue-green release strategies with the Kubernetes ecosystem.

Explore how Kubernetes orchestrates ML deployment and inference at scale. Learn core concepts like scheduling, networking, and self-healing across containerized workloads, including GPUs.

Publish the house price model and Streamlit images, then build a Kubernetes inference infrastructure using pods, deployments, and services for scalable, interconnected access via service discovery.

Set up a three-node Kubernetes cluster in a lab using kind with Docker or Podman, managed by kubectl, including a cluster.yaml configuration and port mappings for learning.

Orchestrate a Streamlit front-end on Kubernetes by creating a deployment and service, pulling images from a registry, and scaling replicas while monitoring health checks and replica sets.

Expose a Streamlit app on Kubernetes with a deployment and nodeport service, enabling external access and load balancing across pods via port 8501.

Deploy a two-replica FastAPI model deployment named house price predictor, exposed via node port 30100 and port 8000, enabling Streamlit to connect and load balance across pods.

Learn to connect a Streamlit UI to a FastAPI model in Kubernetes using DNS-based service discovery, replacing localhost with the model service name, and manage rolling upgrades and scaling.

Convert kubectl commands to YAML manifests for Kubernetes deployments and services, learning API version, kind, metadata, and spec, using dry-run to generate and version-control your manifests for Argo CD deployments.

Build a scalable, highly available, fault-tolerant inference infrastructure on Kubernetes for real-world MLOps deployments, and explore the core Kubernetes features powering practical ML systems.

Explore auto scaling of machine learning models on Kubernetes with horizontal pod autoscaler, vertical pod autoscaler, and Keda, and set up Prometheus and Grafana for monitoring.

Scale the model on a three-node Kubernetes cluster based on prediction requests, and set up Prometheus and Grafana observability to monitor FastAPI latency and request rates.

Deploy a kube-prometheus-stack monitoring system for your kubernetes environment with helm, exposing Grafana and Prometheus via node ports, using Artifact Hub presets with dashboards.

Explore Grafana and Prometheus dashboards to monitor a Kubernetes cluster, visualize CPU, memory, and network metrics, and connect Prometheus as the data source for insights.

Add instrumentation to FastAPI to expose metrics and update dependencies. Redeploy with kubectl and enable Prometheus scraping via a service monitor, then visualize metrics in Grafana.

Explore automatic capacity scaling for ml deployments by using horizontal and vertical pod autoscalers, Grafana and Prometheus monitoring, and Keda to trigger scaling from custom metrics.

Install Keda in its own namespace and configure resource requests and limits in the model-deploy.yaml to enable scaling with Keda, which integrates with Prometheus and Grafana for metrics.

Configure scaled objects with Keda using Prometheus metrics, such as the 95th percentile latency, to drive autoscaling decisions, with additional request-rate triggers and monitoring via HPA.

Apply ai-assisted troubleshooting with ChatGPT to diagnose Prometheus data gaps during load tests, isolate metrics on a separate port, and update Docker and Kubernetes monitoring.

Run load tests to drive autoscaling with Keda scaled objects, tune thresholds, monitor latency and requests via Prometheus and Grafana, and observe multi-pod model inference.

Set up cpu based auto scaling in kubernetes by installing the metrics server, then add a cpu utilization trigger in KEDA to scale pods.

Master vertical pod autoscaler to optimize Kubernetes resources by adjusting CPU and memory requests, complementing HPA, with Keda integration and observability dashboards for model deployments.

Set up monitoring with Prometheus and Grafana using Helm charts, instrument the FastAPI wrapper to track latency and p95 requests, and scale with Keda HPA and VPA using Prometheus data.

Discover how GitOps, the de facto standard for release engineering and continuous deployment on Kubernetes, enables ML model deployments with Argo CD. Learn key concepts and begin implementing GitOps.

Discover the origins of GitOps and its four principles—declarative configuration, git-stored desired state, automated changes, and continuous delivery with agents like Argo CD—applied to Kubernetes and ML deployments.

Enable Argo CD as a GitOps continuous deployment platform in your Kubernetes cluster. Create the Argo CD namespace, deploy manifests, and access the web UI to configure GitOps applications syncing.

Discover how Argo CD manages applications as custom resources to deploy to Kubernetes from a git repository, detailing source and destination configurations, namespaces, and sync policies in a GitOps workflow.

Apply and manage ml deployments with Argo CD using gitops, deploying the model and Streamlit app, and configuring automatic syncing, pruning, and horizontal pod autoscaling with Keda.

Automate ci/cd for ml apps with gitops—code changes or model updates to kubernetes deployment via github actions, docker hub artifacts, and argo cd, using a main to release branch workflow.

Follow four GitOps principles to deploy ML apps on Kubernetes by writing everything as code, versioning with git, and using Argo CD to automate CI/CD and artifacts.