Rust, Docker & K8s Performance Bundle

Show Details

Course Introduction

Ultimate Rust: This course covers many best practices to help you with integrate Rust into your workflow, and let Rust’s tooling work for you. It includes formatting, linting, dependencies, vulnerabilities, code style and general development advice..

This course is part of the Ultimate Rust track. Not sold separately.

Note: All of our bundles are for a one-year subscription.

At the end of the subscription period, your membership does not automatically renew.

Course Outline

Getting Started with Rust:

1.0 - Introduction
1.1 - Setup & Update Rust
1.2 - Setup Dev Environment
1.3 - IDE Configuration
1.4 - Rust Fundamentals
1.5 - Console Text Input
1.6 - Create a Library
1.7- World’s Simplest Login System
1.8 - Enumerations
1.9 - Structures
1.10 - Vectors
1.11 - HashMaps
1.12 - Serialization/Deserialization
1.13 - Hashing Passwords
1.14 - Start a CLI App

Fearless System Thread Concurrency:

2.0 - Introduction
2.1 - System Threads: Overview
2.2 - Create Your First Thread
2.3 - Spawning Threads with Parameters and Closures
2.4 - Returning Data from Threads
2.5 - Dividing Workloads
2.6 - The ThreadBuilder Pattern
2.7 - Scoped Threads for Easy Local Data Sharing
2.8 - Sharing Data with Atomics
2.9 - Sharing Data with Mutexes
2.10 - Read/Write Locks
2.11 - Deadlocks, Panics and Poisoning
2.12 - Sharing Data with Lock-Free Structures
2.13 - Parking Threads
2.14 - Sending Data Between Threads with Channels
2.15 - Sending Functions to Worker Threads
2.16 - Let’s build a work queue with a thread pool
2.17 - Thread CPU/Core Affinity
2.18 - Thread Priority
2.19 - Making it Easy with Rayon
2.20 - Scopes and Pooled Threads with Rayon

Async/Await Concurrency:

3.0 - ntroduction / Async Overview
3.1 - Hello Async/Await
3.2 - Getting Started with Tokio
3.3 - Working with Tokio Futures: Awaiting, Yielding and Spawning
3.4 - Blocking Tasks
3.5 - Unit Testing Tokio
3.6 - Handling Errors
3.7 - File I/O
3.8 - Basic Network I/O
3.9 - Async Channels (Tokio)
3.10 - Shared State (Tokio)
3.11 - Selecting Futures
3.12 - Pinning
3.13 - Tokio Tracing
3.14 - Working with Databases
3.15 - Axum - A Web Framework built on Tokio
3.16 - Let’s Build a Thumbnail Server

Memory & Resource Management:

4.0 - Why Haven’t We Manually Managed Any Memory Yet?
4.1 - The unsafe Keyword
4.2 - Low-Level Memory Management
4.3 - The Drop Trait & RAII (Resource Acquisition is Initialization)
4.4 - Reference Counting
4.5 - Lifetimes
4.6 - Traits
4.7 - Generics
4.8 - Iterators
4.9 - Cycles and the Difficulty of Linked Lists
4.10 - Memory Fragmentation, Allocators and Arenas
4.11 - Packing, Reordering & Mangling
4.12 - From Bytes to Types
4.13 - Safely Interacting with Other Languages & Surprise: Memory Leaks are Safe!

Build a Network Service:

5.0 - Introduction & Planning Our Project
5.1 - Shared Data Structures
5.2 - Collection Daemon Mk 1
5.3 - Collection Server Mk 1
5.4 - Error Handling in the Collector
5.5 - Setting the Collector ID
5.6 - Web Service Mk 1
5.7 - Web Server
5.8 - Let’s Use Less Bandwidth

Purchase Options

Purchase within Bundle

Ultimate Rust Foundations Ultimate Rust Foundations

Purchase a one year subscription to access all of the courses in this bundle on our education platform.

Purchase Individually

Purchase a one year subscription to access this course on our education platform.

Ultimate Rust: Foundations - Next Steps

This course offers the next steps not covered in Ultimate Rust: Foundations that expands on and optimize what you've already built.

with Herbert Wolverson

1+ Hrs

Beginner - Intermediate

Show Details

Course Introduction

