KUBERNETES: FROM BASIC TO ADVANCED

Module 1: Introduction & Kubernetes Architecture

xdev.asia

Kubernetes Environment Settings 2026

Kubernetes 2026 has made important changes in its underlying technology stack. This lesson guides you through building a full Kubernetes development environment — from system requirements, installing containerd 2.0, creating a local cluster, to state-of-the-art dashboard and CLI tools.

1. System Requirements 2026

1.1. Minimum Hardware

• CPU: 4 cores (recommended 8+ cores to run multi-node cluster)
• RAM: 8 GB (16 GB recommended)
• Disk: 50 GB free space (SSD recommended)
• OS: Linux with kernel 5.15+ (Ubuntu 22.04+, Debian 12+, RHEL 9+, or macOS 14+ for local dev)

1.2. Test and Ensure cgroup v2

This is the most important required. From Kubernetes 1.35, cgroup v1 has been deprecated. From Kubernetes 1.36, only cgroup v2 is supported.

# Kiểm tra cgroup version hiện tại
stat -fc %T /sys/fs/cgroup
# Kết quả cần là: cgroup2fs
# Nếu trả về "tmpfs" -> đang dùng cgroup v1, cần upgrade OS

# Cách khác để kiểm tra
ls /sys/fs/cgroup/
# cgroup v2: chỉ thấy các file như cgroup.controllers, cgroup.procs...
# cgroup v1: thấy nhiều thư mục như cpu, memory, blkio...

# Kiểm tra kernel version
uname -r
# Cần >= 5.15 cho full cgroup v2 support

If you are using cgroup v1, the simplest way is to upgrade OS:

# Ubuntu 20.04 -> 22.04 LTS upgrade
do-release-upgrade

# Hoặc với Debian 10 -> 12 (Bookworm)
# Cgroup v2 mặc định từ Debian 11+

# Bật cgroup v2 thủ công trên Ubuntu 20.04 (kernel boot param)
sudo grubby --update-kernel=ALL \
  --args="systemd.unified_cgroup_hierarchy=1 cgroup_no_v1=all"
sudo update-grub
sudo reboot

# Sau reboot, kiểm tra lại
stat -fc %T /sys/fs/cgroup  # Phải là cgroup2fs

Ubuntu 22.04 LTS and newer use cgroup v2 by default — no additional configuration required.

2. Install containerd 2.0

containerd 2.0 is the standard container runtime for Kubernetes 2026, with native cgroup v2 support and many performance improvements.

2.1. Install on Ubuntu/Debian

# Xóa containerd cũ nếu có
sudo apt remove containerd containerd.io -y

# Cài đặt prerequisites
sudo apt update
sudo apt install -y ca-certificates curl gnupg lsb-release

# Thêm Docker/containerd official GPG key
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | \
  sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

# Thêm repository
echo "deb [arch=$(dpkg --print-architecture) \
  signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Cài containerd 2.0
sudo apt update
sudo apt install -y containerd.io

# Kiểm tra version
containerd --version
# Phải là 2.x.x

2.2. Configuring containerd for Kubernetes

# Tạo thư mục config
sudo mkdir -p /etc/containerd

# Generate default config
sudo containerd config default | sudo tee /etc/containerd/config.toml

# Bật SystemdCgroup = true (BẮT BUỘC cho Kubernetes với systemd)
sudo sed -i 's/SystemdCgroup = false/SystemdCgroup = true/' \
  /etc/containerd/config.toml

# Verify thay đổi
grep SystemdCgroup /etc/containerd/config.toml
# Output phải là: SystemdCgroup = true

# Restart containerd
sudo systemctl restart containerd
sudo systemctl enable containerd

# Kiểm tra containerd đang chạy
sudo systemctl status containerd

# Test containerd hoạt động
sudo ctr version

2.3. Install crictl (CRI CLI tool)

# Cài crictl để interact với containerd qua CRI interface
VERSION="v1.32.0"
curl -L https://github.com/kubernetes-sigs/cri-tools/releases/download/${VERSION}/crictl-${VERSION}-linux-amd64.tar.gz \
  | sudo tar -xz -C /usr/local/bin
Cấu hình crictl dùng containerd
cat <<EOF | sudo tee /etc/crictl.yaml
runtime-endpoint: unix:///run/containerd/containerd.sock
image-endpoint: unix:///run/containerd/containerd.sock
timeout: 10
EOF
Test crictl
sudo crictl version

3. Installing Kubernetes Locally: Kind vs k3d vs Minikube

3.1. Compare Options

