Author Archives: ameddeb

Mise à jour du système Ubuntu de la version 16.04 à 18.04 LTS

le système conseillé, par ce site personnel, pour une machine de bureau destinée au développement logiciel. Récemment, en fin Juillet 2018 plus exactement, la mise à jour vers la dernière version stable 18.04 (la précédente étant la 16.04) a été considérée par la communauté de cet OS comme fiable. Personnellement je constate que cette nouvelle version est suffisamment stable et fiable et je peux confirmer cette information. Cet article présente la manière de procéder pour effectuer cette mise à jour. Les pré-requis pour cette procédure sont:

  • Le système est déjà à la version 16.04 LTS.
  • La machine dispose d’une connexion à Internet.

1. Désinstaller les logiciels expérimentaux

La durée moyenne de cette procédure de mise à jour est assez longue. Avec un accès standard de type ADSL à Internet, elle ne durera pas moins d’une heure. Cette durée dépend de la quantité de logiciels installés sur le système. Il en résulte que si vous avez installé des logiciels à titre expérimental, comme un navigateur web supplémentaire par exemple, il serait avantageux de les désinstaller.

2. S’assurer de la mise à jour de la version actuelle 16.04

Pour cela, lancer successivement et dans l’ordre les commandes: 
sudo apt update
sudo apt upgrade
sudo apt autoremove
sudo apt dist-upgrade
En moyenne,  cette procédure dure quelques minutes.  On obtient un état complètement à jour de la version 16.04 du système, à la fin de cette partie.

3. Installer le gestionnaire système de mise à niveau de versions

Sur un système Ubuntu on dispose d’un gestionnaire de mise à niveau de version qui facilite cette procédure. Si ce n’est déjà fait, il convient d’installer cet utilitaire. la commande suivante permet de s’en assurer: 
sudo apt install update-manager-core
Cette commande nous en informera dans le cas où l’utilitaire est déjà installé.

4. Installer la nouvelle version 18.04 LTS

A ce stade, il suffit de demande à l’utilitaire de gestion de mise à niveau de procéder à cette opération: 
sudo do-release-upgrade -d
C’est la partie la plus longue de la procédure. D’abord les paquets de la nouvelle version sont téléchargés, ensuite installés. Durant cette partie de la procédure, notamment vers la fin, l’utilitaire pourra marquer des arrêts pour poser des questions auxquelles il faudra répondre. Les réponses à ces questions seront généralement de type Oui/Non mais la procédure sera bloquée pendant ce temps.

5. Redémarrer la machine

A la fin de l’installation il convient de redémarrer la machine pour accéder à la nouvelle version du système et en profiter.

6. Java sur Ubuntu 18.04

La nouvelle version d’Ubuntu installe et configure par défaut la version 11 de Java (le JRE, et oui il semblerait que l’équipe Ubuntu est hyper futuriste). Ceci pourrait entraîner des dysfonctionnements d’applications Java, même récentes. Eclipse ou JXplorer, à titre d’exemple peuvent rencontrer ce type de problème. Dans ce cas il faudra ajuster la version par défaut de Java à une version plus ancienne ou paramétrer l’application concernée pour utiliser une version plus ancienne. L’article de ce blog à ce sujet permet d’avoir plus de détails au sujet de cette configuration de Java. En réalité la version installée par défaut du JRE est la dernière version 10, même si le nom du paquet installé et sa configuration indiquent que c’est la version 11. Celle-ci ne sera effectivement disponible qu’en Septembre 2018 !]]>

pgAdmin 4: Utilisation courante par la pratique

Postgres pgAdmin 4 permet de créer toute sorte d’objets du serveur de bases de données PostgreSQL. Ces objets peuvent être des bases de données (BDD), des schémas, des tables, des utilisateurs.. Cet outil permet également d’exécuter des requêtes SQL. L’accomplissement de ces tâche est conditionné par les droits de l’utilisateur qui sert à la connexion au serveur paramétré. Pour pouvoir agir sans limitation, il faut se connecter avec un utilisateur qui a les droits du super-administrateur. Cet article fait partie d’une série qui concerne le serveur de bases de données PostgreSQL et son utilisation dans un environnement de développement:

  1. Installation de base de PostgreSQL
  2. Utiliser Postgres pgAdmin 3 pour administrer PostgreSQL
  3. Installer PostgreSQL 10
  4. Reconfigurer l’installation par défaut de PostgreSQL 10
  5. Utiliser PostgreSQL 10 dans un environnement de développement
  6. Postgres psql pour administrer le serveur PostgreSQL
  7. Postgres pgAdmin 4 : installation et configuration
  8. Cet article: Postgres pgAdmin 4: Utilisation courante

Affecter un mot de passe au super-administrateur

pgAdmin ne pemet de paramétrer une connexion au serveur en local par le socket Unix. Pour cela on doit d’abord affecter un mot de passe au super-administrateur qui est l’utilisateur/développeur authentifié sur la machine de bureau. On utilise psql: 
psql -d postgres
Une fois connecté, exécuter: 
alter user jdupond with encrypted password 'mpjdupond';

Ajouter un serveur avec une connexion super-administrateur

Afficher le menu contextuel de l’objet Serveurs de développement puis sélectionner: Create / Server... Ceci affiche la fenêtre de paramétrage d’un nouveau serveur. postgres pgadmin Saisir le nom du serveur dans le champ Name: “Serveur local superadmin“. Ensuite passer à l’onglet (à sélectionner en haut de la fenêtre) Connection. Dans cet onglet renseigner les valeurs des champs comme indiqué dans la copie d’écran. A la fin de la saisie, enregistrer avec le bouton Save.

Créer une base de données

Afficher le menu contextuel du serveur Serveur local superadmin puis sélectionner Create / Database.. Dans le 1er onglet qui s’affiche par défaut:postgres pgadminSaisir le nom de la base de données: bdtest Choisir le propriétaire de la BDD dans la Combobox Owner: jdupond Saisir un commentaire: Base de données pour tester pgAdmin Activer, ensuite, le deuxième onglet Definition.postgres pgadmin– Sélectionner dans la Combobox Encoding: UTF8 – Sélectionner dans la Combobox Character type: fr_FR.UTF-8 Sélectionner, ensuite, le dernier onglet SQL postgres pgadmin Après la saisie des paramètres de création de la base de données, on a la possibilité d’examiner le code SQL qui servira à sa création effective.

Créer un schéma

Pour créer un schéma dans la nouvelle base de données créée, on utilise le menu contextuel de cette BDD: Create / Schema…postgres pgadmin Ce menu permet d’accéder à la fenêtre de création de schéma: postgres pgadmin La saisie des paramètres et l’enregistrement par le bouton Save, permet d’achever la création du schéma commerce.

Créer une table

Pour créer une table dans le nouveau schéma créé, on utilise son menu contextuel: Create / Table… Ce menu permet d’accéder à la fenêtre de création de table: Renseigner les données de l’onglet General comme indiqué, puis sélectionner l’onglet Columns qui permet de définir les champs de la table. S’agissant d’une création de table, le tableau de cet onglet est initialement vide. Utiliser le bouton mentionné “Ajouter un champ” pour ajouter les trois champs de la table. Après chaque ajout, paramétrer le champ comme indiqué puis enregistrer avec le bouton Save pour créer la table.

Ajouter ou modifier les données contenues dans une table

Pour modifier les données contenue dans la table produits, on utilise son menu contextuel: View/Edit Data / All Rows. Les 3 autres menus servent quand il y a déjà une grande quantité de données.   Ce menu permet d’accéder à la zone d’édition des données de la table qui apparaît dans le volet droit de l’interface.  ]]>

Postgres pgAdmin 4: Installation et configuration

Postgres pgAdmin 4 est une évolution majeure de l’outil d’administration avec interface graphique du serveur de base de données PostgreSQL. Il est destiné à succéder à pgAdmin 3. Cette nouvelle version est dotée de deux modes de fonctionnements:

  • Le mode station de travail qui est un mode local à une machine de bureau.
  • Le mode Web qui est un mode serveur (web) destiné pour les machines serveurs.
