Intensive Docker & K8s Curriculum

13 Courses

4 Instructors

100+ Hours

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

25 Hrs

Intermediate

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.
Completed at least the majority of the Go Tour.

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:

What is a string?
Unicode basics
Using ftm package for formatted output

Calling REST APIs:

Making HTTP calls with net/http
Defining structs
Serializing JSON

Working with Files:

Handling errors
Using defer to manage resources
Working with io.Reader & io.Writer interfaces

Sorting:

Working with slices
Writing methods
Understanding interfaces

Catching Panics:

The built-in recover function
Named return values

Processing Text:

Reading line by line with bufio.Scanner
Using regular expressions

Distributing Work:

Using goroutines & channels
Using the sync package to coordinate work

Timeouts & Cancellation:

Working with multiple channels using select
Using context for timeouts & cancellations
Standard library support for context

Testing Your Code:

Working with the testing package
Using testify
Managing dependencies with go mod

Structuring Your Code:

Writing sub-packages

Writing an HTTP Server:

Writing handlers
Using gorilla/mux for routing

Adding Metrics & Logging:

Using expvar for metrics
Using the log package and a look at user/zap

Configuration Patterns:

Reading environment variables and a look at external packages
Using the flag package for command line processing

Ultimate Go

The Advanced Ultimate Go class 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

25 Hrs

Intermediate

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 Service with Kubernetes

This course teaches you how to build production-level services in Go leveraging the power of Kubernetes. See the instructor walking through the design philosophies and guidelines for building services in Go.

with Bill Kennedy

25 Hrs

Intermediate

Course Introduction

From the beginning you will pair program with the instructor, walking through the design philosophies and guidelines used to engineer the code. With each new feature, you will learn more about the transition from programming to engineering and the points of refactoring required to write production-level applications.

The class goes beyond just the use of the http package and focuses on building CRUD based services with logging, observability, and debugging. You’ll also learn about POD architectures, Docker and cloud deployment.

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:

1.0 - Intro - (01:00)
1.1 - Design Philosophy, Guidelines, What to Expect - (03:00)
1.2 - Tooling to Install - (05:00)

Modules:

2.0 - Intro - (01:00)
2.1 - Adding Dependencies - (23:00)
2.2 - Module Mirrors - (19:00)
2.3 - Checksum Database - (05:00)
2.4 - Vendoring - (05:00)
2.5 - MVS Algorithm - (18:00)

Kubernetes:

3.0 - Intro - (01:00)
3.1 - Tooling Installation - (05:00)
3.2 - Understanding Clusters, Nodes & Pods - (10:00)
3.3 - Write Basic Service for Testing - (08:00)
3.4 - Zarf Layer - (11:00)
3.4.2 - Kind Configuration - (06:00)
3.4.3 - Core K8s Configuration - (17:00)
3.4.4 - K8s Quotas / Patching - (19:00)

Initial Service Design:

4.0 - Intro - (01:00)
4.1 - Project Layers, Policies, and Guidelines - (18:00)
4.2 - Prepare Project - (19:00)
4.3 - Logging Support - (17:00)
4.4 - Configuration Support - (22:00)
4.5 - Debugging / Metrics Support - (22:00)
4.6 - Shutdown Signaling & Load Shedding - (11:00)

HTTP Routing Basics:

5.0 - Intro - (01:00)
5.1 - Basic Structure of an HTTP Router - (11:00)
5.2 - Add a Readiness, Liveness & Test Handler - (24:00)

Web Framework:

6.0 Intro - (01:00)
6.1 Custom Router - (18:00)
6.2 Custom Handler Function - (13:00)
6.3 Middleware Support - (09:00)
6.4 Sending Responses - (05:00)

Middleware:

7.0 - Intro - (01:00)
7.1 - Logging - (14:00)
7.2 - Request Context - (16:00)
7.3.1 - Understanding what Error Handling Means - (15:00)
7.3.2 - Declaring Custom Error Types - (17:00)
7.3.3 - Consistent Handling & Response - (13:00)
7.4 - Panic Handling - (09:00)
7.5 - Metrics - (18:00)

JSON Web Tokens (JWT):

8.0 - Intro - (01:00)
8.1 - Understanding JWT - (09:00)
8.2 - Private/Public Key Generation - (12:00)
8.3 - Token Generation - (21:00)
8.4 - Token Signature Validation - (07:00)

Authentication / Authorization:

