Hier nur eine kurze und einfache Erklärung der einzelnen Punkte und Services

• Master → Master Node mit den Services API/etcd/Scheduler/Controller Manager
  • API → API
  • etcd → Datenbank
  • Scheduler → Verteilt die Pods auf den Workern
  • Controller Manager → Worker Management

• Worker Node → Worker Node auf denen die Pods laufen

• Pod → Ist quasi eine App. In einem Pod können mehrere Container sein

Die Installation von Kubernetes habe ich unter Ubuntu 20.04 durchgeführt.

Das System sollte am aktuellen Stand sein

apt update
apt dist-upgrade -y

Auf allen Nodes:

apt install -y docker.io
systemctl enable docker.service --now
systemctl status docker
docker --version

Das System darf kein Swap haben. Sonst lässt sich kein Cluster erstellen.
Am besten man installiert das System schon ohne Swap. Hat man dies nicht gemacht und es gibt Swap dann kann man dies deaktivieren

Auf allen Nodes:
swapoff -a
vim /etc/fstab
Swap auskommentieren

Ich hatte bei Ubuntu 20.04 nach einem Reboot oftmal trotzdem Swap gemountet. Daher habe ich die Partiton einfach überschrieben

dd if=/dev/zero of=/dev/sdX3 bs=1048576 count=10 oflag=direct status=progress

Damit Traffic durch die Container geroutet werden kann

Auf alle Nodes: 
vim /etc/sysctl.conf
net.ipv4.ip_forward = 1

Diese Stelle gibt es normal schon und muss nur auskommentiert werden

sysctl -p

Wir verwenden hier ein Repo für Xenial (Ubuntu 16.04) da es kein neueres Repo gibt aktuell

Auf allen Nodes:
apt install -y apt-transport-https curl
curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add
apt-add-repository "deb http://apt.kubernetes.io/ kubernetes-xenial main"
apt update
apt install -y kubelet kubeadm kubectl

Auf der Master Node:
kubeadm init

Hier bekommt man auch gleich den Befehl in die Shell wie man Worker zum Cluster Joint.
Falls man diesen später nicht mehr weiß kann man sich dies Infos dazu holen.

Wenn man den Output für den Join Befehl hat dann diesen nehmen.

Auf den Worker:
kubeadm join 192.168.88.121:6443 --token 78c4by.cs8u65dcvxxxxxxx \
    --discovery-token-ca-cert-hash sha256:3818424273aac366a6faa5b4b417158227a497xxxxxxxxxxxxxxxxxx

Falls man diese nicht mehr hat kann man sich diesen wieder zusammen bauen

k8s@kube01:~$ kubeadm token create --print-join-command | grep join
kubeadm join 192.168.88.121:6443 --token dfipcc.r7ntkgh0n9344c1a     --discovery-token-ca-cert-hash sha256:3818424273aac366a6faa5b4b417158227a4972e2e44fcf1db114bfd6cc64496

Status auf dem Cluster Checken

kubectl get nodes

Es gibt dafür einen ganzen Haufen Möglichkeiten
https://kubernetes.io/docs/concepts/cluster-administration/addons/
Ich habe mich hier für Calico entschieden.

Auf dem Master
kubectl apply -f https://docs.projectcalico.org/v3.14/manifests/calico.yaml

Nach 1-2 Minuten sollte der Status der Worker auf “Ready” gehen

Auf dem Master
kubectl get nodes

Auch die Container sollten alle laufen

Auf dem Master
kubectl get pods --all-namespaces

echo 'source <(kubectl completion bash)' >> ~/.bashrc
source .bashrc

Auf dem Master:
kubectl run --image=nginx nginx-server --port=80
kubectl expose pod nginx-server --port 80 --type=NodePort


kubectl run http-web --image=httpd --port=80
kubectl expose pod http-web --name=http-service --port=80 --type=NodePort

kubectl get pods -o wide

Es gibt unter Kubernetes verschiedene Arten von Storage Provider und Klassen. Darauf gehe ich später ein.

Ein Persistent Volume ist ein lokaler Speicherbereich auf den Worker Nodes.
Dies kann auch ein NFS Share sein der auf den Workern gemountet ist.

Yaml File erstellen

apiVersion: v1
kind: PersistentVolume
metadata:
  name: pv01
  labels:
    type: local
spec:
  storageClassName: manual
  capacity:
    storage: 1G
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: "/mnt/nfs"

Danach kann die Storage Ressource angelegt werden.

k8s@kube01:~$ kubectl apply -f pv01.yaml 
persistentvolume/pv01 created

k8s@kube01:~$ kubectl get pv
NAME   CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS      CLAIM   STORAGECLASS   REASON   AGE
pv01   1G         RWO            Retain           Available           manual                  4m40s

Yaml File erstellen

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc01-nginx
spec:
  storageClassName: manual
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 300M

Danach kann der Claim angelegt werden

k8s@kube01:~$ kubectl apply -f pvc01-nginx.yaml 
persistentvolumeclaim/pvc01-nginx created

k8s@kube01:~$ kubectl get pvc
NAME          STATUS   VOLUME   CAPACITY   ACCESS MODES   STORAGECLASS   AGE
pvc01-nginx   Bound    pv01     1G         RWO            manual         29s

Jetzt kann ein Pod angelegt werden im PVC.
Dazu ein Manifest erstellen:

k8s@kube01:~$ cat nginx-demo01.yaml 
apiVersion: v1
kind: Pod
metadata:
  name: nginx-demo01
spec:
  volumes:
    - name: task-pv-storage
      persistentVolumeClaim:
        claimName: pvc01-nginx
  containers:
    - name: nginx-demo01
      image: nginx
      ports:
        - containerPort: 80
          name: "nginx-http"
      volumeMounts:
        - mountPath: "/mnt/nfs"
          name: task-pv-storage

Deploy vom Pod:

k8s@kube01:~$ kubectl apply -f nginx-demo01.yaml 
pod/nginx-demo01 created
k8s@kube01:~$ 
k8s@kube01:~$ kubectl get pods -o wide
NAME           READY   STATUS    RESTARTS   AGE   IP               NODE     NOMINATED NODE   READINESS GATES
nginx-demo01   1/1     Running   0          9s    172.16.197.198   kube02   <none>           <none>

Serivce dafür anlegen

asdf asdf

Sammlung von CLI Befehlen

kubectl version
kubectl cluster-info

kubectl describe nodes <podname>
kubectl describe pods <podname>

kubectl get pods
kubectl get pods -o wide
kubectl get pods --all-namespaces
kubectl get pods --all-namespaces -o jsonpath="{..image}" | tr -s '[[:space:]]' '\n' | sort | uniq -c
kubectl describe pod/nginx-server -n default
kubectl describe pods nginx-server
kubectl exec nginx-server -- cat /etc/hostname
kubectl exec -ti nginx-server -- /bin/bash
kubectl logs nginx-server
kubectl logs nginx-server -f

Service Befehle
kubectl get service
kubectl get service -o wide
kubectl get service <service>

kubectl delete service <service>

TODO: kubectl delete pv pv01 kubectl delete pvc pvc01-nginx

apt-get install yamllint