Docker and Kubernetes Bootcamp


Kubernetes is an open-source orchestration system for automating management, placement, scaling and routing of containers. It provides an API to control how and where the containers would run. Docker is also an open-source container-file format for automating the deployment of applications as portable, self-sufficient containers that can run in the cloud or on-premises. Together, Kubernetes and Docker have become hugely popular among developers, especially in the DevOps world.

Both Docker and Kubernetes are huge open-source technologies, largely written in the Go programming language, that use human-readable YAML files to specify application stacks and their deployment.

Cognixia brings to you a unique bootcamp covering basic to advanced-level concepts of Docker and Kubernetes. The bootcamp offers an engaging and immersive learning experience for participants where they can take advantage of connecting with an industry expert trainer, develop their competencies to meet industry and organizational standards, as well as learn about real-world best practices.

Schedule Classes

United States
FRI-SAT (5 Weeks)
10:30 PM - 01:30 AM
Looking for more sessions of this class?

What You'll learn

The course will help participants understand:

  • Fundamentals of Docker
  • Fundamentals of Kubernetes
  • Running Kubernetes instances on Minikube
  • Creating and working with Kubernetes clusters
  • Working with resources
  • Creating and modifying workloads
  • Working with Kubernetes API and key metadata
  • Working with specialized workloads
  • Scaling deployments and application security
  • Understanding the container ecosystem


  • Docker introduction
  • Docker architecture
  • Docker installation on Red Hat and Ubuntu OS
  • Working with images (Docker Hub, Docker Registry)
  • Working with containers
  • Container networking
  • Working with volumes and persistent data
  • Managing container apps using Docker Swarm
  • Overview of Docker Enterprise tool
  • Using Kubernetes without installation
  • Installing the Kubernetes CLI, kubectl
  • Installing Minikube to run a local Kubernetes instance
  • Using Minikube locally for development
  • Starting your first application on Minikube
  • Accessing the dashboard in Minikube
  • Installing kubeadm to create a Kubernetes cluster
  • Bootstrapping a Kubernetes cluster using kubeadm
  • Downloading a Kubernetes release from Github
  • Downloading client and server binaries
  • Using a hyperkube Image to run a Kubernetes master node with Docker
  • Writing a systemd unit file to run Kubernetes components
  • Creating a Kubernetes Cluster on Google Kubernetes Engine (GKE)
  • Creating a Kubernetes Cluster on Azure Container Service (ACS)
  • Listing resources
  • Deleting resources
  • Watching resource changes with kubectl
  • Editing resources with kubectl
  • Asking kubectl to explain resources and fields
  • Creating a deployment using kubectl run
  • Creating objects from file manifests
  • Writing a pod manifest from scratch
  • Launching a deployment using a manifest
  • Updating a deployment
  • Creating a service to expose your application
  • Verifying the DNS entry of a service
  • Changing the type of a service
  • Deploying an ingress controller on Minikube
  • Making services accessible from outside the cluster
  • Discovering the API endpoints of the Kubernetes API server
  • Understanding the structure of a Kubernetes manifest
  • Creating namespaces to avoid name collisions
  • Setting quotas within a namespace
  • Labeling an object
  • Using labels for queries
  • Annotating a resource within one command
  • Running a batch job
  • Running a task on a schedule within a pod
  • Running infrastructure daemons per node
  • Managing stateful and leader/follower apps
  • Influencing pods’ startup behavior
  • Exchanging data between containers via a local volume
  • Passing an API access key to a pod using secrets
  • Providing configuration data to an application
  • Using a persistent volume with Minikube
  • Understanding data persistency on Minikube
  • Dynamically provisioning persistent storage on GKE
  • Scaling a deployment
  • Automatically resizing a cluster in GKE
  • Automatically resizing a cluster in AWS
  • Using horizontal pod autoscaling on GKE
  • Providing a unique identity for an application
  • Listening and viewing access control information
  • Controlling access to resources
  • Securing pods
  • Accessing the logs of a container
  • Recover from a broken state with a liveness probe
  • Controlling traffic flow to a pod using a readiness probe
  • Adding liveness and readiness probes to your deployments
  • Enabling Heapster on Minkube to monitor resources
  • Using Prometheus on Minikube
  • Sing Elastic Search-Fluentd-Kibana (EFK) on Minikube
  • Enabling autocomplete for kubectl
  • Removing a pod from a service
  • Accessing a ClusterIP service outside the cluster
  • Understanding and parsing resource statuses
  • Debugging pods
  • Getting a detailed snapshot of the cluster state
  • Adding Kubernetes worker nodes
  • Draining Kubernetes nodes for maintenance
  • Managing etcd
  • Compiling from source
  • Compiling a specific component
  • Using a Python client to interact with the Kubernetes API
  • Extending the APU using Custom Resource Definitions (CRD)
  • Installing Helm, the Kubernetes package manager
  • Sing Helm to install applications
  • Creating your own chart to package your applications with Helm
  • Converting your Docker compose files to Kubernetes manifests
  • Creating a Kubernetes cluster with Kubicorn
  • Storing encrypted secrets in version control
  • Deploying functions with kubeless


  • Basic command knowledge of Linux
  • Basic understanding of DevOps
  • Basic knowledge of YAML programming language (beneficial, not mandatory)

Reach out to us for more information

Interested in this course? Let’s connect!

  • This field is for validation purposes and should be left unchanged.

Course features

Course Duration
Course Duration

32 hours of live, online, instructor-led training

24x7 Support
24x7 Support

Technical & query support round the clock

Lifetime LMS Access
Lifetime LMS Access

Access all the materials on LMS anytime, anywhere

Price Match Gurantee
Price match Gurantee

Guranteed best price aligning with quality of deliverables


This course is best suited for current and aspiring:

  • DevOps developers
  • DevOps engineers
  • Java developers
  • C#/.Net developers
  • Software engineers
  • Backend developers
  • IoT architects
  • QA engineers

Our trainers are subject matter experts in the field of Dockers and Kubernetes. They are have many years of experience in the industry and highly accomplished training professionals.

An internet speed of at least 2 Mbps is essential.

When you enroll for this course, you get lifetime access to our Learning Management System (LMS) which would be your one-stop destination to access class recordings, presentations, sample codes, projects and lots of other learning material. Even if you miss a session, a recording of that session, as well as all the other sessions would be available on the LMS that you can access anytime, anywhere.

For any queries, you can reach out to our technical support team and they will guide you accordingly.

Yes. Once the course is completed, you need to appear for an objective question-based assessment conducted by Cognixia. Based on your performance on different parameters such as attendance in the sessions, assessment scores, etc. you will be awarded a certificate by Cognixia.