Kubernetes Deep Dive: Basics to Real-World Applications

Learn what Kubernetes is, its architecture, core concepts like pods, deployments, services, networking, and storage, and install using cube, ADM, Google Kubernetes Engine, plus run WordPress.

Discover how Kubernetes orchestrates container workloads, automates deployments and updates, and enables self-healing and scalable load balancing across pods and nodes.

Explore Kubernetes architecture, including the master and worker nodes, control plane components like etcd, API server, scheduler, and controller manager, and worker node components such as kubelet and container runtime.

Explore container orchestration as automation that deploys containers across a cluster of nodes, handles lifecycle management, provisioning, and scaling, and presents the cluster as a single deployment target.

Install Kubernetes on Ubuntu, set up Docker, add the Kubernetes apt repository and key, initialize the master, join nodes, deploy a pod network with flannel, and deploy an nginx service.

Install Kubernetes using kubeadm on Ubuntu, configure swap and iptables, install dependencies, set up kubectl, initialize master, join nodes, apply Calico networking, and deploy a sample pod.

Configure Google Kubernetes Engine by creating a Google Cloud project, enabling billing, and assigning IAM roles and a service account. Install Cloud SDK and activate a service account for GKE.

Explore the pod state and lifecycle as the basic unit of a Kubernetes cluster, detailing init containers, main containers, shared volumes, and lifecycle hooks like post-start and prestop.

Explore Kubernetes administration by mastering cloud native concepts, container orchestration, and Kubernetes objects: master, nodes, workloads, services, and config storage, while managing desired state and cluster configuration.

Learn how to access the Kubernetes API, implement authentication and authorization with RBAC, use kubectl and the config file, and manage cluster resources via role bindings and dashboards.

Learn how to package and deploy apps on a multi-node Kubernetes cluster on Ubuntu, including configuring hosts, disabling swap, and installing Docker and Kubernetes repositories.

Learn to install kubeadm, kubectl, kubelet, initialize a Kubernetes master with a pod network, apply Calico CNI, join nodes, and deploy an Apache container as a service.

Explore how Kubernetes creates overlay pod network across nodes with bridges and routing, enabling pod to pod communication, and how services expose deployments via cluster IP, nodeport, and load balancer.

Learn to scale Kubernetes clusters and applications by provisioning resources, managing deployments and pods, and scaling workloads based on CPU, memory, and queue length.

Set up and manage Kubernetes deployments, understand how deployments create replica sets and pods, perform rolling updates, scale, rollback, and track status using kubectl commands.

Set up jobs and cron jobs to reliably run pods to completion, using restart policies never or on failure, while daemonsets ensure pods on nodes with update strategy.

Explore Kubernetes controllers that manage pods to maintain desired states, including replication and deployment, and understand services, volumes, and persistent storage.

Kubernetes offers plugin based persistence volume types like aws ebs and gce persistent disk. A persistent volume claim binds to a volume or remains unbound; storage classes enable dynamic provisioning.

Learn to run WordPress on Kubernetes by creating persistent volume claims and volumes, configuring MySQL and WordPress deployments, and applying a customization.yaml with a secret generator.

Learn to install and manage Kubernetes clusters and deploy applications with rolling updates. Secure, network, and monitor workloads using persistent volumes, RBAC, and monitoring tools.

Install Kubernetes on Ubuntu 18.04 machines (master and two workers), set up Docker, add GPG keys and repositories, install kubelet kubeadm kubectl, configure bridge network, reboot before cluster initialization.

Initialize the Kubernetes cluster with kubeadm init, set the pod network CIDR, disable swap, install the flannel CNI, and verify nodes.

Learn how to add worker nodes to a Kubernetes cluster by generating a join token and running the join command on each node, then verify nodes show ready.

Learn how to cordon and drain worker nodes for maintenance in a Kubernetes cluster, including ignoring daemonsets during drain and removing nodes with kubeadm reset and delete.

