Persistance des données dans une base de données PosgreSQL avec PHP

PHP est un langage de script de serveur largement utilisé. Ses vastes capacités et sa nature légère le rendent idéal pour le développement Web Frontend, et bien qu’il soit possible d’y créer des structures avancées, son utilisation de base est également facile à apprendre, ce qui en fait un bon point de départ pour les débutants également. Les données enregistrées, traitées, envoyées ou affichées par l’application que nous construisons doivent toutefois être stockées quelque part ; Notre page web est sans état sans ces données. Nous pouvons stocker nos données de plusieurs façons ou même les jeter après utilisation, mais la manière la plus standard est de les stocker dans une base de données conçue dans le seul but de stocker les données de manière fiable, et de les présenter si nécessaire, le plus rapidement possible.

Dans ce tutoriel, nous allons créer une page Web simple pour enregistrer et afficher les données de l’utilisateur. Nous utiliserons un SGBDR PostgreSQL comme backend, et développerons notre application en PHP qui fonctionnera sur un serveur Web Apache. De cette façon, nous pouvons accéder à notre application Web à partir de n’importe quel navigateur commun pour la consulter ou l’ajouter à notre base de données d’utilisateurs. C’est la nature de l’application web que de nombreux utilisateurs/opérateurs peuvent travailler avec elle simultanément, tout ce dont ils ont besoin est un navigateur et un accès réseau à notre application.

Dans ce tutoriel, vous allez apprendre :

Comment installer les paquets nécessaires pour la connexion PostgreSQL en PHP
Comment créer la partie base de données de l’application
Comment coder l’exemple d’application
Comment utiliser et vérifier l’application exemple

Enregistrement des données via le navigateur.

Configuration logicielle requise et conventions utilisées

Remarques sur les composants logiciels

Nous configurons notre application sur Ubuntu, mais en gros, ce processus peut être porté sur n’importe quelle distribution. Les différences se situent dans les gestionnaires de paquets et les noms de paquets, ainsi que dans certains chemins de répertoire. Notez également que bien que nous utilisions les versions des composants logiciels mentionnées ci-dessus, cette application peut être construite sur différentes versions des composants avec de petits ajustements. Quelques exemples d’autres distributions seront inclus à des fins de comparaison.

Vous remarquerez peut-être que l’application est minimaliste : c’est intentionnel. L’objectif de ce guide est de montrer les principes de base du développement d’une application capable de communiquer avec une base de données, de la manière la plus simple possible. Un minimum de code, un minimum de composants. N’utilisez pas ce guide pour créer des applications de production, car il ne comporte aucune mesure de sécurité, réutilisation ou optimisation.

Installation des paquets nécessaires

Après avoir installé la base de données PostgreSQL, tout ce dont nous avons besoin est d’ajouter le support php. Pour cela, nous avons besoin du paquet php-pgsql. Nous allons utiliser apt pour l’installer :

apt-get install php-pgsql

Certaines distributions peuvent l’appeler php7-pgsql et autres, mais tous les gestionnaires de paquets fournissent une fonction de recherche, il est donc facile de trouver ce dont nous avons besoin. Par exemple, voici comment installer PostgreSQL sur les systèmes Linux RHEL8/centOS 8.

Nous avons également besoin d’installer php, un serveur web, et le support de php sur le serveur web. C’est à deux forfaits :

apt-get install apache2 libapache2-mod-php

Nous pouvons démarrer les deux services afin qu’ils soient disponibles dans les prochaines étapes. Nous utiliserons systemd pour cela.

systemctl start postgresql
systemclt start apache2

Création de la base de données et des objets nécessaires

Le côté base de données de notre application sera composé d’une base de données, d’une seule table et d’une séquence pour prendre en charge l’attribution automatique des clés primaires.

Nous allons passer à l’utilisateur postgres :
```
su - postgres
```

Connectez-vous à la base de données :

psql
psql (10.9 (Ubuntu 10.9-0ubuntu0.18.04.1))
Type "help" for help.

postgres=#

Créez un nouvel utilisateur :

postgres=# create role exampleuser with login password 'ExamplePass';

Et une base de données avec le propriétaire défini.

postgres=# create database exampledb owner exampleuser encoding 'UTF-8';

Après avoir quitté l’outil psql, nous créons un fichier texte appelé example_table.sql avec le contenu suivant :

