Como implantar Postgres no cluster Kubernetes

O autor selecionou Girst Who Code para receber uma doação como parte do programa Write for DOnations.

Introdução

A implantação de um banco de dados PostgreSQL em um cluster Kubernetes tornou-se uma abordagem popular para gerenciar ambientes de banco de dados escaláveis, resilientes e dinâmicos. O Kubernetes possui recursos de orquestração de contêineres que oferecem uma estrutura robusta para implantação e gerenciamento de aplicativos, incluindo bancos de dados como PostgreSQL, em um ambiente distribuído. Essa integração oferece vantagens significativas de escalabilidade, resiliência e utilização eficiente de recursos. Ao aproveitar os recursos do Kubernetes, como escalabilidade, implantação automatizada e recursos de autocorreção, os usuários podem garantir a operação perfeita de seus bancos de dados PostgreSQL em um ambiente conteinerizado.

Este guia explorará o processo passo a passo de implantação do PostgreSQL em um cluster Kubernetes. Quer você seja um desenvolvedor, engenheiro de DevOps ou administrador de sistema que deseja implantar o PostgreSQL em um ambiente Kubernetes de maneira eficaz, este guia tem como objetivo fornecer insights abrangentes e etapas práticas para configurar e gerenciar bancos de dados PostgreSQL com êxito em um cluster Kubernetes.

Pré-requisitos

Antes de começar este tutorial, você precisará do seguinte:

• Um servidor de desenvolvimento ou máquina local a partir da qual você implantará o PostgreSQL.

• A ferramenta de linha de comando kubectl está instalada em sua máquina de desenvolvimento. Para instalar isso, siga este guia da documentação oficial do Kubernetes.

• Um cluster Kubernetes. Você pode provisionar um cluster DigitalOcean Kubernetes seguindo nosso guia de início rápido do Kubernetes.

Crie um ConfigMap para armazenar detalhes do banco de dados

No Kubernetes, um ConfigMap é um objeto API que armazena dados de configuração em pares chave-valor, que pods ou contêineres podem usar em um cluster. O ConfigMaps ajuda a separar os detalhes de configuração do código do aplicativo, facilitando o gerenciamento e a atualização das definições de configuração sem alterar o código do aplicativo.

Vamos criar um arquivo de configuração ConfigMap para armazenar detalhes de conexão PostgreSQL, como nome do host, nome do banco de dados, nome de usuário e outras configurações.

nano postgres-configmap.yaml

Adicione a seguinte configuração. Defina o nome, usuário e senha padrão do banco de dados.

apiVersion: v1
kind: ConfigMap
metadata:
  name: postgres-secret
  labels:
    app: postgres
data:
  POSTGRES_DB: ps_db
  POSTGRES_USER: ps_user
  POSTGRES_PASSWORD: SecurePassword

Vamos analisar a configuração acima:

• apiVersion: v1 especifica a versão da API Kubernetes usada para este ConfigMap.

• kind: ConfigMap define o tipo de recurso do Kubernetes.

• Em metadados, o campo nome especifica o nome do ConfigMap, definido como “postgres-secret. ” Além disso, rótulos são aplicados ao ConfigMap para ajudar a identificar e organizar recursos.

• A seção dados contém os dados de configuração como pares de valores-chave.

• POSTGRES_DB: Especifique o nome do banco de dados padrão para PostgreSQL.

• POSTGRES_USER: Especifique o nome de usuário padrão para PostgreSQL.

• POSTGRES_PASSWORD: Especifique a senha padrão para o usuário PostgreSQL.

Salve e feche o arquivo e aplique a configuração do ConfigMap ao Kubernetes.

kubectl apply -f postgres-configmap.yaml

Você pode verificar a implantação do ConfigMap usando o comando a seguir.

kubectl get configmap

Saída.

NAME               DATA   AGE
kube-root-ca.crt   1      116s
postgres-secret    3      12s

Crie um PersistentVolume (PV) e um PersistentVolumeClaim (PVC)

PersistentVolume (PV) e PersistentVolumeClaim (PVC) são recursos do Kubernetes que fornecem e reivindicam armazenamento persistente em um cluster. Um PersistentVolume fornece recursos de armazenamento no cluster, enquanto um PersistentVolumeClaim permite que os pods solicitem recursos de armazenamento específicos.

