[New] Kubernetes for Java Developers: Hands‑On Fundamentals

a pod in Kubernetes is a wrapper around one or more containers with its own IP, enabling ephemeral ports and shared storage for co-located containers like a sidecar.

Learn how Kubernetes deployment manages pods, scales to handle traffic, performs rolling updates, supports rollback, self-heals, and monitors rollout status to keep your microservice app available.

Explore how the service object exposes pods as a cluster-internal entry point, acts as a load balancer routing traffic to available ports, and enables optional session affinity for predictable traffic.

Learn how Kubernetes services route traffic to pods via selectors and endpoint lists, and how readiness probes ensure traffic reaches only healthy pods.

Explore ClusterIP, NodePort, LoadBalancer, and ExternalName service types in Kubernetes, and learn how each type controls internal and external access for your applications.

Learn to run Kubernetes locally using Docker Desktop or Minikube, with single-node and multi-node cluster options, and understand Docker, kube admin, and kind integration.

Download Docker Desktop to enable Kubernetes on your computer and ensure Docker is installed for Java developers. Open Docker Desktop and continue to the next lesson.

Learn to create a Kubernetes cluster in Docker Desktop using kind, choose single-node or multi-node configurations, and inspect clusters via the dashboard showing deployments, pods, nodes, and services.

Deploy a Spring Boot users microservice to a Kubernetes cluster, with REST endpoints for create user, login, and get current user details, secured by stateless JSON web token authentication.

Discover how a multi-stage Dockerfile builds a smaller image by downloading dependencies, packaging the app into an executable jar, and running it with a smaller Java runtime.

Publish your local Docker image to Docker Hub by creating a new repository, choosing public access, and enabling pulling from remote servers and Kubernetes clusters.

Tag your docker image, log in if needed, and push it to Docker Hub; pull and run it on any docker-enabled server, with Kubernetes on AWS or Google Cloud.

Compare imperative and declarative approaches to Kubernetes object management, using direct commands for rapid learning and YAML manifests with kube apply for production and version control.

Learn to create a Kubernetes deployment using the imperative approach with kubectl, specify a Docker Hub image, expose port 8082, and scale to three replicas with a rolling update.

Expose your deployment with a service to enable external access, choosing cluster IP, Nodeport, or load balancer, and map port 8082 to the target port 8082.

Post to the service's /users endpoint with a JSON payload via the load balancer port to verify the dockerized app handles unique emails.

Update the Spring Boot version and redeploy by building and pushing a new Docker image using a multi-stage Dockerfile, then update the Kubernetes deployment with kubectl set image.

Learn to view deployment history and record change reasons with kubectl rollout history and kubectl annotate using kubernetes.io/change-cause. See rolling updates replace pods with a new Docker image without downtime.

Update kubernetes deployment environment variables with an imperative kubectl set env command, switching spring profiles active to test and setting log level to debug, triggering a rolling update and verification.

Describe and remove an environment variable in a Kubernetes deployment using kubectl set environment, then annotate the rollout for history and prepare to undo if the new pods fail.

Learn to rollback a Kubernetes deployment by inspecting rollout history, identifying the correct revision, and using kubectl rollout undo to revert to a stable version, then verify the rollout status.

Scale Kubernetes deployments by adjusting replica counts with kubectl, increasing from one to five replicas as traffic grows, and ensuring pods stay available with external data storage.

View logs across all pods created by a deployment with kubectl, and follow new entries in real time using -f, including all containers or a specific one.

Create a new pod for the users microservice by adding a YAML file in a Kubernetes project, using IntelliJ or another IDE.

Define a Kubernetes pod in yaml using api version v1, with metadata labels, and a container running Spring Boot app from Docker Hub image, exposing port 8082 for java developers.

Control when Kubernetes pulls docker images by applying image pull policy, choosing always, if not present, or never, and understand latest versus specific version behavior for development and production.

Validate the pod manifest by running kubectl apply --dry-run=server on users-pod.yaml to simulate creation, catch errors, and ensure the image pull policy uses valid values before creating a pod.

