Go, Rust, Docker & K8s Mastery Bundle

214+ Hours Beginner - Advanced

Purchase of this bundle gives you access to all of our existing & future courses during your membership year (12 month membership).

Free Preview

Go, Rust, Docker & K8s Bundle | Ardan Labs

What You'll Learn

This is a comprehensive and advanced training for the engineer who wants cutting edge training in architecture, microservices, & popular technologies. You will be challenged to think about what you’re doing and why, with a focus on making you a better engineer.

Requirements

You don't need to have prior experience with Go, Rust, Docker, or Kubernetes. However, it is helpful to be familiar with basic programming concepts (i.e structural vs object oriented programming, command line, etc..).

Detailed Course Info

Skill Level: Beginner - Advanced
Bundle Length: 214+ Hrs

Note: All of our bundles are for a one year subscription to the course content. This includes all updates and new content added during that time.

Team Pricing: We offer special pricing models for teams

Courses Included in the Bundle

18+ total hours

Intermediate

Practical Go Foundations

This introductory course explores topics like strings, REST APIs, error handling, testing, sorting, and more! Perfect for engineers just starting their journey into Go.

with: Miki Tebeka

View Course Info

Course Introduction

This course will help you become familiar with the basic concepts of the Go programming language. Through lectures and coding exercises, you’ll learn about the core concepts needed to become a productive Go developer.

This course is part of the Ultimate Go 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:

You need to know how to program and core concepts of working with computers (such as files, HTTP, memory management…)

A basic understanding of the Go programming language.
Some experience with the Go Tour is recommended.

You should have the following installed on your computer prior to the workshop:

Go SDK from golang.org/dl/
An IDE, either VSCode with Go extension or GoLand
Git

Course Outline

Module 1 - Introduction & Setup

1.1 - Introduction to Go
1.2 - Setting Up So You Can Get Started
1.3 - Writing Your First Go Program, Compiling & Running It

Module 2 - Data Structures & REST APIs

2.1 - Understanding Strings in Go, Formatted Output
2.2 - Calling REST APIs, HTTP Requests, JSON
2.3 - Working with Files, Using Defer to Manage Resources, Error Handling
2.4 - Composing io.Reader and io.Writer
2.5 - Working with Slices, Slices Internals

Module 3 - Structures, Methods, & Interfaces

3.1 - Defining & Creating Structs
3.2 - Adding Methods to Structs
3.3 - Creating and Implementing Interfaces
3.4 - The Empty Interface
3.5 - Using Generics

Module 4 - Panics & Maps

4.1 - Handling Panics
4.2 - Calculating Word Frequency, Working with Maps

Module 5 - Concurrency

5.1 - Overview of Concurrency in Go
5.2 - Using goroutines and Channels
5.3 - Iterating Over Channels, Closing Channels
5.4 - Using the Fan-Out Pattern
5.5 - Exercise: Converting Sequential Algorithms to Concurrent
5.6 - Using the Sync Package
5.7 - Using the Select, Working with Multiple Channels, Timeouts and Cancellations
5.8 - Exercise: Real-Time Bidding, Adding Timeouts

Module 6 - Project Engineering

6.1 - Documenting Your Code
6.2 - Testing Your Code
6.3 - Dependency Management, go mod
6.4 - Using the Testify Library
6.5 - Exercise: Reading Test Cases from a TOML File
6.6 - Fuzz Testing
6.7 - Installing and Linters, the “go tool” Command
6.8 - Project Structure, Splitting to Sub-Packages
6.9 - Writing an HTTP Server
6.10 - Testing HTTP Request Handlers
6.11 - Adding Logging and Metrics
6.12 - Configuring Your Server: Environment Variables, Flags, Configuration Files

20+ total hours

Intermediate

Ultimate Go: Language Guide

The Ultimate Go: Language Guide is for developers with some experience with Go trying to dig deeper into the language with a focus on performance. They want to learn internals and make better engineering decisions.

with: Bill Kennedy

View Course Info

Course Introduction

Learn to write better, more idiomatic and performant code in Go with a focus on micro-level engineering decisions. The course begins with a focus on Go internals that are critical to understanding the core tradeoffs on readability, simplicity and performance.

