พื้นฐานการจัดการคลัสเตอร์ด้วย Kubernetes

Welcome to Kubernetes basics! Kubernetes (often called K8s) is an open-source system for automating deployment, scaling, and management of containerized applications.

Think of it as an operating system for your cloud. It helps you run your applications reliably, even when traffic spikes or servers fail.

For Spring Boot applications, Kubernetes offers huge advantages:

• Automated Scaling: Easily scale your app up or down based on demand.
• Self-Healing: K8s restarts failed containers and replaces unresponsive ones.
• Service Discovery: Helps your microservices find each other.
• Load Balancing: Distributes network traffic to ensure stability.

A Kubernetes cluster consists of at least one Control Plane (formerly Master) and one or more Nodes (Worker Machines).

• Control Plane: The "brain" of K8s. It manages the cluster, schedules applications, and maintains the desired state.
• Nodes: Where your applications (containers) actually run. Each node has components like a container runtime (e.g., Docker) and a Kubelet agent.

A Pod is the smallest, most basic deployable unit in Kubernetes. It represents a single instance of a running process in your cluster.

A Pod typically contains one or more tightly coupled containers (like your Spring Boot app and a sidecar logging agent). All containers in a Pod share the same network namespace and storage.

While Pods are fundamental, you don't usually create them directly. Instead, you use a Deployment.

A Deployment manages a set of identical Pods. It ensures you always have a specified number of Pod replicas running, handles rolling updates, and allows easy scaling of your application.

How do users or other applications access your Pods? With a Service!

A Service defines a logical set of Pods and a policy by which to access them. It provides a stable IP address and DNS name, even if the underlying Pods change or scale. Services can also act as load balancers.

You interact with your Kubernetes cluster using the kubectl command-line tool.

It allows you to run commands against Kubernetes clusters, like deploying applications, inspecting cluster resources, and viewing logs. It's your primary interface to K8s.

Let's define a simple Deployment for a 'hello-world' type application using YAML. This tells Kubernetes to run 2 replicas of our image.

Save this as hello-deployment.yaml:

Now, let's apply this definition to our Kubernetes cluster using kubectl. After applying, we can check the status of our Pods.

Our Pods are running, but not accessible externally. Let's create a Service to expose our hello-app Deployment. This will create a load balancer to route traffic.

Save this as hello-service.yaml and apply it:

Which of the following Kubernetes components is responsible for managing a set of identical Pods, handling scaling, and rolling updates?

Great job! In this lesson, you learned the fundamental concepts of Kubernetes:

• What K8s is and why it's useful.
• The core architecture: Control Plane and Nodes.
• Key resources: Pods, Deployments, and Services.
• How to use kubectl to deploy and manage a basic application.

Next, you'll explore advanced topics like distributed tracing and resilience patterns!