Bloggez avec Pelican

Philippe Wambeke - LoliGrUB (16 juin 2018)

Un blog, c'est quoi ?

Contraction des mots “web” et “log”, un blog permet de partager du “contenu” sous forme de “billets” (“post” en anglais).

Ces billets sont présentés au lecteur du plus récent au plus ancien.

Tous les sujets peuvent faire l'objet d'un blog: jardinage, cuisine, logiciels libres, sport, mode, écologie, politique, …

Et à quoi ca sert ?

C'est un moyen simple et bon marché d'exercer son droit à la liberté d'expression.

Comment blogger ?

Il existe 3 solutions pour devenir “blogger”:

  • La solution de “facilité”: utiliser une plate-forme de blogging (Wix, Blogger, Tumblr, …)
  • Les usines à gaz: WordPress, Drupal, Joomla, …
  • Les générateurs de sites statiques: Pelican, Jekyll, Hugo, …

La "facilité"

Malgré leur aspect flatteur (pas d'installation, pas de maintenance, pas de backup, …), vous n'êtes pas le maître à bord, ce qui implique:

  • le contenu du blog peut devenir inaccessible, payant, censuré, …
  • des pubs ou autres indésirables peuvent faire leur apparition sans votre accord
  • comment se passe le changement de plate-forme ?
  • contribue à la centralisation d'Internet

Les usines à gaz

Ces solutions sont souples et puissantes, mais:

  • nécessitent d'autres composants (base de données, PHP, Ruby, …)
  • compliqués à installer et à maintenir
  • compliqués à paramétrer et à backuper
  • compliqués à utiliser
  • constituent un grand vecteur d'attaque
  • lourds à la fois côté serveur et côté client

Les sites statiques

Sous leur aspect “simpliste”, ces solutions offrent de nombreux avantages:

  • ne nécessitent pas (ou très peu) d'autres composants
  • simples à installer et à maintenir
  • simples à paramétrer et à backuper
  • simples à utiliser (un éditeur de texte suffit)
  • vecteur d'attaque quasi nul
  • rapides et légers côté serveur (rpi) et client

Pelican

Pelican est un générateur de sites statiques spécialement dédiés aux blogs.

  • Pas besoin de connaître HTML ou CSS: contenu rédigé en markdown ou reStructuredText
  • Site généré 100% statique (très léger)
  • Nombreux thèmes et plugins disponibles
  • Supporte le multi-langues
  • Supporte les flux RSS
  • …

Comment ça marche ?

Le principe est simple:

  1. on rédige son blog dans un format texte simple (markdown ou reStructuredText)
  2. on lance Pelican
  3. on obtient le site

Exemple de texte

Titre principal
###############
Un paragraphe avec du texte.

Titre
=====
Et ici, une liste à puces:

* élément de la liste
* autre élément de la liste

Sous-titre
----------

Sous-sous-titre
~~~~~~~~~~~~~~~

**Un texte en gras**
*Un texte en italique*

Un lien_
.. _lien: http://www.monlien.tld

Vous pouvez également faire des tableaux :

+--------+--------+
| Pays   | Région |
+========+========+
| France | Europe |
+--------+--------+
| Japon  | Asie   |
+--------+--------+

Exemple de rendu

Installation

L'installation est très simple:

  • sur le serveur web: rien à faire
  • sur le poste de travail: installer le paquet “python-pelican” (Debian) ou “pelican” (autres)

Allons y, bloggons !

Étape 1: la création du blog

Une fois installé, la création d'un nouveau blog se fait à l'aide d'un simple: 

pelican-quickstart

Ce qui crée l'arborescence suivante: 

├── content
│   ├── ...
│   └── pages
│       └── ...
├── ...
├── output
├── pelicanconf.py
└── publishconf.py

Étape 2.1: la rédaction

Le contenu du blog se trouve dans le dossier `content`.

Il peut lui-même être organisé comme bon vous semble, la seule exception est le dossier “`pages`” qui contient autre chose que des billets.

Par exemple: 

├── content
│   ├── arbustes
│   ├── bulbes
│   ├── example.rst
│   ├── matériel
│   ├── pages
│   │   ├── about.md
│   │   └── contact.md
│   ├── potager
│   └── vivaces

Étape 2.2: Le squelette d'un billet

:date: 2018-04-01
:tags: potager, plantations, saisons, recette
:slug: potager
:author: Moi
:summary: Ceci est le résumé ou une phrase d'accroche pour mon billet

Mon potager
###########
Que cultiver dans son potager ?

Qu'est ce qui est planté ?
==========================
Pour une fois, pas windows ;-)

Étape 3: la visualisation

Pelican permet d'avoir un aperçu exact du blog rafraîchi automatiquement au fil de vos modifications: 

make devserver

Cette commande lance un serveur web local accessible à `http://localhost:8000`.

Pour l'arrêter: 

make stopserver

Étape 4: La publication

Une fois satisfait, le blog est prêt à être publié via: 

pelican -s publishconf.py

Il suffit ensuite de copier/coller tous les fichiers se trouvant dans le dossier “`output`” sur le serveur web.

Personnaliser son blog

Il est possible de personnaliser l'apparence du blog grâce:

Exemples et références

Merci

Questions ?