Google Kubernetes Engine: Basic to Advanced on Google Cloud

Explore the Kubernetes architecture with a master node and worker nodes, learning how the API server, controller manager, etcd, scheduler, kubelet, and kube proxy coordinate pods.

An Nginx example demonstrates how a kubectl request reaches the API server and is coordinated by the controller and scheduler to run Nginx containers as pods.

Create Kubernetes manifests in html or json, apply them through the api server, and manage pods on worker nodes under the master's control across on-prem, vm, or cloud environments.

Learn the Kubernetes control plane master node components: API server, etcd, scheduler, and controller manager, and how the API server handles requests, scales, and stores cluster metadata in etcd.

Understand how the kube scheduler on the master node schedules pod creation and selects the best node for new pods using data from the API server, controller manager, and etcd.

Understand how the controller manager on the master node ensures actual state matches the desired state. It coordinates with the scheduler and distinguishes cloud controller manager from kube controller manager.

Create a free tier account on GCP by signing in with a valid Gmail, providing payment details, and starting with $300 credit to explore Kubernetes engine.

Log into the Google Cloud console, open Kubernetes Engine, and create a GKE cluster in standard or autopilot mode, then select region, zone, cluster name, and control plane settings.

Learn to configure a GKE cluster from basics to advanced settings: regional zones, node pools with default 3 nodes, machine types, disk and image options, networking, autoscaling, and maintenance windows.

Activate cloud shell to access your Google Kubernetes Engine cluster, view its green status in Asia-south-2, Delhi, and verify three nodes with kubectl get nodes before creating pods.

Configure kubectl to inspect a three-node GKE cluster, view node details including IP addresses, version, and image. Practice adjusting terminal preferences and using kubectl options for wide output.

Create your first pod using a yaml file by defining apiVersion, kind, metadata, and a single nginx container. Then verify with kubectl commands and observe node scheduling and image pull.

Learn to deploy an ubuntu pod in Kubernetes by creating a pod spec with a running ubuntu container, executing a bash loop, and inspecting pods with kubectl get and describe.

Create a pod named test pod from a yaml file, list pods with kubectl get pods, and view the C00 container logs with kubectl logs -f.

Learn how to run multiple containers in a single pod using a YAML file, deploy two ubuntu-based containers, and monitor them with kubectl describe, get pods, and logs.

Learn to execute a command on a specific container such as C00 inside a pod with kubectl exec. Note that the pod IP is shared by all containers.

Learn how to get a shell into a running container with kubectl exec -it, open container c00 in test pod one, then access c01 to understand pods and containers.

Create a pod with two containers: ubuntu and nginx alpine, then use kubectl exec to access each container and verify the nginx server by inspecting index.html.

Create a Kubernetes pod with a curl container that pulls curl image from Docker Hub, image pull policy IfNotPresent. Run a command that echoes pod running and sleeps two hours.

Demonstrates image pull policy behavior in Kubernetes by showing containers pulled from local images when present, pod creation timing, and back-off restarting failed containers during test curl.

Learn how Kubernetes annotations store non-identifying metadata to provide context for objects like pods and services, including linking image registries and adding descriptions.

Define environment variables for containers in a pod with two containers using a yaml file and kubectl, then verify with env output in each container.

Explore pod-to-pod communication by creating a web server pod and a test curl pod, then curl the web server’s address on port 80 to verify inter-pod networking.

Explore self-healing in Kubernetes by configuring restart policies to restart containers, including always, on failure, and never, and learn when to apply them and how a liveness probe influences restarts.

Learn how Kubernetes restart policies automatically restart containers in pods when they complete or fail. This lab uses a busybox pod with sleep 10 to illustrate the default always policy.

Explore the on-failure restart policy in Kubernetes, using a YAML pod with BusyBox to demonstrate restarts on errors and no restarts on successful completion.

Understand restart policies by comparing never, on failure, and always in a pod, and see how a never policy prevents container restarts after errors.

