Déployer un serveur PostgreSQL SSL sur OpenShift

Dans un monde où la protection des données est une priorité absolue, le chiffrement SSL (Secure Sockets Layer) s’impose comme un prérequis incontournable pour sécuriser les échanges d’informations sensibles. Après avoir exploré la configuration d’un serveur PostgreSQL avec SSL dans un environnement Docker dans mon précédent article, nous allons maintenant relever un nouveau défi : déployer un serveur PostgreSQL avec SSL sur une plateforme OpenShift.

Défis du déploiement PostgreSQL sur OpenShift

Si vous avez déjà travaillé avec OpenShift, vous savez que cette plateforme de conteneurisation offre un environnement de déploiement robuste et sécurisé. Cependant, ce niveau de sécurité élevé peut parfois compliquer la configuration de certaines images, notamment celles nécessitant un utilisateur spécifique. L’image officielle PostgreSQL nécessite justement les utilisateurs root ou postgres. Pour répondre à ce besoin, Red Hat propose une image PostgreSQL compatible avec OpenShift, intégrant les meilleures pratiques de sécurité et de configuration pour un déploiement sécurisé et fiable.

L’image PostgreSQL de Red Hat pour OpenShift

Dans cet article, nous allons utiliser l’image PostgreSQL rhel9/postgresql-13. Si vous utilisez une autre version de l’image proposée par Red Hat, la stratégie reste identique.

La documentation de cette image contient une section similaire à celle de l’image officielle PostgreSQL, ce qui permet de modifier le comportement du conteneur lors de son démarrage. Contrairement à l’image PostgreSQL officielle, celle de Red Hat offre une configuration et une séquence de démarrage plus flexibles. Nous utiliserons ces fonctionnalités pour déployer notre serveur PostgreSQL en mode SSL sur OpenShift.

Stratégie de déploiement PostgreSQL SSL sur OpenShift

L’image PostgreSQL de Red Hat est conçue pour être facilement personnalisable. Cela est possible en montant des fichiers de configuration ou des scripts dans des répertoires spécifiques. Pour déployer notre serveur PostgreSQL en mode SSL sur OpenShift, nous utiliserons les points de montage suivants :

• postgresql-cfg/ : pour étendre la configuration du serveur PostgreSQL.
• postgresql-pre-start/ : pour exécuter des scripts au démarrage du conteneur.

Nous utiliserons deux ressources Kubernetes pour déployer nos fichiers personnalisés :

• Un Secret pour stocker la clé privée et les certificats SSL.
• Un ConfigMap pour stocker le fichier de configuration SSL du serveur PostgreSQL et le script d’initialisation.

Création du Secret pour les certificats SSL

Seule la clé privée doit véritablement être protégée par une ressource Secret. Cependant, pour simplifier la configuration, nous allons inclure les certificats SSL dans le même Secret.

Générer les certificats SSL

Pour créer ces certificats SSL, vous pouvez utiliser un outil comme OpenSSL. Je vous invite à consulter mon article sur la création de certificats SSL autogérés. Ici, nous utiliserons des certificats SSL auto-signés pour simplifier la configuration.

Configurer le Secret

Pour déployer les fichiers SSL, nous créons un Secret de type Opaque qui stocke les fichiers SSL encodés en base64. Utilisez la commande Shell suivante pour encoder un fichier en base64 :

$ base64 postgresql.crt
LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tDQpNSUlEQ1RDQ0FmR2dBd0lCQWdJVUtmMnhveXlG
...
DQozb1BYQm9uUmNvenFJRkxEUmc9PQ0KLS0tLS1FTkQgQ0VSVElGSUNBVEUtLS0tLQ0K

Ensuite, nous créons le fichier YAML qui définit le Secret en référant les fichiers encodés en base64 :

# /secret.yaml
kind: Secret
apiVersion: v1
metadata:
  name: postgres-tls
  labels:
    app: postgresql-ssl
type: Opaque
data:
  postgres.crt: |
    <base64-encoded-certificate> # <1>
  postgres.key: |
    <base64-encoded-private-key> # <1>
  # ca.crt is optional when using a self-signed certificate
  # ca.crt: |
  #  <base64-encoded-ca-certificate> # <1>

Création du ConfigMap pour personnaliser la configuration PostgreSQL

Pour configurer l’image PostgreSQL de Red Hat en mode SSL, nous devons monter deux fichiers dans le conteneur : la configuration SSL et le script d’initialisation.

Initialiser le ConfigMap

Les fichiers cités précédemment sont déployés et montés dans le conteneur PostgreSQL via un ConfigMap. Créons le fichier YAML définissant la ressource ConfigMap qui stocke les fichiers de configuration :

# /configmap.yaml
kind: ConfigMap
apiVersion: v1
metadata:
  name: postgres-configmap
  labels:
    app: postgresql-ssl
data:
  postgres-copy-ssl.sh: |
    # <1>
  ssl.conf: |
    # <2>

Créer le fichier de configuration ssl.conf

Le fichier de configuration ssl.conf est similaire à celui utilisé dans mon article précédent. Nous adaptons les chemins des fichiers SSL pour correspondre à l’image déployée sur OpenShift. Voici la configuration que nous allons utiliser :

 # /configmap.yml
 # ...
   postgres-copy-ssl.sh: |

   ssl.conf: |
-
+    ssl = on
+    ssl_ca_file = '/var/lib/pgsql/ssl/postgres.crt'
+    ssl_cert_file = '/var/lib/pgsql/ssl/postgres.crt'
+    ssl_crl_file = ''
+    ssl_key_file = '/var/lib/pgsql/ssl/postgres.key'
+    ssl_ciphers = 'HIGH:MEDIUM:+3DES:!aNULL'
+    ssl_prefer_server_ciphers = on

