Comprendre la propriété des schémas dans PostgreSQL : un guide pratique pour les administrateurs de base de données (avec des exemples StackOverflow)

L’administration de bases de données implique bien plus que la simple rédaction de requêtes ou la maintenance de sauvegardes. L’un des concepts les plus importants, en particulier dans les environnements comportant plusieurs utilisateurs ou applications, est propriété du schéma. Dans PostgreSQL, les schémas sont essentiels pour organiser les objets de votre base de données et contrôler qui peut les administrer, les modifier ou même les voir.

Pour de nombreux administrateurs de base de données, la propriété des schémas devient un outil essentiel dans la gestion de grands systèmes, en particulier ceux comportant plusieurs applications, plusieurs équipes ou des exigences de gouvernance strictes. Dans cet article, nous explorons le fonctionnement de la propriété des schémas, pourquoi elle est importante et comment la gérer efficacement, à l’aide du populaire Exemple de base de données StackOverflow à titre d’exemple pratique.

Qu’est-ce qu’un schéma dans PostgreSQL ?

Un schéma est un conteneur logique au sein d’une base de données. Vous pouvez le considérer comme un dossier dans votre base de données, contenant des objets tels que :

• Tableaux
• Vues
• Fonctions
• Séquences
• Espèces

Les schémas aident à organiser les objets et à éviter les collisions de noms. Par exemple, deux schémas peuvent tous deux contenir une table appelée Users sans conflit :

public.Users
reporting.Users

Lorsque vous travaillez avec une base de données aussi grande que StackOverflow, qui contient des tables comme Users, Posts, Comments, Badgeset Votesles schémas deviennent encore plus importants. Ils permettent de regrouper des objets, de contrôler l’accès et de séparer les charges de travail telles que :

• Tableaux opérationnels
• Tableaux de rapport
• Zones de transit ETL
• Couches historiques ou archivistiques

Tout cela est directement lié à propriété du schéma.

Propriété par défaut : l’utilisateur qui crée un schéma en est propriétaire

PostgreSQL utilise une règle simple et prévisible :

L’utilisateur qui crée un schéma en devient automatiquement propriétaire.

Le propriétaire reçoit un contrôle total sur ce schéma et sur tous les objets qu’il contient.

Par exemple, imaginez que vous chargez la base de données StackOverflow dans PostgreSQL et qu’un développeur crée un nouveau schéma de reporting :

CREATE SCHEMA reporting;

Ce développeur est désormais propriétaire du schéma et peut y créer des objets, tels que des tableaux de rapport agrégés :

CREATE TABLE reporting.TopTags AS
SELECT TagName, COUNT(*) AS PostCount
FROM Tags t
JOIN PostTags pt ON t.Id = pt.TagId
GROUP BY TagName;

Ce modèle fonctionne bien jusqu’à ce que les responsabilités changent – ​​un problème courant dans les grandes équipes.

Transfert de propriété à l’aide d’ALTER SCHEMA

La propriété peut facilement être réaffectée à l’aide d’une seule commande SQL :

ALTER SCHEMA reporting OWNER TO dba_team;

Voici des exemples pratiques utilisant l’ensemble de données StackOverflow.

Exemple : transfert de la propriété des rapports à l’équipe DBA

Supposons qu’un analyste crée un schéma pour les modèles Power BI, contenant des objets tels que :

• reporting.TopAnswerers
• reporting.WeeklyPostTrends
• reporting.TopTags
• reporting.DailyActivity

Lorsque l’environnement passe à la production, l’équipe DBA devra peut-être s’enapproprier. Une simple commande de transfert gère cela proprement.

Exemple : ETL et schémas de transfert

De nombreux pipelines de données chargent les données brutes StackOverflow dans une zone de transit, par exemple :

staging.StackOverflowRawPosts

Si DevOps a initialement créé le staging Dans ce schéma, le transfert de propriété vers un compte de service contrôlé améliore la gouvernance :

ALTER SCHEMA staging OWNER TO service_etl;

Le transfert de propriété est sûr, prévisible et essentiel pour une administration propre.

Contrôle administratif : gouvernance et sécurité

La propriété du schéma influence directement votre modèle d’autorisation. Le propriétaire contrôle :

• Qui peut créer, déposer ou modifier des objets
• Qui peut lire ou écrire dans le schéma
• Politiques de sécurité
• Octroi et révocation d’autorisations

Cela signifie que la propriété du schéma est étroitement alignée sur :

Sécurité

L’ensemble de données StackOverflow contient des champs sensibles tels que :

• DisplayName
• Location
• EmailHash
• Champs PII facultatifs dans d’autres dumps

Une propriété incorrecte du schéma pourrait exposer les données personnelles à la mauvaise équipe ou au mauvais service.

Gouvernance

Il est courant de séparer les environnements en schémas logiques tels que :

• raw – données StackOverflow importées
• clean – tableaux standardisés
• semantic – couche de modélisation commerciale
• reporting – des ensembles de données prêts pour l’analyse

Chacun nécessite un modèle de propriété clair pour maintenir la cohérence entre le développement, les tests et la production.

Réduction des risques opérationnels

Permettre à un développeur de posséder un schéma de production peut entraîner des modifications accidentelles ou la suppression d’objets. Le transfert de propriété vers des rôles contrôlés réduit considérablement ce risque.

Conclusion

La propriété du schéma est un élément fondamental du modèle de sécurité et d’administration de PostgreSQL. Que vous travailliez avec une petite application ou analysiez des millions d’enregistrements à l’aide de l’ensemble de données StackOverflow, les principes clés restent cohérents :

