CourseFlix

Let’s Rust

12h 40m 9s
English
Paid

This course is live and hands‑on. You build a full ML service in Rust step by step. You train a model, save it, serve it with a REST API, and deploy it on Kubernetes. We skip long theory. You write code, ask questions, and focus on the result.

What You Build

Training Pipeline

You load data from CSV, prepare features with Polars, train a model, and save the artifact.

Simple Model Store

You upload the saved model to Amazon S3 and fetch it from your service.

REST API for Predictions

You write a Rust service that loads the model, reads input, and sends a clear response.

Demo Deploy on Kubernetes

You build the image, package the app, and launch it on a small cluster.

Why Rust

Pros

  • Fast code and low memory use help cut runtime costs.
  • Strict types help you avoid many bugs.
  • The tools guide you to safe code.

Cons

  • The syntax feels complex at first.
  • You must get used to the compiler and its checks.
  • You will not "master Rust in a week", but you will build a real app and learn core ideas like structs, traits, crates, and package use.

Course Result

You finish with a working ML service in Rust. You learn the core parts of the Rust stack and gain the habits needed to ship real tools. You also become more precise in Python, as a second language helps you see design choices more clearly.

About the Author: Pau Labarta Bajo

Pau Labarta Bajo thumbnail
I am a machine learning engineer with many years of experience creating real ML products. Do you want to design, develop, and implement your own solution? I explain how to build complete ML products from idea to production and help leading startups and large companies solve business challenges using AI.

Watch Online 64 lessons

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 64 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: Introduction to the course
All Course Lessons (64)
#Lesson TitleDurationAccess
1
Introduction to the course Demo
08:20
2
What is the goal of this course?
08:52
3
Why Rust?
15:17
4
Our plan
10:43
5
Installing the tools: rustc, cargo, rust-analyzer
16:28
6
How to generate and run the binaries
21:04
7
Steps to train an ML model in Rust
10:00
8
How to download the CSV file - Part 1
26:56
9
How to handle errors and Results with anyhow and ?
20:22
10
Generic types, traits and trait bounds in function definitions
23:10
11
How to download the CSV file - Part 2
10:37
12
Wrap up
03:17
13
Goals for today
05:04
14
Load the CSV file into memory with Polars Rust
18:15
15
Extract functions to lib.rs
05:11
16
Splitting the data into training and test - Part 1
25:31
17
Splitting the data into training and test - Part 2
18:33
18
Questions and answers
04:06
19
Split datasets into features and targets
12:21
20
Transforming Polars DataFrame to DMatrix for XGBoost training
24:43
21
Training the XGBoost model - Part 1
20:48
22
Questions and answers
02:53
23
Training the XGBoost model - Part 2
12:04
24
Pushing the model artifact to AWS S3 bucket
18:41
25
How to set up your AWS credentials to talk to your S3 bucket
01:48
26
Wrap up
01:49
27
Goals for today
03:35
28
Tip -> devcontainers
05:08
29
Add 2 entry points, one for training, one for REST API
05:55
30
Questions and answers
02:35
31
Building a minimal API with health endpoint - Part 1
19:55
32
Building a minimal API with health endpoint - Part 2
10:25
33
Adding a predict endpoint to our REST API
22:20
34
Tip -> How to break a large problem into smaller (easier) ones
02:34
35
Download model artifact from AWS S3 bucket
23:37
36
Refactorings -> Break our lib.rs into separate files
17:27
37
Adding CLI parameters for training using Clap
11:24
38
Loading the model from S3 into memory
07:39
39
Adding model to the AppState so we can use it in our predict functions - Part 1
21:03
40
Adding model to the AppState so we can use it in our predict functions - Part 2
07:46
41
Wrap up
02:32
42
Plan for today
02:17
43
Transform input payload to dmatrix for XGBoost
21:04
44
Formatting the response with the prediction
15:42
45
Extracting the port number as input argument
07:26
46
Two challenges for you
11:22
47
Dockerizing the API - Part 1
20:40
48
Trick -> How to solve Docker no space left problems
06:49
49
Dockerizing the API - Part 2
23:00
50
Dockerizing the API - Part 3
22:35
51
Dockerizing the API - Part 4
21:47
52
Dockerizing the API - Part 5
07:43
53
Dockerizing the API - Part 6
01:51
54
Wrap up
02:37
55
00 - Intro
02:49
56
01 - Bootstrap the project
04:27
57
02 - Hello world with a /health endpoint
21:43
58
03 - A bit of refactoring
02:58
59
04 - Add a /predictions endpoint
08:39
60
05 - Break down project in several files
08:28
61
06 - Start Postgres DB with Docker
07:52
62
07 - Fetch data from Postgres
20:28
63
08 - Loading environment variables
02:07
64
09 - Add GET parameter to the /predictions endpoint and compile for release
04:57
Unlock unlimited learning

Get instant access to all 63 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

Books

Read Book Let’s Rust

#Title
1session 1
2session 2