Advanced Kubernetes: Project-Based Job-Ready Training

Define software as a set of programs that solve real problems, used daily from browsers to devices, driving business operations from retail platforms to delivery, support, and security.

Web applications are software accessed via a browser over the internet, delivered with HTML, CSS, and JavaScript. Front end, back end, databases, and cloud infrastructure power these apps.

Microservices build large software from small, decoupled components that communicate over a network. Bounded contexts like order management, inventory, and shipping reduce complexity and enable independent teams.

Explore a sample microservice project with a React front end, a Java backend, and a Python microservice, coordinating via http calls across AWS cloud deployments for project-based Kubernetes training.

Explore how a three-microservice project is stored on GitHub, with a React front end, a Java backend, and a Python backend, and how to clone the repository for local development.

Launch an AWS Ubuntu instance, clone the public code via git, and prepare front end and back end microservice folders on a Linux machine for execution.

Explore the four-step process to deploy software: bundle code, dependencies and UI, build into an executable artifact, and deploy to cloud machines.

explore the build process for multi-application projects, manage direct and transitive dependencies via package.json, pom.xml, and requirements.txt, and automate assembling executables with build tools.

Learn to build a React frontend with npm by installing dependencies from package.json, resolving transitive dependencies, and creating a browser-ready build folder.

Learn to build a Java backend artifact by compiling source, downloading dependencies, and packaging into a jar using Maven install from pom.xml.

Explore storing and distributing artifacts by turning a build server into an artifact repository, compressing the build folder and jar files, and serving them via nginx over http for deployment.

Deploy three isolated cloud machines on AWS for a front-end web server, a Java backend, and a Python backend, downloading jar and build files from storage and ensuring application isolation.

Deploy the python application on an AWS vm by installing Python 3, cloning GitHub, installing dependencies from requirements.txt, and running the program on port 5000.

Install openjdk 11, download jar with wget, and run it with java -jar; set sa logic API to python private ip:5000 so app on 8080 is accessible via public ip.

Deploy the frontend react application on aws vm by configuring nginx as a web server, hosting the build folder, and exposing port 80 through aws security groups.

Explain how the browser calls the Java app on 8080, the Java app calls the Python app on 5000, and how front-end changes and deployment update the send button URL.

Update the front-end send button to the new Java URL, then build, package, store, and deploy the latest build to the front-end server.

Explore best practices for deploying and scaling multi-machine microservice architectures on cloud infrastructure. Learn about load balancing, central data storage, and stateless design for production readiness.

Package an application with its runtime and dependencies into a container image to create isolated environments. Run these containers on a Linux host to enable multiple applications to operate independently.

Explore how container images package applications with all dependencies, store them in a container registry, and deploy across any linux machine for consistent, scalable software delivery.

Install docker on a linux host, pull the nginx image from hub.docker.com, and run it with docker run; monitor with docker ps and logs, then clean up with docker rm.

Explore how containers differ from virtual machines, using a single host operating system and a container runtime to run many apps efficiently, with container images that start automatically.

Containers use the host kernel to run like virtual machines, while including distro binaries; you can log in and run commands with Docker exec to build Ubuntu-like environments from images.

Explore essential Docker commands to manage containers on a Docker host, including run, ps, exec, inspect, pull, images, build, push, and login, with networking and registry basics.

Develop a container image by bundling your app with nginx, placing the build folder in /var/www/html, and setting automatic startup; then commit and share via hub.docker.com.

Build container images with a dockerfile, using caching to speed builds, installing nginx, copying the build folder, setting the startup command, then push a registry with docker login and push.

Build a frontend container image by starting from the official nginx base, copying the build folder into the nginx root, and publishing the final image to a registry like docker.io.

Learn to build a java container image from a Dockerfile, including an OpenJDK base, copying the jar, setting a default command, and configuring an API URL variable.

Build a python container image by using a Dockerfile to install dependencies from the requirements.txt, copy the sf folder, and set the default command.

Log in on the build server and push three images (front end, Java, Python) to Docker Hub using the latest tag. Understand public versus private repositories and collaborator access.

Deploy containers on a docker host by launching Python, Java, and frontend apps on an AWS deployment server, configuring internal and external networking and IPs with docker run.

Deploy the python app on an AWS docker host using docker run to pull the image from Docker Hub; the container uses a private IP (port 5000) for internal communication.

Deploy the java application as a docker container on the host, expose port 8080 with -p, and define sa_api_url to the python container url so the app communicates.

Pull and run the frontend docker image, expose port 80 via Nginx, and connect to the Java backend with a hardcoded Java url, using a four-step build-deploy workflow.

Explore how a deployment server runs multiple containers with nginx frontend and inter-service communication between Java and Python, exposed by port forwarding.

Discover how Kubernetes orchestrates containerized applications across many machines, automating deployment, scaling, load balancing, service discovery, fault tolerance, and monitoring for resilient operations.