Concrètement il s’agit, à peu de choses près, du même logiciel mais configuré différemment pour chaque mode de fonctionnement. Techniquement c’est une application Python qui fonctionne soit en autonome pour le mode station de travail ou en mode hébergé par un serveur web pour le mode serveur. Pour les système Debian et compatibles, c’est l’installation qui fait la différence entre les deux modes. Cet article fait partie d’une série qui concerne le serveur de bases de données PostgreSQL et son utilisation dans un environnement de développement:
  1. Installation de base de PostgreSQL
  2. Utiliser Postgres pgAdmin 3 pour administrer PostgreSQL
  3. Installer PostgreSQL 10
  4. Reconfigurer l’installation par défaut de PostgreSQL 10
  5. Utiliser PostgreSQL 10 dans un environnement de développement
  6. Postgres psql pour administrer le serveur PostgreSQL
  7. Cet article: Postgres pgAdmin 4 : installation et configuration
  8. Postgres pgAdmin 4: Utilisation courante

1. Installation de Postgres pgAdmin 4

Il s’agit dans tout le reste de ce tutoriel de la version station de travail, car il s’agit toujours du poste de travail d’un développeur d’application. Pour installer Postgres pgAdmin 4 en mode station de travail exécuter: 
sudo apt install pgadmin4
Cette commande installe également un environnement Python s’il n’est pas déjà installé. Des difficultés peuvent apparaître pour exécuter l’application si des conflits de versions, typiques de cet environnement, apparaissent. Dans ce cas, une solution envisageable consiste à désinstaller pgAdmin 4 et toutes les versions de Python installées sur le système. Après cela ré-exécuter la commande d’installation de pgAdmin 4. Toutefois cette solution n’est applicable que si aucune version de Python (notamment moins récente que celle installée avec pgAdmin 4 qui est actuellement la 2.7.13) n’est indispensable par ailleurs. Postgres pgAdmin 4 n’est pas disponible (Août 2018) sur le dépôt officiel des systèmes Debian et Ubuntu. L’utilitaire système de gestion des paquets apt doit pouvoir les récupérer à partir du dépôt spécifique de PostgreSQL pour que la commande d’installation réussisse. Pour cela il faudra d’abord configurer cet utilitaire comme indiqué dans le tutoriel d’installation de la version 10 de PostgreSQL (§ Versions disponibles pour le système installé).

2. Considération générale sur le fonctionnement

L’application pgAdmin 4 s’utilise par l’action des différents menus graphiques disponibles. Il existes deux types principaux de menus:
  • Le menu principal qui se trouve dans la barre d’en-tête de la fenêtre de l’application. Dans ce menu les principales commandes se trouvent dans le menu Object. Les différents menus peuvent être actifs ou non (grisés) selon les droits de l’utilisateur paramétré pour la connexion au serveur. Par exemple, si cet utilisateur n’a pas le droit de créer des bases de données, le menu Object / Create / Database.. sera toujours inactif.
  • Le menu contextuel à un nœud du volet gauche. Ce menu s’obtient par la sélection du nœud concerné (serveur, BDD, table..) dans le volet gauche de l’interface, ensuite cliquer sur le bouton droit de la souris. Ce menu affiche la liste des actions possibles spécifiques à l’objet sélectionné.
Dans la suite de ce tutoriel il convient d’effectuer l’une ou l’autre de ces démarches pour mener l’action demandée.

Paramétrer un groupe de serveurs

postgres pgadmin Au premier lancement de pgAdmin 4, un groupe de serveurs Servers, vide, est paramétré. Cet objet apparaît dans le volet gauche de l’interface. L’objet groupe de serveurs dans pgAdmin, est un conteneur d’organisation de l’affichage. Il ne correspond pas à un objet réel du serveur de base de données. On va commencer par donner un nom significatif à cet objet: postgres pgadminAfficher le menu contextuel du groupe de serveurs et sélectionner Properties.. postgres pgadmin Dans la fenêtre qui s’affiche, modifier le contenu du champ Name en “Serveurs de développement” et cliquer sur le bouton Save pour enregistrer. Pour créer d’autres groupes de serveurs, si besoin, utiliser le menu contextuel d’un groupe de serveur existant: Create / Server Group... Ce menu affiche la même fenêtre utilisée pour la modification du nom. Saisir le nom et enregistrer.

3. Paramétrer un serveur de base de données

postgres pgadmin Afficher le menu contextuel de l’objet Serveurs de développement puis sélectionner: Create / Server… Ceci affiche la fenêtre de paramétrage d’un nouveau serveur. postgres pgadmin Saisir le nom du serveur dans le champ Name: “Serveur local“.postgres pgadmin Ensuite passer à l’onglet Connection (à sélectionner en haut de la fenêtre). Dans cet onglet renseigner les valeurs des champs comme indiqué. Pour rappel le mot de passe de l’utilisateur utappli est mputappli. Après la saisie enregistrer avec le bouton Save. Ce sont les mêmes paramètres de connexion utilisés pour psql et dont les valeurs doivent correspondre à ceux du serveur PostgreSQL à paramétrer.

4. Améliorer le fonctionnement de pgAdmin 4

4.1. Les problèmes

Se connecter au serveur nouvellement paramétré, si ce n’est pas déjà fait: menu contextuel du serveur et sélectionner Connect server. Après l’activation de la connexion, on peut accéder aux objets du serveur: postgres pgadmin
  1. Le tableau de bord (à droite) s’anime avec des graphiques d’information sur le fonctionnement.
  2. Tous les objets du serveurs sont visibles dans le volet gauche.
Il n’est pas recommandé de garder cet affichage par défaut: 1. L’affichage des graphiques est coûteux en ressources pour le serveur sans que l’information ne soit très utile, notamment dans un environnement de développement. Pour s’en rendre compte, exécuter la commande système dans une console: 
tail -f /home/jdupond/pgtest.log
Cette commande permet de suivre l’avolution du contenu du fichier de log du serveur. Elle permet dans notre cas de constater que plusieurs requêtes SQL sont exécutées en permanence. L’exécution continue de ces requêtes s’arrêtera si on se déconnecte du serveur (Menu contextuel de Serveur local puis Disconnect sever). Si vous ne constatez pas l’exécution des requêtes dans le fichier de log comme indiqué, c’est que la génération des logs n’est pas configurée comme il est souhaité. Dans ce cas suivre la procédure expliquée dans l’article sur l’utilisation de PostgreSQL dans un environnement de développement, pour activer ce paramétrage. 2. L’affichage dans le volet gauche est trop chargé. Souvent, on n’a besoin d’afficher qu’un nombre limité de types de données. Ceci permet d’avoir une information beaucoup plus lisible dans l’interface.

4.2. Les solutions

Pour désactiver l’exécution de ces requêtes, on modifie le paramétrage de l’affichage du tableau de bord: postgres pgadmin Pour accéder à cette fenêtre de paramétrage, utiliser le menu: File / Preferences, puis sélectionner Dashboards / Graphs dans le volet de gauche. Par défaut le temps de rafraîchissement des graphiques est paramétré à 1 seconde. Ceci explique l’exécution fréquente des requêtes qui récupèrent les données de ces graphiques. Modifier toutes les valeurs à 999999. Cela désactive l’exécution des requêtes mais aussi l’affichage des graphiques. postgres pgadmin Pour accéder à cette fenêtre de paramétrage utiliser le menu: File / Preferences, puis sélectionner Browser /Nodes dans le volet gauche. Pour désactiver l’affichage d’un élément il suffit de cliquer sur l’icone Show dans le volet droit, qui se transforme alors en Hide. Désactiver de la même manière tous les éléments sauf: Columns, Databases, Schemas , Sequences et Tables. Enregistrer avec le bouton Ok. Après la validation de ce paramétrage, rafraîchir l’affichage: Sélectionner le serveur dans le volet gauche (Serveur local) ensuite actionner le menu contextuel Refresh.. postgres pgadmin L’affichage apparaît maintenant avec les informations sélectionnées seulement.  ]]>