create sequence userid_seq start with 0 increment by 1 no maxvalue minvalue 0 cache 1;
alter sequence userid_seq owner to exampleuser;
create table users (
        userid numeric primary key default nextval('userid_seq'::regclass),
        username text not null,
        email text not null,
        registration_date timestamp default now()
);
alter table users owner to exampleuser;

Ici, nous créons une séquence à ligne 1 qui fournira une clé primaire unique à chaque enregistrement de la table, puis définira sa propriété. À ligne 3, nous créons une table qui contiendra les données utilisateur que nous enregistrerons et afficherons avec l’application. Nous définissons les valeurs par défaut pour l’identifiant et le registration_date, et nous laisserons à la base de données le soin de remplir ces champs pour nous.

Nous chargeons le fichier SQL ci-dessus dans la nouvelle base de données :

psql -d exampledb < example_table.sql 
CREATE SEQUENCE
ALTER SEQUENCE
CREATE TABLE
ALTER TABLE

Avec cela, notre base de données est configurée et prête à servir. PostgreSQL 10.9 sur Ubuntu accepte par défaut les connexions protégées par mot de passe sur le périphérique de bouclage. Si vous utilisez d’autres versions, vous devrez peut-être modifier le fichier pg_hba.conf pour permettre l’accès à la base de données. Il y a un exemple dans notre guide d’installation de Redmine sur la façon de le configurer.

Construire le code de l’application

Bien qu’il existe certainement de nombreux outils formidables pour aider à produire du code source fonctionnel, nous ne les couvrirons pas ici, cela ajouterait à la complexité de ce guide. Nous allons créer un fichier texte appelé recording.php, dans le répertoire DOCUMENT_ROOT par défaut sur Ubuntu 18, /var/www/html/. Sur d’autres distributions, cela pourrait être /srv/www/htdocs/, ou autre chose. Référez-vous à la configuration du serveur web si vous n’êtes pas sûr.

PHP est un langage de script, ce qui signifie que nous n’avons pas besoin de compiler notre code, il suffit de le présenter au serveur web, qui l’interprétera au moment de l’exécution.

Nous pouvons utiliser un éditeur de texte en ligne de commande, tel que vi ou nano pour remplir le fichier php mentionné avec le code source suivant :

<!-- section 1 -->
<!DOCTYPE html>
<html>
<head>
<title>User recording page</title>
</head>
<body>
<p>Please fill out the below form and press submit to record the data.</p>
<!-- section 2 -->
<form name="record" action="recording.php" method="post">
<input type="text" name="username"><br>
<input type="text" name="email"><br>
<input type="submit" value="Submit"><br>
</form>
<hr>
<!--section 3 -->
<?php
/* section 4 */
$dbconn = pg_connect("host=127.0.0.1 port=5432 dbname=exampledb user=exampleuser password=ExamplePass");
if(!$dbconn) {
    die('Error connecting to database: ' . pg_last_error());
}
/* section 5 */
if(isset($_REQUEST["username"]) && isset($_REQUEST["email"])) {
    $un = pg_escape_string($_REQUEST["username"]);
    $mail = pg_escape_string($_REQUEST["email"]);
    $insert_res = pg_query("insert into users (userid, username, email, registration_date) values (default,'$un','$mail',default)");
    if(!$insert_res) {
        echo ("Error while inserting data: " . pg_last_error());
    } else {
        echo ("Recoring successful");
    }
}
/* section 6 */
$result = pg_query("SELECT * from users order by registration_date");

echo "<table border='1'>\n<tr><th>#</th><th>Username</th><th>E-mail address</th><th>Registration date</th></tr>\n";

while($row = pg_fetch_row($result)) {
  echo "<tr><td>" . $row[0] . "</td><td>" . $row[1] . "</td><td>" . $row[2] . "</td><td>" . $row[3] . "</td></tr>\n";
}
echo "</table>\n";
/* section 7 */
pg_close($dbconn);
?>
<!-- section 8 -->
</body>
</html>

Nous commençons notre code sous la forme d’une simple page HTML statique à la section 1. Nous créons un formulaire à la section 2 qui offre à l’utilisateur la possibilité d’enregistrer des données dans l’application. Nous ne vous demanderons qu’un nom d’utilisateur et une adresse e-mail. À la section 3, nous intégrons du code PHP dans la page. La section 4 crée la connexion à la base de données à l’aide des informations de connexion que nous avons configurées à l’étape de la base de données. Si la connexion ne peut pas être établie, l’application meurt avec un message d’erreur.