You will learn about data semantics, guidelines, mechanical sympathy, data oriented design, package oriented design, and how to structure your Go projects for the long term.

This course is part of the Ultimate Go 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:

You need to know how to program and core concepts of working with computers (such as files, HTTP, memory management…)

Studied CS in school or has a minimum of two years of experience programming full-time professionally.
Familiar with structural and object-oriented programming styles.
Has worked with arrays, lists, queues and stacks.
Understands processes, threads and synchronization at a high level.

Operating Systems:

Has worked with a command shell.
Knows how to maneuver around the file system.
Understands what environment variables are.

You should have the following installed on your computer prior to the workshop:

Go SDK from golang.org/dl/
An IDE, either VSCode with Go extension or GoLand
Git

Course Outline

Strings & Formatted Output:

1.1 - Prepare Your Mind - ( 17:38 )
1.2 - Productivity vs. Performance - ( 06:24 )
1.3 - Correctness vs. Performance - ( 07:14 )
1.4 - Code Reviews - ( 19:16 )
1.5 - If Performance Matters - ( 03:31 )

Memory & Data Semantics:

2.1 - Variables - (05:04)
2.2 - Struct Types - (22:55)
2.3.1 - Pointers (Pass by Values) - (17:43)
2.3.2 - Pointers (Sharing Data) - (07:50)
2.3.3 - Pointers ( Escape Analysis) - (19:46)
2.4 - Constants - (23:50)

Data Structures:<

3.2.1 - Arrays (Mechanical Sympathy) - (15:00)
3.2.1 - Arrays (Semantics) - (11:10)
3.2.1 - Arrays (Range Mechanics) - (06:39)
3.3.1 - Slices (Declare, Length & Reference Types) - (10:00)
3.3.2 - Slices (Appending Slices) - (03:00)
3.3.3 - Slices (Taking Slices of Slices) - (03:00)
3.3.4 - Slices (Slices & References) - (05:35)
3.3.5 - Slices (Strings & Slices) - (10:23)
3.3.6 - Slices (Range Mechanics) - (04:15)
3.4 - Maps - (11:23)

Decoupling:

4.1.1 - Methods (Value & Pointer Semantics) - (16:37)
4.1.2 - Methods (Function/Method Variables) - (14:43)
4.2.1 - Interfaces (Polymorphism) - (18:19)
4.2.2 - Interfaces (Method Sets & Address of Value) - (13:42)
4.3 - Embedding - (09:50)
4.4 - Exporting - (09:52)

Composition:

5.1 - Grouping Types - (15:21)
5.2.1 - Decoupling Part 1 - (37:02)
5.3.2 - Conversion & Assertions - (04:49)
5.4 - Interface Pollution - (08:51)
5.5 - Mocking - (08:15)

Error Handling:

6.1 - Default Error Values - (05:51)
6.2 - Error Variables - (10:52)
6.3 - Types as Context - (06:59)
6.4 - Behavior as Context - (08:14)
6.5 - Find the Bug - (04:19)
6.6 - Wrapping Errors - (10:16)

Packaging:

7.1 - Language Mechanics & Design Guidelines - (11:15)
7.2 - Package-Oriented Design - (15:50)

Go Routines:

8.1 - OS Scheduler Mechanics - (33:00)
8.2 - Go Scheduler Mechanics - (27:11)
8.3 - Creating Go Routines - (19:37)

Data Races:

9.1 - Managing Data Races (22:15)

Channels:

10.1 - Signaling Semantics - (11:08)
10.2 - Basic Patterns - (06:21)
10.3 - Fan Out - (05:28)
10.4 - Wait for Task - (02:31)
10.5 - Pooling - (05:14)
10.6 - Fan Out Semaphore - (05:22)
10.7 - Fan Out Bounded - (06:14)
10.8 - Drop Pattern - (05:06)
10.9 - Cancellation Pattern - (07:28)

Concurrency Patterns:

11.1 - Failure Detection (18:30)

Testing:

