DEV Community: Abdallah Kordy

Linux Date Commands

Abdallah Kordy — Tue, 04 Jun 2024 20:01:48 +0000

Explaining different date formats according to your needs
1.Date

date -u :Displays the time in Coordinated Universal Time (UTC).

04 يون, 2024 UTC 07:32:39 م

date -d "next Friday"

07 يون, 2024 EEST 12:00:00 ص

date -R Outputs the date and time in RFC 2822 format.

output

Tue, 04 Jun 2024 22:37:39 +0300

date -I :Outputs the date in ISO 8601 format

output

2024-06-04

date "+%Y-%m-%d %H:%M:%S" customizable formate

2024-06-04 22:49:23

%Y: Year (4 digits)
%m: Month (2 digits)
%d: Day (2 digits)
%H: Hour (00-23)
%M: Minute (00-59)
%S: Second (00-59)
%A: Full weekday name (e.g., Monday)
%a: Abbreviated weekday name (e.g., Mon)
%B: Full month name (e.g., January)
%b: Abbreviated month name (e.g., Jan)

date -s or --set: date -s "2023-12-31 23:59:59"
Sets the system date and time.
date --rfc-3339=seconds

2024-06-04 23:10:08+03:00

date -d "2023-12-31 23:59:59" Display the date and time for a specific date:

31 ديس, 2023 EET 11:59:59 م

Kubernetes installation

Abdallah Kordy — Tue, 04 Jun 2024 13:28:19 +0000

These instructions are for Kubernetes v1.30 (debian-based) controlplane & worker node

Update the apt package index install packages needed to use the Kubernetes apt repository:

sudo apt-get update
# apt-transport-https may be a dummy package; if so, you can skip that package
sudo apt-get install -y apt-transport-https ca-certificates curl gpg

2.Download the public signing key for the Kubernetes package repositories. The same signing key is used for all repositories so you can disregard the version in the URL:

# If the directory `/etc/apt/keyrings` does not exist, it should be created before the curl command, read the note below.
# sudo mkdir -p -m 755 /etc/apt/keyrings
curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.30/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg

3.Add the appropriate Kubernetes apt repository. Please note that this repository have packages only for Kubernetes 1.30; for other Kubernetes minor versions, you need to change the Kubernetes minor version in the URL to match your desired minor version (you should also check that you are reading the documentation for the version of Kubernetes that you plan to install).

# This overwrites any existing configuration in /etc/apt/sources.list.d/kubernetes.list
echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.30/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list

4.Update the apt package index, install kubelet, kubeadm and kubectl, and pin their version:

sudo apt-get update
sudo apt-get install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl

5.(Optional) Enable the kubelet service before running kubeadm:

sudo systemctl enable --now kubelet

6.
You might know about swap space on hard drives, which OS systems try to use as if it were RAM. Operating systems try to move less frequently accessed data to the swap space to free up RAM for more immediate tasks. However, accessing data in swap is much slower than accessing data in RAM because hard drives are slower than RAM.

Kubernetes schedules work based on the understanding of available resources. If workloads start using swap, it can become difficult for Kubernetes to make accurate scheduling decisions. Therefore, it’s recommended to disable swap before installing Kubernetes.

sudo swapoff

sudo sed -i '/ swap / s/^/#/' /etc/fstab

8.
To configure the IPV4 bridge on all nodes, execute the following commands on each node

cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
overlay
br_netfilter
EOF
sudo modprobe overlay
sudo modprobe br_netfilter

# sysctl params required by setup, params persist across reboots
cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-iptables  = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.ipv4.ip_forward                 = 1
EOF

# Apply sysctl params without reboot
sudo sysctl --system

9.
install containerd Runtime

 sudo apt install containerd 
 sudo mkdir /etc/containerd

10.
Then, create a default configuration file for containerd and save it as config.toml using the

containerd config default > /etc/containerd/config.toml

11.

sudo sed -i 's/ SystemdCgroup = false/ SystemdCgroup = true/' /etc/containerd/config.toml

12.
restart containerd & kubelet so as change take effect

sudo systemctl restart containerd.service
sudo systemctl restart kubelet.service

