What is Kubernetes? What are the core concepts and architecture of Kubernetes?

Answer

Kubernetes (abbreviated as K8s) is an open-source container orchestration platform for automating deployment, scaling, and management of containerized applications. It was originally designed by Google and is now maintained by the Cloud Native Computing Foundation (CNCF).

Core Concepts of Kubernetes

1. Pod

A Pod is the smallest deployable unit in Kubernetes and can contain one or more tightly related containers. Containers within the same Pod share the network namespace and storage volumes.

Characteristics:

• Share network IP and ports
• Share storage volumes
• Communicate through local inter-process communication (IPC)
• Short lifecycle, can be destroyed and recreated at any time

2. Node

A Node is a worker machine in the Kubernetes cluster, which can be a physical machine or a virtual machine. Each Node runs necessary Kubernetes components, including kubelet, kube-proxy, and a container runtime (such as Docker).

Node Components:

• kubelet: Responsible for communicating with the Master node and managing Pod lifecycle
• kube-proxy: Responsible for network proxying and load balancing
• Container Runtime: Responsible for running containers (such as Docker, containerd)

3. Deployment

A Deployment manages the number of Pod replicas and update strategies, ensuring that the specified number of Pod replicas are always running.

Functions:

• Declarative management of Pod replicas
• Rolling updates and rollbacks
• Scaling up and down
• Health checks and self-healing

4. Service

A Service provides a stable network access endpoint for a group of Pods, implementing service discovery and load balancing.

Service Types:

• ClusterIP: Access within the cluster (default)
• NodePort: Access through node ports
• LoadBalancer: Access through cloud provider load balancers
• ExternalName: Map to external DNS names

5. ConfigMap and Secret

• ConfigMap: Store non-sensitive configuration data
• Secret: Store sensitive data (such as passwords, keys)

6. Namespace

Namespaces divide cluster resources into multiple logical groups, implementing resource isolation and multi-tenancy support.

Kubernetes Architecture

Master Node Components

1. API Server

   • Unified entry point for the cluster
   • Handles REST operations
   • Provides authentication, authorization, and admission control

2. etcd

   • Distributed key-value storage
   • Stores all cluster configuration and state information
   • Provides data consistency guarantees

3. Scheduler

   • Responsible for scheduling newly created Pods to appropriate Nodes
   • Considers resource requirements, policy constraints, affinity, etc.

4. Controller Manager

   • Runs various controllers
   • Maintains cluster state
   • Common controllers: Node Controller, Replication Controller, Endpoint Controller

Worker Node Components

1. kubelet

   • Communicates with Master
   • Manages Pod lifecycle
   • Reports node status

2. kube-proxy

   • Maintains network rules
   • Implements Service load balancing

3. Container Runtime

   • Runs containers
   • Pulls images
   • Manages container lifecycle

Common Kubernetes Commands

bash
# View cluster information
kubectl cluster-info

# View nodes
kubectl get nodes

# View all Pods
kubectl get pods --all-namespaces

# View Pods in a specific namespace
kubectl get pods -n <namespace>

# View detailed information
kubectl describe pod <pod-name>

# Create resources
kubectl apply -f deployment.yaml

# Delete resources
kubectl delete -f deployment.yaml

# Scale Deployment
kubectl scale deployment <deployment-name> --replicas=3

# View Services
kubectl get services

# Enter container
kubectl exec -it <pod-name> -- /bin/bash

# View logs
kubectl logs <pod-name>

# View events
kubectl get events --sort-by=.metadata.creationTimestamp

Advantages of Kubernetes

1. Automated Operations: Automatic deployment, scaling, and fault recovery
2. Service Discovery and Load Balancing: Built-in service discovery and load balancing mechanisms
3. Storage Orchestration: Automatically mount storage systems
4. Automatic Rolling Updates and Rollbacks: Zero-downtime deployment
5. Self-healing: Automatically restart failed containers, replace nodes
6. Secret and Configuration Management: Unified management of configurations and sensitive information
7. Horizontal Scaling: Automatically scale applications based on load
8. Resource Utilization: Efficient resource scheduling and utilization

Relationship Between Kubernetes and Docker

• Docker: Container runtime, responsible for creating and running containers
• Kubernetes: Container orchestration platform, responsible for managing multiple Docker containers
• Relationship: Kubernetes can use Docker as a container runtime, and also supports other runtimes (such as containerd, CRI-O)

Kubernetes Best Practices

1. Use Declarative API: Define desired state through YAML files
2. Resource Limits: Set CPU and memory limits for Pods
3. Health Checks: Configure liveness and readiness probes
4. Namespace Isolation: Use Namespaces to isolate different environments
5. Configuration Management: Use ConfigMap and Secret to manage configurations
6. Persistent Storage: Use PersistentVolume and PersistentVolumeClaim
7. Monitoring and Logging: Integrate tools like Prometheus, Grafana, ELK
8. Security Hardening: Use security mechanisms like RBAC, NetworkPolicy

Kubernetes Use Cases

• Microservices Architecture: Manage large numbers of microservices
• Continuous Delivery: Integrate with CI/CD pipelines
• Hybrid Cloud Deployment: Deploy across cloud platforms
• Big Data Processing: Run big data applications like Spark, Hadoop
• Machine Learning: Deploy and manage ML models
• Edge Computing: Run applications on edge nodes

Kubernetes is the de facto standard for cloud-native applications. Through powerful orchestration capabilities, it makes the management of containerized applications simple and efficient, and is one of the core technologies of modern DevOps practices.