Modern Container-Based DevOps LiveLessons: Managing Microservices using Kubernetes and Docker

Modern Container-Based DevOps LiveLessons: Managing Microservices using Kubernetes and Docker

English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 6h 34m | 5.82 GB


Modern Container-Based DevOps LiveLessons: Managing Microservices using Kubernetes and Docker is designed to explain containers and Microservices, as well as how to deploy them easily using Kubernetes. This course will guide the user through the procedure of moving to microservices step-by-step, first in theory, and then in practice, with the end-of-lesson Labs.

Modern Container-Based DevOps LiveLessons: Managing Microservices using Kubernetes and Docker focuses on how to run microservices in Docker and Kubernetes by exploring all the vital components in a microservices architecture. After exploring them step-by-step, the end-of-lesson labs throughout the course will put them into practice. By the end of the course, the user will be able to build their own full microservice running on Kubernetes!

The course starts by guiding the user through the concept of microservices, explaining fundamentals and other components in IT that play a vital role in obtaining a microservices architecture. It then digs deeper, including how to use Git, and work with and manage containers using Docker as well as Podman on RHEL 8. The course then covers how to perform daily container management tasks, and works its way through managing container images, storage, and networking. This will give you a solid understanding of the container fundamentals.

The course then discusses implementing microservices with container orchestration platforms and how to work with Kubernetes. In the final lesson, microservices-oriented components that are offered by the Kubernetes platform will be covered, and the course project will be finalized, providing the user with the skills they can immediately apply in their day jobs!

Topics include:

  • Module 1: Microservices Essentials Overview
  • Module 2: Managing Containers
  • Module 3: Implementing Full Microservices with Container Orchestration Platforms

Learn How To

  • Manage a complete container-based datacenter
  • Use containers in Docker and Kubernetes to run microservices
  • Manage containers, using Docker as well as Podman on RHEL 8
  • Manage container images, storage, and networking
  • Implement microservices with container orchestration platforms
  • Work with Kubernetes
  • Build your own full microservice that runs on Kubernetes!

Who Should Take This Course

Modern Container-Based DevOps: Managing Microservices using Kubernetes and Docker aims at IT professionals that want to manage Microservices-based solutions as containers in Kubernetes. Target audience roles:

  • IT Administrators
  • DevOps Engineers
  • Software Developers
  • IT Architects
  • Hybrid Cloud Administrators

Module 1, “Microservices Essentials Overview,” introduces the microservices essentials, including what they are, why Git is so important, and how containers fit into the picture. The last lesson explains everything that’s going on in containers. The labs for this course focus on guiding you through the procedure of moving to microservices step-by-step, which starts in Module 1.

Module 2, “Managing Containers,” explains how to work with containers, including Docker containers and Podman. The lesson covers the common daily container management tasks, including container images, container storage, and container networking.

Module 3, “Implementing Full Microservices with Container Orchestration Platforms,” explores container orchestration platforms, which provide the perfect way of managing microservices in an enterprise environment. In this lesson Kubernetes, the most significant container orchestration platform, is also introduced. The final lesson will have users finalizing their course project and learning how to create container-based microservices in Kubernetes.

+ Table of Contents