12.2 - Table Unit Testing - (04:10)
12.3 - Mocking Web Server Response - (07:21)
12.4 - Testing Internal Endpoints - (09:01)
12.5 - Sub Tests - (05:40)
12.6 - Code Coverage - (03:33)

Benchmarks:

13.1 - Basic Benchmarking - (09:24)
13.2 - Validate Benchmarking - (07:01)
13.3 - CPU-Bound Benchmarking - (07:03)
13.4 - IO-Bound Benchmarking - (06:05)

Profiling & Tracing:

14.1 - Profiling Guidelines - (05:42)
14.2 - Stack Traces - (08:28)
14.3 - Micro Level Optimization - (28:20)
14.4 - Macro Level Optimization - (24:47)
14.5 - Execution Tracing - (38:56)

Ultimate Go: Software Design with Kubernetes Icon

25+ total hours

Intermediate

Ultimate Go: Software Design with Kubernetes

This course teaches you how to build production-level services in Go, leveraging the power of a Domain Driven, Data Oriented Architecture deployed in Kubernetes.

with: Bill Kennedy

View Course Info

Course Introduction

From the beginning of the course, you will pair-program with your instructor Bill Kennedy as he walks you through the design philosophies, architectural decisions, and best practices as they apply to engineering a production-ready Go service.

With each new feature that is added to the service, you will learn how to deploy and manage the Kubernetes environment used to run the service. Throughout the class, the code being worked on is pushed to a repository for personal access and review.

This course is part of the Ultimate Go 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:

You need to know how to program and core concepts of working with computers (such as files, HTTP, memory management…)

Studied CS in school or has a minimum of two years of experience programming full time professionally.
Familiar with structural and object-oriented programming styles.
Has worked with arrays, lists, queues and stacks.
Understands processes, threads and synchronization at a high level.

Operating Systems:

Has worked with a command shell.
Knows how to maneuver around the file system.
Understands what environment variables are.

You should have the following installed on your computer prior to the workshop:

Go SDK from golang.org/dl/
An IDE, either VSCode with Go extension or GoLand
Git

Course Outline

Introduction:

Introduction to the class and all the engineering that you will learn.

1.1: Design Philosophy, Guidelines, What to Expect
1.2: Tooling and Images to Install

Deploy First Mentality:

We begin to build the service with a focus on the ability to deploy the service in Kubernetes.

2.1: Project Layers, Policies, and Guidelines
2.2: Prepare Project
2.3: Build Service with Logging

Kubernetes:

We introduce Kubernetes and get a K8s environment up and running. At this point, everything we do runs in the K8s environment.

3.1: Clusters, Nodes and Pods
3.2: Start the Kubernetes Cluster
3.3: Create/Build Dockerfile for the Service
3.4: Create/Apply K8s Deployment for the Service

Kubernetes Quotas:

We introduce applying Quotas to the deployment and discuss the problems that can result.

4.1: Understanding the Go Scheduler
4.2: Understanding CPU Quotas
4.3: Adding Quotas and Adjusting GOMAXPROCS

Finish Initial Service Startup/Shutdown:

We finish the initial startup and shutdown of the service.

5.1: Configuration
5.2: Debugging / Metrics
5.3: Shutdown Signaling and Load Shedding

Web Framework:

We build out our own router by extending an existing one. This gives us a framework for injecting business logic into the processing of requests. It also allows for more consistency in the handling of requests.

6.1: Basic Structure of an HTTP Router
6.2: Liveness and Readiness Handlers
6.3: Customize the Router
6.4: Middleware Support
6.5: Sending Responses

Middleware:

We add middleware functions for business-level logic that needs to be injected into the processing of requests.

7.1: Logging
7.2: Error Handling
- Understanding What Error Handling Means
- Declaring Custom Error Types
- Consistent Handling and Response
7.3: Panic Handling
7.4: Metrics

JSON Web Tokens (JWT):

We gain an understanding of how JWT's work and their shortcomings. We also learn about OPA and how we will use it to perform the actual authentication and authorization.

8.1: Understanding JWT
8.2: Private/Public Key Generation
8.3: Token Generation
8.4: Token Signature Validation with OPA

Key Store:

