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

Video description

p>8+ Hours of Video Instruction

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

About the Instructor

Sander van Vugt has been teaching Linux classes since 1995 and has written more than 60 books about different Linux-related topics, including the best-selling RHCSA-RHCE 7 Cert Guide. Sander is also the author of more than 25 video courses, including the CKAD and CKA Complete Video Courses. He teaches courses for customers around the world, and is also a regular speaker on major conferences related to open source software. Sander is also the founder of the Living Open Source Foundation, a non-profit organization that teaches open source to talent in different African countries.

Skill Level

  • Intermediate/Advanced

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

Course Requirements

  • Basic understanding of Linux

Lesson Descriptions

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.

About Pearson Video Training

Pearson publishes expert-led video tutorials covering a wide selection of technology topics designed to teach you the skills you need to succeed. These professional and personal technology videos feature world-leading author instructors published by your trusted technology brands: Addison-Wesley, Cisco Press, Pearson IT Certification, Sams, and Que. Topics include IT Certification, Network Security, Cisco Technology, Programming, Web Development, Mobile Development, and more.

Learn more about Pearson Video training at http://www.informit.com/video.

Table of contents

  1. Introduction
    1. Modern Container-Based DevOps: Introduction
  2. Module 1: Microservices Essentials Overview
    1. Module Introduction
  3. Lesson 1: Understanding Microservices
    1. Learning objectives
    2. 1.1 What are Microservices?
    3. 1.2 Microservices and Containers: A Perfect Match
    4. 1.3 Breaking up Monolithic Applications
    5. 1.4 The role of RESTful API in Microservices
    6. 1.5 The Role of CI/CD in Microservices
    7. 1.6 DevOps and Microservices
    8. 1.7 Understanding the Goals of this Course
    9. Lesson 1 Lab: Introducing the Course Microservice Project
  4. Lesson 2: Using Git
    1. Learning objectives
    2. 2.1 Using Git in a Microservices Environment
    3. 2.2 Understanding Git
    4. 2.3 Using Git Repositories
    5. 2.4 Working with Branches
    6. 2.5 Removing Files from Git Repositories
    7. Lesson 2 Lab: Setting up a Github Repository
    8. Lesson 2 Lab Solution: Setting up a Github Repository
  5. Lesson 3: Understanding Containers
    1. Learning objectives
    2. 3.1 What is a Container?
    3. 3.2 Containers are Linux
    4. 3.3 Understanding Why Containers Make Sense in a Microservices Approach
    5. 3.4 Understanding Images and Containers
    6. 3.5 Understanding Container Registries
    7. 3.6 Taking a Docker Test-drive
    8. Lesson 3 Lab: Taking a Container Test-drive
    9. Lesson 3 Lab Solution: Taking a Container Test-drive
  6. Lesson 4: Exploring the Container Landscape
    1. Learning objectives
    2. 4.1 Understanding Container Origins
    3. 4.2 Understanding Container Standardization
    4. 4.3 Understanding Container Runtimes
    5. 4.4 Understanding Container Orchestration
    6. Lesson 4 Lab: Running LXD Containers
    7. Lesson 4 Lab Solution: Running LXD Containers
  7. Module 2: Managing Containers
    1. Module Introduction
  8. Lesson 5: Getting Started with Docker
    1. Learning objectives
    2. 5.1 Setting up Docker on Ubuntu or CentOS
    3. 5.2 Running a Docker Container
    4. 5.3 Verifying Container Availability
    5. 5.4 Investigating Containers on the Host OS
    6. Lesson 5 Lab: Creating Stand Alone Docker Containers for the Course Project
    7. Lesson 5 Lab Solution: Creating Stand Alone Docker Containers for the Course Project
  9. Lesson 6: Using Containers on RHEL 8
    1. Learning objectives
    2. 6.1 Understanding RHEL 8 Container Solutions
    3. 6.2 Managing Access to Registries
    4. 6.3 Running Containers with Podman
    5. 6.4 Managing Images with buildah
    6. Lesson 6 Lab: Creating Stand Alone Podman Containers for the Course Project
    7. Lesson 6 Lab Solution: Creating Stand Alone Podman Containers for the Course Project
  10. Lesson 7: Performing Daily Container Management
    1. Learning objectives
    2. 7.1 Running Containers
    3. 7.2 Managing Containers Resource Limitations
    4. 7.3 Inspecting Containers
    5. 7.4 Managing Running Containers
    6. 7.5 Connecting Containers
    7. Lesson 7 Lab: Managing the Course Project Containers
    8. Lesson 7 Lab Solution: Managing the Course Project Containers
  11. Lesson 8: Managing Container Images
    1. Learning objectives
    2. 8.1 Understanding Container Images
    3. 8.2 Building Images with Dockerfile
    4. 8.3 Building Images with docker commit
    5. 8.4 Pushing Images to Registries
    6. 8.5 Using Tags
    7. 8.6 Creating Private Registries
    8. 8.7 Automating Image Builds from Git Repositories
    9. Lesson 8 Lab: Automating Course Project Image Build from Git Repositories
    10. Lesson 8 Lab Solution: Automating Course Project Image Build from Git Repositories
  12. Lesson 9: Managing Container Storage
    1. Learning objectives
    2. 9.1 Understanding Container Storage
    3. 9.2 Understanding Storage Drivers
    4. 9.3 Using Bind Mount as Container Storage
    5. 9.4 Using Volumes for Persistent Storage
    6. Lesson 9 Lab: Connecting the Course Project to Storage
    7. Lesson 9 Lab Solution: Connecting the Course Project to Storage
  13. Lesson 10: Managing Container Networking
    1. Learning objectives
    2. 10.1 Understanding Container Networking
    3. 10.2 Understanding Bridge Networking
    4. 10.3 Working with Default Bridge Networking
    5. 10.4 Creating a Custom Bridge Network
    6. 10.5 Understanding Microservices Container Networking Needs
    7. Lesson 10 Lab: Investigating Course Project Networking
    8. Lesson 10 Lab Solution: Investigating Course Project Networking
  14. Module 3: Implementing Full Microservices with Container Orchestration Platforms
    1. Module Introduction
  15. Lesson 11: The Role of Container Orchestration
    1. Learning objectives
    2. 11.1 Understanding Enterprise Container Requirements
    3. 11.2 Understanding Platform Requirements in a Microservice Architecture
    4. 11.3 Exploring the Container Orchestration Landscape
    5. 11.4 Understanding Kubernetes
    6. Lesson 11 Lab: Planning for Orchestration in the Course Project
    7. Lesson 11 Lab Solution: Planning for Orchestration in the Course Project
  16. Lesson 12: Understanding Kubernetes
    1. Learning objectives
    2. 12.1 Using Kubernetes in Minikube
    3. 12.2 Using Kubernetes in Google Cloud
    4. 12.3 Understanding Core Application Components in Kubernetes
    5. 12.4 Running Containers through Pods and Deployments
    6. 12.5 Understanding the Philosophy of Decoupling in a Microservices Context
    7. 12.6 Using the kubectl Utility in Declarative or Imperative Mode
    8. 12.7 Understanding the Kubernetes API
    9. 12.8 Troubleshooting Kubernetes Applications
    10. Lesson 12 Lab: Running the Course Project in Kubernetes Deployments
    11. Lesson 12 Lab Solution: Running the Course Project in Kubernetes Deployments
  17. Lesson 13: Creating Container-based Microservices in Kubernetes
    1. Learning objectives
    2. 13.1 Feeding Images into Kubernetes
    3. 13.2 Organizing Pod Storage
    4. 13.3 Using Storage Provisioners
    5. 13.4 Providing Flexible Parameters Using ConfigMaps and Secrets
    6. 13.5 Exposing Applications Using Service Objects
    7. 13.6 Providing Fixed DNS URLs Using Ingress
    8. 13.7 Using Kustomize.yaml
    9. 13.8 Understanding Istio Service Mesh
    10. 13.9 Taking the Istio Testdrive
    11. Lesson 13 Lab: Implementing the Course Project as a Full Microservice on Kubernetes
    12. Lesson 13 Lab Solution: Implementing the Course Project as a Full Microservice on Kubernetes
  18. Summary
    1. Modern Container-Based DevOps: Summary

Product information

  • Title: Modern Container-Based DevOps: Managing Microservices using Kubernetes and Docker
  • Author(s): Sander van Vugt
  • Release date: February 2021
  • Publisher(s): Addison-Wesley Professional
  • ISBN: 013687097X