Aller au contenu
AggregaAggrega
Selectionner la langue: Français
Cette page a été traduite automatiquement. Lire l’original en anglais.

Scripts d’amorçage et configuration personnalisée de PostgreSQL — helm synthétisé

core/datastore/postgres expose deux valeurs facultatives du développeur qui déterminent le premier démarrage de la base de données : init_scripts (du SQL ou du shell exécuté une seule fois à l’initialisation) et custom_config (un fragment de postgresql.conf). Sur la cible helm synthétisée, la Recipe les transporte dans le conteneur sous forme de ConfigMaps montées. Cet exemple montre que la fonctionnalité est additive : un Aggregate qui ne définit aucune des deux valeurs est rendu exactement comme une base de données minimale, et un Aggregate qui les définit obtient les ConfigMaps, les volumes et les montages sans que rien d’autre ne soit perturbé.

Deux Releases du même Component, avec le même Manifest, qui ne diffèrent que par les valeurs du développeur :

  • release-bare.yaml (aggregate-bare.yaml) — init_scripts et custom_config non définis.
  • release-config.yaml (aggregate-config.yaml) — les deux définis.

Générer l’exemple

Vous pouvez construire cet exemple avec les commandes ci-dessous, ou le faire construire pour vous par votre assistant IA.

Écrivez l’exemple dans un nouveau dossier qui porte son nom :

Terminal window
aggrega scaffold --example postgres-init-config

Elle affiche ensuite les prochaines commandes à exécuter. La première vous place dans le nouveau dossier :

Terminal window
cd postgres-init-config

Build

Terminal window
aggrega build --release release-bare.yaml --auto-pull
aggrega build --release release-config.yaml --auto-pull

Le catalogue se résout depuis le registre du hub nommé dans .aggrega-config.yaml, si bien qu’aucun flag --catalog n’est nécessaire, et --auto-pull écrit pendant le build le fichier de verrouillage qui manque à un clone récent. La release dépouillée écrit trois fichiers sous dist/helm/helm/ ; la release configurée écrit ces trois-là plus deux autres sous dist/helm/helm/db/.

Avec un assistant IA

Un assistant IA configuré avec les outils d’Aggrega peut faire de même : collez-lui ce prompt.

Utilisez uniquement les outils Aggrega et ne créez vous-même aucun dossier. Si le dossier Workspace ne contient pas encore de dossier `postgres-init-config`, appelez une fois l’outil `scaffold` avec `example` défini sur `postgres-init-config` et sans `dir` : il écrit l’exemple dans un nouveau dossier `postgres-init-config`. Appelez ensuite l’outil `build` une fois pour chaque Release, dans cet ordre — `release-bare.yaml` et `release-config.yaml` — en définissant à chaque fois `workspace_root` sur `postgres-init-config`, `release` sur ce fichier, `auto_pull` sur true et `write` sur true. Indiquez-moi quels fichiers chaque build a écrits ; ils se trouvent sous `postgres-init-config/dist/`.

Dépouillée — la base de référence additive

aggregate-bare.yaml laisse les deux valeurs non définies. La sortie rendue est un StatefulSet, un Service ClusterIP et un Service headless — aucune ConfigMap, aucun volume configmap, aucun montage de volume dans le répertoire d’initialisation et aucun argument de fichier de configuration sur le conteneur. C’est la forme ordinaire d’une base de données PostgreSQL minimale :

dist/helm/helm/db-statefulset.yaml
dist/helm/helm/db-default-service.yaml
dist/helm/helm/db-headless-service.yaml

Comme les deux valeurs sont protégées par un contrôle de présence dans la Recipe, une valeur non définie n’émet rien — le corps de la ConfigMap est rendu vide et ignoré, et les lignes du volume, du montage et de l’argument du serveur sont écartées par ce contrôle. Un Aggregate qui ne touche jamais à ces valeurs n’est pas modifié par leur existence.

Configurée — scripts et configuration montés

aggregate-config.yaml définit les deux valeurs :

values:
init_scripts:
01-schema.sql: |
CREATE TABLE app_users ( ... );
02-seed.sql: |
INSERT INTO app_users (email) VALUES ('founder@example.com');
custom_config: |
max_connections = 200
shared_buffers = 256MB

Le build écrit maintenant deux ConfigMaps supplémentaires et les câble dans le StatefulSet :

