+
+
+
+

+
+
+
Qdrant À venir
+
Base vectorielle pour recherche sémantique et pipelines de récupération IA.
+
+
+
+
+
+

+
+
+
Medusa À venir
+
Moteur de commerce headless API-first pour boutiques en ligne personnalisées.
+
+
+
+
+
+

+
+
+
Bagisto À venir
+
Plateforme e-commerce Laravel open source pour boutiques en ligne.
+
+
+
+
+
+

+
+
+
Pterodactyl À venir
+
Gérez des serveurs de jeu dans des conteneurs isolés via un panneau web.
+
+
+
+
+
+

+
+
+
Pelican Panel À venir
+
Panneau de contrôle open source moderne et rapide pour serveurs de jeu.
+
+
+
+
+
+

+
+
+
ERPNext À venir
+
CRM, comptabilité, RH et inventaire dans une suite open source.
+
+
+
+
+
+

+
+
+
NocoDB À venir
+
Alternative open source à Airtable qui transforme des bases de données en tables.
+
+
+
+
+
+

+
+
+
Directus À venir
+
CMS headless et plateforme de données au-dessus de bases SQL.
+
+
+
+
+
+

+
+
+
Uptime Kuma À venir
+
Surveillez sites et services avec tableaux de bord et alertes.
+
+
+
+
+
+

+
+
+
Beszel À venir
+
Surveillance serveur légère en temps réel avec un petit agent.
+
+
+
+
+
+

+
+
+
Gatus À venir
+
Page de statut automatisée et tableau de santé pour services.
+
+
+
+
+
+

+
+
+
Zammad À venir
+
Centre d'assistance et billetterie auto-hébergés pour support client.
+
+
+
+
+
+

+
+
+
Rancher À venir
+
Gérez des clusters Kubernetes depuis une console web unique.
+
+
+
+
+
+

+
+
+
Nginx Proxy Manager À venir
+
Gestion du proxy inverse et SSL avec une interface web simple.
+
+
+
+
+
+

+
+
+
Nginx À venir
+
Serveur web et proxy inverse haute performance.
+
+
+
+
+
+

+
+
+
HAProxy À venir
+
Répartiteur de charge TCP et HTTP fiable et haute performance.
+
+
+
+
+
+

+
+
+
Apache Tomcat À venir
+
Conteneur de servlets Java pour exécuter des applications web.
+
+
+
+
+
+

+
+
+
RabbitMQ À venir
+
Broker de messages fiable pour files d'attente et applications événementielles.
+
+
+
+
+
+

+
+
+
Apache Kafka À venir
+
Plateforme de streaming d'événements distribuée pour données en temps réel.
+
+
+
+
+
+

+
+
+
SeaweedFS À venir
+
Stockage de fichiers et d'objets distribué, compatible S3.
+
+
+
+
+
+

+
+
+
Nexus À venir
+
Dépôt universel d'artefacts pour builds et dépendances.
+
+
+
+
+
+

+
+
+
Artifactory À venir
+
Dépôt d'artefacts JFrog pour binaires et paquets.
+
+
+
+
+
+

+
+
+
Harbor À venir
+
Registre de conteneurs sécurisé avec analyse des vulnérabilités.
+
+
+
+
+
+

+
+
+
Gitea À venir
+
Service Git auto-hébergé léger.
+
+
+
+
+
+

+
+
+
Neo4j À venir
+
Base de données graphe pour données connectées et requêtes relationnelles.
+
+
+
+
+
+

+
+
+
ClickHouse À venir
+
Base de données en colonnes rapide pour analyses en temps réel (OLAP).
+
+
+
+
+
+

+
+
+
Mattermost À venir
+
Plateforme auto-hébergée de messagerie d'équipe et de collaboration.
+
+
+
+
+
+

+
+
+
Wiki.js À venir
+
Wiki et plateforme de documentation moderne, auto-hébergé.
+
+
+
+
+
+