We create a simple key store for the project to store and retrieve the private key.

9.1: Key Store Package

Authentication / Authorization:

We integrate authentication and authorization support into the project by developing a package to generate and validate tokens. Then we integrate the packages into the application and test that things are working.

10.1: Auth Package
10.2: Auth Unit Test
10.3: Add Middleware
10.4: Auth Service
10.5: Auth Client

Domain Driven, Data-Oriented Architecture:

We talk about the data-driven data oriented architecture that is implemented in the project. We discuss the design philosophy, guidelines, and semantics of how the three layers of App, Business, and Storage work together.

11.1: Architecture Review
11.2: Data Flow Trust vs Non-Trust

Database Support:

We add a Postgres database to our K8s environment. Then we write a small database package that provides more effective support for using the SQLx package. Finally, integrate the database package on application startup.

12.1: Kubernetes Support for Postgres
12.2: Create Database Package
12.3: Update Readiness Handler to Perform DB Checks

Database Migrations and Seeding:

We define our schema and provide support for migration schema changes over time. We also provide support for seeding the database. Finally, we added support in Kubernetes to run the migration and seeding on POD startup.

13.1: Maintaining Database Schemas and Seeds
13.2: Admin Tooling and Init Containers to Automate Migrations

API, App, Business, and Storage Implementation:

We implement the Create domain inside the App, Business, and Storage layers.

14.1: User Business Domain Support
14.2: User Storage Domain Support
14.3: User App Domain Support
14.4: User API Domain Support

Testing:

We add docker and unit testing support for writing tests against a real database and write the actual user package tests.

15.1: Starting and Stopping Containers
15.2: Database Testing Support
15.3: Unit and API Testing Support
15.4: Write User Business Test
15.5: Write User API Tests

Delegate and Transactions:

We talk about how the delegate and transaction systems work.

16.1: Delegate System
16.2: Transaction System

Observability:

We add tracing to the project by integrating Open Telemetry and Zipkin.

17.1: Integrate OTEL into the Project

Review Service Project:

Review service project and get it running.

18.1: Check For Dependency Upgrades, Rebuild, Run

20+ total hours

Intermediate

Ultimate Go: Advanced Engineering

Learn advanced Go concepts by building a reference implementation of a blockchain in Go! The goal of this class is to share how to code complex engineering tasks required to build blockchain technology.

with: Bill Kennedy

View Course Info

Course Introduction

From the beginning, you will pair program with the instructor, walking through the design philosophies and guidelines used to engineer the code. Throughout the class, you will learn more about Go and the advanced engineering features of the language.

This course is part of the Ultimate Go 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:

You need to know how to program and core concepts of working with computers (such as files, HTTP, memory management…)

An intermediate understanding of the Go programming language is recommended.
Students will derive the most value if they have taken our Ultimate Go: Language Guide and Ultimate Go: Software Design with Kubernetes classes.

You should have the following installed on your computer prior to the workshop:

Course Outline

Introduction:

1.1: Design Philosophy, Guidelines, What to Expect
1.2: Tooling to Install
1.3: Initial Code for the Project

Blockchain Fundamentals:

2.1: Blockchain Fundamentals
2.2: Genesis
2.3: Transactions and Blocks
2.4: Digital Signatures
2.5: Account Management
2.6: Memory Pooling
2.7: Mining and Consensus
2.8: Fraud Detection

Genesis:

3.1: What is Genesis
3.2: Configuration Options
3.3: Reading From Disk

Digital Signatures:

4.1: What is a Digital Signature
4.2: Hashing
4.3: Stamping
4.4: Signing
4.5: Addressing
4.6: Verification

Database:

5.1: What is Inside the Blockchain Database
5.2: Transaction Types
5.3: Accounting
5.4: Block Types

Cryptographic Audit Trails:

6.1: What is a Cryptographic Audit Trail
6.2: Chaining
6.3: Merkle Tree Proofs
6.4: Account Database Proof

Memory Pools:

7.1: What is a Mempool
7.2: Storing Transactions
7.3: Transaction Selection

Accepting Signed Transations:

8.1: Handler function
8.2: Transaction Signature Verification
8.3: Mempool Inclusion

