aA

Kubernetes podstawy – czyli tworzymy pierwszy load balancer

kubernetes podstawy

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.

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.

minikube

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.

dashboard-el

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.

deployment

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.

app

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

replica_status

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.

replica_pods

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

extensions

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

service_status

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.

Dodaj komentarz

Twój adres email nie zostanie opublikowany. Pola, których wypełnienie jest wymagane, są oznaczone symbolem *