Primeiro, crie um arquivo YAML para PersistentVolume.

nano psql-pv.yaml

Adicione a seguinte configuração.

apiVersion: v1
kind: PersistentVolume
metadata:
  name: postgres-volume
  labels:
    type: local
    app: postgres
spec:
  storageClassName: manual
  capacity:
    storage: 10Gi
  accessModes:
    - ReadWriteMany
  hostPath:
    path: /data/postgresql

Aqui está a explicação de cada componente:

• storageClassName: manual especifica o StorageClass para este PersistentVolume. O StorageClass denominado “manual” indica que o provisionamento do armazenamento é feito manualmente.

• Capacidade especifica a capacidade desejada do PersistentVolume.

• accessModes define os modos de acesso suportados pelo PersistentVolume. Nesse caso, é definido como ReadWriteMany, permitindo que vários pods leiam e gravem no volume simultaneamente.

• hostPath é o tipo de volume criado diretamente no sistema de arquivos do nó. É um diretório no sistema de arquivos da máquina host (caminho: “/data/postgresql”) que será usado como local de armazenamento para o PersistentVolume. Este caminho se refere a um local no host onde os dados do PersistentVolume serão armazenados.

Salve o arquivo e aplique a configuração acima ao Kubernetes.

kubectl apply -f psql-pv.yaml

Em seguida, crie um YAML para PersistentVolumeClaim.

nano psql-claim.yaml

Adicione as seguintes configurações.

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: postgres-volume-claim
  labels:
    app: postgres
spec:
  storageClassName: manual
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 10Gi

Vamos decompor os componentes:

• kind: PersistentVolumeClaim indica que este YAML define um recurso PersistentVolumeClaim.

• storageClassName: manual especifica o StorageClass desejado para este PersistentVolumeClaim.

• accessModes especifica o modo de acesso exigido pelo PersistentVolumeClaim.

• Recursos definem os recursos solicitados para o PersistentVolumeClaim:

• A seção solicitações especifica a quantidade de armazenamento solicitada.

Salve o arquivo e aplique a configuração ao Kubernetes.

kubectl apply -f psql-claim.yaml

Agora, use o seguinte comando para listar todos os PersistentVolumes criados em seu cluster Kubernetes:

kubectl get pv

Este comando exibirá detalhes sobre cada PersistentVolume, incluindo nome, capacidade, modos de acesso, status, política de recuperação e classe de armazenamento.

NAME              CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS   CLAIM                           STORAGECLASS   REASON   AGE

postgres-volume   10Gi       RWX            Retain           Bound    default/postgres-volume-claim   manual                  34s

Para listar todos os PersistentVolumeClaims no cluster, use o seguinte comando:

kubectl get pvc

Este comando mostrará informações sobre os PersistentVolumeClaims, incluindo seus nomes, status, armazenamento solicitado, volumes vinculados e seu PersistentVolume correspondente, se estiverem vinculados.

NAME                    STATUS   VOLUME            CAPACITY   ACCESS MODES   STORAGECLASS   AGE

postgres-volume-claim   Bound    postgres-volume   10Gi       RWX            manual         22s

Crie uma implantação PostgreSQL

A criação de uma implantação PostgreSQL no Kubernetes envolve a definição de um manifesto de implantação para orquestrar os pods PostgreSQL.

Crie um arquivo YAML ps-deployment.yaml para definir a implantação do PostgreSQL.

nano ps-deployment.yaml

Adicione o seguinte conteúdo.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: postgres
spec:
  replicas: 3
  selector:
    matchLabels:
      app: postgres
  template:
    metadata:
      labels:
        app: postgres
    spec:
      containers:
        - name: postgres
          image: 'postgres:14'
          imagePullPolicy: IfNotPresent
          ports:
            - containerPort: 5432
          envFrom:
            - configMapRef:
                name: postgres-secret
          volumeMounts:
            - mountPath: /var/lib/postgresql/data
              name: postgresdata
      volumes:
        - name: postgresdata
          persistentVolumeClaim:
            claimName: postgres-volume-claim

