Introduction to Kubernetes: The Fundamentals

What Is Kubernetes?

Kubernetes (K8s) is an open-source platform designed to automate the deployment, scaling, and operation of containerized applications. Originally developed by Google, it is now maintained by the Cloud Native Computing Foundation (CNCF).

Kubernetes automatically manages Docker containers (or other container runtimes) by grouping them into logical units to make them easier to manage and discover. It offers a declarative approach for defining the desired state of your infrastructure.

Why Kubernetes?

Key Benefits

1. Automation: Deploy and update applications with no service interruption.
2. Scalability: Automatically adjust the number of containers based on load.
3. High availability: Distribute containers across multiple nodes to avoid single points of failure.
4. Portability: Run your applications the same way across different environments (development, testing, production).
5. Cost savings: Optimize resource utilization and reduce infrastructure costs.

Use Cases

• Microservices applications
• Cloud-native applications
• Complex deployments
• Multi-cloud environments
• Applications that require high availability

Kubernetes Architecture

Kubernetes follows a client-server architecture with the following components:

Control Plane Components

1. API Server: The entry point for all commands and communications.
2. etcd: A distributed database that stores all configuration data.
3. Scheduler: Determines which nodes should run which pods.
4. Controller Manager: Manages the various controllers that regulate the state of the cluster.
5. Cloud Controller Manager: Integrates with cloud services (load balancers, volumes, etc.).

Node Components

1. Kubelet: An agent that runs on each node and handles communication with the control plane.
2. Container Runtime: The software that runs containers (Docker, containerd, CRI-O).
3. Kube-proxy: Manages network rules and connections.
4. Pods: The smallest deployable unit in Kubernetes, containing one or more containers.

Core Concepts

Pods

A pod is the smallest deployable unit in Kubernetes. It can contain one or more containers that share:

• A network namespace
• An IPC namespace
• A UTS namespace
• A PID namespace (optional)
• Shared storage (volumes)

Services

A service is an abstraction that defines a logical set of pods and a policy for accessing them. Service types include:

• ClusterIP: Exposes the service on an internal cluster IP
• NodePort: Exposes the service on each node’s port
• LoadBalancer: Exposes the service externally through a load balancer
• ExternalName: Maps the service to an external DNS name

Deployments

A Deployment provides declarative updates for pods and ReplicaSets. It lets you:

• Define the desired number of replicas
• Roll out pod updates gradually
• Roll back to a previous version if something goes wrong

ConfigMaps and Secrets

• ConfigMaps: Store non-confidential data as key-value pairs
• Secrets: Store sensitive data (passwords, tokens, keys)

Volumes

Volumes allow container data to persist. Kubernetes supports many types of volumes:

• Local volumes (emptyDir, hostPath)
• Cloud volumes (AWS EBS, GCP Persistent Disk)
• Network volumes (NFS, Ceph)

Getting Started with Kubernetes

Installing minikube

Minikube is a tool that lets you run Kubernetes locally:

# Installation de minikube
curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
sudo install minikube-linux-amd64 /usr/local/bin/minikube

# Démarrage de minikube
minikube start

Installing kubectl

kubectl is the command-line tool for interacting with Kubernetes:

# Installation de kubectl
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl

Basic Commands

# Vérifier la version de kubectl
kubectl version

# Lister les nœuds
kubectl get nodes

# Lister les pods
kubectl get pods

# Lister les services
kubectl get services

# Créer un déploiement
kubectl create deployment hello-world --image=gcr.io/google-samples/hello-app:1.0

# Exposer un service
kubectl expose deployment hello-world --type=LoadBalancer --port=8080

# Décrire un pod
kubectl describe pod <pod-name>

# Voir les logs d'un pod
kubectl logs <pod-name>

# Exécuter une commande dans un pod
kubectl exec -it <pod-name> -- /bin/bash

Conclusion

Kubernetes has become the industry standard for container orchestration. Its ability to automate the deployment, scaling, and operation of containerized applications makes it an essential tool for modern DevOps teams.

In upcoming articles, we will explore more advanced topics such as:

• Creating complex deployments
• Managing secrets and configurations
• Monitoring and logging
• Security in Kubernetes
• Integration with CI/CD

Stay tuned to learn more about these topics!