Mining:

9.1: What is Consensus and Mining
9.2: Proof Of Work Algorithm
9.3: Implement Mining Workflow

Storage:

10.1: Storage Options
10.2: Writing Blocks
10.3: Reading and Searching Blocks

Peer to Peer Networks:

11.1: What is the P2P Network
11.2: Peer Discovery
11.3: Sharing Transactions
11.4: Sharing Blocks

Wallets:

12.1: Chrome Plugin Basics
12.2: Javascript Support
12.3: Send Signed Transaction

16+ total hours

Beginner

Intermediate

Ultimate Debugging

Learn the latest tips, tricks, and best practices around debugging in Golang.

with: Derek Parker

View Course Info

Course Introduction

This course is designed for developers who want to become proficient debugging Go software using the Delve debugger. Whether you’ve never used a debugger in your life or are a Delve expert, everybody will walk away with new information that can be used in their day to day development workflow.

The course will initially focus on Delve, which is the de facto Go debugger. We will start with the basics and move into more advanced use cases over the 5 days. On the last day of class, we will dig into new tools and cover profiling / perf tools, how to use them effectively, and how to interpret the data for root cause analysis.

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

Requirements:

A basic understanding of the Go programming language. Students do not have to be expert Go users, but they will get the most from the workshop if they have completed the majority of the [Go Tour] (https://tour.golang.org/).

Course Outline

Day 1:

Introduction, getting started, navigating your program, inspecting program state, changing program state.

Day 2:

Advanced program navigation, tracing your program, examining core dumps (post-mortem debugging). Part 1

Day 3:

Advanced program navigation, tracing your program, examining core dumps (post-mortem debugging). Part 2

Day 4:

Scripting Delve, remote debugging, using the JSON-RPC API, record and replay debugging.

Day 5:

Debugging containerized applications, debugging an application on Kubernetes. Part 1

Day 6:

Debugging containerized applications, debugging an application on Kubernetes. Part2

Day 7:

Using proof profiling tools, using perf on Go binaries, and deep dive into Delve and Go internals. Part 1

Day 8:

Using proof profiling tools, using perf on Go binaries, and deep dive into Delve and Go internals. Part 2

1+ total hours

Intermediate

Writing Secure Go Code

This course covers best practices for securing your Go applications. You’ll work with a simple Go app & identify security vulnerabilities from the OWASP Top Ten.

with: Miki Tebeka

View Course Info

Course Introduction

Follow along with the instructor as he overviews common vulnerabilities in a live Go application. You’ll learn about tools and strategies to help you identify security vulnerabilities and how to think about security when it comes to your Golang application.

This course is part of the Ultimate Go 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:

You need to know how to program and core concepts of working with computers (such as files, HTTP, memory management…)

Studied CS in school or has a minimum of two years of experience programming full time professionally.
Familiar with structural and object-oriented programming styles.
Has worked with arrays, lists, queues and stacks.
Understands processes, threads and synchronization at a high level.

You should have the following installed on your computer prior to the workshop:

Go SDK from golang.org/dl/
An IDE, either VSCode with Go extension or GoLand
Git

Course Outline

What's Covered:

The Security Mindset - (03:00)
Go Security Policy - (04:43)
OWASP Top Ten - (06:46)
Input - (09:10)
Output - (17:46)
Authentication - (25:56)
Infrastructure - (28:42)

PDF & Paperback

Ultimate Go: Notebook

The ultimate companion to the Ultimate Go: Language Guide course. Help turn your programming to engineering with this notebook.

with: Bill Kennedy

View Course Info

About This Book

This notebook has been written and designed to provide a reference to everything covered in our Ultimate Go class. If you have taken the class before, this notebook will be invaluable for reminders on the content. If you have never taken the class, there is still tremendous value in this book. It covers more advanced topics not found in other books today.

Guidelines, design philosophy, white-boarding, and notes shared from the Ultimate Go training.
Learn advanced concepts in Go from types to profiling.
Get started with generic functions and types.

View the full details

5+ total hours

Beginner

Ultimate Rust: Crash Course

This course will provide you with the fundamentals you need to boost you up Rust's steep learning curve. A fast-paced, entertaining, and curiously informative hands-on crash course in the Rust programming language. Learn how to write high-performance code without the worry of crashes or security vulnerabilities.

with: Nathan Stocks

View Course Info

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.

What you’ll learn:

Rust language basics, tooling, and ecosystem
Fundamentals such as variables, scope, functions, modules, scalar & compound types, control flow, strings, structs, traits, enums, and more.
Fun tips & tricks for using Rust and systems programming in general
Concepts essential to understanding Rust such as ownership, references & borrowing, the memory model, and why Rust focuses on safety, concurrency, and speed.

Requirements:

A basic understanding of general programming concepts
Familiarity with other programming languages such as Python, C, etc. is helpful, but not required.
Rust installed and ready to use - you’ll learn more by doing the exercises!

Who this course is for:

Aspiring systems programmers, software developers, engineers, wizards, warriors, and hobbits
Any developer who needs to run code fast, efficiently, securely, under tight restraints, or with a minimum of bugs
A desire to begin using Rust

Course Outline

Module 1: Introduction

Lesson 1.1 - Introduction
Lesson 1.2 - Exercises Overview
Lesson 1.3 - Installation
Lesson 1.4 - Editor/IDE

Module 2: Fundamentals

Lesson 2.1 - Cargo
Lesson 2.2 - Variables
Lesson 2.3 - Scope
Lesson 2.4 - Memory Safety
Lesson 2.5 - Exercise A - Variables
Lesson 2.6 - Functions
Lesson 2.7 - Exercise B - Functions
Lesson 2.8 - Module System
Lesson 2.9 - Exercise C - Module System

Module 3: Primitive Types & Control Flow

Lesson 3.1 - Scalar Types
Lesson 3.2 - Compound Types
Lesson 3.3 - Exercise D - Simple Types
Lesson 3.4 - Control Flow
Lesson 3.5 - Exercise E - Control Flow
Lesson 3.6 - Strings
Lesson 3.7 - String Literals
Lesson 3.8 - Exercise F - Strings

Module 4: The Heart of Rust

Lesson 4.1 - Ownership
Lesson 4.2 - References & Borrowing
Lesson 4.3 - Exercise G - Ownership & References

Module 5: The Meat of Rust

Lesson 5.1 - Structs
Lesson 5.2 - Exercise H - Structs
Lesson 5.3 - Traits
Lesson 5.4 - Exercise I - Traits
Lesson 5.5 - Collections
Lesson 5.6 - Exercise J - Collections
Lesson 5.7 - Enums
Lesson 5.8 - Exercise K - Enums

4+ total hours

Intermediate

Ultimate Rust 2: Intermediate Concepts

This is the second course in the Ultimate Rust series following the Ultimate Rust Crash Course. It will provide an even deeper dive into the Rust programming language with the same fast-paced, entertaining, curiously-informative, hands-on styled curriculum. If you like that course, you'll love this one!

with: Nathan Stocks

View Course Info

Course Introduction

This is a hands-on course! Not only are there targeted exercises for each topic discussed, there are also a series of project scenarios that walk you through using what you’ve learned to put together playable game prototypes that work on macOS, Linux, and Windows.

These projects will make use of Rusty Engine, a game engine developed specifically for this course to keep game engine concepts to a minimum so you can focus on using exactly what you learned in this course.

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

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

What you’ll learn:

How to write idiomatic, well-tested, documented Rust code
Threads, channels, closures, iterators, code documentation, std library traits, error handling, testing, benchmarks, logging, attributes, turbofish and more!
Rust concepts beyond the fundamentals taught in the “Ultimate Rust Crash Course”
How to use Rust to make video game prototypes

Requirements:

A beginner’s knowledge of Rust (taking the “Ultimate Rust Crash Course” is recommended)
Intermediate+ experience with general programming concepts and languages.
Rust installed and ready to use - this is a hands-on course!

Who this course is for:

Experienced systems programmers, software developers, engineers, wizards, warriors, and hobbits
Any developer who needs to run code fast, efficiently, securely, under tight restraints, or with a minimum of bugs
Anyone planning to use Rust frequently

Course Outline

Module 1: Introduction

Lesson 1.1 - Introduction
Lesson 1.2 - Exercises Overview

Module 2: Lectures & Exercises

Lesson 2.1 - Idiomatic Code
Lesson 2.2 - Exercise - Idiomatic Code
Lesson 2.3 - Documentation
Lesson 2.4 - Exercise - Documentation
Lesson 2.5 - Publishing
Lesson 2.6 - Exercise - Publishing
Lesson 2.7 - Iterators
Lesson 2.8 - Closures
Lesson 2.9 - Exercise - Closures & Iterators
Lesson 2.10 - Common Traits
Lesson 2.11 - Exercise - Traits
Lesson 2.12 - Creating Errors
Lesson 2.13 - Handling Errors
Lesson 2.14 - Exercise - Errors
Lesson 2.15 - Unit Tests
Lesson 2.16 - Integration Tests
Lesson 2.17 - Benchmarks
Lesson 2.18 - Exercise - Testing
Lesson 2.19 - Logging
Lesson 2.20 - Exercise - Logging
Lesson 2.21 - Multithreading
Lesson 2.22 - Channels
Lesson 2.23 - Exercise - Threads & Channels

Module 3: Project - Learn Rusty Engine

Lesson 3.1 - Project Overview
Lesson 3.2 - Configuration
Lesson 3.3 - Engine Initialization
Lesson 3.4 - Game State
Lesson 3.5 - Game Logic Function
Lesson 3.6 - Sprites
Lesson 3.7 - Colliders
Lesson 3.8 - Keyboard Input
Lesson 3.9 - Mouse Input
Lesson 3.10 - Text
Lesson 3.11 - Audio
Lesson 3.12 - Timer
Lesson 3.13 - Engine & Game Structs

Module 4: Game - Road Race

Lesson 4.1 - Common Setup
Lesson 4.2 - Road Race

Module 5: Game - Car Shoot

Lesson 5.1 - Car Shoot, part 1
Lesson 5.2 - Car Shoot, part 2
Lesson 5.3 - Car Shoot, part 3
Lesson 5.4 - Car Shoot, part 4

20+ total hours

Beginner

Intermediate

Ultimate Rust Foundations

This comprehensive course is designed to take you from zero to hero in Rust, equipping you with the skills to excel in basic development and web service creation. Through practical, hands-on training, you'll establish a robust understanding of Rust fundamentals

with: Herbert Wolverson

View Course Info

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

Ultimate Rust: Foundations - Next Steps Icon

1+ total hours

Beginner

Intermediate

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

View Course Info

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

1+ total hours

Beginner

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

View Course Info

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

6+ total hours

Beginner

Intermediate

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

View Course Info

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

7+ total hours

Beginner

Intermediate

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

View Course Info

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

20+ total hours

Beginner

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

View Course Info

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

20+ total hours

Intermediate

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

View Course Info

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)

