Docker - Kubernetes

Introduction

Kubernetes is an open-source platform for automating the deployment, scaling, and management of containerized applications. It provides a robust framework for running distributed systems, allowing developers to efficiently manage containerized workloads across clusters of machines. This tutorial covers the essentials of Kubernetes, including its architecture, setup, components, and best practices for orchestrating Docker containers.

Note: Kubernetes integrates seamlessly with Docker, making it an ideal choice for managing Docker containers in production environments.

What is Kubernetes?

Kubernetes, often abbreviated as K8s, is a container orchestration platform that automates the deployment, scaling, and operation of application containers across clusters of hosts. It provides advanced features like self-healing, load balancing, and automatic scaling, ensuring high availability and efficient resource utilization.

Orchestration: Automate the deployment and scaling of containerized applications.
Self-Healing: Automatically restart failed containers and reschedule disrupted workloads.
Scalability: Easily scale applications up or down to handle dynamic workloads.

1. Setting Up a Kubernetes Cluster

Setting up a Kubernetes cluster involves initializing the control plane, configuring worker nodes, and ensuring network connectivity. Here are the steps to create a basic Kubernetes cluster using kubeadm:

Prerequisites

Ensure Docker is installed on all nodes. Verify installation using docker --version.
Ensure all nodes can communicate over the network and are accessible via their IP addresses.
Ensure each node has at least 2GB of RAM.

Step 1: Install Kubernetes Tools

Install kubeadm, kubelet, and kubectl on all nodes. These tools are essential for setting up and managing a Kubernetes cluster:

sudo apt-get update
sudo apt-get install -y apt-transport-https curl
curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
cat <<EOF | sudo tee /etc/apt/sources.list.d/kubernetes.list
deb https://apt.kubernetes.io/ kubernetes-xenial main
EOF
sudo apt-get update
sudo apt-get install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl

Step 2: Initialize the Control Plane

On the master node, run the following command to initialize the control plane:

sudo kubeadm init --pod-network-cidr=192.168.0.0/16

After initialization, follow the instructions to set up the local kubectl configuration:

mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

Step 3: Install a Pod Network

Install a pod network add-on to allow communication between pods. Calico is a popular choice:

kubectl apply -f https://docs.projectcalico.org/manifests/calico.yaml

Step 4: Join Worker Nodes to the Cluster

On each worker node, run the join command provided by kubeadm init to join them to the cluster:

sudo kubeadm join <CONTROL-PLANE-HOST>:<CONTROL-PLANE-PORT> --token <TOKEN> --discovery-token-ca-cert-hash <HASH>

Replace placeholders with the appropriate values from the output of the initialization process.

2. Kubernetes Architecture

Kubernetes architecture consists of several components working together to manage containerized applications:

Master Node: Hosts the control plane components, including the API server, scheduler, and controller manager.
Worker Nodes: Run application containers and provide the runtime environment for pods.
Pod: The smallest deployable unit in Kubernetes, consisting of one or more containers.

3. Key Kubernetes Components

Kubernetes consists of several core components that enable its orchestration capabilities:

API Server: Exposes the Kubernetes API and serves as the entry point for all administrative tasks.
Etcd: A distributed key-value store that holds cluster state and configuration data.
Controller Manager: Manages controllers that regulate the state of the cluster.
Scheduler: Assigns pods to nodes based on resource availability and requirements.
Kubelet: An agent that runs on each worker node, managing containers and reporting to the control plane.

4. Deploying Applications in Kubernetes

Deploy applications in Kubernetes by defining them in YAML files, which specify the desired state and configuration for the application:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: my-app
        image: my-app-image:latest
        ports:
        - containerPort: 80

Apply the configuration using kubectl apply:

kubectl apply -f my-app-deployment.yaml

5. Scaling Applications in Kubernetes

Kubernetes allows easy scaling of applications to handle varying loads. Use the scale command to adjust the number of replicas:

kubectl scale deployment my-app --replicas=5

This command scales the my-app deployment to five replicas.

6. Updating Applications in Kubernetes

Kubernetes supports rolling updates, allowing applications to be updated with minimal downtime. Use the set image command to modify deployment configurations:

kubectl set image deployment/my-app my-app=my-app-image:new-version

This command updates the my-app deployment to use a new image version.

