
Kubernetes podstawy – czyli tworzymy pierwszy load balancer

Kubernetes to przenośna platforma Open Source służąca do zarządzania, automatyzacji i skalowania aplikacji kontenerowych. Dostarcza środowisko do uruchamiania systemów rozproszonych o wysokiej niezawodności. W tym artykule utworzymy własny, autoskalowalny klaster Kubernetes na maszynie lokalnej (bez kosztów). To wszystko w desktopowej wersji systemu EuroLinux 8.
Kubernetes to przenośna platforma Open Source służąca do zarządzania, automatyzacji i skalowania aplikacji kontenerowych. Dostarcza środowisko do uruchamiania systemów rozproszonych o wysokiej niezawodności. W tym artykule utworzymy własny, autoskalowalny klaster Kubernetes na maszynie lokalnej (bez kosztów). To wszystko w desktopowej wersji systemu Enterprise Linux 8.
W artykule zawarte są trzy definicje obiektów w plikach YAML. W celu zapoznania się z ich strukturą i możliwościami odsyłamy do dokumentacji Kubernetes. Ponieważ temat jest znacznie obszerniejszy, ograniczamy się tylko do ogólnych informacji pozwalających jednak na uruchomienie autoskalowalnego klastra.
Instalacja
Pierwszym krokiem będzie instalacja zestawu wirtualizacyjnego KVM/QEMU/libvirt zgodnie z naszym poprzednim artykułem. Minikube (narzędzie, które pozwala uruchomić klaster Kubernetes na maszynie lokalnej) potrzebuje bowiem hipernadzorcy, a powyższy zestaw jest najbardziej wydajnym rozwiązaniem wirtualizacyjnym w systemie GNU/Linux.
Po instalacji zestawu musimy dodać swojego użytkownika do grupy libvirt:
sudo usermod -aG libvirt nazwa_uzytkownika
Następnie pobieramy najnowszą wersję minikube – plik RPM dla architektury x86_64 ze strony: https://github.com/kubernetes/minikube/releases i instalujemy w systemie.
Po instalacji minikube poniższe polecenie powinno zwrócić wersję programu:
minikube version
Uruchamiamy maszynę wirtualną poleceniem:
minikube start
Minikube pobierze obraz iso, z którego zbuduje i uruchomi klaster korzystając z libvirt.
Kolejnym krokiem jest instalacja najnowszej wersji oprogramowania kubectl, czyli programu CLI do zarządzania klastrami Kubernetesa. Program możemy pobrać z: https://kubernetes.io/docs/tasks/tools/install-kubectl-linux/ i zainstalować poleceniem:
sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl
Poprawne wyświetlenie wersji kubectl oznacza, że możemy zacząć korzystać z minikube.
kubectl version
Polecenie:
minikube dashboard
otworzy stronę WWW z dashboardem minikube w nowym oknie przeglądarki. Korzystając z dashboardu możemy podglądać i wprowadzać zmiany w naszym klastrze.
Do naszej wirtualnej maszyny minikube możemy dostać się również poprzez SSH poleceniem:
minikube ssh
Deployment
Utwórzmy teraz nową aplikację za pomocą interfejsu WWW. W przeglądarce wybieramy znak plusa Create new resource, a następnie zakładkę Create from form i wpisujemy:
App Name: cntident
Container image: eurolinuxid/cntident
Number of pods: 1
Następnie naciskamy przycisk Deploy.
Nasz EuroLinuksowy, testowy kontener powinien się pobrać z repozytorium obrazów Dockera i rozpocząć pracę pod kontrolą Kubernetesa jako „pod”, czyli najmniejsza jednostka obliczeniowa Kubernetesa.
Wyświetlmy nazwę naszego poda z poziomu wiersza poleceń:
kubectl get pod
Po skopiowaniu wyświetlanej nazwy poda przekierujmy port 8080 naszej lokalnej maszyny na port 80 poda:
kubectl port-forward pod/nazwa_poda 8080:80
a następnie w pole adresu przeglądarki wpiszmy: http://127.0.0.1:8080
Wyświetli się prosta strona WWW z identyfikatorem naszego poda i wewnętrznym adresem IP, na którym pod jest uruchomiony.
ReplicaSet
Obiekt ReplicaSet w Kubernetes odpowiada za skalowanie, czyli za kontrolę liczby uruchomionych podów w zależności od określonych warunków.
Utwórzmy definicję obiektu ReplicaSet, korzystając nadal z naszej testowej aplikacji:
apiVersion: apps/v1
kind: ReplicaSet
metadata:
name: ident-rs
labels:
app: cntident
spec:
replicas: 3
selector:
matchLabels:
app: cntident
template:
metadata:
name: cntident
labels:
app: cntident
spec:
containers:
- name: cntident
image: eurolinuxid/cntident
ports:
- containerPort: 80
Wprowadźmy ten plik yaml do minicube za pomocą polecenia:
kubectl apply -f ident-rs.yaml
W lewym menu interfejsu dashboarda, po kliknięciu działu ReplicaSet powinniśmy zobaczyć domyślny ReplicaSet naszego poprzedniego poda oraz obiekt, który właśnie utworzyliśmy za pomocą pliku YAML. Wejdźmy do wewnątrz tego obiektu, klikając link z nazwą ident-rs.
W grupie Pods wyświetlą się trzy pody – usunięcie jednego z nich spowoduje natychmiastowe utworzenie nowego poda z nowym, unikalnym identyfikatorem.
Możemy zeskalować liczbę podów do czterech poleceniem:
kubectl scale rs ident-rs --replicas=4
lub wybierając edycję pliku YAML w interfejsie WWW (opcja: Edit resurce) i wstawiając cyfrę 4 w pozycji replicas.
Zmiana powinna być widoczna w inferfejsie w ciągu kilku sekund.
Możemy też ustawić autoskalowanie naszego klastra w zależności od poziomu zużycia procesora. Wcześniej aktywujmy serwer metryk, który jest niezbędny do prawidłowego działania autoskalowania:
minikube addons enable metrics-server
Poniższe polecenie sprawi, że wraz ze wzrostem obciążenia, płynnie uruchomi się do 10 podów z naszą aplikacją. Wszystko to w ramach zdefiniowanego wcześniej obiektu ReplicaSet ident-rs:
kubectl autoscale rs ident-rs --min=3 --max=10 --cpu-percent=80
Load Balancing z wykorzystaniem dodatku Ingress
Kontroler Nginx Ingress to serwer proxy oparty na serwerze Nginx. Wykorzystuje on dane usługi ident-sv (którą utworzymy w dalszej części artykułu), a następnie proxuje nasze pody na jednym adresie IP.
W pierwszej kolejności musimy włączyć dodatek Ingress – sprawdźmy, czy jest włączony domyślnie:
minikube addons list
Jeżeli jest wyłączony, to włączamy go poleceniem:
minikube addons enable ingress
Następnie musimy dołączyć usługę (service), która wystawia na porcie 8070 ruch do kontenerów nasłuchujących na porcie 80:
apiVersion: v1
kind: Service
metadata:
name: ident-sv
spec:
ports:
- port: 8070
protocol: TCP
targetPort: 80
selector:
app: cntident
type: ClusterIP
Aktywacja usługi:
kubectl apply -f ident-sv.yaml
Ponieważ obecnie mają miejsce małe konflikty w używanych przez Ingressa wersjach API, przed aktywacją definicji Ingressa należy uruchomić tymczasowe obejście problemu:
kubectl delete -A ValidatingWebhookConfiguration ingress-nginx-admission
Teraz możemy utworzyć i aktywować definicję naszego load balancera:
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: ident-ing
namespace: default
annotations:
kubernetes.io/ingress.class: nginx
nginx.ingress.kubernetes.io/ssl-redirect: "false"
nginx.ingress.kubernetes.io/use-regex: "false"
spec:
rules:
- http:
paths:
- pathType: Prefix
path: /
backend:
service:
name: ident-sv
port:
number: 80
Aktywujemy standardowym poleceniem:
kubectl apply -f ident-ing.yaml
W dashboardzie w menu Service -> Ingresses w grupie ident-ing klikamy link z adresem IP znajdujący się w polu Endpoints. Uwaga: adres IP wyświetla się dopiero po pełnej aktywacji usługi, co może potrwać ponad minutę. Odświeżając stronę otrzymamy wynik działania aplikacji z różnych podów zdefiniowanych w naszym obiekcie ReplicaSet, czyli inaczej mówiąc: poprawnie działający load balancing.
Podsumowanie
W artykule korzystałem z systemu EuroLinux 8, ale z powodzeniem można zastosować te rozwiązania w innych desktopowych wersjach systemu Linux klasy Enterprise m.in. Red Hat® Enterprise Linux®, CentOS, czy Oracle® Linux. Minikube jest lekką implementacją Kubernetesa – wdraża prosty klaster zawierający tylko jeden węzeł. Jednak dzięki niemu możemy zapoznać się z obsługą Kubernetes bezkosztowo w domowym zaciszu, a nabyte doświadczenia wykorzystać w komercyjnych rozwiązaniach chmurowych.