dist/helm/helm/db/initdb-configmap.yaml
dist/helm/helm/db/config-configmap.yaml

Les deux se trouvent sous db/, le nom propre du composant. La Recipe les nomme dans son bloc artifacts:, et un fichier nommé là porte la clé que son auteur a écrite plutôt que quoi que ce soit qui identifie le composant — si bien que le build l’écrit sous le composant qui l’a déclaré, et deux composants qui partagent une Recipe ne peuvent pas aboutir au même chemin. Le StatefulSet et les deux Services sont nommés par la cible d’après le composant auquel ils appartiennent, si bien qu’ils restent dans le répertoire propre de la frontière.

Les deux valeurs voyagent dans des ConfigMaps distinctes parce que chacune est montée en entier dans un chemin différent du conteneur :

  • init_scripts → ConfigMap db-initdb, une clé de données par script (01-schema.sql, 02-seed.sql). Un volume configmap la monte sur /docker-entrypoint-initdb.d, où PostgreSQL exécute les fichiers une seule fois lors de la première initialisation, dans l’ordre alphabétique des clés.
  • custom_config → ConfigMap db-config, une clé de données postgresql.conf. Un second volume configmap la monte sur /etc/postgresql, et les args: du conteneur dirigent le serveur vers elle : postgres -c config_file=/etc/postgresql/postgresql.conf. Les paramètres que le fragment omet conservent leurs valeurs par défaut intégrées.
# db-statefulset.yaml (container)
containers:
- name: main
image: postgres:16
args:
- postgres
- -c
- config_file=/etc/postgresql/postgresql.conf
[… omitted: the container's port, environment and resources]
volumeMounts:
- name: data
mountPath: /var/lib/postgresql/data
- name: initdb
mountPath: /docker-entrypoint-initdb.d
- name: pgconf
mountPath: /etc/postgresql
[… omitted: the liveness and readiness probes]
volumes:
- name: initdb
configMap:
name: db-initdb
- name: pgconf
configMap:
name: db-config

Ces arguments du serveur arrivent sous forme d’args: plutôt que de command:, et la différence décide si la base de données démarre peuplée : args: fournit des arguments au point d’entrée de l’image, tandis que command: le remplace. Ce point d’entrée est le script de démarrage qui crée la base de données dans un répertoire de données vide, lit l’environnement POSTGRES_* et exécute les fichiers sous /docker-entrypoint-initdb.d. Le remplacer démarrerait le serveur avec le postgresql.conf monté et sauterait à la fois l’initialisation et les scripts d’amorçage — les valeurs que l’Aggregate a définies seraient rendues dans le manifeste et jamais exécutées.

Ne définir qu’une seule des deux valeurs est tout aussi valide — la ConfigMap, le volume et le montage de l’autre sont simplement absents, et l’argument de fichier de configuration n’apparaît que lorsque custom_config est défini.

Compose

La Recipe Compose pour core/datastore/postgres lit le même Component et réalise les deux valeurs via la primitive propre à compose : elle rend des entrées configs: de premier niveau, et le service monte chacune d’elles comme un fichier.

  • init_scripts → une config par clé, chacune montée sous son propre nom de fichier dans /docker-entrypoint-initdb.d. L’image exécute une seule fois les fichiers qu’elle y trouve, dans l’ordre des noms de fichier, et uniquement lorsque le répertoire de données est vide — une base de données qui contient déjà des données n’est pas touchée.
  • custom_config → une config, montée comme l’unique fichier /etc/postgresql/postgresql.conf, avec les mêmes arguments postgres -c config_file=… qui dirigent le serveur vers lui. Les paramètres que le fragment omet conservent leurs valeurs par défaut intégrées.

Chaque moitié est ici aussi protégée par un contrôle de présence, si bien qu’un Aggregate qui laisse une valeur non définie est rendu comme si cette clé n’existait pas.

Un paramètre mérite d’être cité lorsqu’on écrit un bloc custom_config pour une Release sur compose : listen_addresses n’accepte par défaut que les connexions locales, si bien qu’un bloc qui l’omet laisse la base de données injoignable depuis les autres services du réseau compose.

Le Manifest de cet exemple achemine core/datastore/postgres vers la Recipe helm. Construire le même Aggregate sur compose implique plutôt un Manifest qui l’achemine vers compose/postgres ; les valeurs du développeur ne sont pas touchées.