7. Managing Pods in Kubernetes

Pods are the fundamental units of deployment in Kubernetes. Manage pods using the following commands:

List Pods: Use kubectl get pods to list all pods in a namespace.
```
kubectl get pods
```
Describe Pod: Use kubectl describe pod to view detailed information about a specific pod.
```
kubectl describe pod <POD-NAME>
```
Delete Pod: Use kubectl delete pod to remove a pod from the cluster.
```
kubectl delete pod <POD-NAME>
```

8. Kubernetes Networking

Kubernetes provides a robust networking model that enables communication between pods, services, and external clients:

Service: An abstract way to expose an application running on a set of pods as a network service.
```
kubectl expose deployment my-app --type=LoadBalancer --name=my-service
```
Ingress: Manages external access to services, typically HTTP.
```
kubectl apply -f my-ingress.yaml
```

9. Monitoring and Logging in Kubernetes

Monitoring and logging are essential for managing Kubernetes clusters. Kubernetes integrates with several tools for observability:

Metrics Server: Aggregates resource usage data and provides it to the API server.
```
kubectl top pods
```
Prometheus and Grafana: Popular tools for monitoring and visualizing metrics.

10. Security Considerations in Kubernetes

Kubernetes includes several security features to protect your cluster and applications:

RBAC: Role-Based Access Control manages permissions and access to resources.

Secrets: Manage sensitive information securely.

kubectl create secret generic my-secret --from-literal=key1=value1

Network Policies: Control the communication between pods.
```
kubectl apply -f my-network-policy.yaml
```

11. Handling Failures in Kubernetes

Kubernetes provides mechanisms to handle node and pod failures, ensuring application resilience:

Pod Restart: Pods are automatically restarted on failure.
Node Drain: Safely evict pods from nodes for maintenance or upgrades.
```
kubectl drain <NODE-NAME> --ignore-daemonsets --delete-local-data
```

12. Helm: Kubernetes Package Manager

Helm is a package manager for Kubernetes, allowing the management of complex applications as charts. Helm simplifies deployment and versioning:

helm install my-release my-chart

Helm charts are reusable, shareable packages that can be used to manage applications in Kubernetes.

13. Deploying Stateful Applications in Kubernetes

Kubernetes supports the deployment of stateful applications using StatefulSets, which manage stateful pods:

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: my-stateful-app
spec:
  selector:
    matchLabels:
      app: my-stateful-app
  serviceName: "my-service"
  replicas: 3
  template:
    metadata:
      labels:
        app: my-stateful-app
    spec:
      containers:
      - name: my-container
        image: my-stateful-image
        ports:
        - containerPort: 80

14. Custom Resource Definitions (CRDs) in Kubernetes

Custom Resource Definitions extend Kubernetes capabilities by allowing you to define your own resource types:

apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  name: myresources.example.com
spec:
  group: example.com
  names:
    kind: MyResource
    listKind: MyResourceList
    plural: myresources
    singular: myresource
  scope: Namespaced
  versions:
  - name: v1
    served: true
    storage: true

CRDs enable you to create custom controllers and extend Kubernetes functionality.

15. Kubernetes Federation

Kubernetes Federation enables the management of multiple Kubernetes clusters as a single entity, providing global control and consistency:

It allows you to deploy applications across multiple clusters and ensures consistent configurations.

16. Kubernetes Best Practices

Follow these best practices to optimize Kubernetes usage and enhance application management:

Use Namespaces: Organize and manage resources effectively using namespaces.
Secure Your Cluster: Implement RBAC, use network policies, and manage secrets securely.
Automate Deployments: Use CI/CD pipelines for automated and consistent deployments.
Monitor and Optimize: Regularly monitor cluster performance and optimize resource usage.

17. Summary

Kubernetes is a powerful orchestration platform for managing containerized applications at scale. By mastering Kubernetes and following best practices, you can ensure high availability, scalability, and efficient management of complex applications in production environments.

DOCKER TUTORIAL

DOCKER BASICS

DOCKER ADVANCED TOPICS

DOCKER CI/CD INTEGRATION

DOCKER CONFIGURATION

DOCKER MONITORING & LOGGING

DOCKER BEST PRACTICES

DOCKER MISCELLANEOUS