Postgres psql pour administrer le serveur PostgreSQL

Postgres psql est un client en ligne de commande du serveur PostgreSQL. Il permet de se connecter au serveur de bases de données en local sur la machine serveur ou à distance depuis une autre machine. Une fois connecté, l’utilisateur autorisé peut exécuter des commandes spécifiques à psql qui retournent différentes informations utiles ou exécuter des requêtes SQL. A ce titre il constitue un outil léger et performant pouvant rendre de nombreux services au cours d’un développement qui utilise ce serveur de bases de données. Dans ce tutoriel le login de l’utilisateur authentifié sur la machine est supposé être jdupond. Pour exécuter les commandes des exemples, remplacer toujours ce login par le votre. Cet article fait partie d’une série qui concerne le serveur de bases de données PostgreSQL et son utilisation dans un environnement de développement:

  1. Installation de base de PostgreSQL
  2. Utiliser Postgres pgAdmin 3 pour administrer PostgreSQL
  3. Installer PostgreSQL 10
  4. Reconfigurer l’installation par défaut de PostgreSQL 10
  5. Utiliser PostgreSQL 10 dans un environnement de développement
  6. Cet article: Administrer PostgreSQL avec psql
  7. Postgres pgAdmin 4 : installation et configuration
  8. Postgres pgAdmin 4: Utilisation courante

1. Connexion au serveur de BDD avec Postgres psql

La commande de connexion est de la forme suivante: 
psql -h <AdresseServeur> -p <Port> -U <UtilisateurBDD> -d <BaseDeDonnees>
Aucun des 4 paramètres n’est obligatoire. Quand l’un de ces paramètres n’est pas fourni, sa valeur par défaut est prise en compte:
Paramètre Contenu Valeur par défaut
h Adresse de la machine serveur de base de données Connexion en local par le socket Unix
p Port de connexion sur la machine serveur 5432
U Utilisateur de base de données login de l’utilisateur qui exécute la commande
d Base de données login de l’utilisateur qui exécute la commande
A titre de test, exécuter: 
psql
La commande échoue, le message d’erreur indique qu’il n’y a pas de BDD qui a pour nom le login. Si on exécute: 
psql -d postgres
La connexion réussit dans le cas d’un cluster personnalisé pour l’utilisateur authentifié. Pour se connecter en tant que utappli sur la BDD bdappli: 
psql -h localhost -U utappli -d bdappli
La commande demande le mot de passe car utappli est soumis à ce type d’authentification, puis réussit.

2. Postgres psql peut se souvenir de la BDD par défaut et des mots de passe

Il existe deux paramétrages possibles qui permettent de simplifier la commande de connexion.
  • Modifier la BDD à utiliser par défaut.
Pour cela créer le fichier .postgresqlrc comme suit: 
vi /home/jdupond/.postgresqlrc
Son contenu doit être: 
10  pgtest  bdappli
Exécuter après avoir enregistré: 
psql
La connexion réussit. La BDD à laquelle on se connecte est bdappli qui remplace, par défaut, le login de l’utilisateur.
  • Se souvenir du mot de passe de l’utilisateur de connexion
Pour se connecter en tant que utappli, psql demande de saisir le mot de passe à chaque fois. Ce comportement peut être modifié en renseignant le mot de passe dans le fichier /home/jdupond/.pgpass Créer ce fichier avec le contenu (mputappli est le mot de passe de utappli): 
localhost:5432:*:utappli:mputappli
Ce nouveau fichier contenant un mot de passe, il faut le sécuriser: 
chmod 600 /home/jdupond/.pgpass
Exécuter ensuite: 
psql -h localhost -U utappli -d bdappli
La connexion réussit sans demander le mot de passe de l’utilisateur.

3. Utiliser les commandes de Postgres psql

En plus de la capacité d’exécuter des requêtes SQL, l’utilitaire psql fournit un ensemble de commandes utiles pour l’exploitation du serveur. Etant connecté au serveur PostgreSQL, à la base de données bdappli, avec l’utilitaire psql, on va tester un certain nombre de ces commandes. Exécuter l’une de ces commandes revient à la saisir et ensuite utiliser la touche entrée du clavier. 
\?
Permet d’afficher la liste complète des commandes psql avec une description de leurs fonctions. Remarquer que ces commandes commencent toujours par le caractère backslash (\). 
\h select
Fournit une explication complète de la syntaxe de la commande SQL select. La commande psql \h est un aide mémoire précieux du langage SQL. 
\l
Affiche la liste des bases de données du serveur. 
\dn
Permet de voir la liste des schémas de la base de données active. 
\d commerce.*
Affiche les informations à propos de toutes les tables du schéma commerce. Remarquer la table créée automatiquement pour gérer la séquence du champ id 
\d commerce.produits
Affiche les informations à propos de la table produits du schéma commerce.

4. Echanger les données avec des fichiers grâce à Postgres psql

Créer le fichier /home/jdupond/produits.csv avec le contenu: 
CU;clé usb 500 Go
EC;ecran 26 pouces
SR;souris 3 boutons
CA;clavier azerty
Se connecter à la base de données bdappli et exécuter les deux requêtes l’une après l’autre: 
copy commerce.produits(code,nom) from '/home/jdupond/produits.csv' (format csv, delimiter ';', header, encoding 'utf8');
select * from commerce.produits;
Comme le montre le résultat de la deuxième requête, le contenu du fichier a été transféré dans la table de la base de données. Exécuter maintenant: 
copy commerce.produits to '/home/jdupond/extraction_produits.csv' (format csv, delimiter ';', header, encoding 'utf8');
Le contenu entier de la table est transféré dans le fichier indiqué et au format indiqué. Le contenu transféré peut être partiel, selon une condition, en utilisant une requête SQL: 
copy (select * from commerce.produits where id=1 or id=2) to '/home/ameddeb/dvlp/travaux/pgdoc/extractionl_produits.csv' (format csv, delimiter ';', header, encoding 'utf8');
Seulement les deux enregistrements demandés ont été transférés.

5. Exécuter une requête SQL depuis le shell système

Postgres psql permet d’exécuter une requête SQL sans se connecter préalablement au serveur. Depuis le shell, exécuter: 
psql -c "select * from commerce.produit;"
Le résultat est affiché sur la console.

6. Exécuter un script SQL depuis un fichier

Créeer le fichier /home/jdupond/cree_prix.sql avec le contenu: 
create table commerce.prix(id serial, produitid int, prixachat numeric(7,2), prixvente numeric(7,2));
insert into commerce.prix(produitid, prixachat, prixvente) values(1, 6.2, 7.35);
insert into commerce.prix(produitid, prixachat, prixvente) values(2, 230.5, 274.75);
Ensuite exécuter depuis le shell système: 
psql -f /home/jdupond/cree_prix.sql
psql -c "select * from commerce.prix;"
Le script s’exécute, crée la table et y insère deux enregistrements. Le résultat de la requête exécutée après le script le confirme.]]>

Utiliser PostgreSQL 10 dans un environnement de développement

  • Installation de base de PostgreSQL
  • Utiliser Postgres pgAdmin 3 pour administrer PostgreSQL
  • Installer PostgreSQL 10
  • Reconfigurer l’installation par défaut de PostgreSQL 10
  • Cet article: Utiliser PostgreSQL 10 dans un environnement de développement
  • Administrer PostgreSQL avec psql
  • Postgres pgAdmin 4 : installation et configuration
  • Postgres pgAdmin 4: Utilisation courante

    •  Créer un utilisateur de base de données standard

    Il est fortement conseillé, même dans un environnement de test/développement, de ne pas utiliser le super administrateur pour une utilisation courante. Pour cela la première chose à faire après l’installation du serveur est de créer un utilisateur standard. Se connecter au serveur en tant que super administrateur: 
    psql -d postgres
    Une fois connecté, exécuter: 
    create user utappli with login encrypted password 'mputappli';
    Ensuite vérifier la création effective de cet utilisateur: 
    select * from pg_roles where rolname='utappli';
    Enfin quitter psql 
    \q
    Pour tester la connexion de l’utilisateur utappli, exécuter: 
    psql -h localhost -d postgres -U utappli
    Fournir le mot de passe paramétré: mputappli, quand il sera réclamé.  Cet utilisateur et son mot de passe peuvent être utilisés par l’application en développement pour se connecter au serveur.

    Créer une base de données

    Pour stocker les données de l’application en développement, il y a un besoin de créer une base de données. Pour cela se connecter en tant que super administrateur et exécuter la requête de création d’une base de données dont le propriétaire est utappli: 
    psql -d postgres