Intensive Kubernetes: Advanced Concepts Icon

16+ total hours

Intermediate

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

View Course Info

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

.5+ total hours

Beginner

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

View Course Info

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

Deep Dive Into Kubernetes Networking with CNI Icon

1+ total hours

Beginner

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

View Course Info

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?

Managing AWS Resources with Terraform Icon

1+ total hours

Beginner

Managing AWS Resources with Terraform

This course explores the basics of using Terraform to manage resources on AWS. Perfect for engineers looking to implement more automation and simplify deployments.

with: Michael Bright

View Course Info

Course Introduction

Get started with the basics of Infrastructure-as-code and see a live demo on how to spin up a web server with Terraform.

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

Managing AWS With Terraform:

1.1.1 - What is Infrastructure as Code (IaC)
1.1.2 - Benefits of Terraform
1.1.3 - Getting Started: Basic Terraform Commands
1.1.4 - Example Terraform Configuration File
1.1.5 - Intro to Terraform .tf Files
1.1.6 - Creating AWS resources with Terraform
1.1.7 - Enabling SSH connectivity with Terraform
1.1.8 - Turning our server into a web server
1.1.9 - Making the server production ready
1.2.0 - Creating an S3 bucket with Terraform

Why Engineers & Teams Trust Ardan Labs

