Używanie Kubernetes do wdrażania PostgreSQL

Wprowadzenie

Kubernetes to system orkiestracji kontenerów typu open source do automatyzacji wdrażania, skalowania i zarządzania aplikacjami kontenerowymi. Uruchamianie bazy danych PostgreSQL na Kubernetes jest obecnie tematem dyskusji, ponieważ Kubernetes zapewnia sposoby udostępniania kontenerów stanowych przy użyciu trwałych woluminów, zestawów stanów itp.

Ten blog ma na celu przedstawienie kroków do uruchomienia bazy danych PostgreSQL w klastrze Kubernetes. Nie obejmuje instalacji ani konfiguracji klastra Kubernetes, chociaż wcześniej pisaliśmy o tym w tym blogu na MySQL Galera Cluster na Kubernetes.

Wymagania wstępne

• Pracujący klaster Kubernetes
• Podstawowe zrozumienie Dockera

Możesz udostępnić klaster Kubernetes u dowolnego dostawcy chmury publicznej, takiego jak AWS, Azure lub chmura Google itp. Zapoznaj się z krokami instalacji i konfiguracji klastra Kubernetes dla CentOS tutaj. Możesz również sprawdzić we wcześniejszym poście na blogu podstawy dotyczące wdrażania PostgreSQL w kontenerze Docker.

Aby wdrożyć PostgreSQL na Kubernetes, musimy wykonać następujące kroki:

• Obraz dokowany Postgres
• Mapy konfiguracji do przechowywania konfiguracji Postgres
• Wolumen pamięci trwałej
• Wdrażanie PostgreSQL
• Usługa PostgreSQL

Obraz dokera PostgreSQL

Używamy PostgreSQL 10.4 Obraz platformy Docker z rejestru publicznego. Ten obraz zapewni funkcjonalność dostarczania niestandardowych konfiguracji/zmiennych środowiskowych PostgreSQL, takich jak nazwa użytkownika, hasło, nazwa bazy danych i ścieżka itp.

Mapy konfiguracji dla konfiguracji PostgreSQL

Będziemy używać map konfiguracji do przechowywania informacji związanych z PostgreSQL. Tutaj używamy bazy danych, użytkownika i hasła w mapie konfiguracji, która będzie używana przez pod PostgreSQL w szablonie wdrożenia.

Plik:postgres-configmap.yaml

apiVersion: v1
kind: ConfigMap
metadata:
  name: postgres-config
  labels:
    app: postgres
data:
  POSTGRES_DB: postgresdb
  POSTGRES_USER: postgresadmin
  POSTGRES_PASSWORD: admin123

Utwórz zasób map konfiguracji Postgres

$ kubectl create -f postgres-configmap.yaml 
configmap "postgres-config" created

Wolumen pamięci trwałej

Jak wszyscy wiecie, kontenery Docker mają charakter efemeryczny. Wszystkie dane generowane przez lub w kontenerze zostaną utracone po zakończeniu instancji kontenera.

Aby zapisać dane, będziemy używać trwałych woluminów i zasobu trwałego żądania woluminu w Kubernetes do przechowywania danych w trwałych magazynach.

Tutaj używamy lokalnego katalogu/ścieżki jako trwałego zasobu pamięci (/mnt/data)

Plik:postgres-storage.yaml

kind: PersistentVolume
apiVersion: v1
metadata:
  name: postgres-pv-volume
  labels:
    type: local
    app: postgres
spec:
  storageClassName: manual
  capacity:
    storage: 5Gi
  accessModes:
    - ReadWriteMany
  hostPath:
    path: "/mnt/data"
---
kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  name: postgres-pv-claim
  labels:
    app: postgres
spec:
  storageClassName: manual
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 5Gi

Twórz wdrożenia związane z pamięcią masową

$ kubectl create -f postgres-storage.yaml 
persistentvolume "postgres-pv-volume" created
persistentvolumeclaim "postgres-pv-claim" created

Wdrażanie PostgreSQL