9.0 - Intro - (01:00)
9.1 - Auth Package - (11:00)
9.2 - Implementation of an In-Memory Key Store - (09:00)
9.3 - Middleware - (14:00)
9.4 - Auth Unit Test - (20:00)

Database Support:

10.0 - Intro - (01:00)
10.1 - Kubernetes Support for Postgres - (10:00)
10.2 - Using Sqlx - (01:00)
10.3 - Update Readiness Handler to Perform DB Checks - (06:00)

Database Migrations and Seeding:

11.0 - Intro - (01:00)
11.1 - Maintaining Database Schemas - (16:00)
11.2 - Seeding Data - (05:00)
11.3 - Init Containers - (10:00)

Business Packages:

12.0 - Intro -(01:00)
12.1 - Design Philosophies, Policies, & Guidelines -(12:00)
12.2 - User Data Models & API Precision -(18:00)
12.3 - Data Model Validation -(08:00)
12.4 - User CRUD Data Business Package APIs -(27:00)
12.5 - User Core Business Package APIs -(08:00)

Testing Data Business Packages:

13.0 - Intro - (01:00)
13.1 - Support for Starting and Stopping Containers - (14:00)
13.2 - Support for Starting & Stopping a Unit Test - (11:00)
13.3 - Write User CRUD Data Unit Tests - (12:00)

Rest API:

14.0 - Intro - (01:00)
14.1 - Writing User Web Handlers - (14:00)
14.2 - Support for Starting & Stopping an Integration Test - (04:00)
14.3 - Write Integration Tests for Users - (11:00)

Open Telemetry:

15.0 - Intro -(01:00)
15.1 - Integrate OTEL Web Handler into the Framework -(12:00)
15.2 - Integrate OTEL into Service Startup -(09:00)
15.3 - Add Zipkin into POD -(11:00)
15.4 - Add Tracing Calls Inside Functions to Trace -(08:00)

Review Service Project:

16.0 - Intro - (01:00)
16.1 - Check For Dependency Upgrades - (07:00)
16.2 - Rebuild and Run the Project - (07:00)

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

25 Hrs

Intermediate

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 and Ultimate Go: Web Services 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

Refactoring with Bill

This course features Bill Kennedy working with various projects while emphasizing points of refactoring. Perfect for anyone looking to improve their engineering skills writing programs in Go.

with Bill Kennedy

25 Hrs

Intermediate

Course Introduction

Follow along with the instructor as he builds projects with you on the fly. You’ll get an insight into his thought process and the mental models used to refactor Go applications.

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:

A basic understanding of the Go programming language.
Completed at least the majority of the Go Tour.

Course Outline

Refactoring: Go Violin:

1.0 - Refactoring: Go Violin - (1:32:26)
2.1 - Refactoring: Go Violin - (29:32)
2.2 - Refactoring: Go Violin - (30:50)
2.3 - Refactoring: Go Violin - (22:42)

Refactoring: Twitter API + Dgraph:

1.0 - Refactoring: Twitter API + Dgraph - (40:59)
2.0 - Refactoring: Twitter API + Dgraph - (1:02:37)
3.0 - Refactoring: Twitter API + Dgraph - (1:04:27)
4.0 - Refactoring: Twitter API + Dgraph - (1:12:14)

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

25 Hrs

Intermediate

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)

Ultimate Go: Notebook

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

with Bill Kennedy

View Details

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

Ultimate 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

9 Hrs

Beginner

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

Getting Started:

1.1 - The “Why” of Containers
1.2 - Setting Up Our Environment
1.3 - Running Our First Containers
1.4 - Background Containers

Building Container Images:

2.1 - Images, Layers & Containers Images
2.2 - Building Images Interactively
2.3 - Writing Our First Dockerfile
2.4 - Using CMD & Entrypoint

Optimizing Container Images:

3.1 - Copying Files During The Build
3.2.1 - Exercise: Writing Docker Files
3.2.2 - Solution: Writing Docker Files
3.3 - Reducing Image Sizes
3.4 - Multi-Stage Builds
3.5 - Publishing Images to the Docker Hub
3.6 - Tips for Efficient Docker Files
3.7 - Dockerfile Examples
3.8.1 - Exercise: Writing Better Docker Files
3.8.2 - Solution: Writing Better Docker Files

Managing Containers:

4.1 - Naming & Inspecting Containers
4.2 - Labels
4.3 - Getting Inside A Container
4.4 - Limiting Resource

Container Networking:

5.1 - Container Networking Basics
5.2 - Container Networking Drivers
5.3 - The Container Network Model
5.4 - Service Discovery With Containers
5.5 - Ambasadors

