Description

Price: 10.00 USD | Size: 3.20 GB |  Duration : 15+ Hours  | 188 Video session | Bonus : Kubernetes PDF Guides 

BRAND: Expert TRAINING | ENGLISH | INSTANT DOWNLOAD | ⭐️⭐️⭐️⭐️⭐️ 4.9

Kubernetes: From Basics to Guru (Video Course)

15+ Hours of Video Instruction

Go from basic to guru in the Kubernetes world!

Overview:

Kubernetes: From Basics to Guru is your one-stop course to mastering the Kubernetes world. The course is a comprehensive guide to learn fundamentals through advanced concepts in a carefully curated course. You will master container orchestration, Kubernetes deployments, and unlock the full potential of cloud-native applications.

Learn to run applications in Kubernetes and create a minikube and cloud native environment. You will learn how to manage security settings, understand API access, setup RBAC, deploy applications using YAML manifests and demonstrate continuous delivery using GitOps principles.

The course is divided into 26 lessons categorized under 6 modules. The modules are Fundamentals, DevOps and GitOps, Kubernetes, Advanced Kubernetes Services, Microservices and Gitops.

This master course includes lessons from:

• Building and Managing Microservices with Kubernetes and Istio
• Automating Kubernetes with GitOps
• Getting Started with Containers
• Kubernetes and Cloud Native Associate (KCNA) Complete Video Course
• Certified Kubernetes Administrator (CKA) Complete Video Course, 3rd Edition
• Getting Started with Kubernetes

Skill Level:

• Beginner to Intermediate

Learn How To:

• Run Applications in Kubernetes
• Setup Kubernetes for GitOps
• Use DevOps, GitOps, and pipelines
• Run Kubernetes, Minikube environment, and run applications in Kubernetes
• Run applications in a cloud native environment
• Create a Kubernetes cluster
• Manage Kubernetes Networking
• Manage Cluster Nodes
• Troubleshoot Kubernetes Clusters and Applications

Course requirement:

• A computer with a recent operating system and at least 4GB RAM and 20GB available disk space
• Basic knowledge of Kubernetes is recommended.
• Students without Kubernetes knowledge are recommended to watch Getting Started with 

Who Should Take This Course:

• Developers that need to learn how to write efficient and well-structured Rust applications
• People with prior OOO language experience

Table of contents

