W teorii wszystko wygląda prosto: Deployment zarządza Podami, a Service je wystawia. Czas zobaczyć, jak to działa w praktyce! W tej lekcji napiszemy nasze pierwsze pliki konfiguracyjne YAML i wdrożymy prosty serwer NGINX na naszym klastrze Minikube.

YAML: Język Komunikacji z Kubernetesem

YAML (co jest rekurencyjnym akronimem od “YAML Ain’t Markup Language”) to czytelny dla człowieka format zapisu danych, bardzo popularny w świecie konfiguracji. W Kubernetesie używamy plików YAML, aby w deklaratywny sposób opisać, jak mają wyglądać nasze obiekty.

Każdy plik konfiguracyjny obiektu w Kubernetesie musi zawierać cztery kluczowe pola:

  • apiVersion: Wersja API Kubernetesa, której używamy do stworzenia obiektu.
  • kind: Rodzaj obiektu, który tworzymy (np. Deployment, Service, Pod).
  • metadata: Metadane, które identyfikują obiekt, takie jak jego name (nazwa) i labels (etykiety).
  • spec: Specyfikacja, czyli serce pliku. Tutaj opisujemy pożądany stan naszego obiektu.

Krok 1: Tworzenie Deploymentu

Naszym celem jest uruchomienie dwóch replik serwera NGINX.

Stwórz na swoim komputerze plik o nazwie deployment.yaml i wklej do niego poniższą zawartość:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: moj-serwer-www  # Nazwa naszego Deploymentu
spec:
  replicas: 2  # Chcemy, aby zawsze działały 2 repliki (Pody)
  selector:
    matchLabels:
      app: moj-serwer-www  # Ten selektor mówi Deploymentowi, którymi Podami ma zarządzać
  template:  # To jest szablon Poda, który będzie tworzony
    metadata:
      labels:
        app: moj-serwer-www  # Nadajemy Podom etykietę, która musi pasować do selektora wyżej
    spec:
      containers:
      - name: nginx-container
        image: nginx:1.21.6  # Użyjemy konkretnej wersji obrazu NGINX
        ports:
        - containerPort: 80  # Aplikacja w kontenerze nasłuchuje na porcie 80

Najważniejsza jest tu relacja między spec.selector a spec.template.metadata.labels. Deployment używa etykiet, aby “wiedzieć”, które Pody należą do niego.

Teraz zastosujmy tę konfigurację w naszym klastrze za pomocą komendy kubectl apply:

kubectl apply -f deployment.yaml

Krok 2: Weryfikacja Deploymentu i Podów

Sprawdźmy, czy Kubernetes wykonał nasze polecenie.

Najpierw zobaczmy status naszego Deploymentu:

kubectl get deployments

Powinieneś zobaczyć swój moj-serwer-www i informację w kolumnie READY, że 2/2 repliki są gotowe.

Teraz zobaczmy Pody, które zostały stworzone:

kubectl get pods

Zobaczysz dwa Pody z losowymi nazwami, oba w statusie Running. To właśnie te Pody, którymi zarządza nasz Deployment!

Krok 3: Tworzenie Service’u

Nasze Pody działają, ale są niedostępne z zewnątrz. Musimy je “wystawić” za pomocą Service’u. Użyjemy typu NodePort, który jest prosty i idealny dla Minikube.

Stwórz plik service.yaml i wklej do niego:

apiVersion: v1
kind: Service
metadata:
  name: moj-serwer-www  # Nazwa naszego Service'u
spec:
  type: NodePort  # Typ Service'u, który wystawia port na każdym węźle klastra
  selector:
    app: moj-serwer-www  # Ten selektor musi pasować do etykiet Podów, które chcemy targetować
  ports:
    - protocol: TCP
      port: 80  # Port, na którym Service nasłuchuje wewnątrz klastra
      targetPort: 80  # Port, na który ruch ma być przekierowany (port kontenera)

Zauważ, że spec.selector w Service’ie jest identyczny jak etykiety naszych Podów. To właśnie tak Service wie, dokąd kierować ruch.

Zastosujmy konfigurację:

kubectl apply -f service.yaml

Krok 4: Dostęp do aplikacji

Sprawdźmy, czy nasz Service działa:

kubectl get services

Zobaczysz moj-serwer-www na liście.

Minikube dostarcza bardzo przydatną komendę, która generuje adres URL, pod którym dostępna jest nasza aplikacja:

minikube service moj-serwer-www --url

Komenda zwróci adres URL, podobny do http://192.168.49.2:31234. Skopiuj go i wklej do przeglądarki. Powinieneś zobaczyć stronę powitalną NGINX!

Krok 5: Sprzątanie

Gdy skończysz zabawę, dobrą praktyką jest posprzątanie po sobie. Możemy usunąć stworzone obiekty za pomocą tych samych plików, których użyliśmy do ich stworzenia, używając komendy kubectl delete.

kubectl delete -f service.yaml
kubectl delete -f deployment.yaml

Podsumowanie

Gratulacje! Właśnie wdrożyłeś i wystawiłeś swoją pierwszą aplikację na Kubernetesie! To ogromny kamień milowy. Zrozumiałeś najważniejszy przepływ pracy: piszesz deklaratywną konfigurację w pliku YAML, a następnie zlecasz jej wykonanie Kubernetesowi za pomocą kubectl apply.

W kolejnych lekcjach będziemy dalej zgłębiać możliwości Kubernetesa.