Local Development With Compose:

6.1 - Local Development Workflow With Compose
6.2 - Windows Containers
6.3 - Working With Volumes
6.4 - Compose For Development Stacks
6.5.1 - Exercise: Writing A Compose File
6.5.2 - Solution: Writing A Compose File

Prepairing For Production:

7.1 - Advanced Docker Files
7.2 - Application Configuration
7.3 - Logging

Container Orchestration:

8.1 - Orchestration Overviews

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

8 Hrs

Intermediate

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

Kubernetes Foundations:

1.1 - Running a microservices application in containers
1.2 - Kubernetes concepts
1.3 - First contact with kubectl
1.5 - Pods, Deployments, Batch and Cron jobs
1.6 - Viewing container output from the CLI
1.7 - The Kubernetes network model
1.8 - Exposing containers with Services
1.9 - Deploying the microservices application on Kubernetes

Scaling and Rolling Updates:

2.1 - Deploying with YAML manifests
2.2 - Scaling with Deployments and Replica Sets
2.4 - Load balancing traffic with labels and selectors
2.5 - Dynamic load balancer reconfiguration
2.6 - Rolling updates and upgrades
2.7 - Rolling back invalid deployments
2.8 - The role of healthchecks
2.9 - Liveness, readiness, and startup probes

From Sample Apps to Production Use-Cases:

3.1 - Organizing resources with Namespaces
3.2 - Controlling a Kubernetes cluster remotely
3.3 - Accessing internal services
3.4 - The Kubernetes dashboard
3.5 - Exposing HTTP services with Ingress resources
3.6 - Sharing information between containers with volumes
3.7 - The downward API
3.8 - Exposing configuration files with Config Maps
3.9 - Managing sensitive data with Secrets

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

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

Packaging Applications With Kustomize & Helm:

1.1 - Front Matter
1.2 - Dockercoins, Our Sample Application
1.3.1 - Kustomize
1.3.2 - Kustomize
1.4.1 - Helm
1.4.2 - Helm
1.5.1 - Homework: Creating Better Charts
1.5.2 - Homework: Creating Better Charts
1.6 - Extra content

Capacity Management and Kubernetes Operators:

2.0 - Front Matter
2.1.1 - Container capacity planning
2.2 - Cluster Capacity Planning
2.3.1 - Extending the Kubernetes API
2.3.2 - Extending the Kubernetes API

Security Focuses:

3.0 - Front Matter
3.1.1 - Network Policies Part 1
3.1.2 - Network Policies Part 2
3.1.3 Network Policies Part 3
3.1.4 - Network Policies Part 4
3.1.5 - Network Policies Part 5
3.2.1 - Authentication & Authorization Part 1
3.2.2 - Authentication & Authorization Part 2
3.2.3 - Authentication & Authorization Part 3
3.2.4 - Authentication & Authorization Part 4
3.2.5 - Authentication & Authorization Part 5
3.2.6 - Authentication & Authorization Part 6
3.3.1 - Pod Security Policies Part 1
3.3.2 - Pod Security Policies Part 2
3.3.3 - Pod Security Policies Part 3
3.3.4 - Pod Security Policies Part 4
3.3.5 - Pod Security Policies Part 5
3.3.7 - Pod Security Policies Part 6
3.3.7 - Pod Security Policies Part 7
3.4.1 - Managing User Access Part 1
3.4.2 - Managing User Access Part 2
3.4.3 - Managing User Access Part 3

Application Configuration and Stateful Applications:

4.0 - Front Matter
4.1.1 - Volumes
4.1.2 - Volumes
4.1.3 - Volumes
4.1.4 - Volumes
4.1.5 - Volumes
4.1.6 - Volumes
4.1.7 - Volumes
4.2.1 - Managing configuration
4.2.2 - Managing configuration
4.2.3 - Managing configuration

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

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

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

with Jérôme Petazzoni

1 Hrs

Beginner

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

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

1 Hrs

Beginner

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

About The Bundle

Intensive Docker & K8s Curriculum

Practical Go Foundations

Course Introduction

Course Outline

Ultimate Go

Course Introduction

Course Outline

Ultimate Service with Kubernetes

Course Introduction

Course Outline

Ultimate Go: Advanced Engineering

Course Introduction

Course Outline

Refactoring with Bill

Course Introduction

Course Outline

Writing Secure Go Code

Course Introduction

Course Outline

Ultimate Go: Notebook

About This Book

Ultimate 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