Java Training Block 11+12 – Microservices – Tag 9: Minikube + Git

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 neunten Tag in Block 11+12 (wir springen etwas hin und her) gelernt und behalten habe:

Minikube auf einer Linux-Maschine

Unser Dozent hat am gestrigen Abend auf einer geleasten Maschine bei Hetzner ein Kubernetes Minikube installiert. Hier ist die Beschreibung, wie er es gemacht hat:

Folgenden Service hat er gebucht: 2 CPUs, 4 GB RAM, 40 GB Festplate,... bei maximal (also nur wenn es durchgängig benutzt wird) 5,83 €/Monat:

Beschreibung der Installation

Ubuntu 20.04

https://minikube.sigs.k8s.io/docs/start/

User anlagen (root):

sudo adduser icke

sudo usermod -a -G sudo icke

sudo adduser icke mail

System Update (icke)

sudo apt-get update

sudo apt-get upgrade

Install Docker (icke):

sudo apt-get install curl wget apt-transport-https virtualbox virtualbox-ext-pack -y

sudo apt-get install docker.io -y

sudo usermod -aG docker icke
Install Minikube (icke):
Alternative I

sudo apt-get install apt-transport-https

sudo apt install virtualbox virtualbox-ext-pack

-> OK

-> YES

sudo apt install minikube
Alternative II
cd /opt

sudo wget https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64

sudo chmod +x minikube-linux-amd64

sudo mv minikube-linux-amd64 /usr/local/bin/minikube

minikube version
Install Kubernetes-Controller -> kubectl (icke):

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

sudo chmod +x ./kubectl

sudo mv ./kubectl /usr/local/bin/kubectl

kubectl version -o json
Start / Stop des Minikube (icke):

sudo minikube start --driver=docker

docker images

docker ps
Testen:

sudo ps -e  | grep etcd

sudo ps -e  | grep kube

oder

sudo ps -elf | grep etcd

sudo ps -elf | grep kube
Hello Minikube

https://kubernetes.io/de/docs/tutorials/hello-minikube/

Applikation bauen:

Yaml-File -> Pod

https://kubernetes.io/docs/concepts/workloads/controllers/deployment/

cd ~/controllers/

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

kubectl apply -f https://k8s.io/examples/controllers/nginx-deployment.yaml

kubectl apply -f ~/controllers/nginx-deployment.yaml
Docker-Image -> POD

https://kubernetes.io/de/docs/tutorials/hello-minikube/
cd ~/minikube/

vi server.js

var http = require('http');

var handleRequest = function(request, response) {

console.log('Received request for URL: ' + request.url);

response.writeHead(200);

response.end('Hello World!');

};

var www = http.createServer(handleRequest);

www.listen(8080);
vi Dockerfile

FROM node:6.14.2

EXPOSE 8080

COPY server.js .

CMD node server.js
docker build -t echoserver.img .

docker images

docker tag echoserver.img 4point/test-image                          // Images muss GeTag werden
docker login                                                         // Anmeldung Docker HUB

Login with your Docker ID to push and pull images from Docker Hub. If you don't have a Docker ID, head over to https://hub.docker.com to create one.

Username: USER

Password: PASS

docker push 4point/test-image                                        // Imagesin die Docker-Registry hochladen

-> https://hub.docker.com/

-> https://hub.docker.com/repository/docker/4point/test-image

kubectl create deployment hello-node --image=4point/test-image       / Deployment aus Docker HUB

kubectl get deployment

NAME         READY   UP-TO-DATE   AVAILABLE   AGE

hello-node   1/1     1            1           171m
Yaml-File -> POD

vi hello-node.yaml
  apiVersion: apps/v1
  kind: Deployment
  metadata:
    name: hw
    labels:
      app: hw
  spec:
    replicas: 3
    selector:
      matchLabels:
        app: hw
    template:
      metadata:
        labels:
          app: hw
      spec:
        containers:
        - name: hw
          image: 4point/test-image
          ports:
          - containerPort: 8888


Test:

kubectl get deployment

kubectl get service

docker exec -it minikube bash

curl -X GET http://10.100.204.152:8080/

Hier das Ergebnis:

Minikube läuft in einem Docker Container. Wenn wir das Hello-World sehen wollen, müssen wir in den Docker Container rein gehen, da die IP-Adresse nicht nach außen durchgereicht wird. Es sei denn wir bauen einen Router mit ein (was wir hier aber nicht getan haben).

---

Git enhanced

Wir haben noch etwas Theorie und Praxis zu Git und Branches bekommen:

HEAD ist der letzte Stand (das letzte Commit) den wir im jeweiligen Branch haben.

Git push --set-upstream origin alpha   // sorgt dafür, dass der lokale alpha Branch auch auf den Server erstellt wird.

Unterschied git fetch und git pull:

Beim pull wird gemerged, wenn es Unterschiede gibt. Also bei Konflikten muss man sofort lösen.
Beim fetch wird das Mergen auf später verschoben.

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

Trainer: Hans-Joachim Blanke blanke@4point.de

In den nächsten Tagen geht es weiter, so: stay tuned!

Achim Mertens