Learn how labels attach key-value pairs to pods and how selectors filter them with equality-based and set-based rules, using declarative manifests and kubectl labeling for production, development, and testing.

Practice labeling Kubernetes pods with env and department, and use selectors to filter and view labels with kubectl get pods -l, --show-labels, and create pods with kubectl create -f.

Explore declarative labeling with a pod manifest and imperative labeling by updating a running pod using kubectl label, demonstrated with create -f, get pods, and -L to view labels.

Learn to create pods, view their labels, and search pods by labels using kubectl, including env and class filters, with commands like get pods, show labels, and -l.

Practice using labels to search pods with kubectl, then apply set-based searches such as in and not in to filter by environment and department labels.

Learn how node selectors control pod scheduling in a Kubernetes cluster by tagging nodes with labels and using label selectors to run pods on specific nodes.

Label nodes and use a node selector to ensure pods run on a specific node. Use kubectl, labels, and manifests to troubleshoot placement and resolve pending pods.

Replication controller maintains a specified number of pod replicas, recreating failed pods to keep the app available; it uses a manifest with replicas, template, and selectors to deploy identical pods.

Learn how a replication controller creates and manages two pod replicas using a manifest, a selector, and a template, ensuring pods run on different nodes and are recreated if deleted.

Delete a pod in a replication controller and see how it instantly creates a new pod to maintain the desired replica count, using kubectl to monitor pods and describe RC.

Scale a replication controller in Kubernetes by adding or removing pods as load changes, using kubectl scale replicas to maintain performance.

ReplicaSet maintains a stable set of replica pods to guarantee a specified number of identical pods. It adds set-based selectors, advancing replication control with flexible env-based matching.

Participate in a practice lab to create a replica set that spawns multiple identical pods using a manifest, with selectors and labels, and deploying ubuntu containers via kubectl.

Scale a replica set from four to six pods with kubectl, then down to three; deleting a pod prompts the replica set to create a pod to meet the count.

Explore deployment and rollback in Kubernetes, showing how a deployment manages replicas and creates replica sets, enables versioned updates, and performs rollbacks to previous states.

Upgrade a Kubernetes app from version v1 to v2 with a deployment object, creating new replica sets and pods, and validating changes with kubectl and logs.

Roll back your deployment to the previous version using kubectl rollout undo deployment, verify with kubectl get rs and pods, and check logs to confirm version two.

Learn to roll back a Kubernetes app to a specific version using kubectl rollout history and kubectl rollout undo, review revision history, and verify with pod logs.

Explore Kubernetes networking: pods get an IP address, not individual containers, and containers inside a pod communicate via localhost, shown by ubuntu and apache containers on port 80.

Demonstrate how containers in a pod communicate over localhost by opening a port with netcat and accessing it from another container using telnet.

Explore pod-to-pod communication on the same worker node using pod IP, as two pods (nginx and httpd) exchange data via port 80 and verify with ping and curl.

Learn how a service object provides a stable IP address and DNS name to connect frontend and backend pods, keeping communication intact despite pod IP changes.

Learn how cluster ip enables internal pod communication, deploy nginx with a deployment and replica set on port 80, and use a service object to provide a stable virtual ip.

Expose an nginx pod with a service object using a stable cluster IP, mapping a cluster port to the pod’s target port and routing via selectors, even when pods restart.

Enable external access to your app by configuring a node port that exposes a port on each node, alongside the cluster IP and internal port 8080, plus a firewall rule.

Create a firewall rule to open a tcp port for nodeport access, then verify external access to an nginx web server across worker nodes.

Configure a specific node port for a Kubernetes service by editing deployment and service files, applying with kubectl, then access the web server via the external IP and port.

Explore how the load balancer service distributes incoming traffic evenly across multiple nginx pods to achieve better performance and high availability, demonstrated with a three-pod lab.

Log in to multiple web server pods, verify nginx on each, and observe index.html changes across three pods. Learn to create a service object with a load balancer.

Configure a load balancer with a service object for nginx pods. Route TCP 80 from the external IP to the cluster IP and distribute traffic evenly across three pods.