3.55 out of 5
43 reviews on Udemy

Kubernetes + Docker Complete Course – 2 in 1 Hands On!

Kubernetes - Kubernetes Docker - kubernetes AWS - kubernete cloud - kubernetes using docker - 100% Hands On!
Up Degree
299 students enrolled
English [Auto-generated]
Be able to understand, administer and deploy Kubernetes
Deploy Kubernetes clusters
Get started with Containerization and run containers on Kubernetes
Make applications running on Kubernetes using Load Balancing
Be able to run stateless and stateful applications on Kubernetes
Be able to deploy MySQL,Wordpress Kubernetes

This Kubernetes Docker Complete Course will help you to understand how to run, deploy and maintain your applications on Kubernetes. If you are into DevOps, then this is a technology you need to learn. Kubernetes has gained a lot of popularity lately and it is a well-aimed skill by companies.

The course will show you how to build apps in containers using docker and how to deploy it Kubernetes cluster. On the other hand,this Kubernetes Course will explain you how to set up your Kubernetes cluster on your desktop, or on the cloud using AWS.


What is Kubernetes?

Kubernetes is an open-source container orchestration technology system .Kubernetes is mainly used for automating deployment, scaling and management of containerized applications.

Kubernetes was originally designed by Google and then open sourced.And from then to now Kubernetes is maintained by the Cloud Native Computing Foundation.

Kubernetes  aims to provide a “platform for automating deployment, scaling, and operations of application containers across clusters of hosts It works with a range of container tools, including Docker.

Kubernetes is a portable as well as extensible platform for managing containerized workloads and services, that facilitates both declarative configuration and automation. Kubernetes  has a large, rapidly growing ecosystem. There are widely availablity in Kubernetes services, support, and tools.

Google open-sourced the Kubernetes project in 2014. Kubernetes builds upon a decade and a half of experience that Google has with running production workloads at scale, combined with best-of-breed ideas and practices from the community.

Even though Kubernetes provides a lot of functionality, there are always new scenarios that would benefit from new features. Application-specific workflows can be streamlined to accelerate developer velocity. Ad hoc orchestration that is acceptable initially often requires robust automation at scale. This is why Kubernetes was also designed to serve as a platform for building an ecosystem of components and tools to make it easier to deploy, scale, and manage applications.

Labels in Kubernetes empower users to organize their resources however they please. Annotations enable users to decorate resources with custom information to facilitate their workflows and provide an easy way for management tools to checkpoint state.

The Kubernetes control plane is mainly built upon the same APIs that are available to developers and users. Users can write their own controllers, such as schedulers, with their own APIs that can be targeted by a general-purpose command-line tool.

This design has enabled a number of other systems to build the Kubernetes.

On the other hand Kubernetes is not a traditional or all-inclusive Platform as a Service( PaaS) system. Since Kubernetes operates at the container level rather than at the hardware level, it provides some generally applicable features common to PaaS offerings, such as deployment, scaling, load balancing, logging, and monitoring. However, Kubernetes is not monolithic, and these default solutions are optional and pluggable. Kubernetes provides the building blocks for building developer platforms but preserves user choice and flexibility where it is important.


Here are some advantages of Kubernetes

Firstly Kubernetes does not limit the types of applications supported. Moreover, Kubernetes aims to support an extremely diverse variety of workloads, including stateless and stateful even data-processing workloads. Thatswhy If an application can run in a container, it should run great on Kubernetes.

Kubernetes never  deploy source code and does not build your application. Continuous Integration, Delivery, and Deployment (CI/CD) workflows are determined by organization cultures and preferences as well as technical requirements.

Kubernetes does not provide application-level services, such as middleware (e.g., message buses), data-processing frameworks (for example, Spark), databases like MySQL, caches as built-in services. Such components can run on Kubernetes, and/or can be accessed by applications running on Kubernetes through portable mechanisms, such as the Open Service Broker.

Kubernetes never dictate logging, monitoring, or alerting solutions. It provides some integrations as proof of concept, and mechanisms to collect and export metrics.

Kubernetes does not also provide nor mandate a configuration language/system (e.g., jsonnet). It provides a declarative API that may be targeted by arbitrary forms of declarative specifications.

Kubernetes never provide nor adopt any comprehensive machine configuration, maintenance, management, or self-healing systems.

Though Kubernetes is not a mere orchestration system. In fact,kubernetes eliminates the need for orchestration. In contrast, Kubernetes is comprised of a set of independent, composable control processes.Kubernetes also drive the current state continuously towards the provided desired state.


What is Kubernetes for ?