Create and manage pods using kubectl and a pod manifest yaml; monitor pod status, view details and events, and delete pods when finished.

Create a deployment manifest for a spring boot app by adding a YAML file named Users deployment.yaml in the kubernetes folder, and set API version and kind deployment.

Add metadata to the deployment manifest by setting a name and optional key-value labels to identify, group, and filter deployments, and to scale by label.

The deployment spec defines the pod template and containers, including the Docker image and port 8082, with environment variables; Kubernetes uses labels and a replica set to manage pods.

Learn how a deployment selector uses labels to match pods and manage ports, enabling accurate scaling and rolling updates; ensure the pod template labels align with the selector.

Learn how to configure replica counts in a Kubernetes deployment manifest to run multiple pod copies, ensuring high availability and automatic replacement on failure, with scaling up and down.

Apply a deployment manifest with kubectl to deploy yaml files, create pods and a replica set, and verify deployments, pods, and deployment details in a Kubernetes cluster.

Scale your stateless rest API by increasing the deployment replicas to create more pods, using kubectl apply -f and kubectl get pods to verify; note that node-level scaling is separate.

Update a Kubernetes deployment by building and pushing a new Docker image after updating the Spring Boot version in pom.xml, then apply the new image tag from the deployment manifest.

Update a Kubernetes deployment to run a new Spring Boot Docker image, change the tag from 1.0.0 to 1.0.1, and add annotations for change history with a rolling update.

learn how to roll back a kubectl deployment to a previous working version after a buggy release, by inspecting revision history and undoing to a chosen revision.

Create a Kubernetes service manifest by defining API version, kind, and metadata with a name and labels, and use labels to filter services and plan ports.

Learn how to update a Kubernetes service manifest by adding a specification with a selector and ports, using labels to connect to deployment ports and configure port mappings.

Expose a deployment with a Kubernetes service to provide a stable cluster IP, enabling internal access and routing traffic to the deployment's ports.

Launch a temporary BusyBox container with kubectl run port-test to test in-cluster access, then use wget to hit the users service's /users endpoint and verify authentication.

Learn how to expose a Kubernetes service externally by using node port, including the 30000–32767 range and port forwarding, and compare with load balancer options for docker setups.

Switch from nodeport to a load balancer service, configure external access, and verify the external address or localhost on Docker Desktop.

Explore how Kubernetes ConfigMaps store non-confidential configuration as key-value pairs to externalize settings, enable environment-specific values, and allow updates without rebuilding the Docker image.

Learn to create a Kubernetes ConfigMap manifest, populate it with application properties as string key-value pairs, apply it to the cluster, and verify its contents.

Learn to wire a ConfigMap to a deployment so pods receive environment variables at startup, using envFrom and a ConfigMap ref to enable externalized configuration for Spring Boot.

Learn to inspect a Kubernetes pod, convert ConfigMap values into environment variables inside the Docker container, and verify the Spring Boot profile by checking logs with kubectl exec.

Update the configmap to switch spring profiles active from test to default, apply the change with kubectl, and restart pods so new containers read the updated configuration.

Store sensitive data as Kubernetes secrets instead of hard-coding or embedding in images, choose a secret type (opaque, tls, docker registry), and inject at runtime as files or env vars.

Create a Kubernetes secret to store sensitive data, using base64 encoded values, and learn how to reference it in deployments for pod environment variables.

Apply the users MySQL secret YAML to the Kubernetes cluster, verify with get and describe, then reapply the configmap and update the deployment to load credentials from the secret.

Connect secret to deployment by loading database credentials from a secret into the env section alongside the configmap, triggering a rolling update and exposing spring data source vars.

Learn to mount secrets as files in a Kubernetes container, using a db secrets volume and a mount path to replace environment variables with decoded secret data.

Apply the deployment to mount secrets as files inside the container. Enter the running pod and inspect /opt/secrets/db to verify username and password are decoded.

Discover how a Spring Boot app reads secrets mounted by Kubernetes via config tree, mapping files under /opt/secrets/db to properties, and verify access through deployment and logs.