This course offers the next steps not covered in Ultimate Rust: Foundations that expands on and optimizes what you’ve already built.

Note: All of our bundles are for a one-year subscription.

At the end of the subscription period, your membership does not automatically renew.

Course Outline

Ultimate Rust: Foundations - Next Steps

1.0 - Bi-Directional Communication
1.2 - Sending Commands & Prevent Unbounded Growth
1.3 - Giving the Collector a Diet
1.4 - Giving the Collector a Diet (Cont)
1.5 - Optimizing File Reading & Adapting Files In Flight

Purchase Options

Purchase within Bundle

Ultimate Rust: Foundations - Next Steps Ultimate Rust: Foundations - Next Steps

Purchase a one year subscription to access all of the courses in this bundle on our education platform.

Purchase Individually

Purchase a one year subscription to access this course on our education platform.

Ultimate Rust Best Practices

This course covers many best practices to help you with integrate Rust into your workflow, and let Rust’s tooling work for you. It includes formatting, linting, dependencies, vulnerabilities, code style and general development advice.

with Herbert Wolverson

1+ Hrs

Beginner

Show Details

Course Introduction

Note: All of our bundles are for a one-year subscription.

At the end of the subscription period, your membership does not automatically renew.

Course Outline

Section 1: Tooling

1.0 - Introduction - Formatting
1.1 - Clippy (the linter)
1.2 - Documentation
1.3 - Understanding Dependencies
1.4 - Managing Your Own Dependencies
1.5 - Checking for Vulnerabilities
1.6 - Check for Outdated Dependencies
1.7 - Denying Dependencies by Licensing

Section 2 : Code Best Practices

2.0 - Favor Iterators
2.1 - Minimize Cloning (we have an alternative name as well Cloning Can Be a Code Smell)
2.2 - Don’t Emulate OOP
2.3 - Favor Small Functions
2.4 - Clever Code
2.5 - Floating Point Numbers
2.6 - Platform & Feature Specific Code

Section 3 : General Best Practices

3.0 - TANSTAAFL (There Ain’t No Such Thing As A Free Lunch)
3.1 - YAGNI : You Ain’t Gonna Need It
3.2 - Domain Boundaries
3.3 - Taming Compile Times

Purchase Options

Purchase within Bundle

Ultimate Rust Best Practices Ultimate Rust Best Practices

Purchase a one year subscription to access all of the courses in this bundle on our education platform.

Purchase Individually

Purchase a one year subscription to access this course on our education platform.

Rust From C/C++

This course bridges the transition from C and C++ to Rust by highlighting their similarities and differences. Exploring Rust's native compilation, memory management, and advanced features, you'll compare and contrast key concepts like types, control flow, and data structures in this class. Delve into Rust's strengths in memory safety and concurrency, alongside its unified tool, Cargo, streamlining development. Additionally, learn how Rust facilitates interoperability with C and C++ through Foreign Function Interface (FFI).

with Herbert Wolverson

6+ Hrs

Beginner - Intermediate

Show Details

Course Introduction

This course bridges the transition from C and C++ to Rust by highlighting their similarities and differences. Exploring Rust’s native compilation, memory management, and advanced features, you’ll compare and contrast key concepts like types, control flow, and data structures in this class. Delve into Rust’s strengths in memory safety and concurrency, alongside its unified tool, Cargo, streamlining development. Additionally, learn how Rust facilitates interoperability with C and C++ through Foreign Function Interface (FFI).

This course is part of the Ultimate Rust track. Not sold separately.

Note: All of our bundles are for a one-year subscription.

At the end of the subscription period, your membership does not automatically renew.

Course Outline

Introduction:

1.0 - Introduction

Hello World:

2.1 - Setup & Update Rust
2.2 - Setup Dev Environment
2.3 - IDE Configuration
2.4 - Rust Fundamentals

Touring the Rust Langauge:

3.1 - Primitive Types
3.2 - Mutability
3.3 - Primitive Type Conversion
3.4 - Numeric Overflow
3.5 - Control Flow
3.6 - Loops
3.7 - Strings
3.8 - Functions and Scopes
3.9 - Structures
3.10 - Structure Functions
3.11 - Destructors - Drop
3.12 - Tuples and Destructuring
3.13 - Enums
3.14 - Containers
3.15 - Iterators
3.16 - Move by Default
3.17 - Borrowing
3.18 - Slices
3.19 - Memory Management
3.20 - Concurrency
3.21 - Program Organization
3.22 - Traits
3.23 - Generics
3.24 - Error Handling

