Description
Kubernetes course: from basics to guru. This comprehensive training course will guide you on your journey to becoming a seasoned expert in the world of Kubernetes. Whether you are a beginner or an intermediate student, this course will teach you the basic and advanced concepts of containerization and orchestration step by step.
In this course, you will gain the necessary skills to manage and run software on the Kubernetes platform, configure a Minikube environment, and develop cloud applications. You’ll also learn how to manage security settings, access APIs, configure RBAC, deploy software using YAML files, and implement continuous delivery using GitOps principles. The course is divided into 6 sections and 26 lessons covering the fundamentals of DevOps and GitOps, Kubernetes, advanced Kubernetes services, microservices and GitOps.
What you will learn:
- Running Software on Kubernetes
- Setting up Kubernetes for GitOps
- Using DevOps, GitOps and Pipelines
- Running Kubernetes, Minikube environments, and running software on Kubernetes
- Running software in the cloud
- Creating a Kubernetes cluster
- Kubernetes Network Management
- Cluster node management
- Troubleshooting Kubernetes clusters and software
This course is suitable for people who:
- Have basic knowledge of Kubernetes.
- Developers who want to improve their skills in running and managing software in cloud and container environments.
- Infrastructure and operations (DevOps) professionals looking to expand their knowledge of container orchestration.
Course details
- Publisher: Oreily
- From: Sander van Vugt
- Level of training: from beginner to advanced
- Duration of training: 15 hours 6 minutes
Course headings
- Introduction
- Kubernetes: From Basics to Guru: Introduction
- Module 1: Basics
- Introduction to the module
- Lesson 1: Understanding Cloud Native
- 1.1 Cloud architecture
- 1.2 Cloud native components
- 1.3 Serverless computing
- 1.4 Scalability
- 1.5 Microservices
- 1.6 Cloud computing standards
- 1.7 Role of the CNCF
- 1.8 Job roles in the cloud environment
- Lesson 2: Understanding Containers
- 2.1 What is a container?
- 2.2 Containers are Linux
- 2.3. Understanding why containers make sense when using a microservices approach
- 2.4. Understanding images and containers
- 2.5. Understanding container registries
- 2.6 Docker test drive
- Lesson 2. Laboratory work: Container test drive
- Lesson 2. Laboratory solution: container test drive
- Lesson 3: Running Containers
- 3.1 Container research
- 3.2 Understanding Namespaces and Cgroups
- 3.3 Container runtime
- 3.4 Using container and registry images
- 3.5 Running Docker containers
- 3.6 Creating container images
- 3.7 Implementing container security
- Lesson 4. Managing container images
- 4.1. Understanding Container Images
- 4.2 Creating images using Dockerfile
- 4.3 Creating images using docker commit
- 4.4 Using tags
- 4.5 Creation of private registries
- 4.6 Best practices for using images
- Lesson 4. Lab: Automating image assembly
- Lesson 4. Lab solution: automating image building
- Lesson 5: Creating 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 Storage management in SELinux environment
- Lesson 6 Lab: Setting up persistent storage
- Lesson 6: Lab Solution: Setting Up Persistent Storage
- Module 2: DevOps and GitOps
- Introduction to the module
- Lesson 7: Understanding DevOps and GitOps
- 7.1 Understanding DevOps
- 7.2 Learning GitOps
- 7.3 Kubernetes and GitOps
- 7.4 Deploy everything as code
- 7.5 Core Components of DevOps and GitOps
- 7.6 DevOps environments
- 7.7 Stages of DevOps
- 7.8 Webhooks and operators
- Lesson 8: Using Git
- 8.1 Understanding Git
- 8.2 Git Basics
- 8.3 Using Git Advanced Authentication
- 8.4 Working with branches and merges
- 8.5 Organizing Git repositories for GitOps environments
- Lesson 9: Using Conveyors
- 9.1 What is a conveyor
- 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
- Introduction to the module
- Lesson 10: Understanding Kubernetes and Cloud Computing
- 10.1 Understanding cloud computing
- 10.2 Running applications in the cloud
- 10.3 Why containers make sense in cloud environments
- 10.4. The Rise of Kubernetes
- 10.5 Kubernetes ecosystem
- 10.6 Standardization of cloud computing
- Lesson 11: Installing Kubernetes
- 11.1 Understanding Kubernetes distributions
- 11.2 Using Kubernetes in the cloud, on-premises or on a 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 on Google Cloud
- 11.7 Using Kubernetes on Amazon
- 11.8 Using Kubernetes in Azure
- 11.9 Creating your own local Kubernetes cluster
- Lesson 11 Lab: Creating a Kubernetes Cluster
- Lesson 11. Lab solution: building a Kubernetes cluster
- Lesson 12. Running applications in Kubernetes
- 12.1 Using Kubernetes
- 12.2 Using the Minicube
- 12.3 Kubernetes Resources
- 12.4 Running an application declaratively
- 12.5 Providing access to applications
- Lesson 13: Granting Access to Applications
- 13.1 Understanding Kubernetes networking
- 13.2 Use of services
- 13.3 Explore automatic registration of Kubernetes applications using DNS
- 13.4 Working with input
- 13.5 Using port forwarding to access applications
- Lesson 13 Lab: Presenting Applications
- Lesson 13: Lab Solution: Granting Access to Applications
- Lesson 14: Setting up storage
- 14.1. Understanding Ephemeral Container Storage
- 14.2 Managing module volumes
- 14.3 Separating storage from applications
- 14.4 Creating persistent volumes
- 14.5 Managing persistent volume claims
- 14.6 Configuring modules to use persistent volumes
- Lesson 14 Lab: Providing Storage Access
- Lesson 14: Lab Solution: Granting Storage Access
- Lesson 15: Separating Application-Specific Information
- 15.1 Separating configuration files and variables from applications
- 15.2 Using ConfigMap for Variables
- 15.3 Storing configuration files in ConfigMaps
- 15.4 Use of secrets for confidential information
- 15.5 Using Docker Registry Secrets
- Lesson 15 Lab: Providing Variables through ConfigMaps
- Lesson 15: Lab Solution: Providing Variables via ConfigMaps
- Module 4: Advanced Kubernetes Services
- Introduction to the module
- Lesson 16: Managing Security Settings
- 16.1. Understanding API Access
- 16.2 Security context management
- 16.3 Using ServiceAccounts to configure API access
- 16.4 Configuring Role-Based Access Control (RBAC)
- 16.5 Configuring cluster roles and role bindings
- 16.6 Creating Kubernetes user accounts
- Lesson 16 Lab: Security Management
- Lesson 16 Lab Solution: Security Management
- Lesson 17: Controllers and Operators
- 17.1 User resources
- 17.2 Providing access to operator API
- 17.3 Understanding Controllers and Operators
- 17.4 Creating a custom operator
- Lesson 18: Networking
- 18.1 Managing CNI and network plugins
- 18.2 General information about automatic service registration
- 18.3 Using network policies to control traffic between modules
- 18.4 Configuring network policies to control traffic between namespaces
- Lesson 18 Lab: Using Network Policies
- Lesson 18: Lab Solution: Using NetworkPolicies
- Module 5: Microservices
- Introduction to the module
- Lesson 19: Understanding Microservices
- 19.1 What are microservices?
- 19.2. Microservices and containers: a perfect combination
- 19.3 From monolithic application to microservice
- 19.4 The role of 12-factor applications in microservices
- 19.5 DevOps and microservices
- 19.6 Understanding the objectives of this course
- 19.7 Introduction to the microservice project of the course
- Lesson 20: Building container-based microservices in Kubernetes
- 20.1 Loading Images into Kubernetes
- 20.2 Organization of storage of modules
- 20.3 Using storage providers
- 20.4 Providing flexible options using ConfigMap and secrets
- 20.5 Representing 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. Laboratory work. Implementation of a course project as a full-fledged microservice in Kubernetes.
- Lesson 20. Laboratory solution. Implementation of a course project as a full-fledged microservice in 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 Launching the Bookinfo demo application
- 21.5 Using the toolbar
- Lesson 21 Lab Setting up Istio Service Mesh
- Lesson 21. Laboratory solution. Setting up Istio Service Mesh.
- Lesson 22: Managing Microservices with Istio Service Mesh
- 22.1 Controlling traffic flow with Istio
- 22.2 Using Istio to Inject Errors
- 22.3 Querying metrics using Prometheus and Istio
- 22.4 Visualizing metrics using Grafana and Istio
- 22.5 Using Istio to access external services
- 22.6 Managing a Sample Course Project with Istio
- Lesson 22. Laboratory work. Completing a course project in Istio.
- Lesson 22. Laboratory solution. Completing a course project in Istio.
- Module 6: GitOps
- Introduction to the module
- Lesson 23: Using GitOps to Ensure Application Updates with Zero Downtime
- 23.1 Using rolling update deployment
- 23.2 Applying Blue/Green Deployment Updates
- 23.3 Using Canary Deployments
- 23.4 Service-Based Canary Deployments
- Lesson 24. Starting a GitOps project
- 24.1 Understanding the project
- 24.2 Preparation: Setting up Git
- 24.3 Preparation: Creating a working image
- 24.4 Preparation: Setting up storage
- 24.5 Preparation: Creating YAML Files
- 24.6 Implementing the CI process
- 24.7 Implementing the CD process
- 24.8 Performing a Blue/Green App Update
- Lesson 25. Automatically updating application code
- 25.1 Introduction to CI/CD solutions
- 25.2 Flux setup
- 25.3 Use of flux
- 25.4 Learning OpenShift
- 25.5 Using an OpenShift source for an image
- 25.6 Understanding the Argo CD
- 25.7 Using the Argo CD
- Lesson 26: Implementing Observability
- 26.1. Understanding Observability
- 26.2 Using Kubernetes observability solutions
- 26.3 Using the Metrics Server
- 26.4 Using Prometheus
- 26.5 GitOps Observability
- Summary
- Kubernetes: From Basics to Guru: Summary
Course Prerequisites
- A computer with the latest operating system, at least 4 GB of RAM and 20 GB of free disk space.
- Basic knowledge of Kubernetes is preferred.
- Students without knowledge of Kubernetes are advised to take a look Getting Started with Kubernetes, 3rd Edition Sander van Vugt: https://learning.oreilly.com/videos/getting-started-with/9780138057626/
Kubernetes Images: From Basics to Guru Course
Example video course
installation instructions
Once extracted, watch using your favorite player.
English subtitles
Quality: 720p
Download link
Password for file(s): www.downloadly.ir
size
2.9 GB