Kubernetes i PostgreSQL: Jak uruchomić bazę danych w chmurze?

W dzisiejszych czasach, gdy większość aplikacji przenosi się do chmury, zarządzanie bazami danych staje się coraz bardziej złożone. Jednym z popularnych rozwiązań do uruchamiania aplikacji w chmurze jest Kubernetes. Ale jak to wszystko połączyć z PostgreSQL? W tym artykule pokażę Ci, jak uruchomić PostgreSQL w Kubernetes, jakie są zalety tego rozwiązania i jak skonfigurować go krok po kroku w swojej infrastrukturze. Czeka Cię nie tylko porcja teorii, ale także praktyczne przykłady, które pomogą Ci zrozumieć, jak Kubernetes współpracuje z PostgreSQL.

Dlaczego Kubernetes i PostgreSQL?

PostgreSQL to jeden z najbardziej popularnych systemów zarządzania relacyjnymi bazami danych. Jego otwartoźródłowy charakter, wydajność, elastyczność oraz możliwość dostosowania do wielu różnych scenariuszy sprawiają, że jest wykorzystywany na szeroką skalę. Kubernetes z kolei to platforma do zarządzania kontenerami, która umożliwia automatyzację wdrażania, skalowania oraz zarządzania aplikacjami w chmurze.

Połączenie PostgreSQL z Kubernetes daje nam potężne narzędzie, które pozwala na:

• Automatyczne skalowanie – Kubernetes pozwala na dynamiczne dostosowywanie liczby podów, co jest szczególnie przydatne w przypadku wzrostu obciążenia bazy danych.
• Wysoką dostępność – Kubernetes umożliwia łatwe tworzenie klastrów, co zapewnia wysoką dostępność aplikacji i bazy danych.
• Łatwiejsze zarządzanie – Dzięki Kubernetes możesz zarządzać wszystkimi aspektami wdrożenia PostgreSQL w sposób zautomatyzowany i powtarzalny.

Podstawowe pojęcia związane z Kubernetes i PostgreSQL

Aby w pełni zrozumieć, jak uruchomić PostgreSQL w Kubernetes, warto poznać kilka podstawowych pojęć związanych z tymi technologiami:

• Pod: Jest to podstawowa jednostka uruchomieniowa w Kubernetes. Pod zawiera jeden lub więcej kontenerów, które współdzielą zasoby, takie jak sieć i magazyn danych.
• Deployment: Zasób Kubernetes, który umożliwia deklarowanie stanu aplikacji. Dzięki deploymentowi możemy łatwo zarządzać wersjami aplikacji, skalowaniem oraz aktualizacjami.
• StatefulSet: Specjalny rodzaj deploymentu, który jest używany do uruchamiania aplikacji z wymaganiami dotyczącymi przechowywania danych, takich jak bazy danych. StatefulSet zapewnia unikalne identyfikatory dla poszczególnych podów oraz trwałość danych.
• Persistent Volume (PV) i Persistent Volume Claim (PVC): W Kubernetes do przechowywania danych używamy zasobów o nazwie Persistent Volume, które są powiązane z Persistent Volume Claim, czyli żądaniem pamięci masowej. To kluczowe w przypadku baz danych, które wymagają trwałego przechowywania danych.

Jak uruchomić PostgreSQL w Kubernetes? Przykłady

Teraz przejdźmy do konkretów. Poniżej pokażę Ci, jak krok po kroku uruchomić PostgreSQL w Kubernetes, używając StatefulSet oraz Persistent Volumes.

1. Tworzenie Persistent Volume i Persistent Volume Claim

Na początku musimy zadbać o miejsce na dane, które będą przechowywane przez naszą bazę danych. W Kubernetes tworzymy Persistent Volume (PV), który będzie wskazywał na lokalizację w systemie plików lub na zasobie chmurowym, takim jak Amazon EBS czy Google Cloud Persistent Disk. Następnie tworzymy Persistent Volume Claim (PVC), który jest żądaniem tego zasobu.