Kubernetes is an open source system for managing containerized applications across multiple hosts, providing basic mechanisms for deployment, maintenance, and scaling of applications.In short, Kubernetes is a container orchestration tool from Google.

How Does Kubernetes work?

Kubernetes can mainly defines as a set of building blocks.Kubernetes collectively provides mechanisms that deploy, maintain and scale applications. Kubernetes is loosely coupled and extensible to meet different workloads. This extensibility is provided in large part by the Kubernetes API, which is used by internal components as well as extensions and containers that run on Kubernetes

There are some key components which are widely used is Kuberntes are

  • Pods

  • Labels and selectors

  • Controllers

  • Services

What is the pod in Kubernetes

A Kubernetes pod is a group of containers. Pods can be deployed together on the same host. If you frequently deploy single containers, you can generally replace the word “pod” with “container” and accurately understand the concept.

Pods operate at one level higher than individual containers because it’s very common to have a group of containers work together to produce an artifact or process a set of work.

For example, consider this pair of containers: a caching server and a cache “warmer”. You could build these two functions into a single container, but now they can each be tailored to the specific task and shared between different projects.


What is labels and selectors in Kubernetes?

Labels and selectors are the primary grouping mechanism in Kubernetes and determine the components an operation applies to.

Labels are key-value pairs that are attached to Kubernetes objects, such as Pods. They are intended to be used to specify object attributes which are meaningful and relevant to users, while not directly impacting implying semantics of the core system.

Unlike names and UIDs, labels in Kubernetes do not provide uniqueness. In general, we expect many objects to carry the same label(s).

 Via a label selector, the client/user can identify a set of objects. The label selector is the core grouping primitive in Kubernetes.

The API currently supports two types of selectors: equality-based and set-based. A label selector can be made of multiple requirements which are comma-separated. In the case of multiple requirements, all must be satisfied so the comma separator acts as a logical AND (&&) operator.

What is Controllers  in Kubernetes?

A controller is a reconciliation loop that drives actual cluster state toward the desired cluster state. It does this by managing a set of pods. One kind of controller is a replication controller, which handles replication and scaling by running a specified number of copies of a pod across the cluster. It also handles creating replacement pods if the underlying node fails. Other controllers that are part of the core Kubernetes system include a “DaemonSet Controller” for running exactly one pod on every machine or some subset of machines and a “Job Controller” for running pods that run to completion, as part of a batch job. The set of pods that a controller manages is determined by Kubernetes label selectors that are part of the controller’s definition.

What is Services in Kubernetes?

A Kubernetes service is a set of pods which can work together, such as one tier of a multi-tier application. The set of pods that constitute a service are defined by a label selector.Kubernetes provides service discovery and request routing by assigning a stable IP address and DNS name to the service, and load balances traffic in a round-robin manner to network connections of that IP address among the pods matching the selector even as failures cause the pods to move from machine to machine.By default, a service is exposed inside a cluster but a service can also be exposed outside a kubernetes cluster.

Why you should start learning Kubernetes?

When our clients ask us to create a highly available distributed system, we usually recommend Kubernetes, because Kubernetes is really easy to use and even though it has a steep initial learning curve and kubernetes still a lot more simple than other competing orchestration engines.

Kubernetes also works perfectly with Node apps because it’s based on Docker.Thatswhy  you can run any kind of application using Kubernetes.

As we all know kubernetes is a open source project spun out of Google which  automates the process of deploying and managing multi-container applications at scale. While Kubernetes works mainly with Docker, it can also work with any container system that conforms to the Open Container Initiative (OCI) standards for container image formats and runtimes.

And because Kubernetes is open source, with relatively few restrictions on how it can be used, it can be used freely by anyone who wants to run containers, most anywhere they want to run them.

Kubernetes introduces new abstractions and concepts, and the learning curve for Kubernetes is high so it is only normal to ask what the long-term payoffs are for using Kubernetes. Here’s a rundown of some of the specific ways running apps inside Kubernetes becomes easier.

Kubernetes manages app health, replication, load balancing, and hardware resource allocation for you. One of the most basic duties Kubernetes takes off your hands is the busywork of keeping an application up, running, and responsive to user demands. Apps that become “unhealthy,” or don’t conform to the definition of health you describe for them, can be automatically healed using kubernetes.

Another benefit of Kubernetes is that it maximizes the use of hardware resources including memory, storage I/O, and network bandwidth. Applications can have soft and hard limits set on their resource usage. Many apps that use minimal resources can be packed together on the same hardware; apps that need to stretch out can be placed on systems. And again, rolling out updates across a cluster, or rolling back if updates break, can be automated.