Demonstrates testing a new Kubernetes cluster by deploying a sample to-do app, verifying pods and deployment, exposing a node port service, and accessing via port forwarding and a browser.

Learn how to schedule pods on a specific node by labeling nodes and using a node selector in a YAML deployment to target an SSD disk.

Learn how node affinity enables flexible pod scheduling in Kubernetes using required during scheduling and ignore during execution rules, balancing pods across region-labeled and disk-type labeled nodes.

Understand how to set pod resource requests and limits in Kubernetes, including CPU and memory, how requests must fit under limits, and how node selectors and pending scheduling affect deployment.

Learn to deploy applications with Kubernetes using deployments, manage replicas and rolling updates, scale pods, expose services with a node port, and perform rollbacks for zero-downtime production updates.

Learn how to update a Kubernetes deployment using YAML edits and image updates, then roll out, pause for canary testing, and rollback with undo and revision targets.

Learn to pass secrets to Kubernetes deployments by creating a secret, injecting it as environment variables via secretKeyRef, and mounting it as a volume.

Create a storage class, a persistent volume, and a persistent volume claim to store Kubernetes application data using local storage.

Create a persistent volume and a claim, bind them to a deployment, and mount to /app data to show data persists across pod and deployment changes.

Generate certificates for a user to access a Kubernetes cluster, sign certificate request, and configure role-based access control with role, cluster role, and bindings for namespaced and non-namespaced resources.

Connect to the Kubernetes cluster by configuring kubectl with a kubeconfig file, setting the cluster, credentials, and context, and switch contexts to manage a namespace.

Define a read-only role and bind it to a test user in the my app namespace, then create a cluster role binding and verify access to pods and deployments.

Define a cluster role named pb reader cluster and create a cluster role binding to grant test user one access to list persistent volumes. This binding is cluster-wide, not namespace-scoped.

Monitor a Kubernetes cluster and apps with Prometheus and Grafana by applying yaml files in the cluster monitoring namespace, configuring config maps, deployments, services, kube-state-metrics, and node port access.

Set up Grafana for Kubernetes monitoring by deploying Grafana, exposing port 3000, and configuring a Prometheus data source to import a dashboard that visualizes CPU, memory, and network usage.

Master essential Kubernetes troubleshooting commands for control plane and nodes, including kubectl get events, logs, node status, Docker and Kubelet checks, and service endpoints in the app namespace.

Troubleshoot cluster issues by inspecting pods with kubectl get pods and describe, then view logs. Export yaml, edit deployments, and connect to pods with kubectl exec for debugging.

Discover how to build a custom Docker image, push it to Docker Hub, and deploy on Google Kubernetes Engine with kubectl, including deployments, services, replicas, and rolling updates.

Explore kubernetes cluster architecture—from kubectl interface to master components (api server, scheduler, controller manager, etcd) and worker nodes with kubelet, pods, and kube proxy, plus replica sets for scaling.

Explore how Kubernetes services act as load balancers, routing end-user requests to the healthiest pod via a stable IP, ensuring scalability and availability through replicas, rolling updates, and blue-green deployment.

Install and configure Google Cloud SDK, kubectl, and Docker on a CentOS VM to deploy a custom Docker image to a Google Kubernetes Engine cluster.

Install cube CTL from the google cloud repository, install and configure docker community edition, verify docker, complete the google cloud sdk setup, and outline creating a custom docker image.

Create a custom docker image from CentOS 7 and deploy a war file to Tomcat. Learn how to prepare for Kubernetes deployment via a Dockerfile.

Build a custom Docker image by installing Java, deploying the DevOps war to Tomcat, and exposing port 8080. Configure the entry point to launch Tomcat in the CentOS container.

Verify the docker image by running it locally, then upload it to Docker Hub using proper tagging and port forwarding, preparing for deployment to a Kubernetes cluster.