create database bdappli owner utappli;
\q

    Créer les tables de données

    L’utilisateur utappli étant le propriétaire de la base de données bdappli, il a tous les droits sur cet objet. Par conséquent, on n’a plus besoin de se connecter en tant que super administrateur. Pour créer une table dans la base de donnée qui vient d’être créée, il faut se connecter à cette base de données en tant que utappli et exécuter les requêtes: 
    psql -h localhost -U utappli -d bdappli
create schema commerce;
create table commerce.produits (id serial, code varchar(12), nom varchar(100));
select * from commerce.produits;
    La dernière requête SQL exécutée permet de vérifier la création effective de la table. Au cours du développement cette requête permettra de vérifier le contenu géré par le code de l’application. Bien entendu d’autres tables ou schémas peuvent être créés de la même manière.

    Se connecter au serveur à partir d’une autre machine

    Par défaut, la configuration du serveur ne permet que des connexions à partir de la même machine. Cela peut convenir pour un utilisateur-développeur qui utilise seul son serveur. Si une autre personne, qui utilise donc une autre machine, souhaite utiliser les données de ce serveur elle ne pourra pas. Ce comportement peut être changé par la modification de deux fichiers de configuration. Editer pg_hba.conf: 
    vi /etc/postgresql/10/pgtest/pg_hba.conf
    Ajouter la ligne suivante: 
    host    all     all    0.0.0.0/0     md5
    Editer postgresql.conf: 
    vi /etc/postgresql/10/pgtest/postresql.conf
    Repérer la ligne: 
    #listen_addresses = 'localhost'
    Modifier cette ligne, en (enlever le # et remplacer localhost par *): 
    listen_addresses = '*'
    Pour tenir compte de ces modifications, redémarrer le serveur: 
    pg_ctlcluster 10 pgtest restart
    Pour se connecter, la personne distante, doit utiliser la même commande que pour la connexion locale sauf pour le paramètre -h (host): 
    psql -h xxx.xxx.xxx.xxx -U utappli -d bdappli
    xxx.xxx.xxx.xxx est l’adresse IP de la machine serveur de base de données, par exemple 192.168.0.1. Pour trouver cette adresse IP, exécuter sur cette machine: 
    sudo ifconfig
    Repérer dans la réponse l’adresse qui est mentionnée par le libellé inet. Si cela vous semble compliqué, exécuter: 
    sudo ifconfig | sed "s/^[ ]*//g" | egrep ^inet | egrep -v "(^inet6|127.0.0.1)" | awk '{ print $2 }'
    Cette commande doit afficher une seule adresse IP, utilisez la. Si elle affiche plusieurs, c’est que la machine est connectée à plusieurs réseaux (filaire et wifi par exemple). Dans ce cas toutes ces adresses peuvent être utilisées si la machine de connexion est également connectée au même réseau.

    Contrôler les requêtes SQL exécutées par l’application

    Il est très utile de pouvoir contrôler les requêtes SQL exécutées par le code de l’application en développement, afin de les affiner. Cette faculté de contrôle est plus nécessaire encore s’il s’agit d’une application de type JEE qui s’exécute dans un serveur d’application. Par défaut le serveur PostgreSQL n’inscrit pas dans son fichier de log le texte de ces requêtes. Ce comportement est modifiable par le fichier postgresql.conf. Editer ce fichier et repérer la ligne qui commence par: 
    #log_statement = 'none'
    Modifier cette ligne, en (enlever # et remplacer none par all): 
    log_statement = 'all'
    Pour la prise en compte, recharger les fichiers de configuration par la commande: 
    pg_ctlcluster 10 pgtest reload
    A partir de ce moment, le serveur inscrit dans son fichier de log toutes les requêtes exécutées. Pour tester ce comportement, se connecter et exécuter une requête quelconque: 
    psql -d postgres
select * from pg_roles;
\q
    Ensuite vérifier: 
    cat ~/pgtest.log
    La requête qui vient d’être exécutée doit apparaître à la fin de ce fichier.  ]]>

    Reconfigurer l'installation par défaut de PostgreSQL 10

    cluster de bases de données installé par défaut. L’objectif est d’obtenir une installation qui convient pour une utilisation dans un environnement de développement sur une machine de bureau. Cet article fait partie d’une série qui concerne le serveur de bases de données PostgreSQL et son utilisation dans un environnement de développement:

    1. Installation de base de PostgreSQL
    2. Utiliser Postgres pgAdmin 3 pour administrer PostgreSQL
    3. Installer PostgreSQL 10
    4. Cet article: Reconfigurer l’installation par défaut de PostgreSQL 10
    5. Utiliser PostgreSQL 10 dans un environnement de développement
    6. Administrer PostgreSQL avec psql
    7. Postgres pgAdmin 4 : installation et configuration
    8. Postgres pgAdmin 4: Utilisation courante

    L’installation par défaut ne convient pas pour un environnement de développement

    La première installation de PostgreSQL crée un utilisateur système: postgres. Le cluster créé lors de cette installation appartient à cet utilisateur: fichiers et droits système. Un utilisateur de base de données (BDD) de même nom: postgres, est également créé. Cet utilisateur est le super administrateur du cluster. Un accés local au serveur de base de données est configuré pour l’utilisateur système postgres. Cet accés local permet à postgres de se connecter au serveur sans authentification supplémentaire en tant qu’utilisateur BDD postgres. Ce comportement convient à une installation sur un serveur réel. En revanche, il rend contraignant son utilisation sur une machine de développement. Le contrôle du fonctionnement du serveur, la modification de la configuration et l’accès local au serveur doivent se faire en passant par l’utilisateur système postgres. Pour une gestion plus simple du serveur, la meilleure solution est de substituer le login de l’utilisateur-développeur à postgres.

    Supprimer le cluster PostgreSQL installé par défaut

    Il faut arrêter le serveur s’il est démarré et supprimer le cluster créé par défaut: main. Pour cela exécuter: 
    sudo pg_dropcluster --stop 10 main

    Créer un cluster PostgreSQL personnalisé

    Si le login du développeur sur sa machine est jdupond (Pour Jean Dupond), le système lui attribue systématiquement un groupe système jdupond et un répertoire personnel: /home/jdupond. Dans /home/jdupond tout est permis pour l’utilisateur. Ceci nous amène à exécuter la commande suivante pour créer le cluster: 
    sudo pg_createcluster -u jdupond -g jdupond --locale=fr_FR.UTF-8 -l /home/jdupond/pgtest.log -d /home/jdupond/pgtest 10 pgtest
    Cela veut dire, créer le cluster pgtest avec les paramètres:
    • Le propriétaire (fichiers, droits et utilisateur BDD d’administration) est jdupond
    • La locale qui détermine le format des données et le mode de recherche est le français de France avec encodage unicode UTF-8.
    • Le fichier de log qui est très utile pour le développement parcequ’il permet de visualiser les requêtes SQL exécutées par l’application est /home/jdupond/pgtest.log
    • Les données sont dans /home/jdupond/pgtest/ ce qui permet leur manipulation directe par l’utilisateur-développeur.

    Contrôle du serveur de base de données PostgreSQL

    Avec le cluster personnalisé le contrôle du serveur PostgreSQL devient faisable directement par l’utilisateur authentifié. Voici les commandes principales de contrôle avec, en commentaire (après le caractère #), la signification 
    pg_ctlcluster 10 pgtest start # démarrage
pg_ctlcluster 10 pgtest stop  # arrêt
pg_ctlcluster 10 pgtest status # affichage du statut marche/arrêt
pg_ctlcluster 10 pgtest reload # recharger la configuration
pg_ctlcluster 10 pgtest restart # redémarrer le serveur
    Le contrôle inclu même la suppression de ce cluster. Pour cela exécuter: 
    pg_dropcluster --stop 10 pgtest
    Faire attention, toutefois, car la suppression du cluster entraîne la suppression définitive des données qu’il gère.

    Gérer les données avec l’utilitaire psql

    L’utilitaire en ligne de commande psql est un client de connexion au serveur PostgreSQL. Entre autres choses, il permet à un utilisateur authentifié sur la machine serveur de se connecter à travers le socket Unix du serveur PostgreSQL sans authentification supplémentaire. La connexion se fait avec la commande du shell: 
    psql -d <NomDeBaseDeDonnees>
    Avec le cluster personnalisé pour jdupond, le super administrateur des bases de données est jdupond. Il peut se connecter en local à la BDD postgres créée par défaut: 
    psql -d postgres
    Une fois connecté, on peut vérifier le statut de super administrateur de jdupond. Pour cela exécuter: 
    select rolname, rolsuper from pg_roles;
    Le résultat de cette requête doit montrer un ‘t‘ (true) pour jdupond dans le champ rolsuper. Le champ rolsuper est un indicateur pour le profile super administrateur. On remarquera également l’absence de l’utilisateur postgres de la liste. De la même manière il est possible à l’utilisateur-développeur, en exécutant des requêtes SQL, de créer, consulter, modifier ou supprimer tout type d’objets de bases de données: utilisateurs, bases de données, schémas, tables..  ]]>

    Installer PostgreSQL 10

  • Installation de base de PostgreSQL
  • Utiliser Postgres pgAdmin 3 pour administrer PostgreSQL
  • Cet article: Installer PostgreSQL 10
  • Reconfigurer l’installation par défaut de PostgreSQL 10
  • Utiliser PostgreSQL 10 dans un environnement de développement
  • Administrer PostgreSQL avec psql
  • Postgres pgAdmin 4 : installation et configuration
  • Postgres pgAdmin 4: Utilisation courante

    • Spécificité de l’installation de PostgreSQL 10

    La version 10 de PostgreSQL a constitué une évolution majeur de ce serveur de bases de données objets, relationnelles et noSQL. Elle a marqué également une rupture avec la politique historique de la progression des numéros de version, spécialement en relation avec la compatibilité avec les données antérieures. Avant la version 10 (jusqu’à la version 9.6 donc), PostgreSQL n’assurait pas la compatibilité des données quand le numéro de version mineur s’incrémente. A titre d’exemple, la version 9.6 ne peut pas et ne doit pas gérer des données créées avec la version 9.5. Ceci explique l’insertion automatique du numéro de version dans sa forme majeur.mineur dans tous les chemins qui concernent l’installation du serveur. Cette insertion permettrait de minimiser le risque de confusion entre les versions binaires vs données. Cela explique également la présence de ce format de numéro de version dans les paquets d’installation des distributions Debian et Ubuntu. Pour visualiser la version disponible pour votre système, exécuter : 
    sudo apt-get update