Touring the Rust Ecosystem:

4.1 - Tool Equivalencies
4.2 - Unit Tests
4.3 - Benchmarking

Calling C from Rust with FFI:

5.1 - Calling C from Rust with FFI

Purchase Options

Purchase within Bundle

Rust From C/C++ Rust From C/C++

Purchase a one year subscription to access all of the courses in this bundle on our education platform.

Purchase Individually

Purchase a one year subscription to access this course on our education platform.

Rust as a Service

This course teaches integrating Rust into service-oriented architectures, covering REST server development, data handling, error management, and modularization. You'll learn tracing, automated OpenAPI documentation, configuration for different environments, and alternative connectivity mechanisms like gRPC and WebSockets. Explore deploying a test service in a containerized environment, along with insights into service design, deployment strategies, and scaling. This prepares you for deploying high-performance Rust services in enterprise environments.

with Herbert Wolverson

7+ Hrs

Beginner - Intermediate

Show Details

Course Introduction

This course teaches integrating Rust into service-oriented architectures, covering REST server development, data handling, error management, and modularization. You’ll learn tracing, automated OpenAPI documentation, configuration for different environments, and alternative connectivity mechanisms like gRPC and WebSockets. Explore deploying a test service in a containerized environment, along with insights into service design, deployment strategies, and scaling. This prepares you for deploying high-performance Rust services in enterprise environments.

This course is part of the Ultimate Rust track. Not sold separately.

Note: All of our bundles are for a one-year subscription.

At the end of the subscription period, your membership does not automatically renew.

Course Outline

Introduction:

1.0 - Introduction

REST Service:

2.1 - Minimal HTTP Server
2.2 - Service Stack
2.3 - Extractors
2.4 - Add a Simple Tower Layer (State)
2.5 - Add a Simple Tower Layer (Mutable State)
2.6 - Multiple States - Extension Layers
2.7 - Quick Recap on State and Layers
2.8 - Nesting Multiple Routers
2.9 - Nested Routers with State
2.10 - Calling Other Services
2.11 - Returning Status Codes
2.12 - Using IntoResponse
2.13 - Error Handling with IntoResponse
2.14 - Quick Recap on Nesting, Making Calls and Responses
2.15 - Serving Static Content with Tower
2.16 - Simple Header-Based Authentication
2.17 - Simple Header-Based Auth with Middleware
2.18 - Middleware Auth with Injection
2.19 - Selectively Applying Layers
2.20 - Router Layers
2.21 - Layer Recap

Tracing:

3.1 - Minimal Example
3.2 - Logging Axum/Tower
3.3 - Timing Spans
3.4 - Axum Spans
3.5 - Logging to a File
3.6 - Structured Logging to JSON
3.7 - OpenTelemetry

OpenAPI Documentation:

4.1 - OpenAPI Documentation

Handling Service Configuration:

5.1 - Environment Variables with .env
5.2 - The Config Crate - Basics
5.3 - Loading Config via HTTP
5.4 - CLI configuration with Clap
5.5 - Recap

Handling Service Configuration:

6.1 - Hello Tonic - Protocol Definition
6.2 - Hello Tonic - Project Definition and Build
6.3 - Hello Tonic - The Server
6.4 - Hello Tonic - The Client
6.5 - gRPC Streaming
6.6 - gRPC Streaming - Protocol Definition
6.7 - gRPC Streaming - The Server
6.8 - gRPC Streaming - The Client
6.9 - Recap So Far
6.10 - Authentication
6.11 - Tracing
6.12 - When to use gRPC

Web Sockets:

7.1 - Minimal Echo Server
7.2 - A native WS client
7.3 - JSON

Service Deployment:

8.1 - Test Service
8.2 - Native Host Deployment
8.3 - Docker Deployment

Service Design:

9.1 - Understanding Your Company Architecture
9.2 - Designing Individual Services
9.3 - Combining Services into a Modular Monolith
9.4 - Service Exposure
9.5 - Scaling Out