Aqui está uma breve explicação de cada parâmetro:

• réplicas: 3 especifica o número desejado de réplicas.

• O seletor especifica como a implantação identifica quais pods ela gerencia.

• template define o modelo de pod usado para criar novos pods controlados por esta implantação. Em metadados, o campo de rótulos atribui rótulos aos pods criados a partir deste modelo, com app: postgres.

• containers especificam os contêineres dentro do pod.

• nome: postgres é o nome atribuído ao contêiner.

• image: postgres:14 especifica a imagem Docker para o banco de dados PostgreSQL.

• imagePullPolicy: “IfNotPresent ” especifica a política para extrair a imagem do contêiner.

• portas especificam as portas que o contêiner expõe.

• envFrom permite que o contêiner carregue variáveis de ambiente de um ConfigMap.

• volumeMounts permite montar volumes no contêiner.

• volumes definem os volumes que podem ser montados no pod.

• nome: postgresdata especifica o nome do volume.

• persistentVolumeClaim refere-se a um PersistentVolumeClaim denominado “postgres-volume-claim”. Esta declaração provavelmente é usada para fornecer armazenamento persistente ao contêiner PostgreSQL para que os dados sejam retidos durante reinicializações ou reprogramações do pod.

Salve e feche o arquivo e aplique a implantação.

kubectl apply -f ps-deployment.yaml

Este comando cria a implantação do PostgreSQL com base nas especificações fornecidas no arquivo YAML.

Para verificar o status da implantação criada:

kubectl get deployments

A saída a seguir confirma que a implantação do PostgreSQL foi criada com sucesso.

NAME       READY   UP-TO-DATE   AVAILABLE   AGE
postgres   3/3     3            3           17s

Para verificar os pods em execução, execute o seguinte comando.

kubectl get pods

Você verá os pods em execução na saída a seguir.

NAME                        READY   STATUS    RESTARTS      AGE
postgres-665b7554dc-cddgq   1/1     Running   0             28s
postgres-665b7554dc-kh4tr   1/1     Running   0             28s
postgres-665b7554dc-mgprp   1/1     Running   1 (11s ago)   28s

Crie um serviço para PostgreSQL

No Kubernetes, um serviço é usado para definir um conjunto lógico de pods que permite que outros pods dentro do cluster se comuniquem com um conjunto de pods sem a necessidade de saber os endereços IP específicos desses pods.

Vamos criar um arquivo de manifesto de serviço para expor o PostgreSQL internamente no cluster Kubernetes:

nano ps-service.yaml

Adicione a seguinte configuração.

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

Salve o arquivo e aplique esta configuração YAML ao Kubernetes.

kubectl apply -f ps-service.yaml

Depois que o serviço é criado, outros aplicativos ou serviços dentro do cluster Kubernetes podem se comunicar com o banco de dados PostgreSQL usando o nome Postgres e a porta 5432 como ponto de entrada.

Você pode verificar a implantação do serviço usando o comando a seguir.

kubectl get svc

Saída.

NAME         TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
kubernetes   ClusterIP   10.96.0.1       <none>        443/TCP          6m6s
postgres     NodePort    10.98.119.102   <none>        5432:30344/TCP   6s

Conecte-se ao PostgreSQL via kubectl

Primeiro, liste os pods disponíveis em seu namespace para encontrar o pod PostgreSQL:

kubectl get pods

Você verá os pods em execução na saída a seguir.

NAME                        READY   STATUS    RESTARTS      AGE
postgres-665b7554dc-cddgq   1/1     Running   0             28s
postgres-665b7554dc-kh4tr   1/1     Running   0             28s
postgres-665b7554dc-mgprp   1/1     Running   1 (11s ago)   28s

Localize o nome do pod PostgreSQL na saída.

Depois de identificar o pod PostgreSQL, use o comando kubectl exec para conectar o pod PostgreSQL.

kubectl exec -it postgres-665b7554dc-cddgq -- psql -h localhost -U ps_user --password -p 5432 ps_db

• postgres-665b7554dc-cddgq: este é o nome do pod onde o contêiner PostgreSQL está sendo executado.