apiVersion: v1
kind: PersistentVolume
metadata:
  name: postgres-pv
spec:
  capacity:
    storage: 10Gi
  volumeMode: Filesystem
  accessModes:
    - ReadWriteOnce
  persistentVolumeReclaimPolicy: Retain
  storageClassName: standard
  hostPath:
    path: /mnt/data/postgresql
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: postgres-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi
  storageClassName: standard

W powyższym przykładzie definiujemy Persistent Volume, który wykorzystuje lokalną ścieżkę na węźle Kubernetes, oraz Persistent Volume Claim, który żąda 10 GB pamięci.

2. Tworzenie StatefulSet dla PostgreSQL

Teraz przejdźmy do stworzenia samego PostgreSQL. W Kubernetes najlepiej używać StatefulSet, aby zapewnić trwałość i unikalność identyfikatorów dla poszczególnych podów. Oto jak może wyglądać manifest StatefulSet dla PostgreSQL:

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: postgres
spec:
  serviceName: "postgres"
  replicas: 1
  selector:
    matchLabels:
      app: postgres
  template:
    metadata:
      labels:
        app: postgres
    spec:
      containers:
        - name: postgres
          image: postgres:13
          env:
            - name: POSTGRES_USER
              value: "admin"
            - name: POSTGRES_PASSWORD
              value: "adminpassword"
            - name: POSTGRES_DB
              value: "mydatabase"
          volumeMounts:
            - name: postgres-storage
              mountPath: /var/lib/postgresql/data
  volumeClaimTemplates:
    - metadata:
        name: postgres-storage
      spec:
        accessModes:
          - ReadWriteOnce
        resources:
          requests:
            storage: 10Gi

W tym przypadku uruchamiamy PostgreSQL 13 w jednym podzie, z użytkownikiem, hasłem i nazwą bazy danych. Podłączamy również Persistent Volume Claim do katalogu, w którym PostgreSQL przechowuje swoje dane.

3. Tworzenie usługi (Service) dla PostgreSQL

Aby umożliwić dostęp do bazy danych, musimy stworzyć usługę (Service), która pozwoli na komunikację z naszym kontenerem PostgreSQL. Oto jak wygląda manifest dla usługi:

apiVersion: v1
kind: Service
metadata:
  name: postgres
spec:
  selector:
    app: postgres
  ports:
    - port: 5432
      targetPort: 5432
  clusterIP: None

Usługa ta pozwala na dostęp do naszego PostgreSQL w ramach klastra Kubernetes. Dzięki niej kontenery w tym samym klastrze mogą się komunikować z naszą bazą danych.

4. Dostęp z aplikacji do PostgreSQL

Po uruchomieniu PostgreSQL w Kubernetes, aplikacja może uzyskać dostęp do bazy danych przez usługę postgres na porcie 5432. Oto przykładowa konfiguracja połączenia z PostgreSQL z aplikacji w Kubernetes:

postgres://admin:adminpassword@postgres:5432/mydatabase

Warto zauważyć, że zamiast adresu IP, używamy nazwy usługi Kubernetes, czyli postgres. Kubernetes automatycznie zapewni nam dostęp do odpowiedniego poda.

Podsumowanie

Uruchamianie PostgreSQL w Kubernetes to świetne rozwiązanie dla aplikacji, które potrzebują skalowalnej i niezawodnej bazy danych. Dzięki użyciu StatefulSet oraz Persistent Volumes możesz mieć pewność, że Twoje dane są trwałe i łatwe do zarządzania. Kubernetes automatycznie dba o skalowanie i dostępność Twojej bazy danych, co pozwala skupić się na rozwoju aplikacji, zamiast na zarządzaniu infrastrukturą.

Jeśli jeszcze nie pracujesz z Kubernetes i PostgreSQL, warto zacząć eksperymentować z tym rozwiązaniem. Dzięki niemu możesz wykorzystać wszystkie zalety chmurowej infrastruktury, jednocześnie zapewniając swoim aplikacjom solidne wsparcie w postaci stabilnej bazy danych.