Extremely well organized and high value

"The course is extremely well organized and the pace is also very conducive to the learning process. The exercises are very well organized. Delivered very high value."

- Cisco

Best training in the Go community

"You should reach out to the team over at @ardanlabs. They have been training the Go community since the beginning and I've yet to see anyone do it better."

- Kelsey Hightower

Go features that made work better

"Feeling so happy with myself: yesterday at work I refactored some code to use @golang 1.16 built-in, embed I learned about it at @ardanlabs service class."

- Jessica Greene

Well-structured and useful advice

"Excellent class. The instructor is a hacker speaking to hackers, so we got very useful information and advice. Well-structured and paced. 10/10 would gopher it again."

- Zip Recruiter

Best ever—learned to build great services

"I finished Ultimate Service from @ardanlabs. I'm telling you this was the best ever. Talking from project structures to metrics. Now I can write good services in Go."

- Adeniyi Oluwatola

Improved productivity with Go

"Thanks @ardanlabs for a great Ultimate Go class! Bill is a great teacher and I'm definitely more productive in Go now."

- Steve Francia

Complex topics explained clearly

"Highly recommend Ultimate Go by @goinggodotnet & @ardanlabs. I appreciate how Bill explains complex topics simply and clearly. The labs were incredibly helpful too."

- Matt Holt