apt-cache search postgresql | egrep "^postgresql-[0-9]+(.[0-9])? "
    En réponse à cette commande voici le résultat obtenu pour la dernière version stable de Debian (Le 10/03/2018 – Debian 9.3, Stretch): 
    postgresql-9.6 - object-relational SQL database, version 9.6 server
    Cette contrainte nécessitait, si on voudrait passer à une nouvelle version, de migrer les données en passant par un format texte du dump (dump sous forme d’ordres SQL). Or, cette opération est très lente et devient vite contraignante à partir de quelques dizaines de Go de données. Dans ce cas également, un arrêt du service de l’application qui utilise le serveur, et qui peut être excessivement long, doit être envisagé. A partir de la version 10, PostgreSQL assurera la compatibilité des données entre les versions mineurs. En d’autres termes, aucune migration de données n’est nécessaire entre les versions 10.1 et 10.2 par exemple. Ceci permettra une plus grande flexibilité pour la mise à jour du serveur. Si on sait que le passage entre la première version 9.0 stable et la 10 stable s’est fait en 7 ans, contre 10 mois entre la 9.5 et la 9.6, il est évident que le gain en terme de stabilité du format des données est substantiel. Pour cette raison, le numéro de version inclut par défaut dans les chemins d’installation du serveur ne comporte plus que le premier chiffre. C’est également le cas pour le numéro qui accompagne les paquets d’installation des distributions Debian et Ubuntu.

    Versions disponibles pour le système installé

    Même avec la dernière version stable du système (Debian 9.3, Stretch ou Ubuntu 16.04 LTS, Xenial au 10/03/2018), on ne dispose pas encore de la version 10 de PostgreSQL. Ceci a été vérifié avec la commande de visualisation des version disponibles exécutée précédemment. En tout cas vous n’aurez toujours pas la totalité des versions stables publiées de ce serveur. En réalité ceci est vrai quand on ne référence que le dépôt officiel du système. Pour pouvoir accéder à l’ensemble des versions stables publiées, il faut ajouter le dépôt PostgreSQL à la liste des sources de paquets de la machine. Pour cela il faut créer un fichier de configuration de ce dépôt suivant la version installée de l’OS: 
    sudo vi /etc/apt/sources.list.d/postgresql-sources.list
    Le contenu de ce fichier doit être pour un système Debian 9 – Stretch: 
    deb http://apt.postgresql.org/pub/repos/apt/ stretch-pgdg main
    Et pour un système Ubuntu 18.04 LTS – Bionic: 
    deb http://apt.postgresql.org/pub/repos/apt/ bionic-pgdg main
    Bien entendu il faudra adapter le nom de code de la version du système selon le cas dans ce fichier de configuration. Après avoir enregistré, exécuter dans l’ordre: 
    wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | sudo apt-key add -
sudo apt-get update
apt-cache search postgresql | egrep "^postgresql-[0-9]+(.[0-9])? "
    La première commande configure la clé de vérification de l’authenticité des paquets. La troisième liste les versions disponibles. En réponse à cette dernière commande, voici le résultat obtenu toujours pour la dernière version stable de Debian: 
    postgresql-9.6 - object-relational SQL database, version 9.6 server
postgresql-10 - object-relational SQL database, version 10 server
postgresql-9.2 - object-relational SQL database, version 9.2 server
postgresql-9.3 - object-relational SQL database, version 9.3 server
postgresql-9.4 - object-relational SQL database, version 9.4 server
postgresql-9.5 - object-relational SQL database, version 9.5 server
    6 versions stables sont disponibles dont la dernière version 10. Remarquer le nouveau format du nom de paquet de la version 10.

    Installation

    Pour installer la dernière version stable 10, exécuter: 
    sudo apt-get install postgresql-10
    Cette commande installe le serveur PostgreSQL ainsi que les utilitaires d’administration. La commande crée également un cluster de bases de données par défaut (ou instance de serveur) qui s’appelle ‘main’. Les principaux chemins relatifs à cette installation sont:
    • /var/lib/postgresql/10/main/: les fichiers des données.
    • /var/log/postgresql/postgresql-10-main.log: le fichier de log du cluster.
    • /etc/postgresql/10/main/: les fichiers de configuration.
    • /usr/lib/postgresql/10/: fichiers binaires du serveur, exécutables et librairies.
    La locale qui est un paramètre important du cluster est positionnée selon la configuration système de la machine. Pour une machine configurée avec la locale français de France sa valeur doit être fr_FR.UTF-8. Ce paramètre conditionne principalement le format de la date, de l’heure et de la recherche textuelle. Pour vérifier cette configuration du système, exécuter: 
    locale
    C’est la variable LANG qui est la plus importante.

    Désinstallation

    Pour désinstaller la version 10 du serveur PostgreSQL de votre machine, exécuter: 
    sudo pg_ctlcluster 10 main stop