Au point 5, nous traitons toutes les données qui sont envoyées pour traitement avec le formulaire que nous avons créé au point 2. Si « nom d’utilisateur » et « email » sont affichés, nous vérifierons s’ils ne sont pas vides, et s’ils ne le sont pas, nous les insérerons dans la base de données en utilisant notre connexion à la base de données.

Indépendamment de la réception des données publiées, nous interrogerons la table de la base de données pour les données utilisateur déjà enregistrées à la section 6. Nous allons générer le code HTML nécessaire pour fournir une table remplie avec les données renvoyées par la base de données.

À la section 7, nous fermons notre connexion à la base de données (nettoyons toujours les objets qui ne sont plus nécessaires !), et à la section 8, nous laissons le code PHP et terminons notre page avec de simples balises HTML. Et avec cela, notre application est complète, nous pouvons commencer à l’utiliser.

Utilisation de l’application

Nous pointerons un navigateur vers http://localhost/recording.php. La seule page de notre exemple d’application s’affichera.

La table Users est vide.

Nous pouvons remplir les champs du formulaire avec des données aléatoires pour tester l’application. Lorsque du texte est ajouté aux deux champs, nous pouvons soumettre les données.

Remplir les champs du formulaire avec des exemples de données.

Après l’envoi, la page affiche le même formulaire où nous pouvons enregistrer notre prochain utilisateur, ainsi que celui déjà enregistré, qui est interrogé à partir de la base de données après l’insertion. Nous avons atteint notre objectif d’une application d’enregistrement des données utilisateur.

L’application répertorie les données déjà enregistrées.

Nous pouvons également vérifier que les données sont stockées avec succès dans la base de données à l’aide de psql :

psql -d exampledb
exampledb=# select * from users;
 userid | username |         email          |     registration_date      
--------+----------+------------------------+----------------------------
      0 | foobar   | foo.bar@maildomain.org | 2019-06-25 20:28:18.224375
(1 row)

Réflexions finales

Nous avons créé un exemple d’application en utilisant les connaissances de différents domaines, la base de données, le serveur web, le protocole HTTP en général, et bien sûr le développement PHP. Ce guide a pour but de montrer à quel point il est facile de créer quelque chose d’utile avec l’union de ces domaines. J’espère que ce guide pourra aider les débutants à comprendre certains des aspects du développement, et pourra démontrer qu’il ne s’agit pas de sciences spatiales - nous avons seulement ajouté quelques lignes de code ici et là, et le tout commence à fonctionner ensemble.

Bien que cet exemple d’application remplisse son objectif de démonstration, le code et l’ensemble de la solution demandent bien sûr à être améliorés. Pour n’en nommer que quelques-uns...

Rien n’empêche un opérateur d’enregistrer deux fois le nom d’utilisateur et/ou l’e-mail exacts. Cela entraînerait des enregistrements redondants. Cela pourrait être géré à la fois du côté de la base de données (contrainte unique) et de l’application (vérification des données avant l’insertion).
D’où proviennent les données enregistrées ? Qu’est-ce qui protège l’application d’un mauvais acteur ? Pour l’instant rien, un seul script shell suffirait à le surcharger, seules les défenses par défaut du serveur web sont en place – mais cela ne m’empêche pas de poster la trilogie complète du Seigneur des Anneaux dans l’un des champs 1000 fois par minute (uniquement de la bande passante). Dans cet état de l’application, il est facile de remplir les disques sous la base de données avec des données aléatoires – la vérification des entrées de l’utilisateur entre à nouveau en jeu ici, mais aussi l’authentification et l’autorisation.
La conception Web est parfaitement absente à ce stade. Un peu de css, un peu plus de texte qui aide le travail de l’opérateur, des messages d’erreur utiles... La convivialité est également un point de vue important.
Naturellement, l’enregistrement du nom d’utilisateur d’un utilisateur et de l’e-mail associé n’est qu’un exemple, nous pourrions enregistrer le nom et le prénom, le numéro de téléphone peut-être, plus d’un e-mail par utilisateur... Tout ce qui est utile à stocker.

La liste pourrait s’allonger encore et encore. C’est à vous, le lecteur, d’améliorer votre propre application. Si ce guide vous a aidé à vous développer, que ce soit comme passe-temps ou dans le but de devenir un professionnel, alors il a bien rempli son objectif.