Wrap Up:

10.1 - Wrap Up

Purchase Options

Purchase within Bundle

Rust as a Service Rust as a Service

Purchase a one year subscription to access all of the courses in this bundle on our education platform.

Purchase Individually

Purchase a one year subscription to access this course on our education platform.

Intensive Docker

This is a course for devs, ops, architects; all kinds of IT professionals and engineers who need to understand Docker and containers.

with Jérôme Petazzoni

20 Hrs

Beginner

Show Details

Course Introduction

This course will help you establish foundational concepts of Docker & containers. You’ll complete labs and assignments that will help you become productive at designing, packaging, deploying and operating modern applications.

This course is part of the Intensive Docker & Kubernetes track. Not sold separately.

Note: All of our bundles are for a one-year subscription.

At the end of the subscription period, your membership does not automatically renew.

Requirements:

Should be comfortable using the command line.
Docker installed on your machine.
No prior experience with containers necessary.

Course Outline

Day 1:

Introduction to the Docker CLI
Containers, images, and layers
What’s signal handling and why it’s important
Managing container lifecycle
Building images with Dockerfiles
Understanding and managing the build cache

Day 2:

Container networking concepts
Connecting and exposing containers
Containerized development environments
Assembling stacks with Docker Compose
Service discovery with containers

Day 3:

Debugging containers
Names and labels
Tips, tricks, and best practices for efficient Dockerfiles
Techniques to reduce image size
Multi-stage builds

Day 4:

Advanced BuildKit usage
Multi-arch images (e.g. for ARM64 platforms)
Container network drivers
Control groups and Linux kernel namespaces
Security features: LSM, capabilities, seccomp2

Purchase Options

Purchase within Bundle

Intensive Docker Intensive Docker

Purchase a one year subscription to access all of the courses in this bundle on our education platform.

Purchase Individually

Purchase a one year subscription to access this course on our education platform.

Intensive Kubernetes

This is a course for devs, ops, architects; all kinds of IT professionals and engineers who need to understand Kubernetes and container orchestration.

with Jérôme Petazzoni

20 Hrs

Intermediate

Show Details

Course Introduction

This is a course for any engineer who needs to deploy, scale, and operate applications in “Cloud Native” environments. You’ll complete labs and assignments that will help you become productive with Kubernetes.

This course is part of the Intensive Docker & Kubernetes track. Not sold separately.

Note: All of our bundles are for a one-year subscription.

At the end of the subscription period, your membership does not automatically renew.

Requirements:

No Kubernetes experience necessary.
Knowing the difference between a container and an image.
Knowing how to run a container and how to build an image (with Docker or any other container engine).
Using SSH to connect to a remote Linux machine.
Basic shell commands (navigate directories, set environment variables…).
Using a text editor like vi, nano, or similar.

Course Outline

Day 1:

Kubernetes architecture overview
Nodes, Namespaces
Pods, Replica Sets, Deployments
Services, service types, and the Kubernetes network model
Deploying a micro-services application

Day 2:

YAML in action
Label and annotations
Managing logs
Imperative and declarative models
Running a local development cluster
Accessing remote clusters

Day 3:

Scaling mechanisms
Daemon Sets
Labels and selectors
Rolling updates
Healthchecks

Day 4:

Exposing HTTP services with Ingress resources
Volumes
Configuration management
Managing secrets

Day 5:

Executing batch jobs
Leveraging Tilt for development environments
Deploying a cluster with Terraform/OpenTofu (11+ cloud providers supported)

Purchase Options

Purchase within Bundle

Intensive Kubernetes Intensive Kubernetes

Purchase a one year subscription to access all of the courses in this bundle on our education platform.

Purchase Individually

Purchase a one year subscription to access this course on our education platform.

Intensive Kubernetes: Advanced Concepts

This course covers advanced concepts around application packaging, capacity planning, resource management, security, operators, and the specific mechanisms associated with stateful application deployment.

with Jérôme Petazzoni

16 Hrs

Intermediate

Purchase for $320

Show Details

Course Introduction

This course is for devs, ops, and architects, who have already started working with Kubernetes and want to learn more advanced concepts. Students will complete numerous labs and exercises.

This course is part of the Intensive Docker & Kubernetes track. Not sold separately.