1 Modern Container-Based DevOps – Introduction
2 Module Introduction
3 Learning objectives
4 1.1 What are Microservices
5 1.2 Microservices and Containers – A Perfect Match
6 1.3 Breaking up Monolithic Applications
7 1.4 The role of RESTful API in Microservices
8 1.5 The Role of CI_CD in Microservices
9 1.6 DevOps and Microservices
10 1.7 Understanding the Goals of this Course
11 Lesson 1 Lab – Introducing the Course Microservice Project
12 Learning objectives
13 2.1 Using Git in a Microservices Environment
14 2.2 Understanding Git
15 2.3 Using Git Repositories
16 2.4 Working with Branches
17 2.5 Removing Files from Git Repositories
18 Lesson 2 Lab – Setting up a Github Repository
19 Lesson 2 Lab Solution – Setting up a Github Repository
20 Learning objectives
21 3.1 What is a Container
22 3.2 Containers are Linux
23 3.3 Understanding Why Containers Make Sense in a Microservices Approach
24 3.4 Understanding Images and Containers
25 3.5 Understanding Container Registries
26 3.6 Taking a Docker Test-drive
27 Lesson 3 Lab – Taking a Container Test-drive
28 Lesson 3 Lab Solution – Taking a Container Test-drive
29 Learning objectives
30 4.1 Understanding Container Origins
31 4.2 Understanding Container Standardization
32 4.3 Understanding Container Runtimes
33 4.4 Understanding Container Orchestration
34 Lesson 4 Lab – Running LXD Containers
35 Lesson 4 Lab Solution – Running LXD Containers
36 Module Introduction
37 Learning objectives
38 5.1 Setting up Docker on Ubuntu or CentOS
39 5.2 Running a Docker Container
40 5.3 Verifying Container Availability
41 5.4 Investigating Containers on the Host OS
42 Lesson 5 Lab – Creating Stand Alone Docker Containers for the Course Project
43 Lesson 5 Lab Solution – Creating Stand Alone Docker Containers for the Course Project
44 Learning objectives
45 6.1 Understanding RHEL 8 Container Solutions
46 6.2 Managing Access to Registries
47 6.3 Running Containers with Podman
48 6.4 Managing Images with buildah
49 Lesson 6 Lab – Creating Stand Alone Podman Containers for the Course Project
50 Lesson 6 Lab Solution – Creating Stand Alone Podman Containers for the Course Project
51 Learning objectives
52 7.1 Running Containers
53 7.2 Managing Containers Resource Limitations
54 7.3 Inspecting Containers
55 7.4 Managing Running Containers
56 7.5 Connecting Containers
57 Lesson 7 Lab – Managing the Course Project Containers
58 Lesson 7 Lab Solution – Managing the Course Project Containers
59 Learning objectives
60 8.1 Understanding Container Images
61 8.2 Building Images with Dockerfile
62 8.3 Building Images with docker commit
63 8.4 Pushing Images to Registries
64 8.5 Using Tags
65 8.6 Creating Private Registries
66 8.7 Automating Image Builds from Git Repositories
67 Lesson 8 Lab – Automating Course Project Image Build from Git Repositories
68 Lesson 8 Lab Solution – Automating Course Project Image Build from Git Repositories
69 Learning objectives
70 9.1 Understanding Container Storage
71 9.2 Understanding Storage Drivers
72 9.3 Using Bind Mount as Container Storage
73 9.4 Using Volumes for Persistent Storage
74 Lesson 9 Lab – Connecting the Course Project to Storage
75 Lesson 9 Lab Solution – Connecting the Course Project to Storage
76 Learning objectives
77 10.1 Understanding Container Networking
78 10.2 Understanding Bridge Networking
79 10.3 Working with Default Bridge Networking
80 10.4 Creating a Custom Bridge Network
81 10.5 Understanding Microservices Container Networking Needs
82 Lesson 10 Lab – Investigating Course Project Networking
83 Lesson 10 Lab Solution – Investigating Course Project Networking
84 Module Introduction
85 Learning objectives
86 11.1 Understanding Enterprise Container Requirements
87 11.2 Understanding Platform Requirements in a Microservice Architecture
88 11.3 Exploring the Container Orchestration Landscape
89 11.4 Understanding Kubernetes
90 Lesson 11 Lab – Planning for Orchestration in the Course Project
91 Lesson 11 Lab Solution – Planning for Orchestration in the Course Project
92 Learning objectives
93 12.1 Using Kubernetes in Minikube
94 12.2 Using Kubernetes in Google Cloud
95 12.3 Understanding Core Application Components in Kubernetes
96 12.4 Running Containers through Pods and Deployments
97 12.5 Understanding the Philosophy of Decoupling in a Microservices Context
98 12.6 Using the kubectl Utility in Declarative or Imperative Mode
99 12.7 Understanding the Kubernetes API
100 12.8 Troubleshooting Kubernetes Applications
101 Lesson 12 Lab – Running the Course Project in Kubernetes Deployments
102 Lesson 12 Lab Solution – Running the Course Project in Kubernetes Deployments