sudo apt-get remove postgresql-10 postgresql-client-10 postgresql-client-common postgresql-common
sudo apt-get purge postgresql-10 postgresql-client-10 postgresql-client-common postgresql-common
    La troisième commande nettoie les données créées par l’installation.]]>

    DocBook – Créer le contenu du document

    DocBook est de montrer comment construire le contenu d’un document conformément aux spécifications de cet outil. Les trois premiers articles de cette série ayant montré la manière de générer les formats HTML et PDF d’un document DocBook, on verra dans cet article comment créer le contenu lui même. Cet article fait partie d’une série qui traite de l’utilisation de DocBook et qu’il convient de lire dans l’ordre indiqué:

    1. Installation et utilisation de base
    2. Utilisation avancée et amélioration de la présentation en HTML
    3. Utilisation avancée et amélioration de la présentation en PDF
    4. Cet article: Créer le contenu du document

    Présentation

    Le fichier du contenu DocBook est un document au format XML qui correspond à la DTD DocBook. Qui dit format XML, dit une hiérarchie d’éléments XML structurée en arbre. Ces éléments sont délimités par des balises XML et la structure doit correspondre exactement à ce qui est défini par la DTD. La DTD (Document  type definition) étant un ensemble de règles qui définissent le contenu du document et sa structure. Un tel document est dit valide et bien formé. 
    <racine param1="..." param2="...">
  <niveau1a>
    ......
  </niveau1a>
  <niveau1b>
    <niveau2a>
      ......
      <niveau3a>
        ......
      </niveau3a>
      <niveau3b param1="...">
        .....
      </niveau3b>
      <niveau3c>
        ......
      </niveau3c>
    </niveau2a>
    <niveau2b>
      ......
    </niveau2b>
  </niveau1b>
</racine>
    Dans cet exemple l’élément « racine » est la racine de l’arbre qui constitue le document. Cet arbre contient deux éléments de niveau 1:
    • « niveau1a”: élément final qui ne contient que des données (matérialisées par 6 points) et aucun élément.
    • « niveau1b »: contient deux éléments:
      • « niveau2a »: contient trois éléments:
        • des données et aussi « niveau3a », « niveau3b » et « niveau3c » qui sont des éléments finaux.
      • « niveau2b »: élément final.
    On note également qu’un élément peut avoir un nombre quelconque de paramètres, ou ne pas en avoir du tout. Les règles de la DTD définissent, principalement, les noms possibles des éléments, leurs contenus possibles, les paramètres et leurs valeurs possibles.

    L’en-tête et l’élément racine

    Un canevas vide d’un document DocBook doit ressembler à ce qui suit: 
    <?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE article PUBLIC "-//OASIS//DTD docbook XML V5.0b5//EN" "http://www.oasis-open.org/docbook/xml/5.0b5/dtd/docbook.dtd">
<article xmlns='http://docbook.org/ns/docbook' version='5.0' xml:lang='fr'>
</article>
    • La première ligne est la déclaration de la nature XML du document et de l’encodage de son contenu. Dans l’exemple on utilise « UTF-8 » dont l’usage systématique est fortement conseillé.
    • La deuxième ligne référence la DTD utilisée par le document. le tag de cette déclaration doit correspondre au nom de l’élément racine. Dans l’exemple c’est « article » qui est utilisé.
    • La troisième et la quatrième lignes sont les balises d’ouverture et de fermeture de l’élément racine. L’ensemble du contenu du document doit se trouver entre ces deux balises. Les paramètres de cet élément sont:
      • xmlns: la référence du namespace DocBook, utiliser l’URL indiquée.
      • version: la version de DocBook,  actuellement la dernière version est la 5.0
      • xml:lang : Positionne la langue du document. On utilise un code ISO 639-1 à deux lettres pour définir ce paramètre. Il détermine principalement la langue des termes introduits automatiquement par DocBook dans le contenu, comme: « Table des matières » ou « Chapitre ». Il détermine également l’orientation du texte pour les langues qui s’écrivent de droite à gauche comme l’Arabe ou le Persan.
    L’élément racine a une importance capitale car il détermine la nature du document. principalement on utilisera: book pour un livre ou article pour un article dont le contenu est plus court. Dans une moindre mesure on utilisera: journal ou newsposting.

    Informations à propos du document

    C’est l’élément articleinfo (pour un livre il faudra utiliser bookinfo) qui contient ces informations. Il s’agit du titre, des auteurs, des contributeurs, de la date de publication, du résumé et des mots-clé. Dans la pratique, et ceci est valable pour tous les éléments DocBook, on choisit seulement les rubriques estimées utiles pour le document, aucune n’étant obligatoire. Concrètement pour notre exemple, il faudra insérer dans le canevas vide ce qui suit: 
    <articleinfo>
    <title>Comment débuter avec DocBook</title>
    <authorgroup>
      <author>
        <firstname>Meddeb</firstname>
        <surname>Abdelhamid</surname>
        <affiliation>
          <address><email>a@meddeb.net</email></address>
        </affiliation>
      </author>
      <author>
        <firstname>Dupond</firstname>
        <surname>Nathalie</surname>
      </author>
    </authorgroup>
    <othercredit>
      <firstname>Durand</firstname>
      <surname>Michel</surname>
      <contrib>Illustration</contrib>
    </othercredit>
    <pubdate>25/02/2018</pubdate>
    <abstract>
      <para>Présente de manière simplifiée la création du contenu d'un document DocBook.</para>
      <para>Texte integral à consulter <ulink url="http://tutoriels.meddeb.net/docbook-installation-utilisation-de-base">sur ce le blog de l'un des auteurs</ulink>.</para>
    </abstract>
    <keywordset>
      <keyword>DocBook</keyword>
      <keyword>Contenu</keyword>
    </keywordset>
 </articleinfo>
    Cela donne le résultat suivant en PDF: DocBook

    Le corps du document

    Le corps d’un document DocBook est constitué d’une succession de sections: élément « section ». Chaque section peut contenir un nombre quelconque de sous-sections qui ne sont en réalité, elles-mêmes, que des sections. Une sous-section est donc une section fille contenue dans une section mère. La profondeur d’imbrication ainsi constituée pouvant être quelconque. Par ailleurs, une section (ou sous-section) est composée d’un nombre quelconque de paragraphes: élément « para ». L’exemple suivant montre un contenu avec deux sections, dont l’une d’entre elles possède plusieurs sous-sections. 
    <section>
  <title>Titre de la première section</title>
  <para>
    Le corps d'un document DocBook est constitué d'une succession de sections: élément « section ».
    La section suivante sera une section qui possède plusieurs sous-sections.
  </para>
</section>
<section>
<title>Titre de la deuxième section</title>
  <para>
    Chaque section peut contenir un nombre quelconque de sous-sections qui ne sont en réalité, elles-mêmes, que des sections. Une sous-section est donc une section fille contenue dans une section mère.
  </para>
  <section>
    <title>Titre de la sous-section de niveau 1</title>
    <para>
      Chaque section peut contenir un nombre quelconque de sous-sections qui ne sont en réalité, elles-mêmes, que des sections. Une sous-section est donc une section fille contenue dans une section mère.
    </para>
    <section>
      <title>Titre de la sous-section de niveau 2</title>
      <para>
        La profondeur d'imbrication ainsi constituée pouvant être quelconque. 
      </para>
    </section>
  </section>
</section>
    Ce contenu donne le résultat suivant en PDF: DocBook

    Citer un code informatique

    Pour citer un code informatique dans un document, on utilise l’élément programlisting. L’exemple suivant illustre cette utilisation: 
    <programlisting>
  #include &lt;stdio.h&gt;
  #include &lt;stdlib.h&gt;
  int main(int argc, char *argv[])
  {
    printf("Hello world!");
  }