Introduction
Kubernetes: From Basics to Guru: Introduction
Module 1: Fundamentals
Module Introduction
Lesson 1: Understanding Cloud Native
1.1 Cloud Native Architecture
1.2 Cloud Native Components
1.3 Serverless Computing
1.4 Scalability
1.5 Microservices
1.6 Standards in Cloud Native Computing
1.7 The Role of the CNCF
1.8 Job Roles in a Cloud Native Environment
Lesson 2: Understanding Containers
2.1 What is a Container?
2.2 Containers are Linux
2.3 Understanding Why Containers Make Sense in a Microservices Approach
2.4 Understanding Images and Containers
2.5 Understanding Container Registries
2.6 Taking a Docker Test-drive
Lesson 2 Lab: Taking a Container Test-drive
Lesson 2 Lab Solution: Taking a Container Test-drive
Lesson 3: Running Containers
3.1 Exploring Containers
3.2 Understanding Namespaces and Cgroups
3.3 Container Runtimes
3.4 Using Container Images and Registries
3.5 Running Docker Containers
3.6 Building Container Images
3.7 Implementing Container Security
Lesson 4: Managing Container Images
4.1 Understanding Container Images
4.2 Building Images with Dockerfile
4.3 Building Images with docker commit
4.4 Using Tags
4.5 Creating Private Registries
4.6 Image Use Best Practices
Lesson 4 Lab: Automating Image Builds
Lesson 4 Lab Solution: Automating Image Builds
Lesson 5: Building Container Images
5.1 Understanding Image Formats
5.2 Using Dockerfile
5.3 Creating a GitOps Container Image
5.4 Using Webhooks to Automate Container Image Updates
Lesson 6: Managing Container Storage
6.1 Understanding Container Storage
6.2 Understanding Storage Drivers
6.3 Using Bind Mount as Container Storage
6.4 Using Volumes for Persistent Storage
6.5 Using NFS for Persistent Storage
6.6 Managing Storage in an SELinux Environment
Lesson 6 Lab: Configuring Persistent Storage
Lesson 6 Lab Solution: Configuring Persistent Storage
Module 2: DevOps and GitOps
Module Introduction
Lesson 7: Understanding DevOps and GitOps
7.1 Understanding DevOps
7.2 Exploring GitOps
7.3 Kubernetes and GitOps
7.4 Deploying Everything as Code
7.5 Devops and GitOps Core Components
7.6 DevOps Environments
7.7 DevOps Stages
7.8 Webhooks and Operators
Lesson 8: Using Git
8.1 Understanding Git
8.2 Git Fundamentals
8.3 Using Git Advanced Authentication
8.4 Working with Branches and Merges
8.5 Organizing Git Repositories for GitOps Environments
Lesson 9: Using Pipelines
9.1 What is a Pipeline
9.2 Creating Pipelines for DevOps
9.3 Creating Pipelines for GitOps
9.4 Integrating DevOps and GitOps Pipelines
9.5 Getting Started with Jenkins
9.6 Exploring Pipelines in Jenkins
Module 3: Kubernetes
Module Introduction
Lesson 10: Understanding Kubernetes and Cloud Native Computing
10.1 Understanding Cloud Computing
10.2 Running Applications in Cloud
10.3 Why Containers Make Sense in Cloud Environments
10.4 The Rise of Kubernetes
10.5 The Kubernetes Ecosystem
10.6 Standardization in Cloud Native Computing
Lesson 11: Installing Kubernetes
11.1 Understanding Kubernetes Distributions
11.2 Using Kubernetes in Cloud, on Premise, or on your Laptop
11.3 Using Minikube on Linux
11.4 Using Minikube on Windows
11.5 Using Minikube on MacOS
11.6 Getting Started with Kubernetes in Google Cloud
11.7 Using Kubernetes in Amazon
11.8 Using Kubernetes in Azure
11.9 Building Your Own On-Premise Kubernetes Cluster
Lesson 11 Lab: Building a Kubernetes Cluster
Lesson 11 Lab Solution: Building a Kubernetes Cluster
Lesson 12: Running Applications in Kubernetes
12.1 Using Kubernetes
12.2 Using Minikube
12.3 Kubernetes Resources
12.4 Running Applicaiton the Declarative Way
12.5 Providing Access to Applications
Lesson 13: Providing Access to Applications
13.1 Understanding Kubernetes Networking
13.2 Using Services
13.3 Exploring Kubernetes Application Auto-registration with DNS
13.4 Working with Ingress
13.5 Using Port Forwarding to Access Applications
Lesson 13 Lab: Exposing Applications
Lesson 13 Lab Solution: Exposing Applications
Lesson 14: Configuring Storage
14.1 Understanding Ephemeral Container Storage
14.2 Managing Pod Volumes
14.3 Decoupling Storage from the Applications
14.4 Creating Persistent Volumes
14.5 Managing Persistent Volume Claims
14.6 Setting up Pods to Use Persistent Volumes
Lesson 14 Lab: Providing Access to Storage
Lesson 14 Lab Solution: Providing Access to Storage
Lesson 15: Decoupling Application-Specific Information
15.1 Decoupling Configuration Files and Variables from Applications
15.2 Using ConfigMaps for Variables
15.3 Storing Configuration Files in ConfigMaps
15.4 Using Secrets for Sensitive Information
15.5 Using Docker-registry Secrets
Lesson 15 Lab: Providing Variables through ConfigMaps
Lesson 15 Lab Solution: Providing Variables through ConfigMaps
Module 4: Advanced Kubernetes Services
Module Introduction
Lesson 16: Managing Security Settings
16.1 Understanding API Access
16.2 Managing SecurityContext
16.3 Using ServiceAccounts to Configure API Access
16.4 Setting Up Role Based Access Control (RBAC)
16.5 Configuring Cluster Roles and RoleBindings
16.6 Creating Kubernetes User Accounts
Lesson 16 Lab: Managing Security
Lesson 16 Lab Solution: Managing Security
Lesson 17: Controllers and Operators
17.1 Custom Resources
17.2 Providing Operator API Access
17.3 Understanding Controllers and Operators
17.4 Creating a Custom Operator
Lesson 18: Networking
18.1 Managing the CNI and Network Plugins
18.2 Understanding Service Auto Registration
18.3 Using Network Policies to Manage Traffic Between Pods
18.4 Configuring Network Policies to Manage Traffic Between Namespaces
Lesson 18 Lab: Using NetworkPolicies
Lesson 18 Lab Solution: Using NetworkPolicies
Module 5: Microservices
Module Introduction
Lesson 19: Understanding Microservices
19.1 What are Microservices?
19.2 Microservices and Containers: A Perfect Match
19.3 From Monolithic Application to Microservice
19.4 The Role of 12-Factor Apps in Microservices
19.5 DevOps and Microservices
19.6 Understanding the Goals of this Course
19.7 Introducing the Course Microservice Project
Lesson 20: Creating Container-based Microservices in Kubernetes
20.1 Feeding Images into Kubernetes
20.2 Organizing Pod Storage
20.3 Using Storage Provisioners
20.4 Providing Flexible Parameters Using ConfigMaps and Secrets
20.5 Exposing Applications Using Service Objects
20.6 Providing Fixed DNS URLs Using Ingress
20.7 Using Kustomize.yaml
20.8 Using Canary Deployments in Kubernetes
Lesson 20 Lab Implementing the Course Project as a Full Microservice on Kubernetes
Lesson 20 Lab Solution Implementing the Course Project as a Full Microservice on Kubernetes
Lesson 21: Getting Started with Istio Service Mesh
21.1 Understanding What a Service Mesh is Used for
21.2 Understanding Istio
21.3 Setting up Istio
21.4 Running the Bookinfo Demo Application
21.5 Using the Dashboard
Lesson 21 Lab Setting up Istio Service Mesh
Lesson 21 Lab Solution Setting up Istio Service Mesh
Lesson 22: Managing Microservices with Istio Service Mesh
22.1 Managing Traffic Flow with Istio
22.2 Using Istio for Fault Injection
22.3 Querying Metrics with Prometheus and Istio
22.4 Visualizing Metrics with Grafana and Istio
22.5 Using Istio to Access External Services
22.6 Managing the Course Sample Project with Istio
Lesson 22 Lab Running the Course Project in Istio
Lesson 22 Lab Solution Running the Course Project in Istio
Module 6: GitOps
Module Introduction
Lesson 23: Using GitOps to Provide Zero-downtime Application Updates
23.1 Using Deployment Rolling Updates
23.2 Applying Blue/Green Deployment Updates
23.3 Using Canary Deployments
23.4 Service-based Canary Deployments
Lesson 24: Running a GitOps Project
24.1 Understanding the Project
24.2 Preparation: Setting up Git
24.3 Preparation: Creating a Worker Image
24.4 Preparation: Setting up Storage
24.5 Preparation: Creating the YAML Files
24.6 Implamenting the CI Process
24.7 Implamenting the CD Process
24.8 Performing the Blue/Green Application Update
Lesson 25: Automatically Updating Code to Applications
25.1 Introducing CI/CD Solutions
25.2 Setting up Flux
25.3 Using Flux
25.4 Exploring OpenShift
25.5 Using OpenShift Source to Image
25.6 Understanding Argo CD
25.7 Using Argo CD
Lesson 26: Implementing Observability
26.1 Understanding Observability
26.2 Using Kubernetes Observability Solutions
26.3 Using Metrics Server
26.4 Using Prometheus
26.5 GitOps Observability
Summary
Kubernetes: From Basics to Guru: Summary