Intéressé par des cours d'informatique en ligne ?
Visitez mon nouveau site
https://www.yesik.it !
PostgreSQL est un système de gestion de bases de données relationnelles (SGBD-R) des plus évolués. Bien qu'étant un logiciel libre, PostgreSQL peut rivaliser avec ses cousins commerciaux. Mais toutes ses fonctionnalités viennent aussi avec leur lot de complexité. Dans cet article, nous allons voir comment installer PostgreSQL. Par ailleurs, nous verrons comment créer une première base pour valider l'installation de ce serveur de bases de données. Enfin, nous terminerons en jetant les bases de la gestion des utilisateurs sous PostgreSQL.
Les informations données ici sont pour une distribution Linux/Debian (Lenny). Mais tout ce qui est dit est aussi valide pour les distributions dérivées comme Ubuntu. Et peut être adapté sans trop de difficultés à d'autres distributions.
Installer PostgreSQL
Le serveur et le client...
Sous Debian, l'installation à proprement parler est facilitée par le fait que PostgreSQL soit disponible dans les dépôts standards – et dans une version relativement récente. Il est donc possible de l'installer avec apt-get:
sh# apt-get install postgresql
Non seulement l'installation du paquet postgresql a installé le serveur et le client sur votre machine. Mais le processus a aussi créé un nouvel utilisateur nommé postgres sur votre système. A ce stade, c'est uniquement sous cette identité que vous pouvez vous connecter à votre serveur de bases de données PostgreSQL:
sh# su postgres
sh$ psql
Welcome to psql 8.3.7, the PostgreSQL interactive terminal.
Type: \copyright for distribution terms
\h for help with SQL commands
\? for help with psql commands
\g or terminate with semicolon to execute query
\q to quit
postgres=#
Piège:
Il faut être root pour prendre l'identité postgres!
Accessoirement, si sudo est installé sur votre système, vous pouvez aussi taper:
sh# sudo -u postgres psql
Welcome to psql 8.3.7, the PostgreSQL interactive terminal.
Type: \copyright for distribution terms
\h for help with SQL commands
\? for help with psql commands
\g or terminate with semicolon to execute query
\q to quit
postgres=#
C'est peut-être une solution préférable, puisque sudo peut être configuré pour permettre à d'autres utilisateurs que root de prendre l'identité postgres. Reportez vous au manuel de sudo pour plus d'informations.
... et la documentation
Si vous le désirez, vous pouvez aussi en profiter pour installer localement la documentation de PostgreSQL à l'aide du paquet postgresql-doc:
sh# apt-get install postgresql-doc
Ce paquet installera le manuel de référence de PostgreSQL dans votre répertoire /usr/share/doc/postgresql-doc-8.3.
Créer une base
Pour continuer, nous allons nous assurer du fonctionnement de PostgreSQL en créant une première base.
PostgreSQL est livré avec un certain nombre d'utilitaires permettant de faciliter la vie de l'administrateur de la base de données. Ainsi, par exemple vous pouvez créer une nouvelle base directement à partir du shell – sans avoir à lancer le client psql. C'est d'ailleurs ce que nous allons commencer par faire, car cette méthode se révélera à la fois simple et instructive.
A partir du shell
L'utilitaire pour créer une nouvelle base PostgreSQL à partir du shell est createdb:
sh# sudo -u postgres \
createdb -e DemoDB
CREATE DATABASE "DemoDB";
Remarque:
Si vous n'avez pas installé sudo sur votre système, vous devrez d'abord prendre l'identité postgres avant d'utiliser cette commande:
sh# su postgres sh$ createdb -e DemoDB CREATE DATABASE "DemoDB";
La raison pour laquelle je suggérais que cette commande était instructive est que grâce à l'option -e elle m'indique la commande SQL exécutée. En effet, createdb n'est qu'un utilitaire générant des commandes SQL pour créer la base – et les envoyant à PostgreSQL pour les exécuter.
Par exemple, si j'ajoute l'option --encoding pour préciser l'encodage des données, je pourrai constater que la clause SQL correspondante est ENCODING:
sh# sudo -u postgres \
createdb -e DemoDB2 --encoding UTF-8
CREATE DATABASE "DemoDB2" ENCODING 'UTF-8';
Enfin, autre commande à connaître, dropdb pour supprimer une base de données. Commande qui d'ailleurs supporte également l'option -e:
sh# sudo -u postgres \
dropdb -e DemoDB2
DROP DATABASE "DemoDB2";
Bien puisque nous en sommes à voir des commandes SQL, pourquoi ne pas essayer de créer directement une base avec à partir du client psql?
A partir du client psql
Maintenant que nous avons vu les utilitaires shell permettant de créer et supprimer une base, essayons d'en faire autant à partir du client PostgeSQL. Mais avant toute chose, il nous faut nous connecter au serveur de base de données. Exactement comme nous l'avons fait en tout début de cet article:
sh# sudo -u postgres psql
Welcome to psql 8.3.7, the PostgreSQL interactive terminal.
Type: \copyright for distribution terms
\h for help with SQL commands
\? for help with psql commands
\g or terminate with semicolon to execute query
\q to quit
postgres=#
A partir de maintenant, nous pouvons envoyer des commandes au serveur sous la forme de requêtes SQL. Par exemple pour créer une base (commande CREATE DATABASE) ou la supprimer (DROP DATABASE):
postgres=# CREATE DATABASE "MaBase"; -- Création d'une nouvelle base CREATE DATABASE postgres=# DROP DATABASE "MaBase"; -- Suppression de la base qui vient d'être créée DROP DATABASE
Piège:
N'oubliez pas le point-virgule à la fin des commandes SQL!
Créer une table et la peupler
Bon, cet article n'est pas un tutoriel sur SQL, mais juste pour nous assurer que tout est en ordre, nous allons tout de même créer et peupler une petite base. Le prétexte de celle-ci sera la gestion d'une collection de bandes dessinées:
postgres=# CREATE DATABASE "MesBDs"; CREATE DATABASE
Créer une base ne suffit pas pour travailler dessus. Il faut ensuite s'y connecter. Dans psql cela se fait avec la commande \c (backslash c):
postgres=# \c MesBDs You are now connected to database "MesBDs". MesBDs=#
Note:
Contrairement aux commandes SQL (traitées par le serveur PostgreSQL), il n'y a pas de point-virgule à la fin des commandes du client psql.
Remarque:
Il est aussi possible de se connecter automatiquement à une base au lancement de psql:
sh# sudo -u postgres psql MesBDs Welcome to psql 8.3.7, the PostgreSQL interactive terminal. Type: \copyright for distribution terms \h for help with SQL commands \? for help with psql commands \g or terminate with semicolon to execute query \q to quit MesBDs=#
Maintenant que nous sommes connectés, créons une table pour stocker le titre de mes BDs – et ajoutons quelques enregistrements:
MesBDs=# CREATE TABLE Album ( MesBDs(# id SERIAL PRIMARY KEY, -- Identifiant unique de la BD MesBDs(# titre VARCHAR(255) UNIQUE NOT NULL, -- Le titre de l'album MesBDs(# serie VARCHAR(255) NOT NULL -- La série à laquelle il appartient MesBDs(# ); NOTICE: CREATE TABLE will create implicit sequence "album_id_seq" for serial column "album.id" NOTICE: CREATE TABLE / PRIMARY KEY will create implicit index "album_pkey" for table "album" NOTICE: CREATE TABLE / UNIQUE will create implicit index "album_titre_key" for table "album" CREATE TABLE
SERIAL
Remarquez que j'ai utilisé le type SERIAL pour le champ id. C'est la manière dans PostgreSQL d'indiquer un champ qui va contenir un numéro séquentiel pouvant être attribué automatiquement par le serveur à chaque nouvel enregistrement.
La requête précédente crée une table nommée Album dotée de trois champs. Une fois la table créée, il est possible d'y insérer des données:
MesBDs=# INSERT INTO Album (titre, serie)
MesBDs-# VALUES
MesBDs-# ('La Forge de Vulcain', 'Yoko Tsuno'),
MesBDs-# ('L''Orgue du Diable', 'Yoko Tsuno'),
MesBDs-# ('Le Trio de l''Étrange', 'Yoko Tsuno');
INSERT 0 3
Note:
Dans PostgreSQL, c'est l'apostrophe qui sert de délimiteur de chaînes de caractères. Notez aussi que, conformément au standard SQL, pour insérer une apostrophe dans une chaîne il faut la doubler:
[...]
('L''Orgue du Diable', 'Yoko Tsuno'),
[...]
Une requête SELECT nous permet de vérifier que les données sont bien remplies – et au passage de constater que PostgreSQL a bien rempli automatiquement le champ id:
postgres=# SELECT * FROM Album; id | titre | serie ----+----------------------+------------ 1 | La Forge de Vulcain | Yoko Tsuno 2 | L'Orgue du Diable | Yoko Tsuno 3 | Le Trio de l'Étrange | Yoko Tsuno (3 rows)
J'ai d'autres albums à insérer de la série Blake et Mortimer. Mais comme c'est un peu fastidieux de répéter le nom de la série pour chaque enregistrement, je vais utiliser la capacité de PostgreSQL à gérer des INSERT complexes:
MesBDs=# INSERT INTO Album(titre, serie)
MesBDs-# SELECT * FROM (
MesBDs(# VALUES ('L''Affaire du Collier'),
MesBDs(# ('Le Piège Diabolique'),
MesBDs(# ('S.O.S. Météores'),
MesBDs(# ('L''Énigme de l''Atlantide')
MesBDs(# ) AS titre(titre), (
MesBDs(# VALUES ('Blake et Mortimer')) AS serie(serie);
INSERT 0 4
MesBDs=# SELECT * FROM Album;
id | titre | serie
----+-------------------------+-------------------
1 | La Forge de Vulcain | Yoko Tsuno
2 | L'Orgue du Diable | Yoko Tsuno
3 | Le Trio de l'Étrange | Yoko Tsuno
4 | L'Affaire du Collier | Blake et Mortimer
5 | Le Piège Diabolique | Blake et Mortimer
6 | S.O.S. Météores | Blake et Mortimer
7 | L'Énigme de l'Atlantide | Blake et Mortimer
(7 rows)
Informations sur les tables
Si vous êtes perdu, dans psql, à tout moment vous pouvez obtenir la liste des tables (et autres objets) gérés par la base de données à l'aide de la commande \d:
MesBDs=# \d
List of relations
Schema | Name | Type | Owner
--------+--------------+----------+----------
public | album | table | postgres
public | album_id_seq | sequence | postgres
(2 rows)
Cette commande permet également d'examiner la structure d'une table:
MesBDs=# \d album
Table "public.album"
Column | Type | Modifiers
--------+------------------------+----------------------------------------------------
id | integer | not null default nextval('album_id_seq'::regclass)
titre | character varying(255) | not null
serie | character varying(255) | not null
Indexes:
"album_pkey" PRIMARY KEY, btree (id)
"album_titre_key" UNIQUE, btree (titre)
Gestion des utilisateurs
A ce stade, nous avons installé PostgreSQL et vérifié son fonctionnement. Mais, jusqu'à présent toutes les manipulations ont été effectuées en tant qu'administrateur.
C'était suffisant pour cette première prise en main. Mais en utilisation normale, le compte administrateur devrait être réservé à ... l'administration. Il est donc plus que temps de créer nos premiers comptes utilisateurs. C'est donc ce que nous allons voir pour terminer cet article.
Définition: Rôle
Dans PostgreSQL – à partir de la version 8.1 – on ne parle plus d'utilisateur, mais de rôle.
Ce concept est plus large, puisqu'il regroupe à la fois les notions d'utilisateur et de groupe. Par ailleurs, un rôle pouvant être inclus dans un autre rôle – et le cas échéant hériter de ses permissions – cela ouvre des possibilités très fines de gestion des droits.La gestion des utilisateurs est un point clé pour assurer la sécurité des données gérées par le serveur de bases de données. En effet, vous ne souhaitez pas que n'importe qui accède à vos données. De la même manière, ce n'est pas parce qu'il est autorisé à accéder à une base de données qu'un utilisateur peut faire n'importe quoi dessus: par exemple, certains utilisateurs pourraient n'avoir le droit que de consulter les données, alors que d'autres auraient aussi le droit de les modifier.
Dans un serveur PostgreSQL, la sécurité des données repose sur deux mécanismes:
- l'authentification, qui permet à PostgreSQL de s'assurer de l'identité de l'utilisateur et de vérifier qu'il est autorisé à se connecter au serveur de bases de données;
- la gestion des droits, qui permet à PostgreSQL de savoir ce qu'a le droit de faire l'utilisateur authentifié.
Dans les sections qui viennent, nous allons voir tout d'abord comment vont être authentifiés les utilisateurs qui tentent de se connecter au serveur. Ensuite, nous verrons qu'il y a différentes stratégies possibles pour créer les utilisateurs PostgreSQL. Nous en verrons deux qui correspondent aux cas les plus courants.
Connexion et authentification
Attention:
A partir de maintenant les choses vont se compliquer un peu puisque nous allons manipuler deux types d'identité:
- L'utilisateur du système: c'est à dire le nom sur lequel vous êtes connecté à votre machine.
- L'utilisateur de la base de données: c'est à dire l'utilisateur reconnu par PostgreSQL.
Comme PostgreSQL s'intègre relativement bien avec son environnement d'exécution, ces deux utilisateurs portent parfois le même nom. Comme c'est le cas pour l'utilisateur postgres – qui est à la fois un utilisateur du système, et un utilisateur de la base de données. Mais ce n'est absolument pas une obligation: ainsi, vous pouvez très bien créer des utilisateurs sans PostgreSQL dans nécessairement les ajouter comme utilisateur de votre système.
La configuration de l'accès à PostgreSQL se fait dans le fichier pg_hba.conf (qui se trouve dans mon installation à l'emplacement /etc/postgresql/8.3/main/pg_hba.conf). C'est là que sera indiqué qui a le droit de se connecter au serveur, et comment l'identité de l'utilisateur va pouvoir être vérifiée:
sh# cat /etc/postgresql/8.3/main/pg_hba.conf # PostgreSQL Client Authentication Configuration File # =================================================== # # Refer to the "Client Authentication" section in the # PostgreSQL documentation for a complete description # of this file. A short synopsis follows. # # This file controls: which hosts are allowed to connect, how clients # are authenticated, which PostgreSQL user names they can use, which # databases they can access. Records take one of these forms: # # local DATABASE USER METHOD [OPTION] # host DATABASE USER CIDR-ADDRESS METHOD [OPTION] # hostssl DATABASE USER CIDR-ADDRESS METHOD [OPTION] # hostnossl DATABASE USER CIDR-ADDRESS METHOD [OPTION] [...] # Database administrative login by UNIX sockets local all postgres ident sameuser # TYPE DATABASE USER CIDR-ADDRESS METHOD # "local" is for Unix domain socket connections only local all all ident sameuser # IPv4 local connections: host all all 127.0.0.1/32 md5 # IPv6 local connections: host all all ::1/128 md5
Comme ce fichier est bien documenté, je ne vais pas trop insister. Au pire, vous vous reporterez à la documentation de PostgreSQL. Néanmoins, je vais quand même détailler les quatre règles définies en standard:
-
# TYPE DATABASE USER CIDR-ADDRESS METHOD local all postgres ident sameuser
Cette première règle autorise l'utilisateur de nom postgres (USER: postgres) à se connecter pour accéder à n'importe quelle base de données (DATABASE: all) via une socket Unix à partir de la machine locale (TYPE: local) et à condition que l'utilisateur soit aussi connecté au système sous la même identité (METHOD: ident sameuser). Au passage, c'est grâce à cette règle que nous avons pu nous connecter jusqu'à présent à PostgreSQL.
-
# TYPE DATABASE USER CIDR-ADDRESS METHOD local all all ident sameuser
La seconde règle s'applique aussi aux connexions via une socket Unix (TYPE: local). Mais cette fois ci, elle concerne tous les utilisateurs (USER: all). Cette règle est distincte de la précédente uniquement pour séparer l'authentification de l'administrateur de celle des autres utilisateurs ... même si en standard les deux règles font la même chose.
-
# TYPE DATABASE USER CIDR-ADDRESS METHOD host all all 127.0.0.1/32 md5
Avec la troisième règle arrive l'authentification des utilisateurs tentant de se connecter via une socket IP (TYPE: host). Ici, un utilisateur tentant de se connecter via une socket IPv4 et à partir de l'hôte local (CIDR-ADDRESS: 127.0.0.1/32) devra s'authentifier en fournissant un mot de passe encrypté par l'algorithme MD5 (METHOD: md5).
-
# TYPE DATABASE USER CIDR-ADDRESS METHOD host all all ::1/128 md5
Enfin, la quatrième règle est identique à la troisième, mais concerne les connexions à partir de l'hôte local via une socket IPv6 (TYTPE: host CIDR-ADDRESS: ::1/128). Ici encore, l'utilisateur devra prouver son identité en transmettant un mot de passe encrypté par l'algorithme MD5 (METHOD: md5).
Remarque:
Vous comprenez que si vous souhaitez permettre l'accès à votre serveur PostgreSQL à partir d'une autre machine du réseau, il faudra rajouter une ligne dans ce fichier. Par exemple, pour autoriser les connexions à partir des machines du réseau IPv4 10.129.36.XXX, j'écrirai:
# TYPE DATABASE USER CIDR-ADDRESS METHOD host all all 10.129.36.0/24 md5
Authentification ident sameuser
.png)
Même si les règles décrites plus haut autorisent la connexion d'autres utilisateurs que postgres à votre base de données, cela ne peut se faire qu'à condition d'également créer l'utilisateur correspondant dans PostgreSQL.
Plusieurs stratégies sont possibles. Dans cette section, nous allons voir comment créer un nouveau rôle correspondant à un utilisateur de votre système déjà existant.
Un des moyens de réaliser cette opération est de se connecter (en tant qu'administrateur) à PostgreSQL, et d'utiliser la commande SQL CREATE USER. Ainsi, sur mon système, il y a un utilisateur sylvain. Pour créer un rôle du même nom dans PostgreSQL, il faut utiliser la commande suivante:
postgres=# CREATE USER "sylvain";
CREATE ROLE
postgres=# \du
List of roles
Role name | Superuser | Create role | Create DB | Connections | Member of
-----------+-----------+-------------+-----------+-------------+-----------
postgres | yes | yes | yes | no limit | {}
sylvain | no | no | no | no limit | {}
(2 rows)
Remarque:
Si vous êtes observateur vous avez remarqué une petite anomalie lors de la requête CREATE USER:
postgres=# CREATE USER "sylvain";
CREATE ROLE
En fait, depuis la version 8.1 de PostgreSQL CREATE USER est un alias pour la commande CREATE ROLE ... LOGIN. Ainsi, j'aurais aussi bien pu créer l'utilisateur avec la commande suivante:
postgres=# CREATE ROLE "sylvain" LOGIN; CREATE ROLE
A partir de maintenant, l'utilisateur (du système) sylvain peut se connecter à PostgreSQL et sera reconnu comme appartenant au rôle (PostgreSQL) sylvain:
sh$ whoami # qui suis-je pour le système? sylvain sh$ psql MesBDs Welcome to psql 8.3.7, the PostgreSQL interactive terminal. [...] MesBDs=> \echo :USER -- qui suis-je pour PostgreSQL sylvain
Note:
Tout comme dans le prompt standard du shell un dièse (#) vous rappelle que vous êtes connecté sous l'identité root, sous psql l'invite de commande standard se termine par un dièse si vous êtes identifié comme un administrateur, et par un supérieur (>) dans le cas contraire:
sh$ psql MesBDs
Welcome to psql 8.3.7, the PostgreSQL interactive terminal.
[...]
MesBDs=>
Voilà: nous pouvons nous connecter sous une autre identité à la base. Mais...
MesBDs=> SELECT * FROM Album; ERROR: permission denied for relation album
Et oui! Nous n'avons donné aucune permission à sylvain sur la base MesBds. Il faut donc se reconnecter en tant qu'administrateur à PostgreSQL pour ajuster les permissions:
sh# sudo -u postgres psql MesBDs [...] MesBDs=# GRANT ALL PRIVILEGES ON TABLE Album TO sylvain; GRANT
MesBDs=> SELECT * FROM Album; id | titre | serie ----+-------------------------+------------------- 1 | La Forge de Vulcain | Yoko Tsuno 2 | L'Orgue du Diable | Yoko Tsuno 3 | Le Trio de l'Étrange | Yoko Tsuno 4 | L'Affaire du Collier | Blake et Mortimer 5 | Le Piège Diabolique | Blake et Mortimer 6 | S.O.S. Météores | Blake et Mortimer 7 | L'Énigme de l'Atlantide | Blake et Mortimer (7 rows)
Authentification md5
.png)
Pour terminer avec ce rapide tour d'horizon de la création des rôles, nous allons créer un nouveau rôle, mais cette fois sans correspondance avec un utilisateur du système. Cette stratégie peut par exemple être utile pour permettre aux utilisateurs d'une application web d'accéder à une base de données, sans nécessairement leur ouvrir un compte sur le serveur Linux hôte. Ou encore pour créer un utilisateur générique – sous l'identité duquel plusieurs utilisateurs du système pourraient accéder à la base de données. C'est ce que nous allons faire maintenant en créant un utilisateur consultant qui aura les permissions pour consulter la liste de mes BD, mais pas la modifier.
MesBDs=# CREATE ROLE consultant WITH ENCRYPTED PASSWORD 'mot-de-passe' LOGIN; CREATE ROLE MesBDs=# GRANT SELECT ON Album TO consultant; GRANT
Désormais, un utilisateur peut se connecter à PostgreSQL sous l'identité consultant – à condition de fournir le bon mot de passe – et visualiser la liste de mes BDs. Mais pas en ajouter ou en supprimer:
sh$ psql --user consultant MesBDs # (1) Ceci ne marche pas. Voir encadré ci-dessous pour l'explication... psql: FATAL: Ident authentication failed for user "consultant" sh$ psql --host localhost --user consultant MesBDs Password for user consultant: Welcome to psql 8.3.7, the PostgreSQL interactive terminal. Type: \copyright for distribution terms \h for help with SQL commands \? for help with psql commands \g or terminate with semicolon to execute query \q to quit SSL connection (cipher: DHE-RSA-AES256-SHA, bits: 256) MesBDs=> SELECT * FROM Album WHERE serie = 'Yoko Tsuno' LIMIT 1; id | titre | serie ----+---------------------+------------ 1 | La Forge de Vulcain | Yoko Tsuno (1 row) MesBDs=> DELETE FROM Album WHERE serie = 'Yoko Tsuno'; ERROR: permission denied for relation album
Dans psql vous pouvez à tout moment vérifier l'ensemble des permissions avec la commande \dp:
MesBDs=> \dp
Access privileges for database "MesBDs"
Schema | Name | Type | Access privileges
--------+--------------+----------+--------------------------------------------------------------------------
public | album | table | {postgres=arwdxt/postgres,sylvain=arwdxt/postgres,consultant=r/postgres}
public | album_id_seq | sequence |
(2 rows)
Remarque:
Si vous vous demandez pourquoi la connexion (1) n'a pas fonctionné, la réponse est dans le fichier de configuration pg_hba.conf. Vous vous souvenez que ce fichier spécifie qui a le droit de se connecter au serveur de base de données et comment. Et qu'un certain nombre de règles sont définies en standard:
sh# sed -n '/^[^#]/p' < /etc/postgresql/8.3/main/pg_hba.conf local all postgres ident sameuser local all all ident sameuser host all all 127.0.0.1/32 md5 host all all ::1/128 md5
Les règles qui commencent par local correspondent à des connexions via une socket Unix. C'est la méthode par défaut si le client et le serveur sont sur la même machine.
Les deux dernières règles correspondent aux connexions via une socket IP (respectivement, IPv4 et IPv6).
Ce qui est intéressant, c'est que ces règles divergent aussi par leur dernière colonne. Dans le cas des connexions local, la règle spécifie que l'identification se fait en fonction de l'utilisateur (système) actuellement connecté (ident sameuser). Dans le cas des connexions par socket TCP/IP, l'authentification se fait par mot de passe encodé en MD5 (MD5).
C'est pourquoi, comme notre rôle consultant n'a pas de correspondance avec un utilisateur système, la connexion par socket Unix échoue. Et il faut passer par une socket TCP/IP – à laquelle est associée une authentification par mot de passe.
Et si on voulait pouvoir connecter un consultant via une socket Unix? Il faudrait ajouter la ligne suivante au fichier pg_hba.conf avant les règles par défaut:
local all consultant md5
Celle-ci précise que l'utilisateur consultant peut se connecter à n'importe quelle base en local, à condition de fournir un mot de passe. Après une modification de pg_hba.conf il faut demander à PostgreSQL de recharger la configuration:
sh# /etc/init.d/postgresql-8.3 reload Reloading PostgreSQL 8.3 database server: main.
Et à partir de maintenant, il devient possible de se connecter en consultant à la base via une socket Unix:
sh$ psql --user consultant MesBDs Password for user consultant: Welcome to psql 8.3.7, the PostgreSQL interactive terminal. [...] MesBDs=>
Conclusion
Voilà, nous en avons terminé avec l'installation de PostgreSQL. Et pour tout dire, nous avons été un peu plus loin que la simple installation. Néanmoins, je crois que c'est là le minimum à connaître pour pouvoir commencer à utiliser cet outil. Ainsi, disposez-vous des bases pour pouvoir commencer à vous amuser ... et à travailler avec PostgreSQL.
Ressources
- (en) http://www.debianhelp.co.uk/postgresql.htm – Installation de PostgreSQL sous Debian
- (en) http://www.postgresql.org/docs/current/static/client-authentication.html – Format du fichier pg_hba.conf