Kubernetes Helm charts ease the deployment of preconfigured applications. Package managers such as Debian Linux’s APT and Python’s Pip save users the trouble of manually installing and configuring an application. This is especially handy when an application has multiple external dependencies.

Helm is something like a package manager for Kubernetes. Many popular software applications must run as multiple, ganged-together containers in Kubernetes. Helm provides a definition mechanism, a “chart,” that describes how a given piece of software can be run as a group of containers inside Kubernetes.

Kubernetes simplifies management of storage, secrets, and other application-related resources. Containers are meant to be immutable; whatever you put into them isn’t supposed to change. But applications need state so it means they need a reliable way to deal with external storage volumes. That’s made all the more complicated by the way containers live, die, and are reborn across the lifetime of an app.

Kubernetes always allow containers and apps to deal with storage in the same decoupled way as other resources. Many common kinds of storage, from Amazon EBS volumes to plain old NFS shares, can be accessed via Kubernetes storage drivers, called volumes. Normally, volumes are bound to a specific pod, but a volume subtype called a “Persistent Volume” can be used for data which needs to live on independently of any pod in Kubernetes.

Sometimes these containers need to work with “secrets” which is nothing but credentials like API keys or service passwords that you don’t want hardwired in a container or stashed openly on a disk volume. While third-party solutions are available for this, like Docker secrets and HashiCorp Vault,

In that case, Kubernetes uses its own mechanism of handling secrets. For instance, Etcd must be configured to use SSL/TLS when sending information including secrets between nodes, rather than in plaintext.

Kubernetes apps can run in hybrid and multi-cloud environments. One of the long-standing dreams of cloud computing is to be able to run any app in any cloud or any mix of clouds public or private.

Kubernetes’s architecture makes use of various concepts and abstractions. Some of these are variations on existing, familiar notions, but others are specific to Kubernetes.

The highest-level Kubernetes abstraction, the cluster, refers to the group of machines running Kubernetes (itself a clustered application) and the containers managed by it. A Kubernetes cluster must have a master, the system that commands and controls all the other Kubernetes machines in the cluster. A highly available Kubernetes cluster replicates the master’s facilities across multiple machines. But only one master at a time runs the job scheduler and controller-manager.

Each cluster contains Kubernetes nodes. This Kubernetes nodes might be physical machines or VMs. Again, the idea is abstraction: whatever the app is running on, Kubernetes handles deployment on that substrate. It is also possible to ensure that certain containers run only on VMs or only on bare metal.

Nodes run pods, the most basic Kubernetes objects that can be created or managed. Each pod represents a single instance of an application or running process in Kubernetes and consists of one or more containers. On the other hand Kubernetes starts, stops, and replicates all containers in a pod as a group. Pods keep the user’s attention on the application, rather than on the containers themselves.

Pods are created and destroyed on nodes as needed to conform to the desired state specified by the user in the pod definition. Kubernetes provides an abstraction called a controller for dealing with the logistics of how pods are spun up, rolled out, and spun down.

Controllers come in a few different flavors depending on the kind of application being managed. For instance, the recently introduced “StatefulSet” controller is used to deal with applications that need persistent state. Another kind of controller, the deployment, is used to scale an app up or down, update an app to a new version, or roll back an app to a known-good version if there’s a problem.

Because pods in Kubernetes  live and die as needed, we need a different abstraction for dealing with the application lifecycle. An application is supposed to be a persistent entity, even when the pods running the containers that comprise the application aren’t themselves persistent.

To that end, Kubernetes provides an abstraction called a service.

A service describes how a given group of pods or other Kubernetes objects can be accessed via the network. As the Kubernetes documentation puts it, the pods that constitute the back end of an application might change, but the front end shouldn’t have to know about that or track it. Services make this possible.

A few more pieces internal to Kubernetes round out the picture. The scheduler parcels out workloads to nodes so that they’re balanced across resources and so that deployments meet the requirements of the application definitions. The controller manager ensures the state of the system—applications, workloads, etc.—matches the desired state defined in Etcd’s configuration settings.

How much does a Kubernetes Engineer can make per annum?

The salaries of kubernetes engineers are also very attractive.

Software Engineer– $76K to $152K

Senior Software Engineer – $103K to $166K

Development Operations (DevOps) Engineer – $84K to $154K

Site Reliability Engineer (SRE) – $69K to $164K

Sr. Software Engineer / Developer / Programmer – $92K to $157K

Software Development Engineer – $104K to $118K

Software Architect – $95K to $154K


Career Opportunities in Kubernetes and Companies using Kubernetes :