Tool	Mechanism__HTMLTAG_123___	Advantages	Disadvantages
kind	K8s nodes are Docker containers	Multi-node, CI-friendly, stable	Needs Docker Desktop/Engine, slower than k3d
k3d	k3s (lightweight K8s) in Docker__HTMLTAG_149___	Fastest, lightest, easy multi-node__HTMLTAG_151___	k3s has some differences with full K8s
Minikube	VM or Docker driver__HTMLTAG_161___	Easiest to use, many addons	Single-node default, more resource intensive__HTMLTAG_165___

Recommendation 2026: Use kind for CI/CD pipelines and when needed to test multi-node scenarios close to production. Use k3d for fast local development. This lesson covers both.

3.2. Install and Use kind

# Cài kind
curl -Lo ./kind https://kind.sigs.k8s.io/dl/v0.27.0/kind-linux-amd64
chmod +x ./kind
sudo mv ./kind /usr/local/bin/kind

# Trên macOS
brew install kind

# Tạo cluster đơn giản (single node)
kind create cluster --name dev

# Tạo multi-node cluster với config file
cat < kind-config.yaml
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
name: k8s-lab
nodes:
  - role: control-plane
    kubeadmConfigPatches:
    - |
      kind: InitConfiguration
      nodeRegistration:
        kubeletExtraArgs:
          node-labels: "ingress-ready=true"
    extraPortMappings:
    - containerPort: 80
      hostPort: 80
      protocol: TCP
    - containerPort: 443
      hostPort: 443
      protocol: TCP
  - role: worker
    extraMounts:
    - hostPath: /tmp/kind-storage
      containerPath: /data
  - role: worker
networking:
  podSubnet: "10.244.0.0/16"
  serviceSubnet: "10.96.0.0/12"
  kubeProxyMode: nftables
EOF

kind create cluster --config kind-config.yaml

# Xem danh sách clusters
kind get clusters

# Xóa cluster
kind delete cluster --name k8s-lab

3.3. Install and Use k3d

# Cài k3d
curl -s https://raw.githubusercontent.com/k3d-io/k3d/main/install.sh | bash

# Trên macOS
brew install k3d

# Tạo cluster nhanh
k3d cluster create mycluster

# Tạo multi-node cluster
k3d cluster create k8s-lab \
  --servers 1 \
  --agents 2 \
  --port "8080:80@loadbalancer" \
  --port "8443:443@loadbalancer"

# Xem clusters
k3d cluster list

# Start/stop cluster (tiết kiệm tài nguyên khi không dùng)
k3d cluster stop k8s-lab
k3d cluster start k8s-lab

# Xóa cluster
k3d cluster delete k8s-lab

4. Install kubectl

