PostgreSQL sur Mac OS X
PostgreSQL (prononcez “post-graisse cou elle”) est un Système de Gestion de Bases de Données open-source qui tourne sur la plupart des UNIX, dont Mac OS X. Bien qu’il ait à devenir aussi populaire que son principal concurrent, MySQL, il est pleinement compatible avec ACID, et est capable de gérer des applications avec des bases de données aussi bien petites que complexes. Pour plus de détails au sujet des fonctionnalités de PostgreSQL, jetez un oeil à cette liste complète, ou à sa documentation (NdT : en anglais)
Dans cet article, je vous montrerais comment installer et configurer PostgreSQL sur Mac OS X, et ensuite comment l’utiliser avec Perl, Java et PHP. Enfin, je vous montrerais comment utiliser l’outils Web phpPgAdmin pour administrer vos bases de données.
Installer PostgreSQL
Avant d’installer PostgreSQL, vous aurez besoin d’installer un package nommé readline. La façon la plus simple de l’obtenir est d’utiliser le projet Fink. Le but du projet Fink est de porter les applications open-source Unix sur Darwin et Mac OS X, et de les rendre disponible via un gestionnaire facile d’utilisation. Pour installer Fink, suivez ces directives. Assurez vous d’avoir la version correspondant à votre Mac OS X.
Une fois que Fink est installé, ouvrez une fenêtre de terminal et saisissez le texte suivant pour installer readline :
liz@mail:~> sudo /sw/bin/fink install readline
Vous pouvez installer PostgreSQL via Fink, mais une version plus récente et plus stable est disponible si vous l’installez depuis les sources. Puisque le processus de compilation est simple, j’ai choisi de l’installer depuis les sources, en utilisant la commande curl. La version stable la plus récente (7.3.1, au moment où j’écris) peut être téléchargée chez PostgreSQL.org. Comme d’habitude, vous aurez besoin de la commande sudo pour avoir l’accès root avant d’installer les logiciels systèmes :
liz@mail:~> cd /usr/local/src liz@mail:src> sudo sh Password: root@mail:src> mkdir postgres root@mail:src> cd postgres root@mail:postgres> curl -O http://www.ca.postgresql.org/ftpsite/v7.3.1/postgresql-7.3.1.tar.gz root@mail:postgres> tar -xzvf postgresql-7.3.1.tar.gz root@mail:postgres> cd postgresql-7.3.1
(Notez que je préfère mettre les sources dans /usr/local/src.)
Maintenant que j’ai les sources, je peut lancer le script configure, compiler, et installer. Puisque je viens d’installer readline via Fink, je dois ajouter les dossiers Fink comme arguments au script configure (NdT : j’ai utilisé le package de Marc Liyanage, dont la configuration comporte plus d’options, notamment C++, Java et syslog. Faites un “./configure –help” afin de personaliser tout ça : Python, TCL/TK, Perl, … Pour Java, si vous souhaitez partir des sources, il vous faudra le compilateur “ant” via Fink) :
root@mail:postgresql-7.3.1> ./configure --with-includes=/sw/include/ --with-libraries=/sw/lib root@mail:postgresql-7.3.1> make root@mail:postgresql-7.3.1> make install
Ensuite, j’ai eu à ajouter un utilisateur “administratif” (NdT : mais pas administrateur pour des raisons évidente de sécurité) appelé “postgres” (NdT : personnellement c’est “pgsql”, mais c’est comme vous voulez) qui possède effectivement les bases de données. Pour ajouter un utilisateur dans Mac OS X, ouvrez System Preferences (NdT : Préférences Système) et sélectionnez Accounts (NdT : Comptes), là cliquez New User (NdT : Nouvel utilisateur). Enfin, entrez les valeurs montrées ci-dessous et cliquez Save (NdT : Enregistrer) :
Pour plus de détails sur l’ajout d’utilisateurs dans Mac OS X, voyez l’article MySQL (NdT : ou sa traduction), qui couvre l’ajout d’utilisateurs via NetInfo Manager (NdT : Gestionnaire NetInfo) et la commande niutil.
Ensuite, je retourne dans le terminal pour créer un dossier qui contiendra mes fichiers de données PostgreSQL. Ce dossier sera la propriété de mon nouvel utilisateur “postgres” :
root@mail:~> mkdir /usr/local/pgsql/data root@mail:~> chown postgres /usr/local/pgsql/data
J’ai besoin de me connecter en tant que “postgres” afin de faire les derniers pas. Pour le faire, je saisis dans le terminal, suivi du mot de passe que je viens de créer :
liz@mail:~> su -l postgres
Maintenant, je peux initialiser les bases de données :
postgres@mail:~> /usr/local/pgsql/bin/initdb -D /usr/local/pgsql/data
Comme vous pouvez le voir, la commande initdb, ainsi que les autre exécutables de PostgreSQL, se trouve dans le dossier /usr/local/pgsql/bin (NdT : en fait où vous voulez avec l’option “–with-bindir=xxxx” du script configure). Pour simplifier les choses plus tard, vous voudrez certainement ajouter ce dossier dans le path (la liste des dossiers qui sont scrutés quand vous tapez le nom d’un programme dans la ligne de commande). Si vous utilisez les shells csh ou tcsh, cette commande changera votre path :
setenv PATH ${PATH}:/usr/local/pgsql/bin
Si vous utilisez sh or bash, ceci vous aidera :
export PATH=$PATH:/usr/local/pgsql/bin
Si vous voulez que le changement soit permanent, enregistrez cette commande quelque part où cela sera relancé automatiquement au démarrage d’une session de terminal. Si vous utilisez le shell tcsh shell (par défaut sur Mac OS X), vous pouvez créer un fichier appelé .tcsh dans le dossier départ de chaque utilisateur. Les commandes d’un fichier .tcsh sont lancées par le système à chaque fois qu’un session de terminal commence. Ci-dessous, le fichier .tcsh que j’ai créé pour mes sessions en tant que “postgres.” Il contient les commandes pour ajouter /usr/local/pgsql/bin au path de cet utilisateur, et une ligne contenant la localisation des fichiers de données de PostgreSQL dans une variable d’environnement appelée PGDATA (dont j’aurais besoin plus tard) :
setenv PGDATA /usr/local/pgsql/data
setenv PATH ${PATH}:/usr/local/pgsql/bin
Je peux lancer les commandes de mon fichier .tcsh en tapant : source ~/.tcsh.
Maintenant, je suis prêt à démarrer le serveur PostgreSQL :
postgres@mail> /usr/local/pgsql/bin/pg_ctl -D /usr/local/pgsql/data -l logfile start
Une fois qu’il tourne, je peux créer ma première base en utilisant la commande createdb :
postgres@mail> createdb test
Et c’est tout. Pour entrer dans l’utilitaire en ligne de commande de PostgreSQL et lancer des commandes SQL dans la base de donnée test, saisissez la commande suivante :
postgres@mail> psql test
Les codes exemples dans la suite de cet article supposent l’existence d’une table appelée “foo” dans la base de données “test”. Si vous voulez utiliser les exemples de cet article, allez dans PostgreSQL et exécutez les commandes suivantes. Cela créera la table “foo” et insèrera deux lignes de données dedans :
test=> create table foo (name varchar, foo_id serial);
NOTICE: CREATE TABLE will create implicit sequence 'foo_foo_id_seq' for SERIAL column 'foo.foo_id'
CREATE TABLE
test=> insert into foo (name) values ('Liz');
INSERT 16985 1
test=> insert into foo (name) values ('Jason');
INSERT 16986 1
Accès des utilisateurs et authentification
PostgreSQL est livré avec des règles d’accès assez laxistes. Si vous devez utiliser votre base de données dans un environnement de production, ou sur n’importe quel serveur partagé, vous devez ajouter au moins un niveau minimum de sécurité. Les règles d’authentification des utilisateurs sont définies dans le fichier /usr/local/pgsql/data/pg_hba.conf. Comme c’est expliqué dans la documentation de PostgreSQL (NdT : en anglais), vous pouvez l’éditer pour protéger les comptes utilisateurs par mot de passe, changer les méthodes d’authentification pour les connections locales et à distance, et accepter ou refuser l’accès des utilisateurs aux différentes parties du système.
J’ai choisi de demander le mot de passe pour tout utilisateur en réglant METHOD à md5 pour tous les utilisateurs. En outre, alors que j’ai donné l’accès complet à toutes les bases de données à l’utilisateur “postgres”, j’ai instauré un accès par groupe pour les autres utilisateurs en réglant DATABASE à samegroup pour tous les autres. Par exemple, afin qu’un utilisateur ait la permission d’écrire dans une base de données nommée something, cet utilisateur devra être membre du groupe something. J’ai aussi activé les connections depuis localhost (avec les mêmes règles d’authentification) pour pouvoir utiliser JDBC pour me connecter à PostgreSQL plus tard. Voici ci-dessous les lignes de mon fichier pg_hba.conf :
# TYPE DATABASE USER IP-ADDRESS IP-MASK METHOD host all postgres 127.0.0.1 255.255.255.255 md5 host samegroup all 127.0.0.1 255.255.255.255 md5 local all postgres md5 local samegroup all md5
Après avoir édité le fichier, j’ai besoin de créer un mot de passe pour le super-utilisateur “postgres”, et de redémarrer le serveur pour que les changement soient pris en compte :
postgres@mail:~> psql test test=# alter user postgres with password 'foo'; test=# \q
postgres@mail:~> pg_ctl reload
Maintenant, pour faire une démonstration de l’accès basé sur les groupes, je vais créer deux nouvelles bases, nommées shared et private, avec un groupe nommé shared. Ensuite je vais créer un utilisateur appelé “liz” et ajouter cet utilisateur au groupe shared, mais pas au groupe private :
postgres@mail:~> psql test test=# create database shared; test=# create database private; test=# create group shared; test=# create user liz with password 'liz'; test=# alter group shared add user liz;
Maintenant je peux accéder à la base shared en tant que “liz”:
liz@mail:~> psql shared liz
Password:
Welcome to psql 7.3.1, the PostgreSQL interactive terminal.
Type: \copyright for distribution terms
\h for help with SQL commands
\? for help on internal slash commands
\g or terminate with semicolon to execute query
\q to quit
shared=> \q
liz@mail:~>
Quand j’essaie d’accéder à la base de donnée private en tant que “liz”, je me vois refuser l’entrée :
liz@mail:~> psql private liz psql: FATAL: No pg_hba.conf entry for host localhost, user liz, database private
Bien sûr, l’administrateur de base de données peut accéder à la base private sans être membre d’aucun groupe en particulier :
liz@mail:~> psql private postgres
Password:
Welcome to psql 7.3.1, the PostgreSQL interactive terminal.
Type: \copyright for distribution terms
\h for help with SQL commands
\? for help on internal slash commands
\g or terminate with semicolon to execute query
\q to quit
private=#
Avant de continuer, créez un groupe du nom de test et ajoutez l’utilisateur “liz” à ce dernier :
test=# create group test; test=# alter group shared add user liz;
Ceci permettra au code des exemples de fonctionner tel quel. (Sauf si, bien entendu, vous souhaitez créer votre propre compte et modifier les exemples en conséquence. Dans ce cas, ajoutez votre compte au groupe test et vous serez prêt à continuer.)
PostgreSQL et Perl
Vos scripts Perl peuvent interagir avec PostgreSQL via DBI.pm, la populaire interface de programmation indépendante de tout système de gestion de bases de données. Si vous avez écrit des scripts Perl pour MySQL ou Oracle par le passé, vous serez probablement déjà familiarisé avec ceci. Vous pouvez obtenir DBI pour Mac OS X via CPAN ou Fink:
liz@mail:~> sudo /sw/bin/fink install dbi-pm
ou
liz@mail:~> sudo perl -MCPAN -e 'install DBI'
Après avoir installé DBI, vous aurez besoin d’un driver spécifique à Postgres appelé DBD::Pg. Il est lui aussi disponible via CPAN:
liz@mail:~> sudo perl -MCPAN -e 'install DBD::Pg'
Le portage par Fink de DBD::Pg n’est pour l’instant pas stable, mais devrait l’être bientôt. Si vous avez déjà décidé que vous préfériez Fink, vous pouvez toujours essayer de saisir la commande proposé plus bas. Vous obtiendrez une erreur “package not found” si cela ne fonctionne pas :
liz@mail:~> sudo /sw/bin/fink install dbd-pg-pg
Note : Selon votre configuration système et la façon dont vous aurez installé PostgreSQL, vous pourriez avoir à utiliser la commande ranlib sur votre fichier libpq.a avant de pouvoir installer DBD::Pg. Si vous voyez des messages d’erreur concernant ranlib ou libpq.a, ne vous inquiétez pas. Lancez simplement la commande ci-dessous et vous serez bien :
liz@mail:~> sudo ranlib /usr/local/pgsql/lib/libpq.a
Maintenant, DBI et DBD::Pg devraient être installés. Pour tester tout ça, j’ai installé le code ci-dessous dans un fichier appelé pg.cgi dans mon dossier (/Library/WebServer/CGI-Executables), et je me suis assuré que le fichier est lisible et exécutable en entrant : chmod ugo+rx /Library/WebServer/CGI-Executables/pg.cgi.
#!/usr/bin/perl
use DBI;
use CGI;
use CGI::Carp qw(fatalsToBrowser);
use strict;
my $c = new CGI();
my $dbname = 'test';
my $user = 'liz';
my $pass = 'liz';
print $c->header();
print $c->start_html("Reading names from table 'foo' in db 'test'");
my $dbh = DBI->connect("dbi:Pg:dbname=$dbname", $user, $pass) or die DBI::errstr;
my $res = $dbh->selectall_arrayref("select name from foo order by foo_id");
for my $row (@$res)
{
print 'Name: ' , @$row[0] , '<br>';
}
$dbh->disconnect();
print $c->end_html();
Ceci est la sortie que j’obtiens :
Pour en apprendre plus sur l’utilisation de PostgreSQL et de Perl ensemble, vous pouvez taper perldoc DBI ou perldoc DBD::Pg dans une fenêtre de terminal, ou lire sur CPAN.org les information sur DBI.
PostgreSQL et Java
Les gens de PostgreAQL.org ont créé un driver JDBC pour PostgreSQL, ce qui veut dire que vous pouvez utiliser facilement PostgreSQL comme base de données en support de vos applications Java. Téléchargez un driver JDBC (NdT : si vous partez des sources avec le support de Java, un driver est disponible dans la distribution : /usr/local/pgsql/share/java/postgres.jar) et copiez le dans un dossier de bibliothèques partagées, comme /Library/Java/Extensions/. Ensuite, Assurez vous de régler votre variable d’environnement CLASSPATH sur ce dossier. Pour cet exemple, j’ai créé une nouvelle variable CLASSPATH dans tcsh, comme ceci :
liz@mail:~> setenv CLASSPATH /Library/Java/Extensions/pg73jdbc2ee.jar:.
Les utilisateurs de Bash ou sh écriront ceci à la place :
liz@mail:~> export CLASSPATH="/Library/Java/Extensions/pg73jdbc2ee.jar:."
Avant de vous connecter via JDBC, éditez votre fichier pg_hba.conf comme au dessus. Vous devrez aussi modifier le fichier /usr/local/pgsql/data/postgresql.conf pour autoriser les connections TCP/IP. En tant qu’utilisateur “postgres”, ouvrez postgresql.conf et changez cette ligne :
#tcpip_socket = false
par :
tcpip_socket = true
Et redemarrez le serveur :
postgres@mail:~> pg_ctl reload
Maintenant vous êtes prêt à tester la connection JDBC. Cette petite classe Java contient un code qui se connecte à PostgreSQL et récupère quelques lignes d’une petite table, comme les exemples Perl et PHP. Si vous voulez mettre en place un serveur web basé sur l’environnement Java, je vous recommande de lire les articles de “Apple Internet Developer” sur Java et OS X. Entre-temps, toutefois, créez un fichier PgTest.java avec ce contenu :
import java.sql.*;
import java.text.*;
import java.io.*;
public class PgTest
{
Connection db; // connection object
Statement sql; // statement to run queries with
// the constructor does all the work in this simple example
public PgTest(String argv[])
throws ClassNotFoundException, SQLException
{
String database = argv[0];
String username = argv[1];
String password = argv[2];
// load the JDBC driver for PostgreSQL
Class.forName("org.postgresql.Driver");
// connect to the datbase server over TCP/IP
// (requires that you edit pg_hba.conf
// as shown in the "Authentication" section of this article)
db = DriverManager.getConnection("jdbc:postgresql:"+database,
username,
password);
// create a statement for later use
sql = db.createStatement();
String theQuery = "select name from foo order by foo_id";
System.out.println("Now executing query: \""+ theQuery + "\"\n");
ResultSet results = sql.executeQuery(theQuery);
if (results != null)
{
while (results.next())
{
System.out.println("Name: "+results.getString("name")+"\n");
}
}
else
{
System.out.println("No rows found");
}
results.close();
db.close();
}
public static void showUsage()
{
System.out.println("\nUsage:\n "+
"java PgTest <database> <username> <password> \n");
System.exit(1);
}
public static void main (String args[])
{
if (args.length != 3) showUsage();
try
{
PgTest showMe = new PgTest(args);
}
catch (Exception ex)
{
System.out.println("Caught Exception:\n"+ex);
ex.printStackTrace();
}
}
}
Maintenant vous pouvez compiler et lancer l’application de test Java.
PostgreSQL et PHP
Afin d’utiliser PostgreSQL avec PHP, vous aurez besoin de recompiler PHP (NdT : ou de visiter à nouveau le site de Marc Liyanage). Si vous êtes comme de nombreux utilisateurs de Mac OS X de ce début d’année 2003, cela vous donnera une chance de mettre à jour PHP à la nouvelle version 4.3.0, qui est en chantier depuis huit mois (NdT : c’est une version plus récente que celle de Marc Liyanage à l’heure où je traduis). J’ai choisi de compiler PHP sous la forme d’un module apxs. Ce n’est pas la seule solution, mais cela vous permettra d’utiliser Apache, le serveur web livré par Apple avec Mac OS X. Si vous voulez en apprendre plus sur les autres options de compilation, visitez PHP.net. La chose importante est de configurer PHP avec l’option –with-pgsql avant de compiler.
Premièrement, allez chercher la dernière version stable de PHP, disponible sur PHP.net. Extrayez l’archive et lancez configure et make. Vous pouvez ajouter d’autres arguments à ./configure si vous avez d’autres modules à ajouter (NdT : MySQL par exemple) :
root@mail:src> tar -xzvf php-4.3.0.tar.gz root@mail:src> cd php-4.3.0/ root@mail:php-4.3.0> ./configure --with-pgsql --with-apxs root@mail:php-4.3.0> make root@mail:php-4.3.0> make install root@mail:php-4.3.0> cp php.ini-dist /usr/local/lib/php.ini
Maintenant, modifiez le fichier /etc/httpd/httpd.conf et demandez à Apache de reconnaître l’extension .php :
AddType application/x-httpd-php .php
Enfin, démarrez le serveur web avec la commande apachectl start ou par l’option de partage web dans les Préférences Système.
Une documentation pour les nombreuses fonctions PHP permettant l’accès à PostgreSQL peuvent être trouvées dans cette section du manuel PHP. Vous pouvez toutefois commencer par lancer un script de test. Créez un fichier dans votre racine de document (habituellement /Library/Webserver/Documents/) nommé “pg.php”:
<html>
<head>
<title>Reading names from table 'foo' in db 'test'</title>
<head>
<body>
<?php
$conn = pg_connect("dbname=test user=liz password=liz");
if (!$conn)
{
print "Unable to Connect to DB";
exit;
}
$result = pg_query("select name from foo");
if (!$result)
{
print "Unable to retrieve data";
exit;
}
while ($arr = pg_fetch_array($result))
{
print 'Name: ' . $arr['name'] . '<br>';
}
?>
</body>
</html>
Le résultat devrait ressembler à ça :
Administration de vos bases avec phpPgAdmin
Une fois que vous avez installé PHP et PostgreSQL, vous pourrez profiter de phpPgAdmin, une application web qui rend aisée l’administration de PostgreSQL, que ce soit pour la gestion des bases de données ou pour celle des utilisateurs. Installer phpPgAdmin est une opération simple : téléchargez simplement l’application dans la racine document de votre serveur web, changez quelques paramètres de configuration, et c’est tout :
root@mail:~> cd /Library/WebServer/Documents/ root@mail:Documents> curl -O \ http://unc.dl.sourceforge.net/sourceforge/phppgadmin/phpPgAdmin_2-4-2.tar.gz root@mail:/usr/local/src/phppgadmin> tar -xzvf phpPgAdmin_2-4-2.tar.gz
Si votre serveur est accessible à tous en plus des utilisateurs reconnus, vous devrez ajouter une protection pour l’accès au dossier phpPgAdmin. Si vous ne savez pas comment faire pour ajouter un processus d’authentification à un dossier, ces instructions sur Apache.org vous l’apprendront.
Avant de lancer phpPgAdmin, vous devrez créer et modifier le fichier de configuration de l’application, appelé config.inc.php :
root@mail:src> cd /Library/WebServer/Documents/phpPgAdmin root@mail:phpPgAdmin> cp config.inc.php-dist config.inc.php
Ouvrez config.inc.php et éditez le pour qu’il corresponde au code ci-dessous :
// The $cfgServers array starts with $cfgServers[1]. Do not use $cfgServers[0]. // You can disable a server config entry by setting host to ''. $cfgServers[1]['local'] = false; $cfgServers[1]['host'] = 'localhost'; $cfgServers[1]['port'] = '5432'; $cfgServers[1]['adv_auth'] = true; $cfgServers[1]['user'] = ''; // if you are not using adv_auth, enter the username to connect all the time $cfgServers[1]['password'] = ''; // if you are not using adv_auth and a password is required enter a password $cfgServers[1]['only_db'] = ''; // if set to a db-name, only this db is accessible
Cela dit à l’application
qu’il y a un serveur PostgreSQL sur la machine locale (localhost), et lui
commande de demander aux utilisateurs web d’entrer un nom d’utilisateur et
un mot de passe valides pour accéder à PostgreSQL.
Vous pouvez maintenant voir phpPgAdmin
dans votre navigateur préféré. Entrez “postgres”
comme nom d’utilisateur, et “foo” (ou le mot de passe administrateur choisi
plus tôt) comme mot de passe. Notez que ce n’est pas de mot de passe
de l’utilisateur “postgres” de OS X mais celui que vous avez créé
en tapant alter user postgresql with password
‘foo’ dans le prompt de psql.
Une fois que vous êtes connecté, vous pouvez voir et modifier
vos bases de données, vos tables, vos utilisateurs et vos groupes
—le tout à travers une interface soignée dans votre navigateur
:
Conclusion
PostgreSQL est un SGBDR robuste et open-source qui est idéal pour le développement web sur Mac OS X. Si vous êtes intéressés par ce que peut faire PostgreSQL, je vous recommande la documentation pour développeurs, ou un des nombreux livres disponibles.
Texte original en anglais sur developer.apple.com : PostgreSQL on Mac OS X
Chargement
Commentaires récents