In Kubernetes there are no. of jobs worldwide and the companies which are hiring Kubernetes experts some are listed below

  • Red Hat

  • Oracle

  • Google

  • Microsoft

  • Samsung SDS

  • IBM

  • ING

  • Huawei

  • Naic

  • Monjo

  • Philips

  • Pinterest

  • SAP

  • Soundcloud

  • Yahoo

  • Wink

  • Sling

  • OpenAI

  • The New York Time

  • Mirantis

  • Centurylink

  • Apprenda

  • GitHub

  • Weaveworks

  • Asana

  • Buffer

  • CircleCi

  • Evernote

  • Harvest

  • Intel

  • InVisionApp

  • Shopify

  • Starbucks

  • Digital Ocean

  • Capscale

  • Adform

  • Amadeus

  • Ancestry

  • Box

  • BlackRock

  • Comcast

  • eBay and many more

  • 30-day money-back guarantee!

Now again coming to this course,So this Kubernetes course is ideal for beginners to experts to container technology or those who are new to Kubernetes engineering or who want to enrich their knowledge in Kubernetes much more.

This course includes the following chapters:

  • Course Introduction and Overview

  • What is Kubernetes?

  • Why Kubernetes?

  • Up and Running: Basics

  • Cluster Architecture

  • Core Objects and Primitives

The introduction lectures that show you the Kubernetes desktop installation are free to preview, so you can already put a glance over it before buying the course!

So what are you waiting for? Enroll in the course and get started with Kubernetes today!

You will get 30-day money-back guarantee from Udemy for this course.

If not satisfied simply ask for a refund within 30 days. You will get full refund. No questions whatsoever asked.

Are you ready to take your DevOps skills and career to the next level, take this course now!

You will go from zero to Kubernetes hero in few hours.


Introduction to Kubernetes
Introduction to Kubernetes 2
Why Kubernets are important and What the companies are using Kubernets
Why Kubernets are important,What the companies are using Kubernets Study Note
Why Kubernets are important_part2
A short detail about instructor profile
Introduction to Docker
Introduction to Docker Study Note
Containers vs. Virtual Machines
Containers vs. Virtual Machines Study Notes
Docker Architecture
Docker Architecture Study Note
The Docker Hub
The Docker Hub Part 2
Docker Hub Study Note
Kubernetes Architecture Advanced_part 1
Kubernetes Architecture Advanced_part 2
Kubernetes Architecture Advanced Study Note
Kubernetes Terminology
Kubernetes Terminology Study Note
Introduction to YAML

Kubernetes Setup and Configuration:

what is pod
kubeadm and kubectl
Preparing a cluster of vagrant VMs_1
Preparing a cluster of vagrant VMs_revised_part2
Packages and Dependencies
Install and Configure Master Controller
Install and Configure the Minions
Kubectl: Exploring our Environment
kubernetes in the cloud

Docker Fundamentals

Docker Fundamentals
Docker Image Registry
Demo Creating Docker Image
Demo Pushing Docker Image
Pulling an Image
Running Containers
Managing Ports with Container Deployments
Docker Installation and Image Setup
Docker Installation and Image Setup part 2
Creating Custom Image from a Dockerfile

Pods, Tags and Services

Google Kubernetes Engine - Overview and Account setup
Creating a cluster on GKE
Connecting to GKE cluster via command line
GKE allocatable resources
Object Management in Kubernetes
Namespace in Kubernetes
Namespace in Kubernetes Part 2
Create and Deploy application on Kubernetes Engine
Expose application to the Internet
scale in and scale out deployment
Creating pod using configuation file
Labels in Kubernets
Labels and Selectors
Tags and Image policy
Deployment in kubernetes

Managing Storage in Kubernetes

Volume in Kubernetes
Lifecycle of a volume and claim
Application Deployment using Dynamic Persistent Storage
Application Deployment using Dynamic Persistent Storage _1
Application Deployment using Dynamic Persistent Storage _2
Application Deployment using Dynamic Persistent Storage _3
Application Deployment using Dynamic Persistent Storage _4

Bonus Section

Now What Next?
You can view and review the lecture materials indefinitely, like an on-demand channel.
Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don't have an internet connection, some instructors also let their students download course lectures. That's up to the instructor though, so make sure you get on their good side!
3.6 out of 5
43 Ratings

Detailed Rating

Stars 5
Stars 4
Stars 3
Stars 2
Stars 1
30-Day Money-Back Guarantee


7 hours on-demand video
8 articles
Full lifetime access
Access on mobile and TV
Certificate of Completion