• Les schémas appartiennent par défaut à leurs créateurs
• La propriété peut être transférée en toute sécurité en utilisant ALTER SCHEMA
• Une propriété correcte améliore la gouvernance, la sécurité et la stabilité opérationnelle

Prendre le temps d’examiner la propriété des schémas, en particulier dans les environnements à propriété partagée ou avec de grandes équipes de développement, peut aider à prévenir les conflits d’autorisations, les failles de sécurité et les risques opérationnels.

Prêt à en savoir plus ?

Contactez-nous pour une discussion autour de vos besoins en matière de conseil et de formation en matière de plateforme de formation

Liens utiles

Qui gagne la limite de connexion à la base de données ou la limite d’instance ?

Interrogation de données avec Microsoft Transact-SQL

Payez-vous trop cher pour votre expertise en bases de données ?

PostgreSQL 16 offre de solides capacités de réplication pour garantir que les données restent disponibles et distribuées en temps réel entre le serveur principal (primaire) et un serveur de sauvegarde (veille). Voici les étapes qui doivent être suivies pour configurer la réplication du streaming dans PostgreSQL 16.

Préparation initiale

Installation de PostgreSQL

Assurez-vous que PostgreSQL 16 a été installé sur les deux serveurs (primaire et veille). Sinon, vous pouvez l’installer avec la commande suivante:

sudo apt-get update
sudo apt-get install postgresql-16

Créer une réplication de l’utilisateur

Créez un utilisateur spécial pour la réplication sur le serveur principal:

CREATE ROLE rep_user WITH REPLICATION LOGIN PASSWORD 'password';

Configuration sur le serveur principal

1 et 1 Modifier postgresql.conf

L’emplacement de ce fichier est généralement allumé /etc/postgresql/16/main/postgresql.conf. Ajouter ou modifier les lignes suivantes:

wal_level="replica"
max_wal_senders = 10
max_replication_slots = 10
wal_log_hints="on"
synchronous_standby_names="FIRST 1 (standby1, standby2)"

2 Modifier pg_hba.conf

L’emplacement de ce fichier est généralement allumé /etc/postgresql/16/main/pg_hba.conf. Ajoutez les lignes suivantes pour permettre l’accès depuis le serveur de secours:

host replication rep_user 10.0.0.2/32 scram-sha-256

3 et 3 Redémarrer PostgreSQL

Après avoir modifié la configuration, redémarrez PostgreSQL:

sudo systemctl restart postgresql

4 Créer un emplacement de réplication (facultatif)

Pour faire un emplacement de réplication, exécutez la commande suivante dans PostgreSQL:

SELECT * FROM pg_create_physical_replication_slot('rep_slot');

Configuration sur le serveur de secours

1 et 1 Arrêtez PostgreSQL:

sudo systemctl stop postgresql

2. Copier les données du primaire au veille:

pg_basebackup -h primary_server_ip -D /var/lib/postgresql/16/main -U rep_user -W -P --write-recovery-conf

Option --write-recovery-conf Créera un fichier standby.signal et entrez les paramètres de réplication requis dans postgresql.conf.

3 et 3 Modifier postgresql.conf:

Assurez-vous que le fichier postgresql.conf possède les paramètres suivants:

primary_conninfo = 'host=primary_server_ip port=5432 user=rep_user password=password'
primary_slot_name="rep_slot"  # Jika menggunakan slot replikasi
hot_standby = 'on'

4 Modifier pg_hba.conf:

Ajoutez une entrée pour autoriser les connexions au serveur principal:

host replication rep_user primary_server_ip/32 scram-sha-256

5 Démarrer PostgreSQL:

sudo systemctl start postgresql

Vérification

Vérifiez l’état de réplication en primaire:

SELECT * FROM pg_stat_replication;

Résultats de ContoH

  pid   | usesysid | usename  | application_name | client_addr  | client_hostname | client_port |         backend_start         | backend_xmin |   state   |  sent_lsn   |  write_lsn  |  flush_lsn  | replay_lsn  | write_lag | flush_lag | replay_lag | sync_priority | sync_state |          reply_time           
--------+----------+----------+------------------+--------------+-----------------+-------------+-------------------------------+--------------+-----------+-------------+-------------+-------------+-------------+-----------+-----------+------------+---------------+------------+-------------------------------
 638369 |   340262 | rep_user | 16/main          | 34.50.82.145 |                 |       45992 | 2024-07-10 17:04:53.349471+00 |              | streaming | 30/7C014690 | 30/7C014690 | 30/7C014690 | 30/7C014690 |           |           |            |             0 | async      | 2024-07-10 17:05:23.409507+00
(1 row)

Vérifiez l’état en veille:

SELECT * FROM pg_is_in_recovery();

Résultats de ContoH

postgres@hostname:~/16$ psql
psql (16.3 (Ubuntu 16.3-1.pgdg22.04+1))
Type "help" for help.

postgres=# SELECT * FROM pg_is_in_recovery();
 pg_is_in_recovery 
-------------------
 t
(1 row)

postgres=# 

Si tout se passe bien, vous avez maintenant une configuration de réplication de streaming postgresql active. Cette réplication garantit que les données sur le serveur de secours sont toujours mises à jour en temps réel à partir du serveur principal, augmentant ainsi la disponibilité et la fiabilité de vos données.

Source:

En suivant ce guide, vous pouvez définir facilement la réplication de streaming sur PostgreSQL 16 et vous assurer que vos données sont toujours synchrones entre les serveurs primaires et de secours.