Develop & Deploy Java Springboot App on Kubernetes Cluster

Explore how Docker containerization streamlines building, testing, and deploying Java Spring Boot apps across development, test, acceptance, and production environments, solving dependency and environment mismatches.

Explore how docker, an open source platform, builds, deploys, and manages containerised applications. It bundles dependencies, runtime, and configuration into portable containers that run identically across environments.

Explore how Docker delivers consistency and isolated environments for deployments across Windows, Linux, macOS, with modular bundles for Java Springboot, Node.js, and Python enabling automation, testing, rollback, and scalability.

Learn to write a Dockerfile, build a Docker image, push to a registry, and run containers that isolate and scale a Spring Boot app while enabling inter-container communication.

Compare traditional application deployment with virtualization, highlighting hypervisor-based virtual machines and resource utilization inefficiencies, and set the stage for Kubernetes.

Explore how Docker containers decouple apps from the host operating system, using Docker images to run scalable, self-contained units. Learn about container deployment challenges, health monitoring, security, and inter-container communication.

Explore how Kubernetes acts as a container orchestration tool to manage hundreds and thousands of containers, enabling auto scaling, high availability, monitoring, and secure deployments.

Discover how Kubernetes forms a cluster by linking physical or virtual machines into master and worker nodes, where the master issues commands that workers execute.

Explore the Kubernetes architecture by distinguishing master and worker nodes, and learn how namespaces isolate resources within a cluster, enabling secure deployment of multiple applications.

Explore how a Kubernetes cluster uses worker nodes and kubelet agents to deploy docker containers from images, orchestrated by the master node for scalable, reliable applications.

The API server is the frontend of the Kubernetes control plane, receiving instructions from developers and routing them to the master and worker nodes, accessible via UI, APIs, or CLI.

Explain how the controller manager coordinates node, application, replication, endpoint, and service account and token controllers to maintain nodes and endpoints and issue API tokens for new namespace.

Discover how the master node's scheduler allocates board placements by evaluating node capacity, selecting a suitable worker node, and deploying new boards via the API server.

Explore how the etcd key-value store maintains the Kubernetes cluster state with high availability and consistency, using redundancy across master nodes to keep the cluster operational.

Explore the Kubernetes internal virtual network that enables communication between cluster components, including the master node and worker nodes, ensuring the cluster operates effectively.

Explore how ports are the smallest deployable unit with containers inside, and how a service provides a DNS name and static IP, balancing load across ports despite dynamic IP changes.

Replica sets provide an abstraction on top of parts, guaranteeing a minimum number of identical parts are always running and coordinating with the replication controller.

Explore how a deployment bundles apps and databases into a YAML/JSON for deployment on a Kubernetes cluster, and how kubectl and Helm Chart Manager simplify upgrades, rollbacks, and auto scale.

Explore running Kubernetes clusters with minikube for local testing and opt for production-ready cloud services like AKS, EKS, and GKE, which provision master and worker nodes with pay-as-you-go pricing.

Explore the four Kubernetes service types: clusterIP for internal access, nodePort for static ports on node IPs, load balancer for production traffic, and externalName for domain mapping.

Launch a local single-node Kubernetes with minikube by installing Docker Desktop, downloading minikube, and using kubectl to interact with the cluster on Windows.

Install minikube with the installer, add it to the environment variable, and start the cluster using the Docker driver after confirming Docker desktop is running.

Verify a minikube single-node cluster by checking status with minikube and kubectl, confirming the control plane and node are running.

Generate a Spring Boot project from Spring Initializer, import it into IntelliJ, include Lombok and Java 11, and prepare a jar for deployment on a Kubernetes cluster.

Import and open an extracted springboard project in IntelliJ, wait for indexing and dependencies to download, then plan to create a hello world endpoint for Kubernetes deployment.

Create a hello world controller in a spring boot app with a RestController and request mapping, run the app, and verify the endpoint returns a Kubernetes welcome message on localhost.

Create a dockerfile for our springboot app by using OpenJDK 11, exposing port 8080, copying the built jar into the container, and setting the entrypoint to run the app.

Learn to configure Minikube to access local Docker images, build a Docker image from a Dockerfile, and verify the image is accessible to the Kubernetes cluster.

Create a deployment in a Kubernetes cluster using YAML or CLI, then access deployment details, replicas, and pod logs to verify the containerized app runs on port 8080.

Expose a deployment by creating a NodePort service, compare cluster IP access, and use Minikube service plus the Kubernetes dashboard to monitor the app and resources.

Locate the service node port (30069), connect through minikube to the cluster, and access the springboot app's API endpoints to display its welcome output.

Describe how a Kubernetes deployment uses YAML to declare the desired state, manage replicas, and select pods with labels via a template, then deploy with kubectl apply.

Define a service object with YAML to expose a deployment on a Kubernetes cluster. Link the service to the deployment via a selector and ports to enable external access.

Create deployment and service yaml files for a spring boot app on kubernetes. Apply the deployment and service, then use get deployment and get service to review.