julien/lescarnetsdakkadien.netig.net
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Utilise maintenant Zola v0.23.1

Browse Source
This commit is contained in:
julien
2026-08-06 20:23:55 +02:00
parent 1767245f10
commit d7b8aeab93
30 changed files with 759 additions and 1170 deletions
Download Patch File Download Diff File Expand all files Collapse all files
README.md
+95 -57
View File
@@ -4,32 +4,32 @@
Site public : <https://lescarnetsdakkadien.netig.net>
Le site est construit avec [Zola](https://www.getzola.org/) à partir de fichiers Markdown. Il ne nécessite ni base de données ni interface d’administration : les contenus restent lisibles et modifiables comme de simples fichiers texte.
Le site est généré avec **Zola 0.23.1** et **Tera 2** à partir de fichiers Markdown. Il est entièrement statique : aucune base de données, aucune interface d’administration et aucune exécution côté serveur ne sont nécessaires.
## Sections du site
## Contenu
- **Signes** : signes cunéiformes classés par numéro MZL et par lecture ;
- **Vocabulaire** : fiches adaptées à la nature grammaticale des mots ;
- **Grammaire** : notes organisées par thème ;
- **Grammaire** : notes regroupées par thème ;
- **Textes** : translittérations, traductions et commentaires classés par genre ;
- **Articles** : billets consacrés à l’apprentissage et au projet.
La page d’accueil présente le dernier article et les trois fiches les plus récemment publiées ou mises à jour. Des flux Atom et RSS sont également générés.
La page d’accueil présente le dernier article et les trois fiches les plus récemment publiées ou mises à jour. Un flux Atom est disponible à l’adresse `/atom.xml`.
## Prérequis
Pour travailler directement sur le projet :
Pour le développement local :
- Python 3.11 ou ultérieur ;
- Zola 0.22.1 ;
- Zola 0.23.1 ;
- Git, si le dépôt est versionné avec Git.
Pour le déploiement conteneurisé :
Pour le déploiement décrit ici :
- Docker Engine ;
- Docker Compose.
- Docker Engine et Docker Compose ;
- Caddy 2 sur l’hôte public.
Toutes les commandes ci-dessous sont exécutées depuis la racine du dépôt.
Toutes les commandes suivantes sont exécutées depuis la racine du dépôt.
## Développement local
@@ -39,13 +39,31 @@ Valider la structure des fiches :
./scripts/check-content.py
```
Vérifier la construction Zola, brouillons compris :
Vérifier le chargement du site et ses liens, brouillons compris :
```sh
zola --root src check --drafts
```
Sans accès réseau, les liens externes peuvent être ignorés :
```sh
zola --root src check --drafts --skip-external-links
```
`--skip-external-links` évite de dépendre du réseau. Retirer cette option pour vérifier également les liens externes.
Rendre le site avec les brouillons afin de tester tous les templates :
```sh
zola --root src build --drafts
```
Construire ensuite la version publique, sans les brouillons :
```sh
zola --root src build
```
Les fichiers générés sont écrits dans `src/public/`, répertoire ignoré par Git.
Lancer le serveur de développement :
@@ -59,94 +77,114 @@ Afficher également les brouillons :
zola --root src serve --drafts
```
Construire le site statique :
## Rédaction
```sh
zola --root src build
```
Les contenus sont stockés dans `src/content/`. Trois commandes accompagnent leur rédaction :
Le résultat est écrit dans `src/public/`, répertoire ignoré par Git.
- `new-content.py` crée un brouillon complet pour une section donnée ;
- `update-content.py` actualise son horodatage `updated` ;
- `check-content.py` vérifie la présence et le type des champs prévus.
## Rédaction des contenus
Le module `_schema.py` centralise les modèles utilisés par le générateur et le validateur ; il n’est pas exécuté directement.
Les contenus sont rédigés en Markdown dans `src/content/`. Des scripts permettent de créer des squelettes complets, d’horodater les modifications substantielles et de vérifier que chaque fiche conserve les champs prévus pour son modèle. Ils concernent uniquement les fiches placées dans les cinq sections du site ; les fichiers `_index.md` et les pages autonomes situées directement dans `src/content/` restent gérés manuellement.
Les commandes, conventions et modèles de front matter sont détaillés dans le [guide de rédaction](GUIDE_REDACTION.md).
Les conventions éditoriales, les commandes et les modèles de chaque type de fiche sont décrits dans le [guide de rédaction](GUIDE_REDACTION.md).
## Organisation du dépôt
## Architecture
```text
.
├── Caddyfile.example
├── Dockerfile
├── compose.yml
├── README.md
├── GUIDE_REDACTION.md
├── LICENSE-CODE
├── LICENSE-CONTENT
├── scripts
│ ├── _schema.py
│ ├── check-content.py
│ ├── new-content.py
│ └── update-content.py
└── src
├── content
├── sass
├── static
├── templates
├── scripts/
└── src/
├── content/
├── sass/main.scss
├── static/
├── templates/
│ ├── components.html
│ ├── partials/
│ └── *.html
└── zola.toml
```
- `src/content/` contient les pages Markdown ;
- `src/templates/` contient les templates Tera ;
- `src/sass/main.scss` contient les styles ;
- `src/static/` contient les ressources servies telles quelles ;
- `src/zola.toml` contient la configuration de Zola ;
- `scripts/` contient les outils de création, de mise à jour et de validation structurelle des fiches.
- `src/content/` contient les sources Markdown ;
- `src/templates/components.html` contient les composants Tera 2 paramétrés ;
- `src/templates/partials/` contient les fragments utilisant le contexte courant ;
- `src/templates/sitemap.xml` retire du sitemap les taxonomies sans contenu publié ;
- `src/sass/main.scss` définit l’apparence, le responsive et l’impression ;
- Zola génère `giallo.css` à partir du thème `github-light` pour la coloration syntaxique par classes ;
- `src/static/` contient les images, la police et le favicon servis tels quels ;
- `src/zola.toml` contient la configuration générale, les taxonomies et le flux Atom.
`giallo.css` et `main.css` sont des fichiers générés dans `src/public/` : ils ne doivent pas être ajoutés manuellement à `src/static/`.
## Déploiement avec Docker Compose
L’image est construite en trois étapes : validation structurelle des fiches, construction complète avec Zola 0.22.1, puis service des seuls fichiers statiques.
L’image est construite en trois étapes :
Vérifier la configuration :
1. validation des fiches avec Python ;
2. génération du site avec Zola 0.23.1 ;
3. copie des seuls fichiers publics dans un serveur HTTP statique.
Vérifier puis démarrer le service :
```sh
docker compose config
```
Construire et lancer le service :
```sh
docker compose up -d --build
```
Consulter son état et ses journaux :
```sh
docker compose ps
docker compose logs --tail=100 zola
```
Le service écoute uniquement sur l’interface locale de l’hôte :
Le conteneur est exposé uniquement sur l’interface locale de l’hôte :
```text
http://127.0.0.1:8002
```
Le domaine public et le certificat TLS sont pris en charge par un proxy inverse placé devant le conteneur.
Mettre à jour le déploiement :
Pour mettre à jour le déploiement :
```sh
git pull --ff-only
docker compose up -d --build
```
Arrêter le service :
Pour l’arrêter :
```sh
docker compose down
```
## Proxy inverse Caddy
Caddy prend en charge le domaine public, HTTPS, les en-têtes de sécurité et la politique de cache. Le serveur HTTP interne désactive ses propres en-têtes de cache et de sécurité afin d’éviter deux configurations concurrentes.
[`Caddyfile.example`](Caddyfile.example) fournit le bloc correspondant au port publié par `compose.yml`. Il applique :
- `Cache-Control: no-cache` aux documents ;
- un cache navigateur d’une journée aux feuilles de style, images et polices ;
- une CSP compatible avec les ressources locales du site ;
- HSTS, `Referrer-Policy`, `X-Content-Type-Options` et `X-Frame-Options`.
Le fichier peut être importé au niveau principal du Caddyfile de l’hôte ou servir de modèle pour un bloc existant. Sa syntaxe peut être contrôlée avec :
```sh
caddy validate --config Caddyfile.example --adapter caddyfile
```
## Flux Atom
Le flux est activé dans `src/zola.toml` :
```toml
generate_feeds = true
feed_filenames = ["atom.xml"]
```
Le template de base affiche automatiquement la balise de découverte et le lien du pied de page lorsque cette configuration est active.
## Licences
Le code propre au projet est distribué sous licence MIT ; voir [`LICENSE-CODE`](LICENSE-CODE).