13.

sudo kubeadm config images pull

14
configure best & secured network plugin (kubernetes )

kubectl apply -f https://raw.githubusercontent.com/projectcalico/calico/v3.26.1/manifests/tigera-operator.yaml

Kubernetes Cluster Architecture

Abdallah Kordy — Tue, 04 Jun 2024 10:53:08 +0000

etcd

Cluster State Storage: etcd stores the state of all Kubernetes objects, such as deployments, pods, services, config maps, and secrets.
Configuration Management: Changes to the cluster configuration are stored in etcd, allowing Kubernetes to manage and maintain the desired state of the cluster.
note: etcd could be in kube-system

Kube-api-server

The Kubernetes API server is the central component of the Kubernetes control plane that exposes the Kubernetes API and serves as the gateway for all interactions with the cluster.

The Kubernetes controller

The Kubernetes controller manager is a daemon that runs controllers, which are responsible for monitoring the state of the cluster and making or requesting changes to achieve the desired state. (reach to desired state via registered etcd variables)

Kubelet

The kubelet is the Kubernetes agent responsible for managing the pods on a node, reporting their status, and ensuring the desired state is achieved.

Kubeproxy

In simpler terms, the kube-proxy makes sure that network communication between different components of the Kubernetes cluster (pods, services, etc.) works as expected, by managing the necessary network configuration and rules on each node.

Service Networking: The kube-proxy ensures that all the network traffic intended for a Kubernetes Service can be correctly routed to the appropriate pods providing that service.
Load Balancing: The kube-proxy can perform basic load balancing across the pods that are part of a Service, distributing incoming traffic among them.
Network Proxy: The kube-proxy acts as a network proxy, forwarding traffic to the correct pod based on the Service configuration.
Network Rules: The kube-proxy is responsible for setting up the necessary iptables rules or other network rules on the node to achieve the desired network behavior.

CRI

By using the CRI, Kubernetes can maintain a consistent interface for container management, while allowing users to choose the container runtime that best fits their needs and infrastructure.
(there is options )

Scheduler

The Kubernetes scheduler is essential for ensuring that the cluster's resources are utilized efficiently and that pods are scheduled onto nodes that can handle their resource requirements and constraints.

workernodes or node1 & node2

In simple terms, the worker nodes are the "workhorses" of the Kubernetes cluster, where the actual application workloads are executed. They provide the computing resources (CPU, memory, storage) needed to run the containerized applications, while the Kubernetes control plane manages the overall orchestration and scheduling of these workloads across the cluster.

In simple terms, a Pod in Kubernetes is the smallest and most basic unit of computing that you can create and manage in the Kubernetes system.

Pod

A Pod is a group of one or more containers that are deployed together on the same host (worker node) and share the same resources, such as:

Interaction scenario :

1.Define the Application Configuration:
Create a YAML file describing a deployment for a simple web application.

# my-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-web-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      containers:
      - name: web-container
        image: nginx
        ports:
        - containerPort: 80

2.Apply the Configuration:
Use kubectl to create the deployment in the cluster.

kubectl apply -f my-deployment.yaml

Interaction:

kubectl sends the configuration file to the Kubernetes API server.
The API server validates the configuration and stores it in etcd, the cluster's key-value store.

3.API Server Processes the Request:

The API server creates a new deployment object in etcd.
The API server responds to kubectl with the status of the request.

4.Deployment Controller Actions:

The Deployment controller, part of the controller manager, notices the new deployment object.
It creates ReplicaSet objects to match the desired state specified in the deployment.

5.ReplicaSet Controller Actions:

The ReplicaSet controller sees the new ReplicaSet and ensures that the correct number of pods are running.
It creates new Pod objects in etcd to match the desired replicas.

6.Scheduler Actions:

The Scheduler detects new unscheduled pods and assigns them to appropriate nodes in the cluster.

7.Kubelet Actions:

The kubelet on each assigned node sees the new Pod objects.
It instructs the container runtime (like Docker or containerd) to pull the nginx image and start the containers.

8.Pods Running:

The web application is now running on multiple nodes as specified.
The kubelet continuously monitors the pods to ensure they remain in the desired stat