Java Training Block 11+12 – Microservices – Tag8

Ich nehme derzeit an einer Akademie zum Java Fullstack Software Engineer teil. In den kommenden Wochen möchte ich hier meine Mitschrift, so gut es geht, aufzeichnen und mitteilen. Hier ist das, was ich vom achten Tag in Block 11+12 (wir springen etwas hin und her) gelernt und behalten habe:

Kubernetes

Kubernetes orchestriert eine Microservice Welt
Links:
https://kubernetes.io/de/docs/tutorials/hello-minikube/
https://www.tutorialspoint.com/kubernetes/kubernetes_architecture.htm

Heute wollen wir einen Minikube (in minimales Kubernetes) ausprobieren:

Doch zunächst etwas Theorie:

Vergleich Kubernetes und Docker:

Docker:
Wir haben ein Dockerfile und unser docker-compose.yml

Docker Compose am Beispiel von Wordpress Docker: https://docs.docker.com/samples/wordpress/

Docker Befehle:

Microservices Schnittstellen:

Microservices (z.B. Jar-Files) haben folgende Schnittstellen:

Volumes (Verzeichnisse zum Docker)
Port
Netzwerk
- Bridge (nach draußen)
- Host (fürs Intranet)
Monitoring (jconsole, actuator)
Umgebungsvariablen

Die Microservices kommunizieren untereinander in internen Netzen (blau):

("E.T. im Rollstuhl der nach Hause telefoniert" ;-) )

Hier ein paar informationen zu den Netzwerken in Docker:

docker network ls -> liefert die Netzwerke und deren Namen

docker network inspect NETZWERKNAME -> liefert Detailinfos, inkl. IP-Adresse des Docker Netzwerkes:

Daraus werden Images und Container gebildet:

Das macht man aber heute kaum noch, da Kubernetes das besser kann. Zumindest für größere Netze.

Kubernetes

Kubernetes ist ein Produkt von Microsoft.

Pods beinhalten einen oder mehrere Container. Die Pods können gestartet und gelöscht werden. Diese Pods werden in eine Runtime-Umgebung deployt. Die Service-Zeiten bestimmen wann, wo und wie viele Pods gestartet werden.
Nodes (worker Kubelets) sind virtualisierte Maschinen:

Die Replikation bestimmt, wie viele Pods gebaut werden sollen.
Wenn ein Knoten ausgefallen ist oder wenn ein neuer gebraucht wird, wird dieser wiederhergestellt.

Minikube (Kleines Kubernetes)

Minikube - Install:
https://kubernetes.io/de/docs/tasks/tools/install-minikube/
https://github.com/kubernetes/minikube/releases/tag/v1.11.0

Möchte man ein Minikube lokal auf seinem Linux installieren, geht das wie folgt:

cd /opt/ sudo curl -Lo minikube https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64 && chmod +x minikube sudo chmod 755 minikube

Installation im Home-Verzeichnis
/opt/minikube start
* minikube v1.19.0 on Ubuntu 20.04 (amd64)
* Automatically selected the docker driver. Other choices: none, ssh
* Starting control plane node minikube in cluster minikube
* Pulling base image ...
* Downloading Kubernetes v1.20.2 preload ...
> preloaded-images-k8s-v10-v1...: 491.71 MiB / 491.71 MiB 100.00% 83.58 Mi
> gcr.io/k8s-minikube/kicbase...: 357.67 MiB / 357.67 MiB 100.00% 4.40 MiB
* Creating docker container (CPUs=2, Memory=2200MB) ...
* Preparing Kubernetes v1.20.2 on Docker 20.10.5 ...
- Generating certificates and keys ...
- Booting up control plane ...
- Configuring RBAC rules ...
* Verifying Kubernetes components...
- Using image gcr.io/k8s-minikube/storage-provisioner:v5
* Enabled addons: default-storageclass, storage-provisioner
* kubectl not found. If you need it, try: 'minikube kubectl -- get pods -A'
* Done! kubectl is now configured to use "minikube" cluster and "default" namespace by default

Start-Stop-Status