</programlisting>
    Ce contenu donne le résultat suivant en PDF: DocBook

    Insérer une citation

    Pour insérer une citation, on utilise l’élément quote. 
    <title>Le logiciel libre</title>
  <para>
    <quote lang="en">Steve Jobs, le pionnier qui a rendu la notion de prison informatique appréciée, est mort. Son invention était de priver les crétins de leur liberté.</quote>
  </para>
  <para>
    Richard Stallman, 6 octobre 2011.
  </para>
    Ce contenu donne en PDF: DocBook

    Insérer une note de bas de page

    Pour ajouter une notre de bas de page, on utilise l’élément footnote. 
    <title>Outils de saisie du contenu DocBook</title>
<para>
  Pour saisir le contenu d'un document au format DocBook, on peut utiliser l'éditeur de texte Emacs
  <footnote>
    <para>Le mode nXML d'emacs permet la validation du contenu en fonction de la DTD et aussi la complétion en cours de saisie des balises DocBook</para>
  </footnote>
  qui est un outil puissant et souple. Il est particulièrement adapaté à ce type de tâche.
</para>
    Ce contenu donne en PDF: DocBookNoter la numérotation automatique de la note de bas de page et l’insertion du contenu de l’élément footnote en fin de la page.]]>

    DocBook – Améliorer la présentation en PDF

    DocBook. Dans le premier article de cette série sur l’utilisation de DocBook, nous avons vu comment produire un document cible au format PDF à partir du contenu initial. Dans cet article on verra comment améliorer la présentation de ce document. Cet article fait partie d’une série qui traite de l’utilisation de DocBook et qu’il convient de lire dans l’ordre indiqué:

    1. Installation et utilisation de base
    2. Utilisation avancée et amélioration de la présentation en HTML
    3. Cet article: Utilisation avancée et amélioration de la présentation en PDF
    4. Créer le contenu du document

    Le contenu à transformer

    Dans cet article nous allons utiliser un document de contenu prêt à l’emploi: le fichier document.xml_.txt qu’il convient de télécharger et enregistrer sur le disque de votre machine. Pour cela, faites un Click droit sur le lien et choisir « Enregistrer le lien sous.. » dans le menu. Renommer ensuite en document.xml.

    Générer le format PDF

    Pour générer le document au format PDF exécuter: 
    xsltproc -o document.fo /usr/share/xml/docbook/stylesheet/nwalsh/fo/docbook.xsl document.xml
fop -pdf document.pdf -fo document.fo
    Le document obtenu est composé de 5 pages (cliquer pour agrandir si besoin): [gallery size="medium" ids="705,709,710"] [gallery size="medium" ids="706,712"] Par défaut DocBook:
    • Crée une page pour le titre du livre
    • Une page pour le verso du titre
    • Une page pour la table des matières
    • Insère un saut de page à la fin de chacun des chapitres (2 chapitres dans notre exemple)
    • Le format des page est celui de l’Amérique du nord: US Letter (279 × 216 mm)
    Dans la suite, on va améliorer cette présentation.

    Améliorer le contenu des chapitres

    Comme pour la personnalisation du contenu du document HTML, on doit créer une feuille de style XSL qui sert à modifier certains paramètres en plus d’importer la feuille de style originale. Cette partie s’appelle cutom layer (la couche personnalisée). Pour créer cette feuille de style: 
    vi pdf_document.xsl
    Ensuite saisir et enregistrer: 
    <?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:import href="/usr/share/xml/docbook/stylesheet/nwalsh/fo/docbook.xsl"/>
  <xsl:param name="paper.type">A4</xsl:param>
  <xsl:param name="page.orientation">portrait</xsl:param>
  <xsl:param name="chapter.autolabel">I</xsl:param>
  <xsl:param name="section.autolabel">1</xsl:param>
  <xsl:param name="section.label.includes.component.label">0</xsl:param>
  <xsl:param name="toc.max.depth">3</xsl:param>
  <xsl:attribute-set name="section.title.level1.properties">
    <xsl:attribute name="font-size">11pt</xsl:attribute>
    <xsl:attribute name="color">#008080</xsl:attribute>
  </xsl:attribute-set>
  <xsl:attribute-set name="section.title.level2.properties">
    <xsl:attribute name="font-size">10pt</xsl:attribute>
    <xsl:attribute name="color">#007070</xsl:attribute>
  </xsl:attribute-set>
  <xsl:attribute-set name="component.title.properties">
    <xsl:attribute name="font-size">14pt</xsl:attribute>
    <xsl:attribute name="color">#009595</xsl:attribute>
    <xsl:attribute name="text-align">center</xsl:attribute>
  </xsl:attribute-set>
</xsl:stylesheet>
    Remarquer l’import du fichier XSL origine /usr/share/xml/docbook/stylesheet/nwalsh/fo/docbook.xsl. Avec cet import 9 paramètres sont modifiés:
    1. paper.type: Format du papier positionné à A4 qui est le format européen (297 x 210 mm)
    2. page.orientation : Orientation des pages positionnée à portrait.
    3. Les 4 paramètres suivants sont similaires à ceux modifiés pour le format HTML: numérotation des paragraphes et profondeur de la table des matières.
    4. section.title.level1.properties: Taille et couleur des caractères des titres des paragraphe de niveau 1.
    5. section.title.level2.properties: Taille et couleur des caractères des titres des paragraphe de niveau 2.
    6. component.title.properties: Taille, alignement et couleur des caractères des titres des chapitres.
    Ensuite ré-générer le format PDF du document avec les deux commandes successives: 
    xsltproc -o document.fo pdf_document.xsl document.xml
fop -pdf document.pdf -fo document.fo
    Le résultat obtenu pour les deux pages des chapitres, le reste étant inchangé: [gallery columns="2" size="medium" ids="719,720"]

    Améliorer la présentation du titre du document

    Le titre du document et son sous-titre occupent les deux premières pages:
    • Première page: la couverture du livre (puisqu’il s’agit ici d’un livre)
    • Deuxième page: le verso de la couverture et qui reprend le titre et le sous titre.
    L’amélioration qu’on se propose d’effectuer ici est de modifier la position, la couleur et les tailles de caractère de ces titres d’un côté et de supprimer la page de verso qui ne sert pas à grand chose dans le contexte d’un document électronique, d’un autre côté. La démarche pour arriver à cet objectif est légèrement plus complexe que la première modification effectuée. Elle se compose de trois étapes:

    1. Copier le modèle par défaut

    Pour ne pas modifier les fichiers d’origine de DocBook, il convient de copier le fichier-modèle du titre de document (titlepage) dans le dossier de travail: 
    cp -p /usr/share/xml/docbook/stylesheet/nwalsh/fo/titlepage.templates.xml document_titlepage.xml
    Le nom de fichier cible utilisé ici: document_titlepage.xml, est un nom au choix.

    2. Modifier et/ou ajouter les paramètres cibles de la modification

    Editer le fichier copie du modèle, par exemple: 
    vi document_titlepage.xml
    Repérer l’endroit qui concerne les titres et sous titre du livre, c’est à dire la portion du fichier entre les lignes: 
    <t:titlepage t:element="book" t:wrapper="fo:block">
 ....
 ....