Well documented and well structured

"Their quality is astounding. They went above and beyond what we asked, working in line with best practices. Everything had test cases, was well documented and well structured, and ran smoothly.”

- Cole Calistra

See What's New

From the Lab

Where ideas get tested and shared. From the Lab is your inside look at the tools, thinking, and tech powering our work in Go, Rust, and Kubernetes. Discover our technical blogs, engineering insights, and YouTube videos created to support the developer community.

Explore our content:

Blog News YouTube

Blog Post

Kubernetes CPU Limits and Go

Updated on September 22, 2025

William Kennedy

News

Developers Aren’t Machines: How Smart Teams Are Transforming Outsourcing

Updated on October 14, 2025

Ardan Labs

YouTube

AI Agents, Tooling, and Limitations with Kenneth Stott

Jul 30, 2025 | Watch Now

Ardan Labs

01 / 03

Learning Formats

Why Learn

Featured Event

Need Help?

Solutions We Provide

Our Specializations

Case Studies

Need Help?

Go, Rust, Docker & K8s Mastery Bundle

What You'll Learn

Requirements

Courses Included in the Bundle

Practical Go Foundations

Course Introduction

Course Outline

Ultimate Go: Language Guide

Course Introduction

Course Outline

Ultimate Go: Software Design with Kubernetes

Course Introduction

Course Outline

Ultimate Go: Advanced Engineering

Course Introduction

Course Outline

Ultimate Debugging

Course Introduction

Course Outline

Writing Secure Go Code

Course Introduction

Course Outline

Ultimate Go: Notebook

About This Book

Ultimate Rust: Crash Course

Course Introduction

What you’ll learn:

Requirements:

Who this course is for:

Course Outline

Ultimate Rust 2: Intermediate Concepts

Course Introduction

What you’ll learn:

Requirements:

Who this course is for:

Course Outline

Ultimate Rust Foundations

Course Introduction

Course Outline

Ultimate Rust: Foundations - Next Steps

Course Introduction

Course Outline

Ultimate Rust Best Practices

Course Introduction

Course Outline

Rust From C/C++

Course Introduction

Course Outline

Rust as a Service

Course Introduction

Course Outline

Intensive Docker

Course Introduction

Course Outline

Intensive Kubernetes

Course Introduction

Course Outline

Intensive Kubernetes: Advanced Concepts

Course Introduction

Course Outline

Introduction to KinD

Course Introduction

Course Outline

Deep Dive Into Kubernetes Networking with CNI

Course Introduction

Course Outline

Managing AWS Resources with Terraform

Course Introduction

Course Outline

Why Engineers & Teams Trust Ardan Labs

Extremely well organized and high value

Best training in the Go community