Cómo implementar PostgreSQL en Kubernetes

Introducción

PostgreSQL es un sistema de base de datos relacional confiable y robusto que presenta transacciones compatibles con ACID. Está diseñado para manejar cargas de trabajo de todos los tamaños, por lo que es ideal para uso personal e implementaciones a gran escala, como almacenes de datos, servidores de big data o servicios web.

La implementación de PostgreSQL en Kubernetes crea una instancia de PostgreSQL escalable y portátil, aprovechando los aspectos positivos tanto del RDBMS como de la plataforma de orquestación.

Este artículo le mostrará dos métodos para implementar PostgreSQL en Kubernetes:usar un gráfico de Helm o crear manualmente su configuración.

Requisitos previos

• Un clúster de Kubernetes con kubectl instalado
• Helm 3 instalado
• Privilegios administrativos en su sistema

Implementar PostgreSQL usando Helm

Helm le ofrece una forma rápida y sencilla de implementar una instancia de PostgreSQL en su clúster.

Paso 1:agregar repositorio de Helm

1. Busque en Artifact Hub un gráfico PostgreSQL Helm que desee utilizar. Agregue el repositorio del gráfico a su instalación local de Helm escribiendo:

helm repo add [repository-name] [repository-address]

Este artículo utiliza el gráfico Bitnami Helm para la instalación de PostgreSQL.

2. Después de haber agregado el repositorio, actualice sus repositorios locales.

helm repo update

El sistema confirma la actualización exitosa.

Paso 2:crear y aplicar un volumen de almacenamiento persistente

Los datos en su base de datos de Postgres deben persistir a través de reinicios de pod.

1. Para lograr esto, cree un recurso PersistentVolume en un archivo YAML, usando un editor de texto como nano.

nano postgres-pv.yaml

El contenido del archivo define:

• El recurso en sí.
• La clase de almacenamiento.
• La cantidad de almacenamiento asignado.
• Los modos de acceso.
• La ruta de montaje en el sistema host.

Este ejemplo utiliza la siguiente configuración:

apiVersion: v1
kind: PersistentVolume
metadata:
  name: postgresql-pv
  labels:
    type: local
spec:
  storageClassName: manual
  capacity:
    storage: 10Gi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: "/mnt/data"

2. Guarde el archivo y salga. Luego aplique la configuración con kubectl :

kubectl apply -f postgres-pv.yaml

El sistema confirma la creación del volumen persistente.

Paso 3:crear y aplicar una reclamación de volumen persistente

1. Cree una reclamación de volumen persistente (PVC) para solicitar el almacenamiento asignado en el paso anterior.

nano postgres-pvc.yaml

El ejemplo usa la siguiente configuración:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: postgresql-pv-claim
spec:
  storageClassName: manual
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi

2. Guarde el archivo y salga. Aplicar la configuración con kubectl :

kubectl apply -f postgres-pvc.yaml

El sistema confirma la creación exitosa de PVC.

3. Usa kubectl get para verificar si el PVC está conectado al PV con éxito:

kubectl get pvc

La columna de estado muestra que la reclamación está vinculada. .

Paso 4:Instale el gráfico de Helm

Instale el gráfico de timón con helm install dominio. Añadir --set marca al comando para conectar la instalación al PVC que creó y habilitar los permisos de volumen:

helm install [release-name] [repo-name] --set persistence.existingClaim=[pvc-name] --set volumePermissions.enabled=true

El sistema muestra un informe sobre la instalación exitosa.

Paso 5:Conéctese al cliente de PostgreSQL

1. Exporte el POSTGRES_PASSWORD variable de entorno para poder iniciar sesión en la instancia de PostgreSQL:

export POSTGRES_PASSWORD=$(kubectl get secret --namespace default psql-test-postgresql -o jsonpath="{.data.postgresql-password}" | base64 --decode)

2. Abra otra ventana de terminal y escriba el siguiente comando para reenviar el puerto de Postgres:

kubectl port-forward --namespace default svc/psql-test-postgresql 5432:5432