Manifest PostgreSQL do wdrożenia kontenera PostgreSQL wykorzystuje obraz PostgreSQL 10.4. Wykorzystuje konfigurację PostgreSQL, taką jak nazwa użytkownika, hasło, nazwa bazy danych z utworzonej wcześniej mapy konfiguracji. Montuje również wolumin utworzony z woluminów trwałych i twierdzi, że dane kontenera PostgreSQL będą utrwalane.

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: postgres
spec:
  replicas: 1
  template:
    metadata:
      labels:
        app: postgres
    spec:
      containers:
        - name: postgres
          image: postgres:10.4
          imagePullPolicy: "IfNotPresent"
          ports:
            - containerPort: 5432
          envFrom:
            - configMapRef:
                name: postgres-config
          volumeMounts:
            - mountPath: /var/lib/postgresql/data
              name: postgredb
      volumes:
        - name: postgredb
          persistentVolumeClaim:
            claimName: postgres-pv-claim

Utwórz wdrożenie Postgresa

$ kubectl create -f postgres-deployment.yaml 
deployment "postgres" created

Usługa PostgreSQL

Aby uzyskać dostęp do wdrożenia lub kontenera, musimy udostępnić usługę PostgreSQL. Kubernetes zapewnia różne rodzaje usług, takich jak ClusterIP, NodePort i LoadBalancer.

Dzięki ClusterIP możemy uzyskać dostęp do usługi PostgreSQL w ramach Kubernetes. NodePort daje możliwość ujawnienia punktu końcowego usługi w węzłach Kubernetes. Aby uzyskać dostęp do PostgreSQL zewnętrznie, musimy użyć usługi typu Load Balancer, która udostępnia usługę zewnętrznie.

Plik:postgres-service.yaml

apiVersion: v1
kind: Service
metadata:
  name: postgres
  labels:
    app: postgres
spec:
  type: NodePort
  ports:
   - port: 5432
  selector:
   app: postgres

Utwórz usługę Postgres

$ kubectl create -f postgres-service.yaml 
service "postgres" created

Połącz z PostgreSQL

Aby połączyć się z PostgreSQL, musimy pobrać port Node z wdrożenia usługi.

$ kubectl get svc postgres
NAME       TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
postgres   NodePort   10.107.71.253   <none>        5432:31070/TCP   5m

Musimy użyć portu 31070, aby połączyć się z PostgreSQL z maszyny/węzła znajdującego się w klastrze kubernetes z danymi uwierzytelniającymi podanymi wcześniej w configmapie.

$ psql -h localhost -U postgresadmin1 --password -p 31070 postgresdb
Password for user postgresadmin1: 
psql (10.4)
Type "help" for help.
 
postgresdb=#

Usuń wdrożenia PostgreSQL

Aby usunąć zasoby PostgreSQL, musimy użyć poniższych poleceń.

# kubectl delete service postgres 
# kubectl delete deployment postgres
# kubectl delete configmap postgres-config
# kubectl delete persistentvolumeclaim postgres-pv-claim
# kubectl delete persistentvolume postgres-pv-volume

Mamy nadzieję, że wykonując powyższe kroki, będziesz w stanie udostępnić samodzielną instancję PostgreSQL w klastrze Kubernetes.

Wniosek

Uruchamianie PostgreSQL na Kubernetes pomaga wykorzystać zasoby w lepszy sposób niż przy użyciu maszyn wirtualnych. Kubernetes zapewnia również izolację innych aplikacji korzystających z PostgreSQL w ramach tej samej maszyny wirtualnej lub klastra Kubernetes.

Ten artykuł zawiera przegląd tego, jak możemy używać PostgreSQL na Kubernetes w środowisku programistycznym/POC. Możesz eksplorować/konfigurować klaster PostgreSQL za pomocą zestawów stanów Kubernetes.

Wymagane zestawy StatefulSets?

W Kubernetes zestawy StatefulSets są wymagane do skalowania aplikacji stanowych. PostgreSQL można łatwo skalować za pomocą StatefulSets za pomocą jednego polecenia.

Referencje

• Instalacja Kubernetes na CentOS:https://www.techrepublic.com/article/how-to-install-a-kubernetes-cluster-oen-centos-7
• Konfiguracja Kubectl:https://kubernetes.io/docs/tasks/tools/install-kubectl
• PostgreSQL przy użyciu platformy Docker:https://severalnines.com/blog/deploying-postgresql-docker-container
• Kubernetes:https://kubernetes.io
• Klaster PostgreSQL używający statefulsets https://kubernetes.io/blog/2017/02/postgresql-clusters-kubernetes-statefulsets