Define the desired state of your containerized app in a file and let Kubernetes enforce it across machines with automatic scaling, restarts, and monitoring.

Kubernetes orchestrates containers across machines with an api server centered control plane, scheduling pods and maintaining desired versus actual state through kubelets, controllers, and cloud integration.

Explore how to run Kubernetes across cloud, on premises, or on a laptop, using the API server and kubectl, and prepare for production-scale clusters in Google Cloud.

Learn to create a managed Kubernetes cluster on Google Cloud using GKE, via gcloud CLI or browser console, with a Mumbai region and a Google-managed control plane.

Learn how to connect from your laptop to a GKE cluster, install kubectl, and authenticate with Google IAM using the gcloud auth plugin, then deploy apps with kubectl apply.

Deploy a containerized app to a Kubernetes cluster by creating a YAML manifest, applying it with kubectl, and running pods from a Docker Hub image.

Create a Kubernetes service to expose the front-end pod, use a label selector to route to the container port 80, and apply the YAML to configure cluster networking.

Launch a second nginx container in a GKE cluster and connect to its service on port 80, illustrating Kubernetes service routing across nodes for seamless inter-container communication.

Expose Kubernetes applications to external users by creating a service with type load balancer. Kubernetes provisions a Google Cloud load balancer and a public IP to route traffic via nodeport.

Explore how deployments in Kubernetes act as a controller to maintain three pod replicas, automatically recreating crashed pods or mismatched versions to keep the desired state.

Use a label selector on a service to expose matching ports from a deployment, then load balance across replicas with a public IP.

Deploy three deployments for frontend, Java, and Python, create three services, expose frontend and Java with load balancers, use Python as cluster IP, and rely on service names as DNS.

Discover how Kubernetes services use DNS names for communication, linking Java front end to Python back end via port 80 and 5000, with env var URL in deployment YAML.

Explore how Kubernetes runs containerized apps across clusters, use namespaces for team isolation, and deploy with YAML via kubectl in a local k3d environment.

Explore how a pod in Kubernetes runs one or more containers, with volumes and mounts, and how services expose pods via cluster or public IPs and load balancers.

Define a Kubernetes service to front multiple ports and route traffic to the correct pods. Use YAML to map port and targetPort, enabling internal and external access via load balancers.

Explore how Kubernetes architecture coordinates worker nodes and a control plane, with the API server as the brain managing desired and current state via controllers.

Understand the Kubernetes architecture from the control plane to worker nodes, including API server, scheduler, kubelet, and kube-proxy, and see how namespaces, deployments, pods, and services connect.

Explore how a Kubernetes service is really routing rules on every worker node. Learn how containers such as Java and Python communicate via service names, ports, and optional load balancer.

Explore how Kubernetes services route traffic between containers using cluster IP, node port, and load balancer types, and how cloud versus on‑premise setups affect exposure.

Learn how deployments manage pods and services route traffic in Kubernetes, and implement resource requests and limits, horizontal pod autoscaling, and monitoring for scalable applications.

Explore YAML syntax for Kubernetes resources, defining API version, kind, and metadata, and learn indentation rules, lists with hyphens, and dictionaries to create pods, deployments, and services.

write a kubernetes pod manifest in yaml by following the api reference, defining apiVersion, kind, metadata, namespace, labels, and spec with containers, environment variables, resources, and restart policy.

Troubleshoot Kubernetes by comparing the applied state with the actual state, using reference yaml or customized versions, and inspect pod and deployment status with kubectl -o yaml to ensure reconciliation.

Learn to manage configurations in Kubernetes using configmaps and secrets, injecting environment variables into deployment YAML and keeping code separate from configuration.

Explore how to separate code and configuration with configmaps and secrets in Kubernetes. Mount these configurations as environment variables or as files inside containers, including practical examples and encoding caveats.

Learn to simplify Kubernetes configurations with kustomize by combining base deployment and service yaml with environment-specific customization. Apply with kubectl -k to per-environment namespaces, image tags, and replicas.

Explore Kustomize and customize for managing Kubernetes manifests, including ConfigMaps and secrets, with build and apply workflows. Learn to use common labels, namespace scoping, and image customization across environments.

Learn to manage Kubernetes configurations with ConfigMaps and Secrets, mounting them in containers via volumes or environment variables. Discover how Kustomize simplifies environment-specific YAML and multi-service deployments.

Learn how GKE provides a managed Kubernetes control plane with API server and cloud integration, using node pools, auto scaling, kubectl, and YAML workflows for seamless deployments.

Create a GKE cluster with the gcloud CLI, authenticate, choose a project, and download credentials for kubectl, noting three worker nodes and Google-managed control plane.

Deploy your applications to a GKE cluster by creating a deployment and a service, and switch the service to load balancer to expose a public IP via kubectl.