+
+
+
WG-Easy À venir
+
La façon la plus simple d'exécuter un VPN WireGuard avec une interface web.
diff --git a/src/content/docs/fr/public-cloud/marketplace/jenkins.md b/src/content/docs/fr/public-cloud/marketplace/jenkins.md
index 5c8ee0e..1024aac 100644
--- a/src/content/docs/fr/public-cloud/marketplace/jenkins.md
+++ b/src/content/docs/fr/public-cloud/marketplace/jenkins.md
@@ -2,18 +2,18 @@
title: Jenkins
---
-Jenkins est un serveur d'automatisation open source pour la construction, les tests et le
-déploiement de logiciels. Son modèle de pipeline-as-code et son vaste écosystème de plugins vous
-permettent de mettre en place l'intégration continue et la livraison continue pour presque n'importe
-quelle chaîne d'outils. L'interface web s'exécute sur le port 8080.
+Jenkins est un serveur d'automatisation open source pour compiler, tester et déployer des logiciels.
+Son modèle pipeline-as-code et son grand écosystème de plugins permettent de connecter l'intégration
+continue et la livraison continue à presque n'importe quelle chaîne d'outils. L'interface web
+s'exécute sur le port 8080.
-:::note[Bientôt disponible]
+## Logiciels inclus
-Une image Jenkins préconfigurée arrive bientôt. Pour l'instant, déployez une nouvelle instance
-**Ubuntu 24.04 LTS** depuis la marketplace et suivez les étapes ci-dessous pour installer Jenkins
-vous-même.
-
-:::
+| Composant | Version |
+| --------- | ------------- |
+| Jenkins | 2.555.3 (LTS) |
+| OpenJDK | 21 (JRE) |
+| Ubuntu | 24.04 LTS |
## Prérequis
@@ -23,83 +23,95 @@ vous-même.
| RAM | 2 Go | 4 Go |
| Stockage | 20 Go | 50 Go |
-## Déployer l'instance de base
+## Variables d'environnement
-1. Dans le portail ZSoftly Cloud, ouvrez **Apps**, sélectionnez **Jenkins** et cliquez sur
- **Deploy**, ou créez une instance **Ubuntu 24.04 LTS** depuis **Instances → Create**. Dans les
- deux cas, vous obtenez une VM Ubuntu 24.04 propre.
-2. Choisissez un plan qui répond aux prérequis ci-dessus et sélectionnez votre région (YOW-1 ou
- YUL-1).
-3. Lorsque l'instance est **Running**, connectez-vous en SSH :
+Cette image n'accepte aucune variable au déploiement. Elle ne crée aucun compte administrateur
+partagé. Jenkins génère un mot de passe de déverrouillage unique sur chaque machine virtuelle.
+Lisez-le après le premier démarrage, puis créez votre administrateur dans l'assistant de
+configuration:
```bash
-ssh ubuntu@
+sudo cat /var/lib/jenkins/secrets/initialAdminPassword
```
-4. Mettez le système à jour :
+## Démarrage
+
+### 1. Se connecter à la machine virtuelle
```bash
-sudo apt update && sudo apt upgrade -y
+ssh ubuntu@
```
-## Installer Jenkins
+### 2. Attendre la configuration au premier démarrage
-Jenkins s'exécute sur la JVM. Installez d'abord un OpenJDK pris en charge (17 ou 21) :
+Au premier démarrage, un script lance Jenkins. Jenkins génère ensuite un mot de passe administrateur
+initial unique pour cette instance. Le premier démarrage peut prendre quelques minutes. Suivez la
+progression:
```bash
-sudo apt install -y fontconfig openjdk-21-jre
-java -version
+journalctl -u jenkins-first-boot.service -f
```
-Ajoutez la clé de signature et la liste de sources du dépôt apt Jenkins LTS :
+Le message de connexion (MOTD) confirme quand Jenkins est prêt.
-```bash
-sudo wget -O /etc/apt/keyrings/jenkins-keyring.asc \
- https://pkg.jenkins.io/debian-stable/jenkins.io-2023.key
+### 3. Récupérer le mot de passe administrateur initial
-echo "deb [signed-by=/etc/apt/keyrings/jenkins-keyring.asc] https://pkg.jenkins.io/debian-stable binary/" \
- | sudo tee /etc/apt/sources.list.d/jenkins.list > /dev/null
+```bash
+sudo cat /var/lib/jenkins/secrets/initialAdminPassword
```
-Installez Jenkins :
+### 4. Terminer l'assistant de configuration
-```bash
-sudo apt update
-sudo apt install -y jenkins
+Ouvrez un navigateur et allez à:
+
+```text
+http://:8080
```
-Le paquet installe un service systemd qui démarre au démarrage du système. Vérifiez qu'il est en
-cours d'exécution :
+Collez le mot de passe administrateur initial, installez les plugins suggérés, puis créez votre
+premier compte administrateur.
+
+## Gérer Jenkins
+
+Jenkins s'exécute comme service systemd.
```bash
-sudo systemctl enable --now jenkins
-sudo systemctl status jenkins
+# Vérifier l'état
+systemctl status jenkins
+
+# Redémarrer
+sudo systemctl restart jenkins
+
+# Voir les journaux
+sudo journalctl -u jenkins -f
```
-## Configurer Jenkins
+Répertoire Jenkins home (tâches, plugins et configuration): `/var/lib/jenkins`.
-Jenkins écoute sur le port 8080. Ouvrez `http://:8080` dans un navigateur pour démarrer
-l'assistant de configuration. L'assistant demande d'abord le mot de passe de déverrouillage généré
-automatiquement. Affichez-le depuis le serveur :
+## Sécurité
-```bash
-sudo cat /var/lib/jenkins/secrets/initialAdminPassword
-```
+Le port 8080 est ouvert sur l'interface réseau de la machine virtuelle. UFW est activé et autorise
+SSH (port 22) et Jenkins (port 8080). Aucun port d'agent de build (50000) n'est ouvert par défaut.
-Collez la valeur, installez les plugins suggérés et créez votre premier compte administrateur. Pour
-une configuration de production, placez Jenkins derrière un reverse proxy tel que nginx avec un
-certificat TLS, puis servez l'interface en HTTPS au lieu d'exposer directement le port 8080.
+**Pour limiter l'interface à une adresse IP précise:**
-## Ouvrir le pare-feu
+```bash
+sudo ufw delete allow 8080/tcp
+sudo ufw allow from to any port 8080
+```
-L'instance n'autorise par défaut que le SSH (port 22) en externe. Ouvrez le ou les ports dont
-Jenkins a besoin et ajoutez-les aux règles réseau/de sécurité de l'instance dans le portail :
+**Pour accéder à l'interface sans ouvrir le pare-feu, utilisez un tunnel SSH:**
```bash
-sudo ufw allow 8080/tcp
+# Exécuter cette commande sur votre machine locale
+ssh -L 8080:localhost:8080 ubuntu@
```
-## Étapes suivantes
+**En production**, placez Jenkins derrière un proxy inverse comme nginx avec un certificat TLS, et
+servez l'interface en HTTPS au lieu d'exposer directement le port 8080.
+
+## Prochaines étapes
- [Documentation Jenkins](https://www.jenkins.io/doc/)
-- [Guide d'installation Jenkins](https://www.jenkins.io/doc/book/installing/linux/)
+- [Gérer les plugins](https://www.jenkins.io/doc/book/managing/plugins/)
+- [Référence Pipeline](https://www.jenkins.io/doc/book/pipeline/)
diff --git a/src/content/docs/fr/public-cloud/marketplace/keycloak.md b/src/content/docs/fr/public-cloud/marketplace/keycloak.md
index 25355cb..bf94859 100644
--- a/src/content/docs/fr/public-cloud/marketplace/keycloak.md
+++ b/src/content/docs/fr/public-cloud/marketplace/keycloak.md
@@ -2,19 +2,21 @@
title: Keycloak
---
-Keycloak est une plateforme libre de gestion des identités et des accès. Elle fournit
-l'authentification unique (SSO), la fédération d'utilisateurs, la connexion via les réseaux sociaux
-et le courtage d'identité, ainsi qu'une autorisation fine grâce à des protocoles standards comme
-OpenID Connect, OAuth 2.0 et SAML. Ce guide exécute le conteneur Keycloak officiel, avec des notes
-pour un démarrage rapide en développement et pour une mise en production.
+Keycloak est une plateforme open source de gestion des identités et des accès. Elle fournit le SSO,
+la fédération d'utilisateurs, la connexion sociale ou par courtier d'identité, et des autorisations
+fines avec des protocoles standard comme OpenID Connect, OAuth 2.0 et SAML.
-:::note[Bientôt disponible]
+## Logiciels inclus
-Une image Keycloak préconfigurée arrive bientôt. Pour l'instant, déployez une instance **Ubuntu
-24.04 LTS** neuve depuis la marketplace et suivez les étapes ci-dessous pour installer Keycloak
-vous-même.
+| Composant | Version |
+| ---------- | --------------- |
+| Keycloak | 26.6.4 |
+| PostgreSQL | 18 |
+| Docker | Dernière stable |
+| Ubuntu | 24.04 LTS |
-:::
+Keycloak s'exécute en mode production (`start`) avec une base PostgreSQL, sous forme de pile Docker
+Compose.
## Prérequis
@@ -24,134 +26,105 @@ vous-même.
| RAM | 2 Go | 4 Go |
| Stockage | 20 Go | 40 Go |
-## Déployer l'instance de base
+## Variables d'environnement
+
+Vous pouvez les définir au déploiement de Keycloak depuis la Marketplace. Laissez un champ de mot de
+passe vide pour générer automatiquement une valeur aléatoire sécurisée.
+
+| Variable | Description |
+| ------------------------- | --------------------------------------------------------------------------------------------------------- |
+| `KEYCLOAK_ADMIN` | Nom d'utilisateur du compte administrateur initial. Par défaut: `admin` |
+| `KEYCLOAK_ADMIN_PASSWORD` | Mot de passe du compte administrateur initial |
+| `KC_HOSTNAME` | Nom d'hôte public ou IP depuis lequel Keycloak est servi. Par défaut: l'IP privée de la machine virtuelle |
-1. Dans le portail ZSoftly Cloud, ouvrez **Apps**, sélectionnez **Keycloak** et cliquez sur
- **Deploy**, ou créez une instance **Ubuntu 24.04 LTS** depuis **Instances → Create**. Les deux
- vous donnent une VM Ubuntu 24.04 propre.
-2. Choisissez un forfait conforme aux prérequis ci-dessus et sélectionnez votre région (YOW-1 ou
- YUL-1).
-3. Lorsque l'instance est **Running**, connectez-vous en SSH:
+## Démarrage
+
+### 1. Se connecter à la machine virtuelle
```bash
ssh ubuntu@
```
-4. Mettez le système à jour:
+### 2. Attendre la configuration au premier démarrage
+
+Au premier démarrage, un script génère les mots de passe administrateur et base de données, écrit le
+fichier d'environnement, puis démarre la pile avec Docker Compose. Cela prend 1 à 2 minutes. Suivez
+la progression:
```bash
-sudo apt update && sudo apt upgrade -y
+journalctl -u keycloak-first-boot.service -f
```
-## Installer Keycloak
+Le message de connexion (MOTD) confirme quand Keycloak est prêt et affiche les identifiants
+administrateur.
-Keycloak est distribué sous forme d'image Docker officielle depuis `quay.io`. Installez donc d'abord
-Docker Engine.
+### 3. Récupérer les identifiants administrateur
-Configurez le dépôt APT officiel de Docker pour Ubuntu 24.04 LTS (`noble`):
+Les identifiants sont aussi écrits dans un fichier réservé à root:
```bash
-sudo apt install -y ca-certificates curl
-sudo install -m 0755 -d /etc/apt/keyrings
-sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
-sudo chmod a+r /etc/apt/keyrings/docker.asc
-sudo tee /etc/apt/sources.list.d/docker.sources >/dev/null <:8080
```
-Pour essayer Keycloak rapidement, démarrez-le en mode développement. Cela amorce un utilisateur
-administrateur initial et sert la console sur le port 8080:
+Connectez-vous avec l'utilisateur `admin` et le mot de passe généré.
-```bash
-sudo docker run -d --name keycloak --restart unless-stopped \
- -p 8080:8080 \
- -e KEYCLOAK_ADMIN=admin \
- -e KEYCLOAK_ADMIN_PASSWORD='' \
- quay.io/keycloak/keycloak:latest start-dev
-```
+| Champ | Valeur |
+| ----------------- | -------------------------------------- |
+| Nom d'utilisateur | `admin` |
+| Mot de passe | Depuis `/etc/keycloak/credentials.txt` |
-Ouvrez `http://:8080` et connectez-vous à la console d'administration avec les
-identifiants ci-dessus.
-
-## Configurer Keycloak
-
-Le mode développement utilise une base de données en mémoire et des valeurs par défaut non
-sécurisées. Il ne convient donc pas à la production. Pour un déploiement de production, exécutez
-Keycloak avec la commande `start`, une base de données externe, HTTPS sur le port 8443 et un nom
-d'hôte explicite.
-
-L'exemple ci-dessous utilise Docker Compose avec PostgreSQL. Créez `docker-compose.yml`:
-
-```yaml
-services:
- postgres:
- image: postgres:16
- restart: unless-stopped
- environment:
- POSTGRES_DB: keycloak
- POSTGRES_USER: keycloak
- POSTGRES_PASSWORD:
- volumes:
- - postgres_data:/var/lib/postgresql/data
-
- keycloak:
- image: quay.io/keycloak/keycloak:latest
- restart: unless-stopped
- command: start
- environment:
- KEYCLOAK_ADMIN: admin
- KEYCLOAK_ADMIN_PASSWORD:
- KC_DB: postgres
- KC_DB_URL: jdbc:postgresql://postgres:5432/keycloak
- KC_DB_USERNAME: keycloak
- KC_DB_PASSWORD:
- KC_HOSTNAME: auth.example.com
- KC_PROXY_HEADERS: xforwarded
- KC_HTTP_ENABLED: 'true'
- ports:
- - '8080:8080'
- depends_on:
- - postgres
-
-volumes:
- postgres_data:
-```
+## Gérer Keycloak
-Démarrez la pile:
+Keycloak s'exécute comme pile Docker Compose dans `/opt/keycloak`.
```bash
-sudo docker compose up -d
+# Vérifier l'état
+cd /opt/keycloak && docker compose ps
+
+# Redémarrer
+cd /opt/keycloak && docker compose restart
+
+# Voir les journaux
+cd /opt/keycloak && docker compose logs -f
```
-Faites pointer `auth.example.com` vers la VM et placez Keycloak derrière un reverse proxy (Caddy,
-nginx ou Traefik) qui termine TLS sur 443 et redirige vers le port 8080 de l'hôte.
+Configuration d'environnement: `/opt/keycloak/.env`. Les données PostgreSQL sont stockées sous
+`/opt/keycloak/data/postgres` et ne sont pas exposées hors du réseau Docker.
+
+## Sécurité
+
+Le port 8080 est ouvert sur l'interface réseau de la machine virtuelle. UFW est activé et autorise
+SSH (port 22) et Keycloak (port 8080). Keycloak sert HTTP en clair sur 8080.
-## Ouvrir le pare-feu
+:::caution
-L'instance n'autorise que SSH (port 22) en externe par défaut. Ouvrez le port que Keycloak sert et
-ajoutez-le aux règles réseau/sécurité de l'instance dans le portail:
+`KC_HOSTNAME` prend par défaut l'IP privée de la machine virtuelle. Si vous associez ensuite une IP
+publique, un nom DNS ou un proxy inverse, définissez `KC_HOSTNAME` au déploiement (ou modifiez
+`/opt/keycloak/.env` et exécutez `cd /opt/keycloak && docker compose up -d`), sinon les
+vérifications de nom d'hôte en mode production peuvent rejeter les requêtes provenant de la nouvelle
+adresse.
+
+:::
+
+**En production**, placez Keycloak derrière un proxy inverse (Caddy, nginx ou Traefik) qui termine
+TLS sur le port 443 et relaie vers le port 8080, puis définissez `KC_PROXY_HEADERS=xforwarded` dans
+`/opt/keycloak/.env`. Limitez l'accès direct au port 8080:
```bash
-sudo ufw allow 8080/tcp
+sudo ufw delete allow 8080/tcp
+sudo ufw allow from to any port 8080
```
-Si vous placez Keycloak derrière un reverse proxy, ouvrez plutôt le port 443 et gardez le 8080 en
-interne.
-
-## Étapes suivantes
+## Prochaines étapes
- [Documentation Keycloak](https://www.keycloak.org/documentation)
-- [Guide d'installation de Keycloak](https://www.keycloak.org/getting-started/getting-started-docker)
+- [Configurer le nom d'hôte](https://www.keycloak.org/server/hostname)
+- [Configuration avec proxy inverse](https://www.keycloak.org/server/reverseproxy)
diff --git a/src/content/docs/fr/public-cloud/marketplace/lamp.md b/src/content/docs/fr/public-cloud/marketplace/lamp.md
index 3427cda..8f1214f 100644
--- a/src/content/docs/fr/public-cloud/marketplace/lamp.md
+++ b/src/content/docs/fr/public-cloud/marketplace/lamp.md
@@ -12,21 +12,21 @@ configurés pour fonctionner ensemble, prêts pour le déploiement de votre appl
| -------------- | ------------------------------------------------------ |
| Apache | 2.4.x |
| MariaDB | Dernière stable |
-| PHP | 8.3 |
+| PHP | 8.4 |
| Extensions PHP | cli, mysql, curl, gd, mbstring, xml, zip, bcmath, intl |
| Ubuntu | 24.04 LTS |
## Variables d'environnement
-Vous pouvez définir ces valeurs lors du déploiement de LAMP depuis la marketplace. Laissez un champ
-vide pour générer automatiquement une valeur aléatoire sécurisée.
+Cette image n'accepte aucune variable au déploiement. MariaDB est installé avec authentification par
+socket pour `root`, et aucune base de données applicative n'est créée. Créez-en une après le premier
+démarrage:
-| Variable | Description |
-| --------------------- | --------------------------------------------------- |
-| `MYSQL_ROOT_PASSWORD` | Mot de passe root de la base de données |
-| `MYSQL_DATABASE` | Nom de la base de données applicative à créer |
-| `MYSQL_USER` | Nom d'utilisateur de la base de données applicative |
-| `MYSQL_PASSWORD` | Mot de passe de l'utilisateur applicatif |
+```bash
+sudo mariadb -e "CREATE DATABASE app;"
+sudo mariadb -e "CREATE USER 'app'@'localhost' IDENTIFIED BY '';"
+sudo mariadb -e "GRANT ALL PRIVILEGES ON app.* TO 'app'@'localhost';"
+```
## Bien démarrer
@@ -104,7 +104,7 @@ Répertoires et fichiers importants:
| ------------------------------- | ----------------------------- |
| `/var/www/html/` | Racine Web par défaut |
| `/etc/apache2/sites-available/` | Hôtes virtuels Apache |
-| `/etc/php/8.3/apache2/php.ini` | Configuration PHP pour Apache |
+| `/etc/php/8.4/apache2/php.ini` | Configuration PHP pour Apache |
| `/etc/mysql/mariadb.conf.d/` | Configuration MariaDB |
**Pour créer un hôte virtuel** pour un domaine, ajoutez un fichier de configuration dans
diff --git a/src/content/docs/fr/public-cloud/marketplace/lemp.md b/src/content/docs/fr/public-cloud/marketplace/lemp.md
index 2722706..c29c746 100644
--- a/src/content/docs/fr/public-cloud/marketplace/lemp.md
+++ b/src/content/docs/fr/public-cloud/marketplace/lemp.md
@@ -13,7 +13,7 @@ Compose pour simplifier la gestion.
| -------------- | --------------- |
| Nginx | Dernière stable |
| MariaDB | Dernière stable |
-| PHP-FPM | 8.3 |
+| PHP-FPM | 8.4 |
| Docker | Dernière stable |
| Docker Compose | Dernière stable |
| Ubuntu | 24.04 LTS |
diff --git a/src/content/docs/fr/public-cloud/marketplace/mariadb.md b/src/content/docs/fr/public-cloud/marketplace/mariadb.md
index aa9d1dd..7e6cc2a 100644
--- a/src/content/docs/fr/public-cloud/marketplace/mariadb.md
+++ b/src/content/docs/fr/public-cloud/marketplace/mariadb.md
@@ -1,5 +1,5 @@
---
-title: MariaDB 11.4
+title: MariaDB 11.8
---
MariaDB est un système libre de gestion de bases de données relationnelles et un remplacement direct
@@ -10,7 +10,7 @@ le stockage de données généraliste.
| Composant | Version |
| -------------- | ------------ |
-| MariaDB Server | 11.4.x (LTS) |
+| MariaDB Server | 11.8.x (LTS) |
| Ubuntu | 24.04 LTS |
## Variables d'environnement
diff --git a/src/content/docs/fr/public-cloud/marketplace/mysql.md b/src/content/docs/fr/public-cloud/marketplace/mysql.md
index 8835077..ec1104f 100644
--- a/src/content/docs/fr/public-cloud/marketplace/mysql.md
+++ b/src/content/docs/fr/public-cloud/marketplace/mysql.md
@@ -1,17 +1,20 @@
---
-title: MySQL 8.4
+title: MySQL
---
MySQL est l'une des bases de données relationnelles libres les plus déployées au monde. Cette image
-fournit MySQL 8.4 LTS, une version à support à long terme destinée aux charges de travail de
-production.
+fournit une version à support à long terme destinée aux charges de travail de production.
+
+MySQL est publié sous forme d'une image par ligne LTS maintenue. Choisissez la version voulue au
+moment du déploiement. Les lignes 8.4 et 9.7 sont toutes deux des LTS actuelles, et 9.7 est la suite
+logique de 8.4.
## Logiciels inclus
-| Composant | Version |
-| ------------ | ----------- |
-| MySQL Server | 8.4.x (LTS) |
-| Ubuntu | 24.04 LTS |
+| Composant | Version |
+| ------------ | ------------------------------------- |
+| MySQL Server | 8.4.x ou 9.7.x (LTS, selon le modèle) |
+| Ubuntu | 24.04 LTS |
## Variables d'environnement
@@ -109,5 +112,6 @@ tunnel SSH.
## Prochaines étapes
+- [Documentation MySQL 9.7](https://dev.mysql.com/doc/refman/9.7/en/)
- [Documentation MySQL 8.4](https://dev.mysql.com/doc/refman/8.4/en/)
-- [Guide de sécurité MySQL](https://dev.mysql.com/doc/refman/8.4/en/security.html)
+- [Guide de sécurité MySQL](https://dev.mysql.com/doc/refman/9.7/en/security.html)
diff --git a/src/content/docs/fr/public-cloud/marketplace/n8n.md b/src/content/docs/fr/public-cloud/marketplace/n8n.md
index 5128a65..58ed8e5 100644
--- a/src/content/docs/fr/public-cloud/marketplace/n8n.md
+++ b/src/content/docs/fr/public-cloud/marketplace/n8n.md
@@ -11,7 +11,7 @@ flux de travail.
| Composant | Version |
| -------------- | --------------- |
-| n8n | 1.121.0 |
+| n8n | 2.29.8 |
| Docker | Dernière stable |
| Docker Compose | Dernière stable |
| Ubuntu | 24.04 LTS |
diff --git a/src/content/docs/fr/public-cloud/marketplace/netbird.md b/src/content/docs/fr/public-cloud/marketplace/netbird.md
index da8a14c..967fa58 100644
--- a/src/content/docs/fr/public-cloud/marketplace/netbird.md
+++ b/src/content/docs/fr/public-cloud/marketplace/netbird.md
@@ -11,7 +11,7 @@ client NetBird préinstallé, prêt à joindre votre réseau.
| Composant | Version |
| --------- | --------- |
-| NetBird | 0.71.4 |
+| NetBird | 0.74.3 |
| Ubuntu | 24.04 LTS |
## Variables d'environnement
@@ -20,9 +20,10 @@ Vous pouvez éventuellement fournir une clé de configuration NetBird lors du d
marketplace. Si elle est définie, la VM rejoint automatiquement votre réseau NetBird au premier
démarrage ; sinon, connectez-vous manuellement avec `netbird up` après le déploiement.
-| Variable | Description |
-| -------------- | ---------------------------------------------------------------------- |
-| `NB_SETUP_KEY` | Clé de configuration NetBird pour rejoindre votre réseau au démarrage. |
+| Variable | Description |
+| ------------------- | ----------------------------------------------------------------------- |
+| `NB_SETUP_KEY` | Clé de configuration NetBird pour rejoindre votre réseau au démarrage. |
+| `NB_MANAGEMENT_URL` | Serveur de gestion NetBird auto-hébergé. Omettez-le pour NetBird cloud. |
## Bien démarrer
diff --git a/src/content/docs/fr/public-cloud/marketplace/ollama.md b/src/content/docs/fr/public-cloud/marketplace/ollama.md
index 91adb68..d2381b4 100644
--- a/src/content/docs/fr/public-cloud/marketplace/ollama.md
+++ b/src/content/docs/fr/public-cloud/marketplace/ollama.md
@@ -2,47 +2,49 @@
title: Ollama
---
-Ollama est un environnement d'exécution local pour grands modèles de langage (LLM) qui télécharge,
-exécute et sert des modèles ouverts tels que Llama, Qwen, Gemma et DeepSeek sur votre propre
-matériel. Il expose une API REST simple et une interface en ligne de commande, ce qui vous permet
-d'effectuer de l'inférence en privé sans envoyer vos données à un fournisseur tiers.
+Ollama est un environnement d'exécution local pour grands modèles de langage (LLM). Il télécharge,
+exécute et sert des modèles ouverts comme Llama, Qwen, Gemma et DeepSeek sur votre propre matériel.
+Il expose une API REST simple et une interface en ligne de commande, afin d'exécuter l'inférence en
+privé sans envoyer de données à un fournisseur tiers.
-:::note[Bientôt disponible]
+## Logiciels inclus
-Une image Ollama préconstruite arrive bientôt. Pour l'instant, déployez une instance **Ubuntu 24.04
-LTS** neuve depuis la place de marché et suivez les étapes ci-dessous pour installer Ollama
-vous-même.
+| Composant | Version |
+| --------- | --------- |
+| Ollama | 0.31.2 |
+| Ubuntu | 24.04 LTS |
-:::
+Aucun modèle n'est préchargé. Téléchargez les modèles nécessaires au premier démarrage (voir
+[Démarrage](#démarrage)).
## Prérequis
-Ollama fonctionne sur **CPU et RAM**. Un GPU est optionnel et accélère l'inférence. Deux éléments
-déterminent le forfait dont vous avez besoin :
+Ollama fonctionne avec **CPU et RAM**. Un GPU est facultatif et accélère l'inférence. Deux éléments
+déterminent le forfait nécessaire:
-- **RAM** : elle doit contenir le modèle que vous exécutez (environ la taille du fichier du modèle
- plus une marge pour le contexte). Un modèle qui ne tient pas en RAM ne s'exécutera pas.
-- **Stockage** : il doit contenir les fichiers de modèles que vous téléchargez, plus le système
- d'exploitation et l'espace de travail. Ajoutez la taille de chaque modèle supplémentaire que vous
- conservez, car ils s'accumulent vite.
+- La **RAM** doit contenir le modèle exécuté (environ la taille du fichier modèle plus une marge
+ pour le contexte). Un modèle qui ne tient pas en RAM ne s'exécute pas.
+- Le **stockage** doit contenir les fichiers de modèles téléchargés, ainsi que le système
+ d'exploitation et l'espace de travail. Ajoutez la taille de chaque modèle supplémentaire conservé,
+ car ils s'accumulent vite.
-Dimensionnez l'instance pour le plus grand modèle que vous prévoyez d'exécuter. Les valeurs
-ci-dessous utilisent la quantification Q4, celle par défaut d'Ollama.
+Dimensionnez l'instance pour le plus grand modèle prévu. Les valeurs ci-dessous utilisent la
+quantification Q4, le réglage par défaut d'Ollama.
-| Taille du modèle | Exemple | Fichier du modèle (approx.) | RAM minimale | Disque suggéré |
-| ---------------- | ------------- | --------------------------- | ------------ | -------------- |
-| 1-3B | Llama 3.2 3B | 2-3 Go | 8 Go | 20 Go |
-| 7-8B | Llama 3.1 8B | 5 Go | 8 Go | 30 Go |
-| 13-14B | Llama 2 13B | 9 Go | 16 Go | 40 Go |
-| 32-34B | Qwen 2.5 32B | 20 Go | 32 Go | 60 Go |
-| 70B | Llama 3.3 70B | 40 Go | 64 Go | 100 Go |
+| Taille du modèle | Exemple | Fichier modèle (approx.) | RAM minimale | Disque suggéré |
+| ---------------- | ------------- | ------------------------ | ------------ | -------------- |
+| 1-3B | Llama 3.2 3B | 2-3 Go | 8 Go | 20 Go |
+| 7-8B | Llama 3.1 8B | 5 Go | 8 Go | 30 Go |
+| 13-14B | Llama 2 13B | 9 Go | 16 Go | 40 Go |
+| 32-34B | Qwen 2.5 32B | 20 Go | 32 Go | 60 Go |
+| 70B | Llama 3.3 70B | 40 Go | 64 Go | 100 Go |
## Forfaits recommandés par région
-Les noms de forfaits et les tiers de stockage diffèrent selon la région. Les forfaits à usage
-général ci-dessous couvrent la RAM dont chaque modèle a besoin, et leur disque système contient les
-fichiers de modèles. Consultez [Types d'instances](/fr/public-cloud/compute/instance-types/) et la
-[page des tarifs](https://zcp.zsoftly.ca/pricing) pour les spécifications et prix à jour.
+Les noms de forfaits et les niveaux de stockage varient selon la région. Les forfaits généraux
+ci-dessous fournissent assez de RAM pour chaque modèle, et leur disque racine contient les fichiers
+de modèles. Consultez [Types d'instances](/fr/public-cloud/compute/instance-types/) et la
+[page de tarification](https://zcp.zsoftly.ca/pricing) pour les spécifications et prix actuels.
| Taille du modèle | YOW-1 (Ottawa) | YUL-1 (Montréal) |
| ---------------- | ---------------------------------- | ---------------------------------- |
@@ -51,67 +53,46 @@ fichiers de modèles. Consultez [Types d'instances](/fr/public-cloud/compute/ins
| 32-34B | `ci1.2xl` (8 vCPU, 32 Go, 200 Go) | `ca2.2xl` (8 vCPU, 32 Go, 200 Go) |
| 70B | `ci1.4xl` (16 vCPU, 64 Go, 320 Go) | `ca2.4xl` (16 vCPU, 64 Go, 320 Go) |
-Ajustez ensuite :
+Ajustez ensuite:
-- **Même RAM, coût réduit** : la famille à mémoire optimisée offre la même RAM avec moins de vCPU,
- pratique pour un usage occasionnel. Utilisez `cim1.*` dans YOW-1 ou `cam2.*` dans YUL-1 (par
+- **Même RAM, coût inférieur**: la famille axée mémoire fournit la même RAM avec moins de vCPU, ce
+ qui convient aux usages occasionnels. Utilisez `cim1.*` dans YOW-1 ou `cam2.*` dans YUL-1 (par
exemple `cim1.xl` ou `cam2.xl` pour 64 Go).
-- **Réponses plus rapides** : ajoutez des vCPU avec la famille à processeur optimisé (`cac1.*` dans
- YOW-1, `cac2.*` dans YUL-1), ou choisissez un forfait avec GPU pour les modèles de 13B et plus.
-- **Plusieurs grands modèles sur une instance** : attachez un
- [volume de stockage en mode bloc](/fr/public-cloud/compute/settings/block-storage/) au lieu de
- passer à un forfait plus grand.
+- **Réponses plus rapides**: ajoutez des vCPU avec la famille axée CPU (`cac1.*` dans YOW-1,
+ `cac2.*` dans YUL-1), ou choisissez un forfait GPU pour les modèles 13B et plus.
+- **Plusieurs grands modèles sur une instance**: attachez un
+ [volume de stockage bloc](/fr/public-cloud/compute/settings/block-storage/) au lieu de passer à un
+ forfait plus grand.
-## Déployer l'instance de base
+## Démarrage
-1. Dans le portail ZSoftly Cloud, ouvrez **Apps** et passez à l'onglet **Marketplace**. Il s'ouvre
- sur **Featured** par défaut, sélectionnez donc **Marketplace** à côté. Choisissez votre région
- (YOW-1 ou YUL-1), recherchez **Ubuntu 24.04 LTS** et cliquez sur **Deploy**. Vous pouvez aussi
- créer l'instance depuis **Instances → Create**. Dans les deux cas, vous obtenez une VM Ubuntu
- 24.04 propre.
-
- 
-
- 
-
-2. Choisissez un plan qui répond aux prérequis ci-dessus.
-
-3. Lorsque l'instance est **Running**, connectez-vous en SSH:
+### 1. Se connecter à la machine virtuelle
```bash
ssh ubuntu@
```
-4. Mettez le système à jour:
-
-```bash
-sudo apt update && sudo apt upgrade -y
-```
-
-## Installer Ollama
+### 2. Attendre la configuration au premier démarrage
-Exécutez le script d'installation officiel. Il installe le binaire `ollama`, crée un utilisateur
-système `ollama` dédié et configure un service systemd qui démarre automatiquement:
+Au premier démarrage, un script lance le service. Cela prend moins d'une minute. Suivez la
+progression:
```bash
-curl -fsSL https://ollama.com/install.sh | sh
+journalctl -u ollama-first-boot.service -f
```
-Confirmez que le service est en cours d'exécution et vérifiez la version:
-
-```bash
-systemctl status ollama --no-pager
-ollama --version
-```
+Le message de connexion (MOTD) confirme quand Ollama est prêt.
-Téléchargez un modèle et exécutez une invite rapide:
+### 3. Télécharger un modèle et exécuter un prompt
```bash
ollama pull llama3.2
ollama run llama3.2 "Hello, what can you do?"
```
-L'API écoute sur `127.0.0.1:11434` par défaut. Testez-la localement:
+### 4. Utiliser l'API
+
+L'API écoute sur le port `11434`. Testez-la depuis la machine virtuelle:
```bash
curl http://localhost:11434/api/generate -d '{
@@ -121,43 +102,55 @@ curl http://localhost:11434/api/generate -d '{
}'
```
-## Configurer Ollama
+Depuis un autre hôte, remplacez `localhost` par l'IP de la machine virtuelle.
-Par défaut, Ollama ne se lie qu'à localhost. Pour accepter les connexions d'autres hôtes, définissez
-`OLLAMA_HOST` dans le service systemd:
+## Gérer Ollama
+
+Ollama s'exécute comme service systemd.
```bash
-sudo systemctl edit ollama
-```
+# Vérifier l'état
+systemctl status ollama
+
+# Redémarrer
+sudo systemctl restart ollama
-Ajoutez la surcharge suivante, puis enregistrez:
+# Voir les journaux
+sudo journalctl -u ollama -f
-```ini
-[Service]
-Environment="OLLAMA_HOST=0.0.0.0:11434"
+# Lister, télécharger et supprimer des modèles
+ollama list
+ollama pull qwen2.5
+ollama rm qwen2.5
```
-Rechargez et redémarrez:
+Les modèles sont stockés dans `/usr/share/ollama/.ollama/models`. Un résumé des URL et commandes est
+écrit dans `/etc/ollama/info.txt`.
-```bash
-sudo systemctl daemon-reload
-sudo systemctl restart ollama
-```
+## Sécurité
-Ollama n'a aucune authentification intégrée. Si vous exposez le port 11434, placez-le derrière un
-proxy inverse qui applique TLS et l'authentification, ou restreignez l'accès aux adresses IP de
-confiance uniquement.
+Le port 11434 est ouvert sur l'interface réseau de la machine virtuelle, et Ollama n'a **pas
+d'authentification intégrée**. UFW est activé et autorise SSH (port 22) et l'API Ollama (port
+11434).
-## Ouvrir le pare-feu
+**Pour limiter l'API à une adresse IP précise:**
-L'instance n'autorise par défaut que SSH (port 22) en externe. Ouvrez le port dont Ollama a besoin
-et ajoutez-le aux règles réseau/sécurité de l'instance dans le portail:
+```bash
+sudo ufw delete allow 11434/tcp
+sudo ufw allow from to any port 11434
+```
+
+**Pour accéder à l'API sans ouvrir le pare-feu, utilisez un tunnel SSH:**
```bash
-sudo ufw allow 11434/tcp
+# Exécuter cette commande sur votre machine locale
+ssh -L 11434:localhost:11434 ubuntu@
```
-## Étapes suivantes
+**En production**, placez Ollama derrière un proxy inverse qui impose TLS et l'authentification, ou
+limitez l'accès aux seules adresses IP de confiance.
+
+## Prochaines étapes
- [Documentation Ollama](https://docs.ollama.com/)
-- [Guide d'installation Ollama](https://docs.ollama.com/linux)
+- [Référence de l'API Ollama](https://docs.ollama.com/api)
diff --git a/src/content/docs/fr/public-cloud/marketplace/openbao.md b/src/content/docs/fr/public-cloud/marketplace/openbao.md
index 1b26f8c..12e4c83 100644
--- a/src/content/docs/fr/public-cloud/marketplace/openbao.md
+++ b/src/content/docs/fr/public-cloud/marketplace/openbao.md
@@ -8,10 +8,21 @@ communautaire de HashiCorp Vault maintenu par la Linux Foundation, et il reste c
API. La plupart des outils Vault fonctionnent donc sans modification. Vous l'exécutez comme un
serveur, l'initialisez une seule fois, puis le descellez pour commencer à servir des secrets.
-:::note[Bientôt disponible]
+## Logiciels inclus
-Une image OpenBao préconfigurée arrive bientôt. Pour l'instant, déployez une instance **Ubuntu 24.04
-LTS** neuve depuis la marketplace et suivez les étapes ci-dessous pour installer OpenBao vous-même.
+| Composant | Version |
+| --------- | --------- |
+| OpenBao | 2.5.5 |
+| Ubuntu | 24.04 LTS |
+
+OpenBao s'exécute comme service systemd avec le stockage Raft intégré. Chaque machine virtuelle
+génère son propre certificat TLS au premier démarrage, aucune clé privée n'est donc partagée entre
+les déploiements.
+
+:::caution
+
+Cette image déploie un seul nœud. Un cluster Raft à un nœud n'offre aucun basculement. Pour la haute
+disponibilité, provisionnez d'autres instances depuis ce modèle et joignez-les comme pairs Raft.
:::
@@ -23,121 +34,112 @@ LTS** neuve depuis la marketplace et suivez les étapes ci-dessous pour installe
| RAM | 1 Go | 2 Go |
| Stockage | 10 Go | 20 Go |
-## Déployer l'instance de base
+## Variables d'environnement
-1. Dans le portail ZSoftly Cloud, ouvrez **Apps**, sélectionnez **OpenBao** et cliquez sur
- **Deploy**, ou créez une instance **Ubuntu 24.04 LTS** depuis **Instances → Create**. Les deux
- vous donnent une VM Ubuntu 24.04 propre.
-2. Choisissez un forfait conforme aux prérequis ci-dessus et sélectionnez votre région (YOW-1 ou
- YUL-1).
-3. Lorsque l'instance est **Running**, connectez-vous en SSH:
+Vous pouvez définir ces variables au déploiement d'OpenBao depuis la Marketplace. Laissez-les vides
+pour utiliser l'adresse de la machine virtuelle et recevoir les secrets générés en clair.
-```bash
-ssh ubuntu@
-```
+| Variable | Description |
+| ---------------------------- | -------------------------------------------------------------------------------------- |
+| `OPENBAO_ADDR` | Adresse inscrite dans le certificat TLS et dans l'adresse du cluster Raft |
+| `OPENBAO_UNSEAL_PGP_KEYS` | Clés publiques PGP séparées par des virgules. Chaque part de descellement est chiffrée |
+| `OPENBAO_ROOT_TOKEN_PGP_KEY` | Une clé publique PGP. Le jeton racine est renvoyé chiffré avec cette clé |
-4. Mettez le système à jour:
+Chaque entrée PGP est soit `keybase:`, soit une clé publique ASCII-armored encodée en
+base64. Ces variables ne permettent pas de choisir la valeur des secrets. OpenBao génère toujours
+lui-même le jeton racine et les clés de descellement. Elles déterminent uniquement à qui ces valeurs
+sont chiffrées.
-```bash
-sudo apt update && sudo apt upgrade -y
-```
+:::note
-## Installer OpenBao
+Lorsque vous fournissez `OPENBAO_UNSEAL_PGP_KEYS`, le nombre de clés devient le nombre de parts et
+le seuil de descellement, et la machine virtuelle ne peut pas se desceller elle-même, car elle ne
+détient aucune clé privée. Déchiffrez votre part localement et exécutez `bao operator unseal`
+vous-même.
-OpenBao publie un dépôt APT officiel. Ajoutez sa clé de signature et sa source, puis installez le
-paquet `openbao`.
+:::
-```bash
-sudo apt install -y gpg wget
-sudo mkdir -p /usr/share/keyrings
-wget -qO- https://pkg.openbao.org/gpg.key | sudo gpg --dearmor -o /usr/share/keyrings/openbao-keyring.gpg
-echo "deb [signed-by=/usr/share/keyrings/openbao-keyring.gpg] https://pkg.openbao.org/deb stable main" | sudo tee /etc/apt/sources.list.d/openbao.list
-```
+## Démarrage
-Installez OpenBao:
+### 1. Connectez-vous à votre VM
```bash
-sudo apt update
-sudo apt install -y openbao
+ssh ubuntu@
```
-Le paquet installe la CLI `bao`, un utilisateur `openbao` dédié, un service systemd et un fichier de
-configuration par défaut dans `/etc/openbao/openbao.hcl`.
-
-## Configurer OpenBao
+### 2. Attendez la configuration au premier démarrage
-Modifiez `/etc/openbao/openbao.hcl` pour utiliser le stockage intégré (Raft) et écouter sur toutes
-les interfaces. Ce listener de démarrage rapide désactive TLS afin que vous puissiez vérifier
-l'installation. Consultez la note TLS ci-dessous avant de l'exposer.
+Au premier démarrage, un script génère un certificat TLS pour cette VM, démarre OpenBao,
+l'initialise avec 5 parts de clé et un seuil de 3, puis le descelle. Suivez la progression:
```bash
-sudo tee /etc/openbao/openbao.hcl >/dev/null <<'EOF'
-ui = true
-
-storage "raft" {
- path = "/opt/openbao/data"
- node_id = "openbao-1"
-}
+journalctl -u openbao-first-boot.service -f
+```
-listener "tcp" {
- address = "0.0.0.0:8200"
- tls_disable = true
-}
+### 3. Récupérez les clés de descellement et le jeton racine
-api_addr = "http://127.0.0.1:8200"
-cluster_addr = "https://127.0.0.1:8201"
-EOF
+Ils sont écrits dans un fichier réservé à root:
-sudo mkdir -p /opt/openbao/data
-sudo chown -R openbao:openbao /opt/openbao
+```bash
+sudo cat /etc/openbao/credentials.txt
```
-Activez et démarrez le service, puis pointez la CLI vers l'API locale:
+:::danger
-```bash
-sudo systemctl enable --now openbao
-export BAO_ADDR='http://127.0.0.1:8200'
-```
+Copiez les clés de descellement et le jeton racine en lieu sûr, puis retirez-les de la VM. Quiconque
+détient le jeton racine contrôle entièrement vos secrets, et la perte des clés de descellement rend
+les données irrécupérables.
+
+:::
-Initialisez OpenBao une seule fois. Cette commande affiche les clés de descellement et le jeton root
-initial. Conservez-les en lieu sûr. Ils ne peuvent pas être récupérés:
+### 4. Utilisez l'API
```bash
-bao operator init
+export BAO_ADDR=https://:8200
+export BAO_SKIP_VERIFY=true
+bao status
```
-OpenBao démarre **scellé**. Descellez-le en fournissant le seuil de clés de descellement (trois par
-défaut), en exécutant la commande une fois par clé:
+Le certificat est auto-signé. Faites-lui confiance ou définissez `BAO_SKIP_VERIFY` pendant vos
+tests. Remplacez-le par votre propre certificat en production.
+
+## Gérer OpenBao
```bash
-bao operator unseal
-```
+# Vérifier l'état
+sudo systemctl status openbao
-Une fois descellé, connectez-vous avec le jeton root pour commencer à gérer les secrets:
+# Redémarrer
+sudo systemctl restart openbao
-```bash
-bao login
+# Consulter les journaux
+sudo journalctl -u openbao -f
```
-:::caution
+La configuration se trouve dans `/etc/openbao`, les données Raft dans `/opt/openbao/data`, et le
+certificat propre à la VM dans `/etc/openbao/tls`.
-Le listener de démarrage rapide ci-dessus fonctionne sans TLS. Avant d'exposer OpenBao au-delà de
-cet hôte, activez TLS dans le bloc `listener "tcp"` (définissez `tls_cert_file` et `tls_key_file`,
-supprimez `tls_disable`) ou placez-le derrière un reverse proxy qui termine HTTPS. Ne servez jamais
-de secrets de production en HTTP non chiffré.
+## Sécurité
-:::
+Le port 8200 n'est ouvert qu'après que le service a répondu à un contrôle de santé en TLS. UFW est
+activé et autorise ce port ainsi que SSH (port 22).
+
+OpenBao se rescelle à chaque redémarrage du service. Descellez-le de nouveau avec trois de vos
+parts:
-## Ouvrir le pare-feu
+```bash
+bao operator unseal
+```
-L'instance n'autorise que SSH (port 22) en externe par défaut. Ouvrez le port de l'API qu'OpenBao
-sert et ajoutez-le aux règles réseau/sécurité de l'instance dans le portail:
+**Pour restreindre l'accès à une adresse IP précise:**
```bash
-sudo ufw allow 8200/tcp
+sudo ufw delete allow 8200/tcp
+sudo ufw allow from to any port 8200
```
-## Étapes suivantes
+## Prochaines étapes
- [Documentation OpenBao](https://openbao.org/docs/)
-- [Guide d'installation d'OpenBao](https://openbao.org/docs/install/)
+- [Concepts de scellement et descellement](https://openbao.org/docs/concepts/seal/)
+- [Stockage Raft intégré](https://openbao.org/docs/internals/integrated-storage/)
diff --git a/src/content/docs/fr/public-cloud/marketplace/portainer.md b/src/content/docs/fr/public-cloud/marketplace/portainer.md
index 6c10cf8..1b7b5a7 100644
--- a/src/content/docs/fr/public-cloud/marketplace/portainer.md
+++ b/src/content/docs/fr/public-cloud/marketplace/portainer.md
@@ -3,17 +3,16 @@ title: Portainer
---
Portainer est une interface de gestion légère pour les environnements Docker et Kubernetes. Elle
-vous permet de déployer des conteneurs, de gérer les images, les volumes et les réseaux, et de
-surveiller vos piles depuis une seule console web. L'interface s'exécute sur le port 9443 en HTTPS
-(port 9000 pour le HTTP simple).
+permet de déployer des conteneurs, gérer les images, volumes et réseaux, et surveiller vos piles
+depuis une console web unique. L'interface s'exécute sur le port 9443 en HTTPS.
-:::note[Bientôt disponible]
+## Logiciels inclus
-Une image Portainer préinstallée arrive bientôt. Pour l'instant, déployez une nouvelle instance
-**Ubuntu 24.04 LTS** depuis la marketplace et suivez les étapes ci-dessous pour installer Portainer
-vous-même.
-
-:::
+| Composant | Version |
+| ------------ | --------------- |
+| Portainer CE | 2.39.4 |
+| Docker | Dernière stable |
+| Ubuntu | 24.04 LTS |
## Prérequis
@@ -23,88 +22,101 @@ vous-même.
| RAM | 1 Go | 2 Go |
| Stockage | 20 Go | 40 Go |
-## Déployer l'instance de base
+## Variables d'environnement
+
+Cette image n'accepte aucune variable au déploiement. Elle ne crée aucun compte administrateur
+partagé. Ouvrez l'interface Portainer après le premier démarrage et créez-y le premier
+administrateur.
-1. Dans le portail ZSoftly Cloud, ouvrez **Apps**, sélectionnez **Portainer** et cliquez sur
- **Deploy**, ou créez une instance **Ubuntu 24.04 LTS** depuis **Instances → Create**. Les deux
- vous donnent une VM Ubuntu 24.04 propre.
-2. Choisissez un plan répondant aux prérequis ci-dessus et sélectionnez votre région (YOW-1 ou
- YUL-1).
-3. Lorsque l'instance est **Running**, connectez-vous en SSH:
+Si la session de configuration du premier utilisateur expire avant la fin, redémarrez Portainer et
+rechargez l'interface:
```bash
-ssh ubuntu@
+cd /opt/portainer && docker compose restart portainer
```
-4. Mettez le système à jour:
+## Démarrage
+
+### 1. Se connecter à la machine virtuelle
```bash
-sudo apt update && sudo apt upgrade -y
+ssh ubuntu@
```
-## Installer Portainer
+### 2. Attendre la configuration au premier démarrage
-Portainer s'exécute en tant que conteneur Docker. Installez donc d'abord Docker Engine à l'aide du
-script d'installation officiel:
+Au premier démarrage, un script lance le conteneur Portainer avec Docker Compose. Cela prend moins
+d'une minute. Suivez la progression:
```bash
-curl -fsSL https://get.docker.com | sudo sh
+journalctl -u portainer-first-boot.service -f
```
-Vérifiez que Docker fonctionne:
+Le message de connexion (MOTD) confirme quand Portainer est prêt.
-```bash
-docker version
-```
+### 3. Créer le compte administrateur
-Créez un volume pour les données persistantes de Portainer:
+Ouvrez un navigateur et allez à:
-```bash
-docker volume create portainer_data
+```text
+https://:9443
```
-Exécutez le conteneur du serveur Portainer CE:
+Au premier chargement, créez votre compte administrateur en définissant un nom d'utilisateur et un
+mot de passe fort. Portainer se connecte à l'environnement Docker local via le socket monté. Vos
+conteneurs, images et volumes apparaissent donc immédiatement.
+
+:::caution
+
+Portainer verrouille la configuration initiale si aucun compte administrateur n'est créé peu après
+le démarrage du conteneur. Si la fenêtre de configuration expire, redémarrez Portainer et rechargez
+la page:
```bash
-sudo docker run -d \
- -p 8000:8000 \
- -p 9443:9443 \
- --name portainer \
- --restart=always \
- -v /var/run/docker.sock:/var/run/docker.sock \
- -v portainer_data:/data \
- portainer/portainer-ce:lts
+cd /opt/portainer && docker compose restart
```
-Vérifiez que le conteneur est en cours d'exécution:
+L'interface utilise un certificat autosigné. Votre navigateur affiche donc un avertissement de
+sécurité. Acceptez l'exception pour continuer.
+
+:::
+
+## Gérer Portainer
+
+Portainer s'exécute comme pile Docker Compose dans `/opt/portainer`.
```bash
-docker ps
-```
+# Vérifier l'état
+cd /opt/portainer && docker compose ps
-## Configurer Portainer
+# Redémarrer
+cd /opt/portainer && docker compose restart
-Portainer sert l'interface sur le port 9443 en HTTPS avec un certificat auto-signé. Ouvrez
-`https://:9443` dans un navigateur dans les quelques minutes suivant le démarrage du
-conteneur. Pour des raisons de sécurité, Portainer verrouille la configuration initiale si aucun
-compte administrateur n'est créé peu après le premier démarrage.
+# Voir les journaux
+cd /opt/portainer && docker compose logs -f
+```
-Au premier chargement, créez votre compte administrateur en définissant un nom d'utilisateur et un
-mot de passe fort. Portainer se connecte ensuite à l'environnement Docker local via le socket monté,
-de sorte que vos conteneurs, images et volumes apparaissent immédiatement. Le certificat auto-signé
-déclenche un avertissement du navigateur. Pour un déploiement de production, placez Portainer
-derrière un reverse proxy tel que nginx avec un certificat TLS de confiance.
+Les données persistantes de Portainer sont stockées dans `/var/lib/portainer`. Un résumé des URL et
+chemins est écrit dans `/etc/portainer/info.txt`.
-## Ouvrir le pare-feu
+## Sécurité
-L'instance n'autorise que le SSH (port 22) en externe par défaut. Ouvrez le ou les ports dont
-Portainer a besoin et ajoutez-les aux règles réseau/sécurité de l'instance dans le portail:
+Le port 9443 est ouvert sur l'interface réseau de la machine virtuelle. UFW est activé et autorise
+SSH (port 22) et Portainer (port 9443). Les ports 8000, 9000 et l'API Docker ne sont pas ouverts par
+défaut.
+
+Portainer monte le socket Docker de l'hôte, ce qui lui donne le contrôle complet du démon Docker de
+la machine virtuelle. Limitez l'accès au port 9443:
```bash
-sudo ufw allow 9443/tcp
+sudo ufw delete allow 9443/tcp
+sudo ufw allow from to any port 9443
```
-## Étapes suivantes
+**En production**, placez Portainer derrière un proxy inverse comme nginx avec un certificat TLS de
+confiance.
+
+## Prochaines étapes
- [Documentation Portainer](https://docs.portainer.io/)
-- [Guide d'installation Portainer](https://docs.portainer.io/start/install-ce/server/docker/linux)
+- [Gérer les environnements Docker](https://docs.portainer.io/user/docker)
diff --git a/src/content/docs/fr/public-cloud/marketplace/postgresql.md b/src/content/docs/fr/public-cloud/marketplace/postgresql.md
index dcec559..1fd40a6 100644
--- a/src/content/docs/fr/public-cloud/marketplace/postgresql.md
+++ b/src/content/docs/fr/public-cloud/marketplace/postgresql.md
@@ -1,17 +1,20 @@
---
-title: PostgreSQL 17
+title: PostgreSQL
---
PostgreSQL est une puissante base de données relationnelle-objet libre, reconnue pour sa fiabilité,
sa conformité aux standards et son extensibilité. Elle prend en charge les types de données avancés,
la recherche plein texte, JSON et un vaste éventail d'extensions.
+PostgreSQL est publié sous forme d'une image par version majeure prise en charge. Choisissez 16, 17
+ou 18 au moment du déploiement.
+
## Logiciels inclus
-| Composant | Version |
-| ---------- | --------- |
-| PostgreSQL | 17.x |
-| Ubuntu | 24.04 LTS |
+| Composant | Version |
+| ---------- | ------------------------------------ |
+| PostgreSQL | 16.x, 17.x ou 18.x (selon le modèle) |
+| Ubuntu | 24.04 LTS |
## Variables d'environnement
@@ -81,7 +84,7 @@ sudo systemctl restart postgresql
sudo journalctl -u postgresql -f
```
-Répertoire de configuration: `/etc/postgresql/17/main/`
+Répertoire de configuration: `/etc/postgresql//main/`
Fichiers importants:
@@ -122,5 +125,5 @@ tunnel SSH.
## Prochaines étapes
-- [Documentation PostgreSQL 17](https://www.postgresql.org/docs/17/)
+- [Documentation PostgreSQL](https://www.postgresql.org/docs/current/)
- [Guide de sécurité PostgreSQL](https://www.postgresql.org/docs/current/security.html)
diff --git a/src/content/docs/fr/public-cloud/marketplace/prometheus.md b/src/content/docs/fr/public-cloud/marketplace/prometheus.md
index 39f9ed5..76df7f4 100644
--- a/src/content/docs/fr/public-cloud/marketplace/prometheus.md
+++ b/src/content/docs/fr/public-cloud/marketplace/prometheus.md
@@ -2,19 +2,22 @@
title: Prometheus
---
-Prometheus est une boîte à outils libre de surveillance des systèmes et d'alerte. Il collecte des
-métriques auprès de cibles configurées à intervalles réguliers, les stocke dans une base de données
-de séries temporelles et évalue des règles pour déclencher des alertes. Il expose une interface de
-requête et un navigateur d'expressions intégré sur le port 9090, et s'associe bien à Grafana pour
-les tableaux de bord.
+Prometheus est une boîte à outils open source de surveillance et d'alerte système. Il collecte les
+métriques de cibles configurées à intervalles réguliers, les stocke dans une base de données de
+séries temporelles et évalue des règles pour déclencher des alertes. Il expose une interface de
+requêtes et un navigateur d'expressions intégré sur le port 9090, et fonctionne bien avec Grafana
+pour les tableaux de bord.
-:::note[Bientôt disponible]
+## Logiciels inclus
-Une image Prometheus préconfigurée arrive bientôt. Pour l'instant, déployez une instance **Ubuntu
-24.04 LTS** vierge depuis la marketplace et suivez les étapes ci-dessous pour installer Prometheus
-vous-même.
+| Composant | Version |
+| ---------- | --------- |
+| Prometheus | 3.13.0 |
+| Ubuntu | 24.04 LTS |
-:::
+L'image inclut seulement le serveur Prometheus. Ajoutez les exporters (comme `node_exporter`) comme
+cibles de collecte, et exécutez Alertmanager séparément, en tant que composant distinct, pour gérer
+le routage des alertes.
## Prérequis
@@ -24,144 +27,91 @@ vous-même.
| RAM | 2 Go | 4 Go |
| Stockage | 20 Go | 50 Go |
-## Déployer l'instance de base
+Les besoins de stockage augmentent avec le nombre de séries et la période de rétention.
-1. Dans le portail ZSoftly Cloud, ouvrez **Apps** et passez à l'onglet **Marketplace**. Il s'ouvre
- sur **Featured** par défaut, sélectionnez donc **Marketplace** à côté. Choisissez votre région
- (YOW-1 ou YUL-1), recherchez **Ubuntu 24.04 LTS** et cliquez sur **Deploy**. Vous pouvez aussi
- créer l'instance depuis **Instances → Create**. Dans les deux cas, vous obtenez une VM Ubuntu
- 24.04 propre.
+## Démarrage
- 
-
- 
-
-2. Choisissez un plan qui répond aux prérequis ci-dessus.
-
-3. Lorsque l'instance est **Running**, connectez-vous en SSH :
+### 1. Se connecter à la machine virtuelle
```bash
ssh ubuntu@
```
-4. Mettez le système à jour :
+### 2. Attendre la configuration au premier démarrage
+
+Au premier démarrage, un script lance le service. Cela prend moins d'une minute. Suivez la
+progression:
```bash
-sudo apt update && sudo apt upgrade -y
+journalctl -u prometheus-first-boot.service -f
```
-## Installer Prometheus
+Le message de connexion (MOTD) confirme quand Prometheus est prêt.
-Installez Prometheus depuis la version binaire officielle et exécutez-le comme service systemd.
-C'est la méthode de production courante, qui vous donne un contrôle total sur la version.
+### 3. Accéder à l'interface Prometheus
-Créez un utilisateur système dédié et non privilégié, ainsi que les répertoires de configuration et
-de données :
+Ouvrez un navigateur et allez au navigateur d'expressions et à l'interface intégrée:
-```bash
-sudo useradd --no-create-home --shell /bin/false prometheus
-sudo mkdir -p /etc/prometheus /var/lib/prometheus
+```text
+http://:9090
```
-Téléchargez la dernière version depuis prometheus.io et extrayez-la. Consultez la
-[page des versions](https://prometheus.io/download/) pour connaître la version actuelle et mettez-la
-à jour ci-dessous :
+### 4. Ajouter des cibles de collecte
-```bash
-PROM_VERSION=3.4.1
-cd /tmp
-curl -fsSLO https://github.com/prometheus/prometheus/releases/download/v${PROM_VERSION}/prometheus-${PROM_VERSION}.linux-amd64.tar.gz
-tar -xzf prometheus-${PROM_VERSION}.linux-amd64.tar.gz
-cd prometheus-${PROM_VERSION}.linux-amd64
-```
-
-Installez les binaires et les fichiers de support, puis attribuez la propriété à l'utilisateur
-`prometheus` :
+Modifiez la configuration de collecte, validez-la, puis rechargez sans redémarrage:
```bash
-sudo cp prometheus promtool /usr/local/bin/
-sudo cp -r consoles console_libraries /etc/prometheus/
-sudo cp prometheus.yml /etc/prometheus/prometheus.yml
-sudo chown -R prometheus:prometheus /usr/local/bin/prometheus /usr/local/bin/promtool /etc/prometheus /var/lib/prometheus
+sudo nano /etc/prometheus/prometheus.yml
+promtool check config /etc/prometheus/prometheus.yml
+sudo systemctl reload prometheus
```
-Écrivez une configuration de collecte minimale. Par défaut, elle collecte les métriques de
-Prometheus lui-même sur le port 9090. Ajoutez vos propres cibles sous `scrape_configs` :
+## Gérer Prometheus
+
+Prometheus s'exécute comme service systemd avec un utilisateur dédié `prometheus`.
```bash
-sudo tee /etc/prometheus/prometheus.yml > /dev/null <<'EOF'
-global:
- scrape_interval: 15s
- evaluation_interval: 15s
-
-scrape_configs:
- - job_name: prometheus
- static_configs:
- - targets: ["localhost:9090"]
-EOF
-sudo chown prometheus:prometheus /etc/prometheus/prometheus.yml
-```
+# Vérifier l'état
+systemctl status prometheus
-Créez l'unité de service systemd :
+# Redémarrer
+sudo systemctl restart prometheus
-```bash
-sudo tee /etc/systemd/system/prometheus.service > /dev/null <<'EOF'
-[Unit]
-Description=Prometheus
-Wants=network-online.target
-After=network-online.target
-
-[Service]
-User=prometheus
-Group=prometheus
-Type=simple
-ExecStart=/usr/local/bin/prometheus \
- --config.file=/etc/prometheus/prometheus.yml \
- --storage.tsdb.path=/var/lib/prometheus/ \
- --web.console.templates=/etc/prometheus/consoles \
- --web.console.libraries=/etc/prometheus/console_libraries \
- --web.listen-address=0.0.0.0:9090
-Restart=on-failure
-
-[Install]
-WantedBy=multi-user.target
-EOF
+# Recharger la configuration sans redémarrer
+sudo systemctl reload prometheus
+
+# Voir les journaux
+sudo journalctl -u prometheus -f
```
-Rechargez systemd, puis activez et démarrez le service :
+| Chemin | Rôle |
+| -------------------------------- | ------------------------------------- |
+| `/etc/prometheus/prometheus.yml` | Configuration principale |
+| `/var/lib/prometheus/` | Base de données de séries temporelles |
-```bash
-sudo systemctl daemon-reload
-sudo systemctl enable --now prometheus
-sudo systemctl status prometheus
-```
+## Sécurité
-## Configurer Prometheus
+Le port 9090 est ouvert sur l'interface réseau de la machine virtuelle, et Prometheus n'a **pas
+d'authentification intégrée**. UFW est activé et autorise SSH (port 22) et Prometheus (port 9090).
-1. Ouvrez `http://:9090` dans un navigateur pour accéder au navigateur d'expressions
- Prometheus et à l'interface intégrée.
-2. Ajoutez des cibles de collecte en modifiant `/etc/prometheus/prometheus.yml` (par exemple, un
- `node_exporter` exécuté sur un hôte), puis validez et rechargez :
+**Pour limiter l'interface à une adresse IP précise:**
```bash
-promtool check config /etc/prometheus/prometheus.yml
-sudo systemctl reload prometheus
+sudo ufw delete allow 9090/tcp
+sudo ufw allow from to any port 9090
```
-3. Prometheus ne dispose d'aucune authentification propre. En production, placez-le derrière un
- reverse proxy tel que Nginx ou Caddy pour ajouter le TLS et le contrôle d'accès sur le port 443,
- et restreignez l'accès direct au port 9090.
-
-## Ouvrir le pare-feu
-
-L'instance n'autorise par défaut que le SSH (port 22) en externe. Ouvrez le port dont Prometheus a
-besoin et ajoutez-le aux règles réseau/sécurité de l'instance dans le portail :
+**Pour accéder à l'interface sans ouvrir le pare-feu, utilisez un tunnel SSH:**
```bash
-sudo ufw allow 9090/tcp
+# Exécuter cette commande sur votre machine locale
+ssh -L 9090:localhost:9090 ubuntu@
```
-## Étapes suivantes
+**En production**, placez Prometheus derrière un proxy inverse comme Nginx ou Caddy pour ajouter TLS
+et un contrôle d'accès sur le port 443, puis limitez l'accès direct au port 9090.
+
+## Prochaines étapes
- [Documentation Prometheus](https://prometheus.io/docs/introduction/overview/)
-- [Guide d'installation Prometheus](https://prometheus.io/docs/prometheus/latest/installation/)
+- [Référence de configuration](https://prometheus.io/docs/prometheus/latest/configuration/configuration/)
diff --git a/src/content/docs/fr/public-cloud/marketplace/supabase.md b/src/content/docs/fr/public-cloud/marketplace/supabase.md
index bbd93e3..18e45a5 100644
--- a/src/content/docs/fr/public-cloud/marketplace/supabase.md
+++ b/src/content/docs/fr/public-cloud/marketplace/supabase.md
@@ -2,18 +2,23 @@
title: Supabase
---
-Supabase est une alternative open source à Firebase, construite sur PostgreSQL. Elle regroupe une
-base de données Postgres, l'authentification, des API REST et GraphQL instantanées, les abonnements
-en temps réel, le stockage et un tableau de bord d'administration Studio dans une seule pile
-auto-hébergeable. Le Studio et les API sont servis via la passerelle Kong sur le port 8000.
+Supabase est une alternative open source à Firebase basée sur PostgreSQL. Elle regroupe une base
+Postgres, l'authentification, des API REST et GraphQL instantanées, les abonnements en temps réel,
+le stockage et un tableau de bord Studio dans une pile auto-hébergeable. Studio et les API sont
+servis par la passerelle Kong sur le port 8000.
-:::note[Bientôt disponible]
+## Logiciels inclus
-Une image Supabase préconfigurée arrive bientôt. Pour l'instant, déployez une nouvelle instance
-**Ubuntu 24.04 LTS** depuis la marketplace et suivez les étapes ci-dessous pour installer Supabase
-vous-même.
+| Composant | Version |
+| -------------- | ------------------ |
+| Supabase | Pile auto-hébergée |
+| PostgreSQL | 17 |
+| Docker | Dernière stable |
+| Docker Compose | Dernière stable |
+| Ubuntu | 24.04 LTS |
-:::
+La pile inclut Studio, la passerelle API Kong, Auth (GoTrue), PostgREST, Realtime, Storage et
+postgres-meta, le tout sur PostgreSQL 17.
## Prérequis
@@ -23,112 +28,92 @@ vous-même.
| RAM | 4 Go | 8 Go |
| Stockage | 30 Go | 80 Go |
-## Déployer l'instance de base
+## Variables d'environnement
-1. Dans le portail ZSoftly Cloud, ouvrez **Apps**, sélectionnez **Supabase** et cliquez sur
- **Deploy**, ou créez une instance **Ubuntu 24.04 LTS** depuis **Instances → Create**. Dans les
- deux cas, vous obtenez une VM Ubuntu 24.04 propre.
-2. Choisissez un plan qui répond aux prérequis ci-dessus et sélectionnez votre région (YOW-1 ou
- YUL-1).
-3. Lorsque l'instance est **Running**, connectez-vous en SSH :
+Vous pouvez les définir au déploiement de Supabase depuis la Marketplace. Laissez un champ de mot de
+passe vide pour générer automatiquement une valeur aléatoire sécurisée.
-```bash
-ssh ubuntu@
-```
+| Variable | Description |
+| -------------------- | ---------------------------------------------------------------- |
+| `SITE_URL` | URL publique de l'instance Supabase et du tableau de bord Studio |
+| `POSTGRES_PASSWORD` | Mot de passe de la base PostgreSQL |
+| `DASHBOARD_PASSWORD` | Mot de passe de connexion au tableau de bord Studio |
+
+Ce sont les seules variables à définir au déploiement. `SUPABASE_PUBLIC_URL` et `API_EXTERNAL_URL`,
+mentionnées dans [Sécurité](#sécurité), se modifient dans `/data/supabase/.env` sur la VM en marche.
+
+## Démarrage
-4. Mettez le système à jour :
+### 1. Se connecter à la machine virtuelle
```bash
-sudo apt update && sudo apt upgrade -y
+ssh ubuntu@
```
-## Installer Supabase
-
-Supabase s'auto-héberge sous forme de pile Docker Compose. Installez donc d'abord Docker Engine et
-le plugin Compose.
+### 2. Attendre la configuration au premier démarrage
-Configurez le dépôt APT officiel de Docker pour Ubuntu 24.04 LTS (`noble`) :
+Au premier démarrage, un script génère le mot de passe de base de données, le secret JWT, les clés
+API et les identifiants Studio, puis télécharge les images de conteneurs et démarre la pile. Le
+téléchargement est volumineux. Cela prend environ 15 à 20 minutes. Suivez la progression:
```bash
-sudo apt install -y ca-certificates curl git
-sudo install -m 0755 -d /etc/apt/keyrings
-sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
-sudo chmod a+r /etc/apt/keyrings/docker.asc
-sudo tee /etc/apt/sources.list.d/docker.sources >/dev/null <:8000
+```
-Le dépôt fournit des scripts d'aide pour générer des secrets et des clés d'API cohérents :
+Connectez-vous avec le nom d'utilisateur `supabase` et le mot de passe généré. Les API REST et Auth
+sont servies par la même passerelle à `http://:8000/rest/v1/` et
+`http://:8000/auth/v1/`.
-```bash
-sh utils/generate-keys.sh
-sh utils/add-new-auth-keys.sh
-```
+## Gérer Supabase
-Téléchargez les images et démarrez la pile :
+Supabase s'exécute comme pile Docker Compose dans `/data/supabase`.
```bash
-sudo docker compose pull
-sudo docker compose up -d --wait
-```
+# Vérifier l'état
+cd /data/supabase && docker compose ps
-Une fois les conteneurs sains, le tableau de bord Studio et les API sont servis via Kong sur le port
-8000 :
+# Redémarrer
+cd /data/supabase && docker compose restart
-- Tableau de bord Studio : `http://:8000` (connectez-vous avec `DASHBOARD_USERNAME` /
- `DASHBOARD_PASSWORD`)
-- API REST : `http://:8000/rest/v1/`
-- API Auth : `http://:8000/auth/v1/`
+# Voir les journaux
+cd /data/supabase && docker compose logs -f
+```
-Pour une configuration de production, placez Supabase derrière un reverse proxy tel que nginx avec
-un certificat TLS, puis servez le Studio et les API en HTTPS au lieu d'exposer directement le
-port 8000.
+Configuration d'environnement: `/data/supabase/.env`. Les données de base de données et de stockage
+sont stockées sous `/data/supabase/volumes`.
-## Ouvrir le pare-feu
+## Sécurité
-L'instance n'autorise par défaut que le SSH (port 22) en externe. Ouvrez le ou les ports dont
-Supabase a besoin et ajoutez-les aux règles réseau/de sécurité de l'instance dans le portail :
+Les ports 8000, 80 et 443 sont ouverts sur l'interface réseau de la machine virtuelle. UFW est
+activé et autorise ces ports ainsi que SSH (port 22). L'accès PostgreSQL direct (5432) n'est pas
+exposé.
-```bash
-sudo ufw allow 8000/tcp
-```
+Changez le mot de passe du tableau de bord Studio après la première connexion. **En production**,
+définissez `SUPABASE_PUBLIC_URL`, `API_EXTERNAL_URL` et `SITE_URL` dans `/data/supabase/.env` avec
+votre domaine, redémarrez la pile, puis placez Supabase derrière un proxy inverse comme nginx avec
+un certificat TLS afin que Studio et les API soient servis en HTTPS au lieu d'exposer directement le
+port 8000.
-## Étapes suivantes
+## Prochaines étapes
- [Documentation Supabase](https://supabase.com/docs)
-- [Guide d'auto-hébergement Supabase](https://supabase.com/docs/guides/self-hosting/docker)
+- [Guide d'auto-hébergement](https://supabase.com/docs/guides/self-hosting/docker)
diff --git a/src/content/docs/fr/public-cloud/marketplace/valkey.md b/src/content/docs/fr/public-cloud/marketplace/valkey.md
index aa2503e..287e4ff 100644
--- a/src/content/docs/fr/public-cloud/marketplace/valkey.md
+++ b/src/content/docs/fr/public-cloud/marketplace/valkey.md
@@ -1,5 +1,5 @@
---
-title: Valkey 9.0
+title: Valkey 9.1
---
Valkey est un magasin de données en mémoire libre et haute performance, compatible avec Redis. Il
@@ -10,7 +10,7 @@ réel, la messagerie pub/sub et les files de tâches.
| Composant | Version |
| --------- | --------- |
-| Valkey | 9.0.x |
+| Valkey | 9.1.x |
| Ubuntu | 24.04 LTS |
## Variables d'environnement
diff --git a/src/content/docs/fr/public-cloud/marketplace/vaultwarden.md b/src/content/docs/fr/public-cloud/marketplace/vaultwarden.md
index de0c4cb..ed2f147 100644
--- a/src/content/docs/fr/public-cloud/marketplace/vaultwarden.md
+++ b/src/content/docs/fr/public-cloud/marketplace/vaultwarden.md
@@ -4,16 +4,20 @@ title: Vaultwarden
Vaultwarden est un gestionnaire de mots de passe léger et auto-hébergé qui implémente l'API
Bitwarden. Il est entièrement compatible avec les applications clientes et extensions de navigateur
-officielles de Bitwarden, ce qui vous permet de stocker et de synchroniser mots de passe, notes
-sécurisées et autres secrets sur une infrastructure que vous contrôlez.
+Bitwarden officielles, ce qui permet de stocker et synchroniser mots de passe, notes sécurisées et
+autres secrets sur une infrastructure que vous contrôlez.
-:::note[Bientôt disponible]
+## Logiciels inclus
-Une image Vaultwarden préconstruite arrive bientôt. Pour l'instant, déployez une instance **Ubuntu
-24.04 LTS** neuve depuis la place de marché et suivez les étapes ci-dessous pour installer
-Vaultwarden vous-même.
+| Composant | Version |
+| -------------- | --------------- |
+| Vaultwarden | 1.36.0 |
+| Docker | Dernière stable |
+| Docker Compose | Dernière stable |
+| Ubuntu | 24.04 LTS |
-:::
+Vaultwarden stocke ses données dans une base SQLite intégrée et sert le coffre web en HTTPS sur le
+port 8000 avec un certificat autosigné généré au premier démarrage.
## Prérequis
@@ -23,121 +27,102 @@ Vaultwarden vous-même.
| RAM | 1 Go | 2 Go |
| Stockage | 10 Go | 20 Go |
-Vaultwarden est léger en ressources. Un nom de domaine et un certificat TLS sont fortement
-recommandés, car les clients Bitwarden exigent HTTPS pour se connecter.
-
-## Déployer l'instance de base
+Vaultwarden consomme peu de ressources.
-1. Dans le portail ZSoftly Cloud, ouvrez **Apps** et passez à l'onglet **Marketplace**. Il s'ouvre
- sur **Featured** par défaut, sélectionnez donc **Marketplace** à côté. Choisissez votre région
- (YOW-1 ou YUL-1), recherchez **Ubuntu 24.04 LTS** et cliquez sur **Deploy**. Vous pouvez aussi
- créer l'instance depuis **Instances → Create**. Dans les deux cas, vous obtenez une VM Ubuntu
- 24.04 propre.
+## Variables d'environnement
- 
+Vous pouvez les définir au déploiement de Vaultwarden depuis la Marketplace. Laissez `ADMIN_TOKEN`
+vide pour générer automatiquement une valeur aléatoire sécurisée.
- 
+| Variable | Description |
+| -------------------- | --------------------------------------------------------------------------------------- |
+| `VAULTWARDEN_DOMAIN` | URL publique complète utilisée par les clients, par exemple `https://vault.example.com` |
+| `ADMIN_TOKEN` | Jeton du panneau `/admin` |
-2. Choisissez un plan qui répond aux prérequis ci-dessus.
+## Démarrage
-3. Lorsque l'instance est **Running**, connectez-vous en SSH:
+### 1. Se connecter à la machine virtuelle
```bash
ssh ubuntu@
```
-4. Mettez le système à jour:
-
-```bash
-sudo apt update && sudo apt upgrade -y
-```
-
-## Installer Vaultwarden
+### 2. Attendre la configuration au premier démarrage
-Vaultwarden est distribué sous forme d'image Docker officielle, installez donc d'abord Docker Engine
-et le plugin Compose.
-
-Configurez le dépôt APT officiel de Docker pour Ubuntu 24.04 LTS (`noble`):
+Au premier démarrage, un script génère un certificat TLS autosigné et le jeton administrateur, puis
+démarre le conteneur avec Docker Compose. Cela prend moins d'une minute. Suivez la progression:
```bash
-sudo apt install -y ca-certificates curl
-sudo install -m 0755 -d /etc/apt/keyrings
-sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
-sudo chmod a+r /etc/apt/keyrings/docker.asc
-sudo tee /etc/apt/sources.list.d/docker.sources >/dev/null <:8000
```
-## Configurer Vaultwarden
+Le certificat autosigné déclenche un avertissement du navigateur. Acceptez l'exception pour
+continuer. Le panneau d'administration se trouve à `https://:8000/admin`.
-:::caution
+:::note
-Les applications clientes Bitwarden refusent de se connecter en HTTP simple. N'exposez pas
-Vaultwarden directement. Placez-le toujours derrière un proxy inverse (Caddy, nginx ou Traefik) qui
-termine TLS et transfère vers le port hôte 8080.
+L'inscription libre des utilisateurs est désactivée par défaut (`SIGNUPS_ALLOWED=false`). Pour
+ajouter des utilisateurs, ouvrez le panneau d'administration et invitez-les sous **Users**, ou
+activez l'inscription ouverte sous **General Settings**.
:::
-Un proxy inverse Caddy minimal vous offre HTTPS automatique. Faites pointer le DNS de votre domaine
-vers la VM, puis:
+## Gérer Vaultwarden
+
+Vaultwarden s'exécute comme pile Docker Compose dans `/data/vaultwarden`.
```bash
-sudo apt install -y caddy
-echo 'vault.example.com {
- reverse_proxy 127.0.0.1:8080
-}' | sudo tee /etc/caddy/Caddyfile
-sudo systemctl restart caddy
+# Vérifier l'état
+cd /data/vaultwarden && docker compose ps
+
+# Redémarrer
+cd /data/vaultwarden && docker compose restart
+
+# Voir les journaux
+cd /data/vaultwarden && docker compose logs -f
```
-Définissez `DOMAIN` dans la commande `docker run` ci-dessus avec votre véritable URL `https://` afin
-que les icônes des éléments du coffre, les pièces jointes et WebAuthn fonctionnent correctement. Une
-fois TLS actif, accédez à la page d'administration à `https://vault.example.com/admin` et
-connectez-vous avec le mot de passe que vous avez haché dans `ADMIN_TOKEN`. Traitez ce jeton comme
-un mot de passe root.
+Configuration d'environnement: `/data/vaultwarden/vaultwarden.env`. La base du coffre et le
+certificat sont stockés sous `/data/vaultwarden/data`.
+
+## Sécurité
+
+Le port 8000 est ouvert sur l'interface réseau de la machine virtuelle. UFW est activé et autorise
+SSH (port 22) et le coffre web Vaultwarden (port 8000). Les clients Bitwarden exigent HTTPS, que
+l'image sert avec un certificat autosigné par défaut.
-## Ouvrir le pare-feu
+Traitez le jeton administrateur comme un mot de passe root.
-L'instance n'autorise par défaut que SSH (port 22) en externe. Ouvrez le port HTTPS que votre proxy
-inverse sert et ajoutez-le aux règles réseau/sécurité de l'instance dans le portail:
+**En production**, définissez `DOMAIN` avec l'URL publique complète utilisée par les clients, y
+compris le schéma et le port ou chemin éventuel (par exemple `https://vault.example.com` ou
+`https://:8000`), dans `/data/vaultwarden/vaultwarden.env`, remplacez le certificat
+autosigné par un certificat de confiance (ou placez Vaultwarden derrière un proxy inverse comme
+Caddy qui termine TLS), puis redémarrez la pile:
```bash
-sudo ufw allow 80/tcp
-sudo ufw allow 443/tcp
+cd /data/vaultwarden && docker compose restart
```
-## Étapes suivantes
+## Prochaines étapes
- [Documentation Vaultwarden](https://github.com/dani-garcia/vaultwarden/wiki)
-- [Guide d'installation Vaultwarden](https://github.com/dani-garcia/vaultwarden/wiki/Starting-with-Docker)
+- [Activer HTTPS](https://github.com/dani-garcia/vaultwarden/wiki/Enabling-HTTPS)
diff --git a/src/content/docs/fr/public-cloud/marketplace/zabbix.md b/src/content/docs/fr/public-cloud/marketplace/zabbix.md
index acff933..9697505 100644
--- a/src/content/docs/fr/public-cloud/marketplace/zabbix.md
+++ b/src/content/docs/fr/public-cloud/marketplace/zabbix.md
@@ -2,18 +2,19 @@
title: Zabbix
---
-Zabbix est une plateforme de supervision open source de niveau entreprise pour les réseaux,
-serveurs, services cloud et applications. Elle collecte des métriques via des agents, SNMP, IPMI et
-des contrôles sans agent, puis fournit alertes, visualisation et tableaux de bord depuis un frontend
-web unique. Ce guide installe le serveur Zabbix, le frontend web et l'agent avec une base MySQL sur
-Apache.
+Zabbix est une plateforme de supervision open source pour les réseaux, serveurs, services cloud et
+applications. Elle collecte des métriques via des agents, SNMP, IPMI et des contrôles sans agent,
+puis fournit alertes, visualisation et tableaux de bord depuis un frontend web unique. Cette image
+fournit le serveur Zabbix, le frontend web et l'agent avec une base MySQL sur Apache.
-:::note[Bientôt disponible]
+## Logiciels inclus
-Une image Zabbix préconfigurée arrive bientôt. Pour l'instant, déployez une instance **Ubuntu 24.04
-LTS** neuve depuis la marketplace et suivez les étapes ci-dessous pour installer Zabbix vous-même.
-
-:::
+| Composant | Version |
+| --------- | --------- |
+| Zabbix | 7.0 (LTS) |
+| MySQL | 8.0 |
+| Apache | 2.4.x |
+| Ubuntu | 24.04 LTS |
## Prérequis
@@ -23,111 +24,91 @@ LTS** neuve depuis la marketplace et suivez les étapes ci-dessous pour installe
| RAM | 2 Go | 4 Go |
| Stockage | 30 Go | 60 Go |
-## Déployer l'instance de base
-
-1. Dans le portail ZSoftly Cloud, ouvrez **Apps** et passez à l'onglet **Marketplace**. Il s'ouvre
- sur **Featured** par défaut, sélectionnez donc **Marketplace** à côté. Choisissez votre région
- (YOW-1 ou YUL-1), recherchez **Ubuntu 24.04 LTS** et cliquez sur **Deploy**. Vous pouvez aussi
- créer l'instance depuis **Instances → Create**. Dans les deux cas, vous obtenez une VM Ubuntu
- 24.04 propre.
-
- 
+## Variables d'environnement
- 
+Cette image n'accepte aucune variable au déploiement. Elle ne crée aucun mot de passe administrateur
+partagé. Zabbix est livré avec un mot de passe `Admin` par défaut, et le premier démarrage le
+remplace par une valeur propre à votre machine virtuelle.
-2. Choisissez un plan qui répond aux prérequis ci-dessus.
+## Démarrage
-3. Lorsque l'instance est **Running**, connectez-vous en SSH:
+### 1. Connectez-vous à votre VM
```bash
ssh ubuntu@
```
-4. Mettez le système à jour:
+### 2. Attendez la configuration au premier démarrage
+
+Au premier démarrage, un script initialise MySQL, importe le schéma Zabbix, écrit la configuration
+du frontend, démarre les services et remplace le mot de passe `Admin` par défaut. Suivez la
+progression:
```bash
-sudo apt update && sudo apt upgrade -y
+journalctl -u zabbix-first-boot.service -f
```
-## Installer Zabbix
+Le message de connexion (MOTD) confirme que Zabbix est prêt.
-Installez d'abord le serveur de base de données MySQL et Apache:
+### 3. Récupérez le mot de passe administrateur
-```bash
-sudo apt install -y mysql-server apache2
-```
-
-Ajoutez le dépôt officiel Zabbix. Zabbix 7.4 est la version stable actuelle. Installez le deb
-`zabbix-release` pour Ubuntu 24.04 (`noble`):
+Les identifiants sont écrits dans un fichier réservé à root:
```bash
-wget https://repo.zabbix.com/zabbix/7.4/release/ubuntu/pool/main/z/zabbix-release/zabbix-release_latest_7.4+ubuntu24.04_all.deb
-sudo dpkg -i zabbix-release_latest_7.4+ubuntu24.04_all.deb
-sudo apt update
+sudo cat /root/.credentials/zabbix.txt
```
-Installez les paquets du serveur, du frontend et de l'agent Zabbix:
+### 4. Ouvrez le frontend web
-```bash
-sudo apt install -y zabbix-server-mysql zabbix-frontend-php \
- zabbix-apache-conf zabbix-sql-scripts zabbix-agent2
+Ouvrez un navigateur à l'adresse:
+
+```text
+http:///zabbix/
```
-## Configurer Zabbix
+Connectez-vous en tant que `Admin` avec le mot de passe de l'étape précédente.
-1. Créez la base de données et l'utilisateur Zabbix dans MySQL:
+:::caution
- ```bash
- sudo mysql -uroot -e "CREATE DATABASE zabbix CHARACTER SET utf8mb4 COLLATE utf8mb4_bin;"
- sudo mysql -uroot -e "CREATE USER 'zabbix'@'localhost' IDENTIFIED BY 'ChangeThisPassword';"
- sudo mysql -uroot -e "GRANT ALL PRIVILEGES ON zabbix.* TO 'zabbix'@'localhost';"
- sudo mysql -uroot -e "SET GLOBAL log_bin_trust_function_creators = 1;"
- ```
+Zabbix est livré avec un mot de passe `Admin` par défaut bien connu. Cette image le remplace au
+premier démarrage, ne réutilisez donc pas la valeur par défaut documentée par le projet en amont.
-2. Importez le schéma et les données initiales (le mot de passe `zabbix` vous sera demandé):
+:::
- ```bash
- sudo zcat /usr/share/zabbix-sql-scripts/mysql/server.sql.gz \
- | mysql --default-character-set=utf8mb4 -uzabbix -p zabbix
- ```
+## Gérer Zabbix
-3. Désactivez de nouveau l'option de création de fonctions:
+```bash
+# Vérifier l'état
+sudo systemctl status zabbix-server apache2 mysql
- ```bash
- sudo mysql -uroot -e "SET GLOBAL log_bin_trust_function_creators = 0;"
- ```
+# Redémarrer le serveur
+sudo systemctl restart zabbix-server
-4. Définissez le mot de passe de la base dans `/etc/zabbix/zabbix_server.conf` en décommentant et en
- modifiant la ligne `DBPassword=` pour qu'elle corresponde au mot de passe ci-dessus.
-5. Démarrez et activez tous les services:
+# Consulter les journaux
+sudo tail -f /var/log/zabbix/zabbix_server.log
+```
- ```bash
- sudo systemctl restart zabbix-server zabbix-agent2 apache2
- sudo systemctl enable zabbix-server zabbix-agent2 apache2
- ```
+La configuration du serveur se trouve dans `/etc/zabbix/zabbix_server.conf` et celle du frontend
+dans `/etc/zabbix/web/`.
-6. Ouvrez `http:///zabbix` dans votre navigateur et complétez l'assistant de
- configuration web (connexion à la base, détails du serveur, fuseau horaire).
-7. Connectez-vous avec les identifiants par défaut **Admin** / **zabbix**, puis changez
- immédiatement le mot de passe Admin sous **Users → Users**.
-8. Pour la production, configurez Apache avec votre domaine et un certificat TLS afin que le
- frontend soit servi en HTTPS sur le port 443.
+## Sécurité
-## Ouvrir le pare-feu
+Le port 80 (frontend web) et le port 10051 (serveur Zabbix, utilisé par les agents pour remonter
+leurs données) sont ouverts sur l'interface réseau de la VM. UFW est activé et autorise ces ports
+ainsi que SSH (port 22).
-Par défaut, l'instance n'autorise que le SSH (port 22) depuis l'extérieur. Ouvrez les ports dont
-Zabbix a besoin et ajoutez-les aux règles réseau/sécurité de l'instance dans le portail:
+**Pour restreindre le frontend web à une adresse IP précise:**
```bash
-sudo ufw allow 80/tcp
-sudo ufw allow 443/tcp
-sudo ufw allow 10051/tcp
+sudo ufw delete allow 80/tcp
+sudo ufw allow from to any port 80
```
-Les ports 80/443 servent le frontend web. Le port 10051 est le port du serveur Zabbix utilisé par
-les agents actifs et les proxies qui remontent leurs données.
+**En production**, pointez un enregistrement DNS vers la VM et placez Apache derrière TLS, avec
+votre propre certificat ou un reverse proxy qui termine le TLS.
-## Étapes suivantes
+## Prochaines étapes
-- [Documentation Zabbix](https://www.zabbix.com/documentation/current/)
-- [Guide d'installation de Zabbix](https://www.zabbix.com/download)
+- [Documentation Zabbix](https://www.zabbix.com/documentation/7.0/en/)
+- [Configuration de l'agent Zabbix](https://www.zabbix.com/documentation/7.0/en/manual/appendix/config/zabbix_agentd)
+- [Référence de l'API Zabbix](https://www.zabbix.com/documentation/7.0/en/manual/api)
diff --git a/src/content/docs/fr/tutorials/index.md b/src/content/docs/fr/tutorials/index.md
index a6bf6fd..63010b7 100644
--- a/src/content/docs/fr/tutorials/index.md
+++ b/src/content/docs/fr/tutorials/index.md
@@ -38,3 +38,17 @@ Vous apprenez à :
- [Démarrage rapide Public Cloud](/fr/public-cloud/getting-started/quickstart) : le même premier
déploiement depuis le portail web
- [Journal des modifications](/fr/changelog) : les nouveautés de la plateforme
+
+### [Gérer ZCP avec Terraform ou OpenTofu](/tutorials/manage-infrastructure-terraform)
+
+Provisionnez un réseau et une machine virtuelle de manière déclarative avec le fournisseur officiel
+`zsoftly/zcp`, publié dans les registres Terraform et OpenTofu. Vous écrivez un fichier de
+configuration, l'appliquez, le modifiez et le détruisez, et chaque ressource reste suivie. Environ
+15 minutes. (Tutoriel en anglais.)
+
+Vous apprenez à :
+
+- Installer le fournisseur et vous authentifier avec un jeton API
+- Décrire un réseau et une VM en HCL puis appliquer le plan
+- Redimensionner une VM sans la recréer et importer des ressources créées ailleurs
+- Détruire la pile entière sans laisser de ressources orphelines
diff --git a/src/content/docs/index.mdx b/src/content/docs/index.mdx
index 77f222f..ee3e865 100644
--- a/src/content/docs/index.mdx
+++ b/src/content/docs/index.mdx
@@ -193,7 +193,7 @@ hero:
Terraform / OpenTofu
-
Manage ZCP infrastructure as code. Provider in development at github.com/zsoftly/terraform-provider-zcp.
+
Manage ZCP infrastructure as code. Ships as zsoftly/zcp on the Terraform and OpenTofu registries.
@@ -120,7 +120,7 @@ automatically. Credentials are generated, services are configured, and the image