Note: All of our bundles are for a one-year subscription.

At the end of the subscription period, your membership does not automatically renew.

Requirements:

Understanding of Pods, Deployments, Services.
How to deploy an app and expose it on a Kubernetes cluster.
Basic notions of what are labels, selectors, YAML manifests.
Basic shell commands (navigate directories, set environment variables…).
Using a text editor like vi, nano, or similar.

Course Outline

Day 1: security focus:

Securing access with network policies
Managing permissions with RBAC
Managing secrets with Sealed Secrets
Pod Security Settings and Admission

Day 2: resource management:

Understanding requests and limits
Compressible vs incompressible resources
Pod eviction and kubelet under pressure
Horizontal, vertical, and cluster- autoscaling
Priorities and preemption
Scaling with custom metrics

Day 3: extending the Kubernetes API:

Overview of the different extension mechanisms
Custom Resource Definitions
Dynamic admission control with webhooks
The aggregation layer
Operator concepts

Day 4: operator and controller implementation:

Operator design techniques
Studying operators (e.g. Kyverno, cert-manager)
The kubebuilder framework
Writing a small operator with kubebuilder
Events, finalizers, owners and dependents

Day 5: stateful applications:

Stateful Sets, PV, PVC, Storage Classes
Use-case: running a Consul cluster
Dynamic storage provisioning
Use-case: stateful failover of an active database

Purchase Options

Purchase within Bundle

Intensive Kubernetes: Advanced Concepts Intensive Kubernetes: Advanced Concepts

Purchase a one year subscription to access all of the courses in this bundle on our education platform.

Purchase Individually

Purchase a one year subscription to access this course on our education platform.

Purchase for $320

Introduction to KinD

This course is for IT professionals and engineers who need to understand how to get a local Kubernetes development cluster using KinD. Perfect for anyone looking to stage up disposable clusters.

with Jérôme Petazzoni

.5 Hrs

Beginner

Purchase for $100

Show Details

Course Introduction

Learn how to use KinD (Kubernetes-in-Docker) to get a local Kubernetes cluster across Linux, Mac, and Windows environments.

KinD is primarily used for testing Kubernetes but can also be utilized for local development or CI.

Note: All of our bundles are for a one-year subscription.

At the end of the subscription period, your membership does not automatically renew.

Requirements:

No experience with containers necessary.

Course Outline

Introduction to KinD:

1.0 - Using KinD for local Kubernetes development
1.2 - 5 options for running Kubernetes locally
1.3 - Deploying a KinD cluster with multiple nodes
1.4 - Utilizing docker exec/docker stats with KinD

Purchase Options

Purchase within Bundle

Introduction to KinD Introduction to KinD

Purchase a one year subscription to access all of the courses in this bundle on our education platform.

Purchase Individually

Purchase a one year subscription to access this course on our education platform.

Purchase for $100

Deep Dive Into Kubernetes Networking with CNI

This course covers concepts around the Container Network Interface (CNI) and how pods communicate on Kubernetes.

with Jérôme Petazzoni

1 Hrs

Beginner

Show Details

Course Introduction

This course is for devs, ops, or even architects, who want to dive deeper into Kubernetes and learn concepts around the Container Network Interface (CNI). We’ll discuss CNI plugins and how pods communicate together on Kubernetes. As an example, we will change the CNI plugin on a live Kubernetes cluster.

This course is part of the Intensive Docker & Kubernetes track. Not sold separately.

Note: All of our bundles are for a one-year subscription.

At the end of the subscription period, your membership does not automatically renew.

Requirements:

Students should be comfortable using the command line.
Some experience with Kubernetes recommended.

Course Outline

Kubernets Networking with CNI:

1.0 - What is a Kubernetes pod network?
1.1 - What is Kubernetes CNI?
1.2 - What is the AWS VPC CNI Plugin?
1.3 - How To Change a Kubernetes Pod Network
1.4 - What is a Kubernetes Overlay?

Purchase Options

Purchase within Bundle

Deep Dive Into Kubernetes Networking with CNI Deep Dive Into Kubernetes Networking with CNI

Purchase a one year subscription to access all of the courses in this bundle on our education platform.

Purchase Individually

Purchase a one year subscription to access this course on our education platform.