El sistema comienza a gestionar la conexión del puerto.

3. Minimice la ventana de reenvío de puertos y regrese a la anterior. Escriba el comando para conectarse a psql, un cliente de PostgreSQL:

PGPASSWORD="$POSTGRES_PASSWORD" psql --host 127.0.0.1 -U postgres -d postgres -p 5432

El psql Aparece el símbolo del sistema y PostgreSQL está listo para recibir su entrada.

Implemente PostgreSQL creando una configuración desde cero

La configuración manual de Postgres en Kubernetes le permite ajustar su configuración de implementación.

Paso 1:Crear y aplicar ConfigMap

El recurso ConfigMap contiene los datos que se utilizan durante el proceso de implementación.

1. Cree un archivo YAML de ConfigMap en un editor de texto.

nano postgres-configmap.yaml

2. La parte más importante del archivo es la sección de datos, donde proporciona un nombre para la base de datos , el nombre de usuario y la contraseña para iniciar sesión en la instancia de PostgreSQL.

El ejemplo usa los siguientes parámetros en el archivo ConfigMap.

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

3. Guarde el archivo y salga. Luego aplique el recurso con kubectl :

kubectl apply -f postgres-configmap.yaml

El sistema confirma la creación exitosa del archivo de configuración.

Paso 2:crear y aplicar un volumen de almacenamiento persistente y un reclamo de volumen persistente

1. Cree un archivo YAML para la configuración de almacenamiento.

nano postgres-storage.yaml

2. El método de implementación del gráfico de Helm usó dos archivos separados para el Volumen persistente y el Reclamo de volumen persistente, pero también puede colocar ambas configuraciones en un archivo, como en el ejemplo a continuación.

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

3. Guarde el archivo y salga. Aplicar los recursos con kubectl :

kubectl apply -f postgres-storage.yaml

El sistema confirma la creación exitosa de PV y PVC.

4. Verifique que el PVC esté conectado al PV con el siguiente comando:

kubectl get pvc

El estado de la PVC es Bound y el PVC está listo para usarse en la implementación de PostgreSQL.

Paso 3:crear y aplicar la implementación de PostgreSQL

1. Cree un archivo YAML de implementación.

nano postgres-deployment.yaml

2. El archivo de implementación contiene la configuración de la implementación de PostgreSQL y proporciona especificaciones para los contenedores y volúmenes:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: postgres
spec:
  replicas: 1
  selector:
    matchLabels:
      app: postgres
  template:
    metadata:
      labels:
        app: postgres
    spec:
      containers:
        - name: postgres
          image: postgres:10.1
          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

3. Guarde el archivo y salga. Aplicar la implementación con kubectl :

kubectl apply -f postgres-deployment.yaml

El sistema confirma la creación exitosa de la implementación.

Paso 4:crear y aplicar el servicio PostgreSQL

1. Por último, cree el archivo YAML para configurar el servicio PostgreSQL.

nano postgres-service.yaml

2. Especifique el tipo de servicio y los puertos. El ejemplo usa la siguiente configuración:

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

3. Guarde el archivo y salga. Aplicar la configuración con kubectl :

kubectl apply -f postgres-service.yaml

El sistema confirma la creación exitosa del servicio.

4. Use el siguiente comando para enumerar todos los recursos en el sistema.

kubectl get all

El pod y la implementación muestran el 1/1 estado listo. La cantidad deseada de conjuntos de réplicas refleja lo que está configurado en el archivo YAML de implementación.

Paso 5:Conéctese a PostgreSQL

1. Cuando todos los recursos estén listos, use kubectl exec para iniciar sesión en la instancia de PostgreSQL.

kubectl exec -it [pod-name] --  psql -h localhost -U admin --password -p [port] postgresdb

2. El sistema solicita la contraseña. Escriba la contraseña definida en el Paso 1 y presione Enter . El psql aparece el símbolo del sistema.

La base de datos ahora está lista para recibir la entrada del usuario.