# Lấy latest stable version
KUBECTL_VERSION=$(curl -L -s https://dl.k8s.io/release/stable.txt)
echo "Installing kubectl $KUBECTL_VERSION"

# Download kubectl binary
curl -LO "https://dl.k8s.io/release/${KUBECTL_VERSION}/bin/linux/amd64/kubectl"

# Verify checksum (quan trọng cho security)
curl -LO "https://dl.k8s.io/release/${KUBECTL_VERSION}/bin/linux/amd64/kubectl.sha256"
echo "$(cat kubectl.sha256)  kubectl" | sha256sum --check
# Output phải là: kubectl: OK

# Install
chmod +x kubectl
sudo mv kubectl /usr/local/bin/kubectl

# Kiểm tra
kubectl version --client

# Trên macOS
brew install kubectl
# Hoặc nếu đã cài Docker Desktop, kubectl đã được included

# Enable bash completion
echo 'source <(kubectl completion bash)' >> ~/.bashrc
echo 'alias k=kubectl' >> ~/.bashrc
echo 'complete -o default -F __start_kubectl k' >> ~/.bashrc
source ~/.bashrc

# Zsh completion
echo 'source <(kubectl completion zsh)' >> ~/.zshrc

5. Essential CLI Tools 2026

5.1. k9s — Terminal UI Dashboard

k9s is a terminal-based UI for Kubernetes — providing a real-time view of cluster resources, allowing navigation, viewing logs, executing into containers, all from the terminal.

# Cài k9s
# macOS
brew install k9s

# Linux
curl -sS https://webinstall.dev/k9s | bash
# Hoặc download từ GitHub releases
curl -LO https://github.com/derailed/k9s/releases/latest/download/k9s_Linux_amd64.tar.gz
tar -xzf k9s_Linux_amd64.tar.gz
sudo mv k9s /usr/local/bin/

# Chạy k9s
k9s

# Một số hotkeys trong k9s:
# :pods     -> xem pods (thay bằng bất kỳ resource nào)
# :nodes    -> xem nodes
# l         -> xem logs của pod đang chọn
# e         -> edit resource
# d         -> describe resource
# ctrl+d    -> xóa resource
# /         -> filter/search
# ?         -> help

5.2. kubectx and kubens — Context and Namespace Switching

When working with multiple clusters and namespaces, kubectx and kubens help switch quickly.

# Cài kubectx và kubens
# macOS
brew install kubectx

# Linux
sudo git clone https://github.com/ahmetb/kubectx /opt/kubectx
sudo ln -s /opt/kubectx/kubectx /usr/local/bin/kubectx
sudo ln -s /opt/kubectx/kubens /usr/local/bin/kubens

# Với krew (kubectl plugin manager)
kubectl krew install ctx
kubectl krew install ns

# Sử dụng kubectx
kubectx                        # Liệt kê tất cả contexts
kubectx kind-k8s-lab           # Switch sang context kind-k8s-lab
kubectx -                      # Switch về context trước đó
kubectx prod=kind-k8s-lab      # Rename context

# Sử dụng kubens
kubens                         # Liệt kê tất cả namespaces
kubens kube-system             # Switch sang namespace kube-system
kubens -                       # Switch về namespace trước đó

5.3. stern — Multi-Pod Log Streaming

stern allows streaming logs from multiple Pods at the same time, filtering by regex, and displaying colors by pod.

# Cài stern
# macOS
brew install stern

# Linux
curl -LO https://github.com/stern/stern/releases/latest/download/stern_linux_amd64.tar.gz
tar -xzf stern_linux_amd64.tar.gz
sudo mv stern /usr/local/bin/

# Sử dụng stern
stern .                        # Stream logs tất cả pods trong namespace hiện tại
stern my-app                   # Stream logs tất cả pods có tên chứa "my-app"
stern my-app -n production     # Trong namespace production
stern my-app --tail 50         # Chỉ 50 lines cuối mỗi pod
stern my-app --since 5m        # Logs từ 5 phút trước
stern "app=nginx" --selector   # Dùng label selector
stern . --container sidecar    # Chỉ stream container tên "sidecar"

5.4. krew — kubectl Plugin Manager

# Cài krew
(
  set -x; cd "$(mktemp -d)" &&
  OS="$(uname | tr '[:upper:]' '[:lower:]')" &&
  ARCH="$(uname -m | sed -e 's/x86_64/amd64/' -e 's/arm.*$/arm/' -e 's/aarch64$/arm64/')" &&
  KREW="krew-${OS}_${ARCH}" &&
  curl -fsSLO "https://github.com/kubernetes-sigs/krew/releases/latest/download/${KREW}.tar.gz" &&
  tar zxvf "${KREW}.tar.gz" &&
  ./"${KREW}" install krew
)

# Thêm vào PATH
export PATH="${KREW_ROOT:-$HOME/.krew}/bin:$PATH"
echo 'export PATH="${KREW_ROOT:-$HOME/.krew}/bin:$PATH"' >> ~/.bashrc

# Tìm và cài plugins hữu ích
kubectl krew search
kubectl krew install ctx ns neat tree view-secret

# Một số plugins hữu ích 2026:
# neat       -> output YAML gọn gàng hơn (bỏ managed fields)
# tree       -> hiển thị owner references dạng tree
# view-secret-> decode secrets dễ dàng
# rolesum    -> tóm tắt RBAC permissions
# stern      -> cũng có thể cài qua krew

6. Dashboard 2026: Headlamp

Kubernetes Dashboard (kubernetes/dashboard) was archived January 2026 — the official project is no longer maintained. The currently recommended alternative is Headlamp — a modern, actively maintained web-based dashboard, with much better UI/UX.

6.1. Install Headlamp with Helm

# Cài Helm trước nếu chưa có
curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash

# Thêm Headlamp Helm repo
helm repo add headlamp https://headlamp-k8s.github.io/headlamp/
helm repo update

# Cài Headlamp vào kube-system namespace
helm install headlamp headlamp/headlamp \
  --namespace kube-system \
  --set replicaCount=1

# Xem Headlamp pod đang chạy
kubectl get pods -n kube-system -l app.kubernetes.io/name=headlamp

# Port-forward để truy cập local
kubectl port-forward -n kube-system svc/headlamp 4466:80 &

# Truy cập: http://localhost:4466

6.2. Configure Service Account Token to Login

# Tạo service account với cluster-admin permissions (chỉ dùng cho dev/lab!)
kubectl create serviceaccount headlamp-admin -n kube-system

kubectl create clusterrolebinding headlamp-admin \
  --clusterrole=cluster-admin \
  --serviceaccount=kube-system:headlamp-admin

# Tạo token (Kubernetes 1.24+ dùng TokenRequest API thay vì tự động tạo)
kubectl create token headlamp-admin -n kube-system --duration=720h

# Copy token và paste vào Headlamp login page

6.3. Alternatives for Headlamp

• Lens / OpenLens: Desktop application (Electron), very popular, many features. OpenLens is the open-source fork of Lens.
• k9s: Terminal UI, faster than web dashboard
• Grafana: If you already have a Grafana stack, use kubernetes plugin/dashboards
• Rancher: Full platform when managing multiple clusters

7. IDE and Editor Setup

7.1. Visual Studio Code

# Cài extensions hữu ích cho Kubernetes development
code --install-extension ms-kubernetes-tools.vscode-kubernetes-tools
code --install-extension redhat.vscode-yaml
code --install-extension ms-azuretools.vscode-docker
code --install-extension golang.go   # Nếu dùng Go
code --install-extension hashicorp.terraform  # Nếu dùng Terraform

Extensions needed in VS Code:

• Kubernetes (ms-kubernetes-tools): IntelliSense for YAML manifests, cluster explorer, port-forward from IDE
• YAML (redhat): Schema validation, autocompletion for YAML with Kubernetes schema
• Docker: Dockerfile syntax, image management

7.2. Configure YAML Schema Validation

# Thêm vào VS Code settings.json
# Settings -> Open Settings (JSON) -> thêm:
{
  "yaml.schemas": {
    "kubernetes": "*.yaml"
  },
  "yaml.customTags": [
    "!reference sequence"
  ]
}

8. First Commands: Check Cluster Activity

After installation is complete, run these commands to verify cluster to work properly:

# 1. Thông tin cluster
kubectl cluster-info
# Output mong đợi:
# Kubernetes control plane is running at https://127.0.0.1:XXXXX
# CoreDNS is running at https://...

# 2. Danh sách nodes và trạng thái
kubectl get nodes -o wide
# Tất cả nodes phải ở trạng thái: Ready

# 3. Kiểm tra tất cả system pods
kubectl get pods -A
# Tất cả pods phải ở trạng thái: Running hoặc Completed

# 4. Kiểm tra services hệ thống
kubectl get services -A

# 5. Kiểm tra storage classes
kubectl get storageclasses

# 6. Quick connectivity test - tạo và xóa pod test
kubectl run test-pod --image=nginx:alpine --restart=Never
kubectl get pod test-pod  # Phải là Running sau ~30s
kubectl delete pod test-pod

# 7. Kiểm tra DNS hoạt động
kubectl run dns-test --image=busybox:1.36 --rm -it --restart=Never \
  -- nslookup kubernetes.default.svc.cluster.local
# Phải resolve thành công

# 8. Xem resource usage (cần metrics-server)
kubectl top nodes

9. Configuring kubeconfig and Multiple Clusters

# kubeconfig mặc định ở ~/.kube/config
cat ~/.kube/config

# Xem contexts hiện có
kubectl config get-contexts

# Xem context đang dùng
kubectl config current-context

# Merge nhiều kubeconfig files
export KUBECONFIG=~/.kube/config:~/.kube/config-cluster2
kubectl config view --flatten > ~/.kube/config-merged
mv ~/.kube/config-merged ~/.kube/config

# Set namespace mặc định cho context
kubectl config set-context --current --namespace=my-namespace

# Một số best practices:
# - Không dùng cluster-admin trong development thường ngày
# - Tạo dedicated service account với minimum permissions cần thiết
# - Dùng kubectx/kubens để tránh nhầm cluster/namespace

10. Summary of Setup Checklist

Below is a checklist to verify the environment is ready:

#!/bin/bash
# Kubernetes 2026 Environment Check Script

echo "=== Checking cgroup v2 ==="
CGROUP_TYPE=$(stat -fc %T /sys/fs/cgroup)
if [ "$CGROUP_TYPE" = "cgroup2fs" ]; then
  echo "✓ cgroup v2 active"
else
  echo "✗ cgroup v1 detected! Upgrade required for K8s 1.36+"
fi

echo ""
echo "=== Checking containerd ==="
if command -v containerd &> /dev/null; then
  echo "✓ containerd $(containerd --version | awk '{print $3}')"
else
  echo "✗ containerd not found"
fi

echo ""
echo "=== Checking kubectl ==="
if command -v kubectl &> /dev/null; then
  echo "✓ kubectl $(kubectl version --client --short 2>/dev/null | head -1)"
else
  echo "✗ kubectl not found"
fi

echo ""
echo "=== Checking CLI Tools ==="
for tool in kind k3d helm k9s stern kubectx kubens; do
  if command -v $tool &> /dev/null; then
    echo "✓ $tool installed"
  else
    echo "- $tool not installed (optional)"
  fi
done

echo ""
echo "=== Checking Cluster ==="
if kubectl cluster-info &> /dev/null; then
  echo "✓ Cluster accessible"
  kubectl get nodes --no-headers | awk '{print "✓ Node "$1" - "$2}'
else
  echo "✗ No cluster accessible (run: kind create cluster)"
fi

After completing this lesson, you have a full environment to learn and practice Kubernetes. In the next exercise, we will apply everything installed to deploy the first real application.