</t:titlepage>
    Remarquer t:titlepage qui veut dire les pages de titre et t:element=’book’ qui veut dire qu’il s’agit du type livre (pas article ni slide ..). Dans cette portion on s’intéresse d’abord à la partie: <t:titlepage-content t:side=’recto’>, qui est la première page du livre. Modifier comme indiqué ci-après. Les lignes modifiées ou ajoutées sont en gras: 
    <title
        t:named-template="division.title"
        param:node="ancestor-or-self::book[1]"
        text-align="left" 
        font-size="&hsize2;" 
        space-before="&hsize2space;" 
        color="#009595" 
        margin-top ="60%"
        font-weight="bold"
        font-family="{$title.fontset}"/>
  <subtitle
         text-align="left" 
         font-size="&hsize1;" 
         font-style='italic' 
         font-weight="normal" 
         color="#008080" 
         space-before="&hsize1space;"
         font-family="{$title.fontset}"/>
    Ces modifications concernent l’alignement et la taille des caractères des titres et sous-titres qui ont été modifiés en alignement à gauche au lieu de centre et des tailles de caractères plus petites. Elles concernent également les paramètres de couleur et de position verticale (margin-top) qui ont été ajoutés au titre. Les paramètres de style (font-style) et de couleur qui ont été ajoutés au sous-titre. Ensuite on s’intéresse à la partie <t:titlepage-content t:side=’verso’> qui contrôle le contenu de la deuxième page,  ainsi qu’à <t:titlepage-before t:side=’verso’> qui contrôle le saut de page. On supprime tout ce qui se trouve dans ces deux paramètres: 
    <t:titlepage-content t:side="verso">
</t:titlepage-content>
...
<t:titlepage-before t:side="verso">
</t:titlepage-before>
    Ceci élimine cette deuxième page du document.

    3. Générer la feuille de style à partir du modèle et l’intégrer au custom layer

    Pour générer la feuille de style à partir de ce modèle modifié: 
    xsltproc --output document_titlepage.xsl /usr/share/xml/docbook/stylesheet/nwalsh/template/titlepage.xsl document_titlepage.xml
    Ceci génère le fichier document_titlepage.xsl qu’il convient d’intégrer au custom layer c’est à dire le fichier pdf_document.xsl comme suit: 
    <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:import href="/usr/share/xml/docbook/stylesheet/nwalsh/fo/docbook.xsl"/>
  <xsl:import href="document_titlepage.xsl"/>
  <xsl:param name="paper.type">A4</xsl:param>
  .....
  .....
</xsl:stylesheet>
    La ligne ajoutée (en gras) importe cette feuille de style créée. Ensuite il convient de ré-générer le document PDF comme précédemment, c’est à dire avec les deux commandes successives: 
    xsltproc -o document.fo pdf_document.xsl document.xml
fop -pdf document.pdf -fo document.fo
    On obtient un document au format PDF avec 4 pages cette fois et dont la présentation a été améliorée: [gallery size="medium" columns="2" ids="740,741"] [gallery size="medium" columns="2" ids="742,743"]  ]]>

    DocBook – Améliorer la présentation en HTML

    DocBook. Dans l’article précédent sur l’utilisation de base de DocBook, nous avons vu comment produire un document cible au format HTML à partir du contenu initial. Dans cet article on verra comment améliorer la présentation de ce document HTML. Cette amélioration repose sur l’utilisation des feuilles de style CSS d’un côté et du paramétrage de la transformation du contenu d’un autre. Cet article fait partie d’une série qui traite de l’utilisation de DocBook et qu’il convient de lire dans l’ordre indiqué:

    1. Installation et utilisation de base
    2. Cet article: Utilisation avancée et amélioration de la présentation en HTML
    3. Utilisation avancée et amélioration de la présentation en PDF
    4. Créer le contenu du document

    Le contenu à transformer

    Dans cet article nous allons utiliser un document de contenu prêt à l’emploi: le fichier document.xml_.txt qu’il convient de télécharger et enregistrer sur le disque de votre machine. Pour cela, faites un click droit sur le lien et choisir “Enregistrer le lien sous..” dans le menu. Renommer ensuite en document.xml.

    Générer le format HTML

    Pour générer le document au format HTML exécuter: 
    xsltproc -o document.html /usr/share/xml/docbook/stylesheet/nwalsh/xhtml/docbook.xsl document.xml
    Le résultat obtenu est le suivant (image partielle): DocBookC’est la présentation de base de DocBook comme vue dans l’article précédent. Dans la suite de cet article, il s’agit d’améliorer cette présentation.

    Créer une feuille de style CSS

    Avec un éditeur de texte créer le fichier document.css 
    vi document.css
    Ensuite saisir le contenu suivant: 
    :root {
  --textfont: Carlito;
}
div.titlepage h1 {
  font-size: 135%;
  font-family: var(--textfont);
  font-weight: Bold;
  color: #008080;
}
div.titlepage h2 {
  font-size: 120%;
  font-family: var(--textfont);
  font-weight: Bold;
  color: #008080;
}
div.chapter div.titlepage h2 {
  font-size: 115%;
  font-family: var(--textfont);
  font-weight: Bold;
  color: #009999;
}
div.chapter div.titlepage h3 {
  font-size: 105%;
  font-family: var(--textfont);
  font-weight: Bold;
  color: #009999;
}
div.chapter {
  font-family: var(--textfont);
}
.toc {
  font-family: var(--textfont);
}
.code {
  font-family: courier;
  background-color: lightgray ;
  padding: 10px;
}
    Dans cette feuille de style on définit une variable comme étant le nom d’une police de caractère (Carlito). Cette police de caractère est affectée aux différentes parties du document dont la taille, la couleur et le style du texte sont modifiés également avec des valeurs différentes à chaque fois. Ces parties sont le titre et le sous-titre du document, les titres et les sous-titres des chapitres, la table de matière (toc) et le paragraphe de code (code). Le choix de la police de caractère est arbitraire et peut être différent. Toutefois cette police est d’une assez jolie apparence. La police de caractère Carlito n’est pas installée par défaut sur le système, c’est pourquoi il convient de le faire.

    Installation de la police de caractère Carlito

    Pour cela exécuter: 
    sudo apt-get install fonts-crosextra-carlito

    Générer le document HTML amélioré

    Cette amélioration consiste ici à lier le document produit, avec la feuille de style document.css. Exécuter pour ré-générer le fichier document.html avec ce lien: 
    xsltproc -o document.html --stringparam html.stylesheet document.css /usr/share/xml/docbook/stylesheet/nwalsh/xhtml/docbook.xsl document.xml
    Le document obtenu, visualisé dans un navigateur, est alors: DocBook

    Personnaliser la transformation

    La deuxième possibilité d’amélioration est la personnalisation du document HTML lui même. Ceci est obtenu par un paramétrage de la génération du document. Ce paramétrage passe par la création d’une feuille de style XSL qui importe la feuille de style originale de DocBook avant de modifier les valeurs de certains paramètres. Pour créer cette feuille de style: 
    vi html_document.xsl
    Ensuite saisir et enregistrer: 
    <?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:import href="/usr/share/xml/docbook/stylesheet/nwalsh/xhtml/docbook.xsl"/>
  <xsl:param name="chapter.autolabel">I</xsl:param>
  <xsl:param name="section.autolabel">1</xsl:param>
  <xsl:param name="section.label.includes.component.label">1</xsl:param>
  <xsl:param name="toc.max.depth">3</xsl:param>
  <xsl:param name="generate.toc" select="'book toc'"/>
</xsl:stylesheet>
    Remarquer l’import du fichier XSL origine /usr/share/xml/docbook/stylesheet/nwalsh/xhtml/docbook.xsl. Avec cet import, 5 paramètres sont modifiés:
    1. chapter.autolabel: indique la numérotation des chapitres.
    2. section.autolabel: indique la numérotation des sections (paragraphe numérotés)
    3. section.label.includes.component.label: indique s’il faut inclure le numéro de l’élément parent de la section dans sa numérotation.
    4. toc.max.depth: indique la profondeur de la table des matières
    5. generate.toc: contrôle la génération des tables de matières. Ici on force la génération de la table de matières globale au document seulement.
    Ensuite la ré-génération de document.html se fait avec: 
    xsltproc -o document.html --stringparam html.stylesheet document.css html_document.xsl document.xml
    Remarquer l’appel au fichier XSL personnalisé. Le résultat visible dans un navigateur est désormais:DocBookRemarquer la présence d’une seule table de matières et la numérotation des chapitres, des sections et des sous-sections.]]>