• ps_user: Especifica o nome de usuário que será usado para conectar-se ao banco de dados PostgreSQL.

• –password: solicita a senha de forma interativa.

• ps_db: especifica o nome do banco de dados ao qual se conectar depois de autenticado com o usuário fornecido.

Você será solicitado a fornecer uma senha para usuários do Postgres. Após a autenticação bem-sucedida, você entrará no shell do Postgres.

Password:
psql (14.10 (Debian 14.10-1.pgdg120+1))
Type "help" for help.
ps_db=#

Em seguida, verifique a conexão PostgreSQL usando o seguinte comando.

ps_db=# \conninfo

Você verá a seguinte saída.

You are connected to database "ps_db" as user "ps_user" on host "localhost" (address "::1") at port "5432".

Você pode sair do shell do PostgreSQL usando o seguinte comando.

exit

Dimensione a implantação do PostgreSQL

O dimensionamento de uma implantação do PostgreSQL no Kubernetes envolve o ajuste do número de réplicas no Deployment ou StatefulSet que gerencia os pods do PostgreSQL.

Primeiro, verifique o estado atual da sua implantação do PostgreSQL:

kubectl get pods -l app=postgres

Saída.

postgres-665b7554dc-cddgq   1/1     Running   0              2m12s
postgres-665b7554dc-kh4tr   1/1     Running   0              2m12s
postgres-665b7554dc-mgprp   1/1     Running   1 (115s ago)   2m12s

Para dimensionar a implantação do PostgreSQL para 5 réplicas, use o comando kubectl scale:

kubectl scale deployment --replicas=5 postgres

Em seguida, verifique novamente o status da sua implantação para garantir que a operação de escalabilidade foi bem-sucedida:

kubectl get pods -l app=postgres

Você verá que o número de pods aumentou para 5:

NAME                        READY   STATUS    RESTARTS        AGE
postgres-665b7554dc-cddgq   1/1     Running   0               3m56s
postgres-665b7554dc-ftxbl   1/1     Running   0               10s
postgres-665b7554dc-g2nh6   1/1     Running   0               10s
postgres-665b7554dc-kh4tr   1/1     Running   0               3m56s
postgres-665b7554dc-mgprp   1/1     Running   1 (3m39s ago)   3m56s

Backup e restauração do banco de dados PostgreSQL

Você pode fazer backup de um banco de dados PostgreSQL em execução em um pod do Kubernetes usando o comando kubectl exec em conjunto com a ferramenta pg_dump diretamente no pod.

Primeiro, liste todos os pods para encontrar o nome do seu pod PostgreSQL:

kubectl get pods

Em seguida, use o comando kubectl exec para executar o comando pg_dump dentro do pod PostgreSQL:

kubectl exec -it postgres-665b7554dc-cddgq -- pg_dump -U ps_user -d ps_db > db_backup.sql

Este comando faz dump do banco de dados e redireciona a saída para um arquivo chamado db_backup.sql no diretório local.

Para restaurar o banco de dados de volta ao pod do Kubernetes, você precisará do arquivo de dump SQL e do uso do comando psql para executar o processo de restauração.

Primeiro, use o comando kubectl cp para copiar o arquivo de dump SQL da sua máquina local para o pod PostgreSQL:

kubectl cp db_backup.sql postgres-665b7554dc-cddgq:/tmp/db_backup.sql

Em seguida, conecte-se ao pod PostgreSQL usando o comando a seguir.

kubectl exec -it postgres-665b7554dc-cddgq -- /bin/bash

Em seguida, execute o comando psql para restaurar o backup do arquivo dump.

psql -U ps_user -d ps_db -f /tmp/db_backup.sql

Conclusão

Este guia descreveu as etapas fundamentais necessárias para configurar o PostgreSQL com êxito em um ambiente Kubernetes. Ao aproveitar os recursos de orquestração do Kubernetes, as organizações podem gerenciar com eficiência instâncias do PostgreSQL, dimensionar recursos dinamicamente, garantir alta disponibilidade e agilizar as operações de manutenção.

Se você quiser saber mais sobre Kubernetes e Helm, confira a seção Kubernetes da nossa página da comunidade.