minikube start
* minikube v1.19.0 on Ubuntu 20.04 (amd64)
* Using the docker driver based on existing profile
* Starting control plane node minikube in cluster minikube
* Restarting existing docker container for "minikube" ...
* Preparing Kubernetes v1.20.2 on Docker 20.10.5 ...
* Verifying Kubernetes components...
- Using image gcr.io/k8s-minikube/storage-provisioner:v5
- Using image k8s.gcr.io/metrics-server/metrics-server:v0.4.2
* Enabled addons: storage-provisioner, default-storageclass, metrics-server
* Done! kubectl is now configured to use "minikube" cluster and "default" namespace by default

minikube status
minikube
type: Control Plane
host: Running
kubelet: Running
apiserver: Running
kubeconfig: Configured

minikube stop
* Stopping node "minikube" ...
* Powering off "minikube" via SSH ...
* 1 nodes stopped.

docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
e4fb66bf1961 gcr.io/k8s-minikube/kicbase:v0.0.20 "/usr/local/bin/entr…" 10 hours ago Exited (130) 3 minutes ago minikube

Analyse:
ls -l ~/.minikube

Löschen:
rm -rf ~/.minikube

Install kubectl

https://kubernetes.io/docs/tasks/tools/install-kubectl/
sudo curl -LO https://storage.googleapis.com/kubernetes-release/release/curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt/bin/linux/amd64/kubectl

   % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                  Dload  Upload   Total   Spent    Left  Speed
 100 44.2M  100 44.2M    0     0  30.9M      0  0:00:01  0:00:01 --:--:-- 30.9M

sudo chmod +x ./kubectl
sudo vi /etc/profile
export PATH=/opt:$PATH

. /etc/profile

kubectl version

minikube kubectl -- get pods -A

ReadsMe:

https://minikube.sigs.k8s.io/docs/drivers/none/
sudo apt-get install conntrack -y
sudo -E minikube start --driver=none
sudo minikube config set driver none

Hier der Inhalt der nginx-deployment.yaml Datei:

Folgendes passiert beim Start (bzw. Deployment der Komponenten) von Kubernetes:
1) Beim Deployment werden die Pods gebaut. Sie beinhalten die Container. Die Anzahl der Replikas bestimmt die maximale Anzahl der Pod-Instanzen.
2) Der Scheduler bekommt mit, dass etwas Neues reinkommt.
3) Der Scheduler informiert den Controller, dass es einen neuen Pod-Eintrag gibt. Der Controller ist dafür zuständig die Knoten (Kubelets) zu verwalten
4) Der Controller geht an die API und holt sich die Beschreibung der Replikas (Cluster Infos).

Wir sehen, dass die Replikas von Pod 1 auf die drei Nodes verteilt werden (z.B.). Die beiden Replikas von Pod2 werden auch auf die Nodes aufgeteilt.
Sollte Node 2 wegbrechen, werden die Pods auf die anderen Nodes verteilt/neu erstellt (Hier: Pod1R2 auf Node1):

Die Volumes, die zum Austausch der Daten genutzt werden, müssen auch in (z.B.) die yml-Datei geschrieben werden.

Kubernetes bringt von Hause aus ein Backup mit.

Minikube läuft auch auf einem Raspberry Pi: https://gist.github.com/lucaguada/e4c3725542c1cafa1fb3ea8a56c7e2d0

Man kann Kubernetes natürlich auch auf einem Hetzner-Rechner installieren:

Wir probieren nun Minikube auf der Demo-Seite aus: https://kubernetes.io/de/docs/tutorials/hello-minikube/

Wir klicken auf "Launch Terminal":

Es erscheint eine Konsole:

Wir können die Befehle auf der Webseite anklicken:

Wir klicken auf Preview Port 30000 und kommen damit in den Genuss das komplette Kubernetes Netzwerk mit einem grafischen Tool zu sehen und zu bedienen:

Wenn man bei den Pods rechts in den drei Punkten auf "Ausführen" klickt...

... kommt man in die Shell des Containers:

Disclaimer

Alles was ich mitschrieb und verstanden habe ist ohne Gewähr. Die Bilder stammen teilweise aus dem Internet und wir haben keine Urheberansprüche darauf.

Besten Dank an unseren sehr empfehlenswerten