Le serveur PostgreSQL utilisera ces paramètres pour activer le chiffrement SSL en utilisant les fichiers SSL susmentionnés.

Créer le script d’initialisation postgres-copy-ssl.sh

Le script postgres-copy-ssl.sh copie les fichiers SSL dans un répertoire sécurisé et ajuste les permissions. Nous mettons à jour le ConfigMap pour inclure ce script :

 # /configmap.yml
 # ...
 data:
   postgres-copy-ssl.sh: |
+    #!/usr/bin/env bash

+    # Copy certificates and keys to have right permissions
+    if [ -d /opt/ssl/ ]; then
+      # Create the SSL directory used by the PostgreSQL server
+      mkdir -p /var/lib/pgsql/ssl/
+
+      # Copy the certificates and keys to the SSL directory
+      find /opt/ssl/ -maxdepth 1 \
+        -name "*.pem" -o -name "*.crt" -o -name "*.key" \
+        | xargs cp -t /var/lib/pgsql/ssl/ -L
+
+      chmod 600 /var/lib/pgsql/ssl/*
+    fi
   ssl.conf: |
 # ...

Ce script vérifie la présence du point de montage /opt/ssl/, crée le répertoire /var/lib/pgsql/ssl/, copie les fichiers SSL et ajuste les permissions.

Déployer le serveur PostgreSQL SSL sur OpenShift

Création d’un compte de service

Pour déployer notre serveur PostgreSQL en mode SSL sur OpenShift, nous devons créer un compte de service avec les autorisations nécessaires. Le serveur PostgreSQL s’attend à ce que les fichiers SSL appartiennent à l’utilisateur postgres avec les droits 600, ou à l’utilisateur root avec les droits 640.

Malheureusement, OpenShift lance les conteneurs en tant qu’utilisateur aléatoire, ce qui est incompatible avec les exigences de cette image. Pour résoudre ce problème, nous devons créer un compte de service permettant de lancer le conteneur en tant qu’utilisateur postgres.

Les commandes à exécuter pour créer ce compte de service sont les suivantes :

$ oc create serviceaccount postgresql-sa # <1>
serviceaccount/postgresql-sa created
$ oc adm policy add-scc-to-user anyuid -z postgresql-sa # <1>
clusterrole.rbac.authorization.k8s.io/system:openshift:scc:anyuid added: "postgresql-sa"

Ces commandes créent un compte de service nommé postgresql-sa et lui appliquent le rôle anyuid. Ce rôle évite la contrainte de sécurité visant à utiliser un utilisateur aléatoire et permet à une image de s’exécuter en définissant un utilisateur spécifique ou celui définit dans l’image.

Créer la ressource Deployment

La dernière étape consiste à créer un Deployment pour spécifier à OpenShift comment déployer et configurer le conteneur PostgreSQL afin d’activer le chiffrement SSL. Le fichier YAML suivant définit un Deployment qui utilise les ressources Secret et ConfigMap que nous avons créées précédemment :

# /deployment.yaml
kind: Deployment
apiVersion: apps/v1
metadata:
  name: postgres-deployment
  labels:
    app: postgresql-ssl
spec:
  replicas: 1
  selector:
    matchLabels:
      app: postgresql-ssl
  template:
    metadata:
      labels:
        app: postgresql-ssl
    spec:
      serviceAccountName: postgresql-sa
      restartPolicy: Always
      containers:
        - name: postgresql
          image: 'registry.redhat.io/rhel9/postgresql-13:latest'
          imagePullPolicy: IfNotPresent
          ports:
            - containerPort: 5432
              protocol: TCP
          env:
            - name: POSTGRESQL_USER
              value: <database-user> # <1>
            - name: POSTGRESQL_PASSWORD
              value: <database-password> # <1>
            - name: POSTGRESQL_DATABASE
              value: <database-name> # <1>
          volumeMounts:
            - name: postgresql-start-volume
              mountPath: /opt/app-root/src/postgresql-pre-start/
            - name: postgresql-config-volume
              mountPath: /opt/app-root/src/postgresql-cfg/
            - name: postgresql-ssl-volume
              readOnly: true
              mountPath: /opt/ssl/
      volumes:
        - name: postgresql-start-volume
          configMap:
            name: postgres-configmap
            items:
              - key: postgres-copy-ssl.sh
                path: postgres-copy-ssl.sh
        - name: postgresql-config-volume
          configMap:
            name: postgres-configmap
            items:
              - key: ssl.conf
                path: ssl.conf
        - name: postgresql-ssl-volume
          secret:
            secretName: postgres-tls

Tester la connexion SSL

Pour s’assurer que le serveur PostgreSQL est correctement configuré en mode SSL, nous allons nous connecter à la base de données en utilisant le client psql.

Depuis votre terminal, ou via l’interface d’administration OpenShift, ouvrez une session Shell dans le conteneur PostgreSQL. Exécutez ensuite la commande suivante pour vous connecter à la base de données en mode SSL :

$ psql "sslmode=verify-full host=localhost port=5432 sslrootcert=/var/lib/pgsql/ssl/postgres.crt" <1>
psql (13.16)
SSL connection (protocol: TLSv1.3, cipher: TLS_AES_256_GCM_SHA384, bits: 256, compression: off)
Type "help" for help.

postgres=#
\q

Conclusion

En suivant ce guide, vous avez appris à déployer un serveur PostgreSQL sécurisé avec SSL sur OpenShift. Cette configuration garantit que les communications entre votre application et la base de données sont chiffrées, offrant ainsi une couche supplémentaire de sécurité pour vos données sensibles.

J’espère que cet article vous a été utile. N’hésitez pas à poser vos questions ou à partager vos expériences dans les commentaires, et bon courage pour vos futurs déploiements sur OpenShift !