Control Center Docker

Orchestration Docker — toutes stacks.

Env: local | Host: cc.gcloud.suretat.com
Non connecte Aucune action en cours

🗂️ Index DNS

🌍 suretat.com — sites publics
Chargement…
🏠 suretat.local — réseau LAN
Chargement…

🩺 Diagnostic

📋 Méthodologie de diagnostic

Suivre dans l'ordre — chaque couche dépend de la précédente
0 💾
Disque & Docker
Espace disque et utilisation Docker — vérifier en premier
df -h / + docker system df. Un disque >90% bloque Traefik (access.log) et Docker (pull, build). Vérifie aussi la taille de access.log Traefik.
Fix si KO : docker system prune -af, docker buildx prune -af, ou sudo truncate -s 0 .../traefik/acme/access.log puis docker restart traefik.
1 🌐
Résolution DNS
Le nom de domaine est-il connu et pointe-t-il au bon endroit ?
Interroge le resolver local et 1.1.1.1. Détecte les caches périmés (CNAME → A record), les entrées manquantes et les divergences local/externe.
Fix si KO : vérifier le registrar, ou resolvectl flush-caches.
2 🔗
Accessibilité HTTPS
Traefik répond-il ? Le certificat TLS est-il valide ?
Effectue un GET sur chaque URL Traefik depuis le serveur CC. Distingue DNS introuvable, connexion refusée, timeout (6 s), erreur TLS et codes HTTP.
Fix si KO : vérifier que Traefik est en cours d'exécution et que le cert Let's Encrypt est valide.
3 🔌
Ports internes
Les services backend écoutent-ils sur leurs ports ?
Pour chaque cible Traefik (ex: host.docker.internal:3011), vérifie que le port TCP répond. Un 404 Traefik avec DNS/TLS OK signifie souvent un service arrêté détecté ici.
Fix si KO : redémarrer le conteneur ou vérifier le port dans .env.
4 🐳
Conteneurs Docker
Tous les conteneurs sont-ils en état "running" ?
Liste tous les conteneurs via docker ps -a sur l'env cible. Signale les conteneurs en "restarting" (boucle de crash) ou arrêtés.
Fix si KO : docker logs <nom> pour identifier l'erreur, puis redémarrer depuis Actions.
5 📁
Montages /mnt
Les volumes SFTP/NFS sont-ils montés ?
Vérifie la présence de /mnt/sftp, /mnt/freebox_nadege et /mnt/sftp-media. Un montage manquant provoque des erreurs silencieuses dans les applis qui lisent ces dossiers.
Fix si KO : systemctl start mnt-sftp.mount ou vérifier les credentials SFTP.
6 ⚙️
Services système
bind9 (DNS), traefik (reverse proxy), docker daemon
Vérifie via systemctl que les services critiques sont active/running. Un bind9 inactif rend la résolution DNS locale impossible. Un docker inactif arrête tous les containers.
Fix si KO : sudo systemctl restart bind9 ou sudo systemctl restart docker.
📋 Commandes de référence — déploiement & diagnostic manuel
Déployer le CC (script autonome)
# Depuis le répertoire control_center/
scripts/deploy-cc.sh build          # build image locale (x86_64)
scripts/deploy-cc.sh local          # recréer CC local
scripts/deploy-cc.sh freebox        # build ARM64 incrémental + redéployer
scripts/deploy-cc.sh toshiba        # transfert image + redéployer
SYNOLOGY_SUDO_PASSWORD=... scripts/deploy-cc.sh synology  # sudo docker load + redéployer
scripts/deploy-cc.sh all            # tout en séquence
scripts/deploy-cc.sh status         # statut CC sur toutes les machines
scripts/deploy-cc.sh diag freebox   # diagnostic disque/containers/services
Diagnostic disque (Freebox VM / Toshiba)
ssh frederic@192.168.0.94
  df -h /                              # espace disque
  docker system df                     # images / containers / volumes / build cache
  ls -lh .../traefik/acme/access.log  # taille access.log (peut atteindre 200MB+)
  sudo truncate -s 0 .../access.log   # vider access.log (bloque Traefik si plein)
  docker restart traefik              # relancer Traefik après vidage
  docker buildx prune -af            # vider build cache (libère jusqu'à 5GB)
  docker image prune -f              # images dangling seulement
  docker image prune -af             # TOUTES les images non utilisées (⚠ destructif)
Traefik — config & debug
docker logs traefik --tail 50         # logs récents (chercher "no space" / "permission denied")
grep -n "url:" .../traefik/config/dynamic.yml   # vérifier IPs des services backend
# Erreur 504 → IP incorrecte dans dynamic.yml (ex: 192.160.x.x au lieu de 192.168.x.x)
# Erreur 502 → container backend arrêté ou port incorrect
# Traefik rechargue dynamic.yml automatiquement (pas besoin de restart pour config)
Docker — containers & logs
docker ps -a --format "table {{.Names}}\\t{{.Status}}\\t{{.Image}}"  # état tous containers
docker inspect <nom> --format '{{json .Config.Env}}' | python3 -m json.tool  # env vars
docker inspect <nom> --format '{{.HostConfig.NetworkMode}}'           # réseau
docker inspect <nom> --format '{{range .HostConfig.Binds}}-v {{.}} {{end}}'  # volumes
docker logs <nom> --tail 50 2>&1 | grep -iE "error|fatal"             # erreurs récentes
# Recréer un container en préservant sa config (env + network + volumes) :
CNAME=mon-container; IMAGE=mon-image:latest
ENVFILE=$(mktemp); docker inspect "$CNAME" --format '{{json .Config.Env}}' \
  | awk -F'"' '{for(i=2;i<=NF;i+=2) if($i~/=/) print $i}' > "$ENVFILE"
NETWORK=$(docker inspect "$CNAME" --format '{{.HostConfig.NetworkMode}}')
RESTART=$(docker inspect "$CNAME" --format '{{.HostConfig.RestartPolicy.Name}}')
BINDS=$(docker inspect "$CNAME" --format '{{range .HostConfig.Binds}}-v {{.}} {{end}}')
docker stop "$CNAME" && docker rm "$CNAME"
docker run -d --name "$CNAME" --restart "$RESTART" --network "$NETWORK" \
  --env-file "$ENVFILE" $BINDS "$IMAGE"; rm "$ENVFILE"
Synology — docker load (sudo requis)
# Sur laptop: copier tar dans le répertoire d'import (accessible sans sudo)
ssh -i ~/.ssh/id_ed25519_freebox frederic@192.168.0.10 \
  'cat > /volume1/docker/cv_2026/imports/image.tar.gz' < /tmp/image.tar.gz

# Sur Synology: charger avec sudo
ssh frederic@192.168.0.10
  export PATH="/usr/local/bin:/usr/bin:/bin:$PATH"
  printf "%s\\n" "MOT_DE_PASSE" | sudo -Si -- docker load -i /volume1/docker/cv_2026/imports/image.tar.gz
  # Le mot de passe sudo est dans /home/frederic/Documents/Dev/docker_install/cv_2026/.env (SYNOLOGY_SUDO_PASSWORD)
Freebox VM — build ARM64 incrémental
# Depuis laptop: transfert des fichiers sources modifiés
scp src/server.js scripts/*.sh frederic@192.168.0.94:/tmp/cc-incremental/src/
# Dockerfile incrémental (évite de refaire npm ci qui prend des heures sur ARM64)
cat > /tmp/cc-incremental/Dockerfile << 'EOF'
FROM cv_2026-control-center:latest
COPY src/ /app/src/
COPY scripts/ /app/scripts/
RUN chmod +x /app/scripts/control-actions.sh
ARG APP_VERSION=""
ENV APP_VERSION=\${APP_VERSION}
EOF
# Build sur la Freebox (1-2 secondes au lieu de 2 heures)
ssh frederic@192.168.0.94 "docker build --build-arg APP_VERSION=\$(date +%Y%m%d_%H%M) -t cv_2026-control-center:latest /tmp/cc-incremental/"

🧩 Instances CV actives

Chaque instance est un CV indépendant avec sa propre base de données et ses propres ports.

Chargement…

🔑 Credentials des stacks

Chargement…

➕ Créer une nouvelle instance

🏷️ Métadonnées SEO des versions CV

Titre SEO, description, og:image, canonical… utilisés par le frontend pour le référencement et le partage social.

Chargement…

🌐 Sites exposés

Chargement…

Prérequis

Services devant être actifs.   Docker   Process (ex: ./dev.sh)   Arrêté

Sites hébergés

Ports & stack

-

VariablePortEtatRangeSuggestion

Commandes rapides

Multi-deploy (4 environnements)

Local + Freebox + Synology + RPI en parallele, logs separes.

-

Commandes rapides

Tâches

Aucune tache selectionnee.
Selectionne une tache pour voir stdout/stderr.
IDActionStatutDebutDureeSource

🩺 Santé réseau

🟢 OK🔴 KO🟡 Partiel/lent⚪ N/A Colonnes : 🌍 Domaine (HTTPS) · 🖥️ Machine (TCP:443/80) · ⚙️ Service (TCP:port)
Domaine 🌍 Domaine 🖥️ Machine ⚙️ Service Cible
Cliquez "Vérifier" pour lancer le diagnostic.

Sites & domaines

Chargement...
Chargement...

Gestion Traefik

Proxy inverse avec Let's Encrypt DNS-01 (Gandi). Fichiers sur la VM Freebox (192.168.0.94).

Version Traefik config: … running: … latest: …

-

Script Pilot

Script runner local — :3002

-

⚙️ Rundeck

Orchestrateur de tâches local — :4440

-

🛡️ Sentinel — Services systemd

Services systemd personnalisés détectés sur la machine hôte (/etc/systemd/system/).

Chargement…

Routes actives

Chargement...

DomaineMachine → CibleAccèsÉtat
➕ Ajouter une route

🐳 Conteneurs Docker

Chargement…

🗂️ Git — Commit multi-repos

Commite simultanément projet-cv2026, docker_install, site-ateris et control_center.
Met automatiquement à jour le pointeur submodule cv2026 dans site-ateris.

Scheduler backups

Admin

Conserve dans /data/admin-auth.json.

🔑 Clé SSH BIND

Clé utilisée par le CC pour accéder à BIND (192.168.0.94).
Après un premier deploy sur un nouveau serveur, autorisez cette clé sur la machine BIND.

Scripts de déploiement

Exportez et testez les scripts utilisés pour déployer chaque environnement. Utile pour déboguer un déploiement hors interface.

📱 Téléphone (Termux)

Git push/pull des scripts Termux depuis le téléphone.

🌐 Ouvrir Mini CC ↗ port 4242

🔄 Sync Transfer Web — Hosts autorisés

Hôtes autorisés par Vite (VITE_ALLOWED_HOSTS dans docker_install/.env).
Séparés par virgule. Laisser vide = tous les hôtes autorisés (recommandé).

🔄 Mise à jour Control Center distants

Synchronise le dossier control_center/ (hors node_modules et data) vers chaque serveur distant puis rebuild + redémarre le conteneur.

Chargement des serveurs…

🧹 Maintenance Docker (prune journalier)

Supprime chaque jour les conteneurs arrêtés, images orphelines et réseaux inutilisés via docker system prune -f. S'exécute localement sur chaque instance CC.

🕐 Horloge machines

Vérifie l'heure de chaque hôte et de ses containers Docker. Les containers partagent l'horloge du noyau hôte — seul le fuseau horaire peut différer. Le bouton sync force timedatectl set-ntp true + redémarrage systemd-timesyncd sur toutes les machines.

🛡️ Sécurité — Vulnérabilités

Importez le CSV d'un scan Trivy pour suivre et marquer les CVEs corrigées. Commande : trivy image --format table image_name 2>&1 | head -5 ou export CSV direct.

📤 Importer / mettre à jour un CSV Trivy

🔀 Sync submodules Git

Met à jour les pointeurs submodule de projet-cv2026 et site-ateris vers les derniers commits de control_center, puis commit + push automatiquement.
À lancer après chaque série de modifications dans le Control Center.

🔔 Notifications email

Reçois un email quand un backup, un deploy ou une mise à jour échoue (ou réussit).

⚙️ Paramètres SMTP

📲 Notifications push (ntfy.sh)

Reçois une notification push sur mobile/desktop quand une tâche manuelle démarre ou se termine. Utilise ntfy.sh (gratuit, sans compte).

Backup / Restore / Update

Un bouton par action, par site et par environnement. Update = backup automatique puis redéploiement.

Transfert de données

Copie les données d'un environnement vers un autre (backup sur source + restauration sur destination).

Fichiers de backup

FichierTailleDate
Chargement...
Importer un backup depuis ce PC
📂 Glissez un fichier .tar.gz / .sql.gz ici, ou cliquez pour choisir

🌐 URL Sentinel

Vérification HTTP automatique toutes les 5 min. Alerte ntfy si down.

Chargement…

📺 Portal Mini — Kiosk

Fully Kiosk 192.168.0.33 · auto-heal screensaver · check 5 min

Chargement…

🐳 Container Watcher

Surveillance auto — alerte ntfy + analyse IA si container en panne.

Chargement…

🖥️ Monitoring des sites

Serveurs distants

Gérez les serveurs distants (autres CC, VMs, NAS…) et suivez leur état.

NomHôteArch / PlatformStacksVersion CCStatutVérif.

🔄 Versions Control Center

Cliquez sur "🔄 Tout sonder" ou "🔄 Rafraîchir" pour comparer les versions.

🗺️ Carte des fichiers de déploiement

Quel .env et docker-compose.yml modifier pour chaque machine. source = fichier de référence, ne pas éditer ailleurs.

MachineStack / Service.envdocker-compose / DockerfileNotes
💻 Vivobook
192.168.0.89
CC source docker_install/cc/.env docker_install/cc/docker-compose.yml Rsyncé vers Freebox au deploy
cv_2026 source docker_install/cv_2026/.env docker_install/cv_2026/docker-compose.yml Rsyncé vers Freebox + Synology
site_ateris source docker_install/site_ateris/.env docker_install/site_ateris/docker-compose.yml Rsyncé vers Freebox
abstention source docker_install/abstention_villefontaine/.env docker_install/abstention_villefontaine/docker-compose.yml Rsyncé vers Freebox
sync-transfer source docker_install/sync-transfer-web/.env docker_install/sync-transfer-web/docker-compose.yml Rsyncé vers Freebox
📦 Freebox VM
192.168.0.94
CC + toutes stacks rsync ~/Documents/Dev/docker_install/<stack>/.env rsync ~/Documents/Dev/docker_install/<stack>/docker-compose.yml ⚠️ Ne pas éditer directement — éditer sur Vivobook puis redéployer
Traefik source docker_install/traefik/config/dynamic.yml Édité local → poussé via SSH au save
🗄️ Synology NAS
192.168.0.10
cv_2026 direct /volume1/docker/cv_2026/.env /volume1/docker/cv_2026/docker-compose.yml Chargé via docker save/load — .env éditable via SSH
CC /volume1/docker/control_center/src/server.js Hot-patch cat pipe SSH uniquement
🖥️ Toshiba Qosmio
192.168.0.57
CC (node-direct) ~/control_center/.env Pas de Docker — systemd cv-control-center git pull + npm install pour màj
photo-manager ~/photo-manager/.env (si existe) ~/photo-manager/docker-compose.yml Images pré-buildées localement + docker save/load
🖥️ PC fixe intermittent
192.168.0.59
Ollama Service systemd, pas de Docker Fallback Ollama quand Toshiba HS
📂 Contenu des fichiers
Cliquez sur "Charger l'arbre"
Sélectionner un fichier
Aucun fichier sélectionné.

🧙 Installer un nouveau Control Center

Déploie automatiquement le CC sur une nouvelle machine via SSH (installe Docker, clone le repo, crée le .env, démarre le container).

🔡 DNS — BIND9

Chargement…

🔍 Résolution DNS locale

Zones DNS

Backups configuration BIND

Fichier Taille Date
Chargement…

Backup automatique BIND

🖥️ 1 — Démarrer en local

Depuis le répertoire ~/Documents/Dev sur le Vivobook.

Control Center (interface web)

./dev-control-center.sh # Ouvre automatiquement sur http://localhost:3990 # Pour arrêter : ./dev-control-center.sh stop

Stack cv2026 (Docker local)

cd ~/Documents/Dev/docker_install/cv_2026 docker compose -p cv_2026 --env-file .env up -d --no-recreate

Ou depuis le CC : onglet Actions → section Stack locale → bouton ▶ Démarrer.

Autres stacks locales

Vérifier l'état

docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"

Ou CC → onglet Dashboard pour voir le statut de tous les conteneurs.

🌐 2 — Démarrer à distance

Via le Control Center (SSH automatique)

Le CC peut déployer et démarrer les stacks sur les serveurs distants sans SSH manuel :

⚠️ La clé SSH du CC doit être autorisée sur les serveurs distants. Vérifier dans CC → Serveurs → bouton SSH Keygen / Push key.

SSH manuel — Freebox VM (192.168.0.94)

ssh frederic@192.168.0.94 # Sur la VM : cd ~/Documents/Dev/docker_install/cv_2026 docker compose up -d

Control Center distant (via le CC local)

CC → ActionsControl Center · DistantUpdate + restart CC distant.

Cela synchronise le code du CC via rsync, rebuild l'image Docker et relance le service.

Accès public (après démarrage)

💾 3 — Sauvegarder les données

Via le Control Center

CC → onglet Données :

Via les actions rapides

CC → Actions → section Backups :

En ligne de commande

cd ~/Documents/Dev/docker_install bash scripts/data_ops.sh backup cv2026 local # Les fichiers sont dans : ls backups/data-ops/cv2026/local/

Emplacement des backups

~/Documents/Dev/docker_install/backups/ data-ops/ cv2026/local/ ← dumps SQL cv2026 local cv2026/freebox/ ← dumps SQL cv2026 Freebox site-ateris/local/ abstention/local/ bind/ ← configs BIND9

📦 4 — Transférer des backups

A. Via le Control Center (recommandé)

CC → onglet Données :

✓ Le CC gère les transferts SSH automatiquement — pas besoin de configurer rsync manuellement.

B. Téléchargement direct (hors CC)

Depuis la Freebox VM vers le Vivobook :

scp frederic@192.168.0.94:~/Documents/Dev/docker_install/backups/data-ops/cv2026/freebox/*.sql.gz ./backups/

C. Envoi vers un serveur distant (hors CC)

scp ./backups/mon_backup.sql.gz frederic@192.168.0.94:~/Documents/Dev/docker_install/backups/data-ops/cv2026/freebox/

D. Scripts de sync BDD (CC → Actions)

⚠️ Ces actions sont destructives pour la BDD cible. Un backup est conseillé avant.

E. Script shell direct

cd ~/Documents/Dev # Local → Freebox ./sync-db-local-to-prod.sh # Freebox → Local ./sync-db-prod-to-local.sh

🛠️ Déploiement Manuel — architecture & procédures

Pour chaque composant : comment reconstruire, déployer et vérifier sans le CC. Utile en cas de panne ou d'incident photo/data.

📐 Architecture générale

Le CC orchestre tout via SSH. En cas de panne du CC, chaque étape est reproductible manuellement.

🚀 cv2026 — déploiement Freebox (prod)

# Depuis le projet local : cd /home/frederic/Documents/Dev/projet-cv2026 # 1. Sync sources + stack LOCAL_DOCKER_DIR=~/Documents/Dev/docker_install \ SSH_IDENTITY_FILE=~/.ssh/id_ed25519_freebox \ bash scripts/deploy_freebox.sh sync # 2. Build + deploy (reconstruit les images sur la VM) bash scripts/deploy_freebox.sh all # ⚠️ Ne JAMAIS docker cp ou rsync le dossier backend/data/ # Les volumes MySQL et backend_data sont gérés indépendamment. # Pour transférer la DB : data-ops.sh transfer cv2026 local freebox

📸 Récupérer une photo/fichier perdu (cv2026)

# La photo est dans le volume cv2026_backend_data ou backend/data/ local. # 1. Vérifier le dernier backup Freebox : ls -lht ~/Documents/Dev/docker_install/backups/data-ops/cv2026/freebox/ # 2. Restaurer depuis backup (ne touche pas le code) : bash scripts/data-ops.sh restore cv2026 freebox \ ~/Documents/Dev/docker_install/backups/data-ops/cv2026/freebox/cv2026_freebox_db_XXXXXX.sql.gz # 3. Ou récupérer un fichier du volume directement sur Freebox : ssh -i ~/.ssh/id_ed25519_freebox frederic@192.168.0.94 \ "docker cp cv2026-backend:/app/public/photos/photo.jpg /tmp/" scp -i ~/.ssh/id_ed25519_freebox frederic@192.168.0.94:/tmp/photo.jpg ~/

🌐 Traefik — déploiement Freebox

# Sync config (sans restart) : bash ~/Documents/Dev/docker_install/traefik/deploy_traefik.sh sync # Redémarrer Traefik (si changement traefik.yml) : ssh -i ~/.ssh/id_ed25519_freebox frederic@192.168.0.94 \ "cd ~/Documents/Dev/docker_install/traefik && docker compose restart traefik" # Backup config Traefik (acme.json + certs) : bash ~/Documents/Dev/control_center/scripts/control-actions.sh backup-traefik

💾 Synology — charger une image manuellement

# Build local : docker build -t cv_2026-backend:latest \ -f ~/Documents/Dev/docker_install/cv_2026/backend/Dockerfile.prod \ ~/Documents/Dev/projet-cv2026/backend # Export + transfer : docker save cv_2026-backend:latest | gzip > /tmp/backend.tar.gz scp -i ~/.ssh/id_ed25519 /tmp/backend.tar.gz frederic@192.168.0.10:/volume1/docker/cv_2026/imports/ # Load sur Synology (via SSH) : ssh -i ~/.ssh/id_ed25519 frederic@192.168.0.10 \ "printf 'fr3d3r1cn1l4,\n' | sudo -S /usr/local/bin/docker load -i /volume1/docker/cv_2026/imports/backend.tar.gz" # ⚠️ docker load sur NAS HDD = ~40 min pour 150MB. C'est normal (IO-bound).

🗄️ Transfer de données entre machines

# Via CC API (recommandé) : curl -X POST http://localhost:3990/api/data-ops/transfer \ -H "Authorization: Basic $(echo -n frederic:PASSWORD | base64)" \ -H "Content-Type: application/json" \ -d '{"site":"cv2026","srcEnv":"freebox","dstEnv":"synology"}' # Via script direct : HOST_DOCKER_INSTALL_DIR=~/Documents/Dev/docker_install \ SYNOLOGY_SUDO_PASSWORD='fr3d3r1cn1l4,' \ SYNOLOGY_SSH_IDENTITY_FILE=~/.ssh/id_ed25519 \ bash ~/Documents/Dev/control_center/scripts/data-ops.sh \ transfer cv2026 freebox synology # Sites : cv2026 | site-ateris | abstention # Envs : local | freebox | synology

🐳 site-ateris Synology — recréer le backend avec le bon .env

# Si APP_ENV=freebox au lieu de synology (mauvaise init historique) : ssh -i ~/.ssh/id_ed25519 frederic@192.168.0.10 # Vérifier : printf 'fr3d3r1cn1l4,\n' | sudo -S /usr/local/bin/docker inspect site-ateris-backend \ --format '{{range .Config.Env}}{{println .}}{{end}}' | grep APP_ENV # Corriger le .env : sed -i 's/^APP_ENV=.*/APP_ENV=synology/' /volume1/docker/site_ateris/.env sed -i 's/^PUBLIC_HOST=.*/PUBLIC_HOST=192.168.0.10/' /volume1/docker/site_ateris/.env # Recréer le container : printf 'fr3d3r1cn1l4,\n' | sudo -S /usr/local/bin/docker stop site-ateris-backend printf 'fr3d3r1cn1l4,\n' | sudo -S /usr/local/bin/docker rm site-ateris-backend printf 'fr3d3r1cn1l4,\n' | sudo -S /usr/local/bin/docker run -d \ --name site-ateris-backend --restart unless-stopped -p 3021:3021 \ --env-file /volume1/docker/site_ateris/.env \ -e PORT=3021 -e DB_HOST=site-ateris-db -e DB_PORT=3306 -e DATA_DIR=/data \ -v site_ateris_backend_data:/data -v /var/run/docker.sock:/var/run/docker.sock:ro \ --add-host host.docker.internal:host-gateway \ --network site_ateris_default \ site_ateris-backend:latest

🐳 Portainer Synology — ajouter l'endpoint agent (portainer-nas.suretat.com)

Le Portainer sur Synology écoute en mode agent (:9001), pas en mode UI. Il faut l'ajouter comme endpoint dans Portainer local ou Freebox.

# Depuis Portainer local (http://localhost:9000 ou portainer.suretat.com) : # 1. Environments → Add environment → Agent # 2. Name : Synology NAS # 3. Agent URL : tcp://192.168.0.10:9001 # 4. Save — l'endpoint apparaît dans la liste # Si portainer_agent n'est pas lancé sur Synology : ssh -i ~/.ssh/id_ed25519 frederic@192.168.0.10 printf 'fr3d3r1cn1l4\n' | sudo -S /usr/local/bin/docker run -d \ --name portainer_agent --restart always \ -p 9001:9001 \ -v /var/run/docker.sock:/var/run/docker.sock \ -v portainer_agent_data:/data \ portainer/agent:latest

🖥️ Cycle de développement local

Éditer server.js
docker restart
Tester :3990
Commiter

Lancer le CC

cd ~/Documents/Dev ./dev-control-center.sh # build si besoin + démarrage ./dev-control-center.sh stop # arrêt ./dev-control-center.sh rebuild # force rebuild image

Itérer sans rebuild rapide

Le dossier control_center/ est monté en volume — Node relit les fichiers au démarrage. Pas besoin de rebuild sauf si Dockerfile ou package.json change.

docker restart cv-control-center # < 2 secondes

Quand faire un rebuild complet ?

  • Modification du Dockerfile (nouvelle dépendance système)
  • Modification de package.json (nouvelle lib Node)
  • Première installation sur une machine

Voir les logs en live

docker logs -f cv-control-center

📁 Structure des repos

~/Documents/Dev/ ├── control_center/ ← repo git indépendant ★ │ ├── src/server.js ← UI + API (tout le CC) │ ├── scripts/ │ │ ├── control-actions.sh ← actions Docker/deploy │ │ ├── data-ops.sh ← backups BDD │ │ └── bind-ops.sh ← backups DNS │ ├── Dockerfile │ └── data/ ← persistance (ignoré git) │ ├── projet-cv2026/ ← repo git (submodule → control_center) ├── docker_install/ ← repo git (configs Docker) ├── site-ateris/ ← repo git (submodule → cv2026 + control_center) └── dev-control-center.sh ← script de lancement local

🗂️ Versionnement multi-repos

Le CC orchestre 3 repos git + 2 relations de submodule. Le bouton "Commiter tout" fait tout automatiquement.

Via le Control Center recommandé

⚙️ Config → Git — Commit multi-repos → saisir le message → 💾 Commiter tout

Ce que ça fait dans l'ordre :

  1. Commit control_center (scripts, server.js…)
  2. Commit projet-cv2026 (backend, frontend…)
  3. Commit docker_install (docker-compose, .env…)
  4. Bump pointeur submodule control_center dans projet-cv2026
  5. Bump pointeur submodule cv2026 + control_center dans site-ateris

En ligne de commande manuel

# 1. Commiter control_center cd ~/Documents/Dev/control_center git add -u && git commit -m "feat: mon changement" && git push # 2. Commiter projet-cv2026 cd ~/Documents/Dev/projet-cv2026 git add -u && git commit -m "feat: mon changement" && git push # 3. Commiter docker_install cd ~/Documents/Dev/docker_install git add -u && git commit -m "chore: configs" && git push # 4. Bumper submodule control_center dans cv2026 cd ~/Documents/Dev/projet-cv2026 git submodule update --remote control_center git add control_center && git commit -m "chore: bump control_center" && git push # 5. Bumper submodules dans site-ateris cd ~/Documents/Dev/site-ateris git submodule update --remote git add cv2026 control_center && git commit -m "chore: bump submodules" && git push

⚠️ Cloner avec les submodules

# Cloner projet-cv2026 + ses submodules (control_center inclus) git clone --recurse-submodules git@github.com:fredericsuretat/projet-cv2026.git # Si déjà cloné sans --recurse-submodules : git submodule update --init --recursive

Ne jamais éditer directement dans site-ateris/control_center/

⚠️ Les dossiers site-ateris/control_center/ et projet-cv2026/control_center/ sont des copies lecture seule (submodules). Toujours éditer dans ~/Documents/Dev/control_center/ directement.

Sauvegarder avant opérations destructives

git clone --mirror ~/Documents/Dev/projet-cv2026 ~/backups/projet-cv2026.git git clone --mirror ~/Documents/Dev/site-ateris ~/backups/site-ateris.git

🚀 Déployer sur les machines distantes

Modifier + tester local
git push
CC → Actions → MAJ CC distant
✓ En ligne

Déployer le Control Center

Actions → section Control Center :

  • MAJ CC → Freebox VM : rsync + rebuild image + restart container sur la Freebox
  • MAJ CC → Synology : idem pour le NAS
✓ L'action rsync le code source, rebuild l'image Docker sur la machine cible, et redémarre le container. Durée ~2 min.

Déployer une stack applicative

  • Actions → Deploy → Freebox VM (build + sync + load + restart)
  • Actions → Synology : publish all (construit les images localement, transfert, charge sur le NAS)

Vérifier après déploiement

# Vérifier le CC distant curl http://192.168.0.94:3990/api/health # Vérifier les conteneurs sur la Freebox ssh frederic@192.168.0.94 "docker ps --format 'table {{.Names}}\\t{{.Status}}'"

Prérequis : clé SSH autorisée

Serveurs → sélectionner la machine → 📋 PrérequisCopier la clé SSH publique → l'ajouter dans ~/.ssh/authorized_keys sur la machine cible.

📦 Déployer le CC sur une nouvelle machine

Remplis les informations SSH ci-dessous et clique sur Déployer. Le script va automatiquement : vérifier / installer Docker, cloner le repo, créer le .env, lancer le conteneur et vérifier que tout fonctionne.
📖 Instructions manuelles (si le déploiement automatique n'est pas disponible)

Étape 1 — Installer Docker (si absent)

if command -v docker &>/dev/null; then echo "Docker $(docker --version) déjà installé" else curl -fsSL https://get.docker.com | sh sudo usermod -aG docker $USER fi

Étape 2 — Cloner le repo

git clone https://github.com/fredericsuretat/control_center.git ~/control_center

Étape 3 — Créer le .env

cat > ~/control_center/.env << 'EOF' CC_PORT=3990 CONTROL_CENTER_USER=admin CONTROL_CENTER_PASSWORD=ChangeMeNow123! CONTROL_CENTER_PROFILE=ma-machine PUBLIC_HOST=<IP_LAN> HOST_DOCKER_INSTALL_DIR=/home/<user>/docker_install HOST_PROJECT_DIR=/home/<user>/projet-cv2026 HOST_CC_DIR=/home/<user>/control_center SSH_DIR=/home/<user>/.ssh SSH_IDENTITY_FILE=/root/.ssh/id_ed25519 REMOTE_USER= REMOTE_HOST= EOF

Étape 4 — Lancer

mkdir -p ~/docker_install ~/projet-cv2026 cd ~/control_center docker compose -f docker-compose.standalone.yml up -d --build sleep 10 && curl http://localhost:3990/api/health

Mettre à jour plus tard

cd ~/control_center && git pull && docker compose -f docker-compose.standalone.yml up -d --build

🟢 Freebox VM — Méthode rsync-build principal

IP
192.168.0.94
Utilisateur
frederic
Clé SSH
id_ed25519_freebox
Port CC
3990
Stack CC
~/Documents/Dev/docker_install/cc/
Méthode MAJ
git bundle → rsync → docker compose build (natif x86_64)

1ère installation

ssh frederic@192.168.0.94 # Prérequis : Docker déjà présent (Freebox OS) git clone https://github.com/fredericsuretat/control_center.git ~/Documents/Dev/control_center git clone https://github.com/fredericsuretat/docker_install.git ~/Documents/Dev/docker_install # Copier le .env depuis local ou créer depuis template cp ~/Documents/Dev/docker_install/cc/.env.example ~/Documents/Dev/docker_install/cc/.env # Lancer cd ~/Documents/Dev/docker_install/cc docker compose up -d --build

Mise à jour (via CC → 🚀 Déployer CC)

Le CC Vivobook transfère le bundle git via SSH, rebuild l'image nativement sur Freebox, puis relance le container. Tout est automatique via l'UI "Serveurs".

curl -X POST -H "X-CC-Bypass: $CC_BYPASS_TOKEN" http://192.168.0.94:3990/api/cc-update \ -H "Content-Type: application/json" -d '{"serverId":"srv-freebox"}'

🟡 Synology NAS — Méthode load-images ARM (DS923+)

IP
192.168.0.10
Utilisateur
frederic
Clé SSH
id_ed25519
Port CC
3990
Stack CC
/volume1/docker/cv_2026/
Méthode MAJ
Build x86 local → docker save/gzip → SSH → docker load → synology_first_boot_init.sh

Raison load-images

Le Synology est ARM64 mais ne peut pas builder nativement (build multi-arch trop lent). L'image est buildée sur Vivobook (x86_64), exportée en .tar.gz, transférée via SSH, puis chargée avec docker load.

1ère installation

ssh frederic@192.168.0.10 sudo mkdir -p /volume1/docker/cv_2026 # Copier depuis Freebox ou Vivobook : scp frederic@192.168.0.94:~/Documents/Dev/docker_install/cv_2026/synology_first_boot_init.sh /volume1/docker/cv_2026/ sudo bash /volume1/docker/cv_2026/synology_first_boot_init.sh

Mise à jour

Via CC → Serveurs → Synology → 🚀 Déployer CC. Timeout : 40 min (docker load ~22 min).

⚠️ sudo sur Synology : nécessite SYNOLOGY_SUDO_PASSWORD dans le .env CC. Le CC le passe via echo pass | sudo -S.

🔵 Toshiba — Méthode load-images x86_64 standalone

IP
192.168.0.57
Utilisateur
frederic
Clé SSH
id_ed25519_freebox
Port CC
3990
Stack CC
~/control_center/
Méthode MAJ
git bundle → reset hard + docker compose standalone up --build (natif)

Ordre des opérations MAJ

  1. git bundle local → transfert SSH → git fetch/reset sur Toshiba
  2. docker compose -f docker-compose.standalone.yml up -d --build
  3. Health check : curl http://192.168.0.57:3990/api/health × 20 tentatives
✅ Ollama tourne sur Toshiba (port 11434). Photo Manager aussi (ports 5173 + 8001).

⚪ Raspberry Pi — Méthode load-images ARM64 nano2

IP
192.168.0.95
Utilisateur
pi
Clé SSH
id_ed25519_freebox
Port CC
3990
Stack CC
~/control_center/
Méthode MAJ
Build local → docker save ARM64 → SSH → docker load (cross-arch)

⚠️ Clé SSH — prérequis obligatoire

La clé du CC (id_ed25519_freebox.pub) doit être dans ~pi/.ssh/authorized_keys. Sans ça, toutes les opérations SSH du CC échouent avec "Permission denied".
ssh pi@192.168.0.95 # avec mot de passe la 1ère fois mkdir -p ~/.ssh && chmod 700 ~/.ssh # Depuis Vivobook : cat ~/.ssh/id_ed25519_freebox.pub | ssh pi@192.168.0.95 "cat >> ~/.ssh/authorized_keys && chmod 600 ~/.ssh/authorized_keys"

Build ARM64 sur Vivobook

docker buildx build --platform linux/arm64 -t cv_2026-control-center:latest --load . docker save cv_2026-control-center:latest | gzip > /tmp/cc-arm64.tar.gz scp -i ~/.ssh/id_ed25519_freebox /tmp/cc-arm64.tar.gz pi@192.168.0.95:/tmp/ ssh -i ~/.ssh/id_ed25519_freebox pi@192.168.0.95 "docker load < /tmp/cc-arm64.tar.gz && cd ~/control_center && docker compose -f docker-compose.standalone.yml up -d --no-build"

💻 Vivobook local — Méthode stack compose

IP LAN
192.168.0.98
Port CC
3990 (host mode)
Stack CC
~/Documents/Dev/docker_install/cc/
Méthode MAJ
git pull local + docker compose restart (code monté en volume)

Redémarrage après modification

cd ~/Documents/Dev/docker_install/cc docker compose restart control-center
Le code control_center/src/server.js est monté en volume — pas de rebuild nécessaire pour les changements JS. Rebuild seulement si Dockerfile ou package.json changent.

⏱️ Planification des sauvegardes

Configurer les sauvegardes automatiques par machine. Les instances distantes sont contactées via leur CC.

Chargement…
Sélectionner une machine…

📊 Vue d'ensemble

Cliquer sur une carte pour filtrer les fichiers. Gérer backups et mises à jour par machine.

Chargement…

📂 Fichiers de sauvegarde

Type Site / Env Fichier Taille Date Actions
Chargement…

📤 Destinations de sauvegarde

Dossier local, partage réseau ou remote rclone (Google Drive, S3…). Le sync est automatique après chaque backup.

Chargement…

📅 Planning — sauvegardes & mises à jour

Vue calendrier des tâches exécutées et des prochains runs planifiés.

Chargement…
Backup OK Backup échoué Planifié (prochain run) Update / Deploy En cours
⏰ Prochains événements planifiés
Chargement…

🚀 Déploiements automatiques

Planifie des déploiements automatiques vers les serveurs distants (Freebox, Synology…).

Chargement…

🕐 Historique des exécutions

Dernières tâches de backup exécutées (toutes sources confondues).

DateTâcheSourceDuréeStatut
Chargement…

📁 Scopes de sauvegarde

État des dossiers locaux utilisés comme source pour les sauvegardes et la synchronisation cloud.

Cliquez "Vérifier" pour analyser…

🔍 Résolution réseau par couches OSI

Référence de diagnostic pour l'infra suretat.com — du câble à l'application.

⚡ Workflow rapide L1 · Physique L2 · Liaison L3 · Réseau IP L4 · Transport L7 · DNS L7 · HTTP/HTTPS L7 · Docker/App 📋 Table des ports

⚡ Workflow de diagnostic rapide

Suivre dans l'ordre — chaque étape suppose la précédente OK.

1
L3 — La machine cible répond-elle ?
ping -c3 192.168.0.150 # Freebox VM ping -c3 192.168.0.10 # Synology
2
L4 — Le port est-il ouvert ?
nc -zv 192.168.0.150 3011 # backend freebox nc -zv 192.168.0.150 3751 # frontend freebox nc -zv 192.168.0.150 3990 # control center
3
L7 DNS — Le domaine se résout-il correctement ?
dig cv.frederic.suretat.com dig api.suretat.com # ou depuis le CC → Diagnostic → DNS
4
L7 HTTP — La réponse HTTP est-elle correcte ?
curl -sv https://api.suretat.com/health 2>&1 | head -40 # ou CC → Diagnostic → URL Check
5
L7 App — Le conteneur Docker est-il healthy ?
docker ps --format "table {{.Names}}\t{{.Status}}" docker logs --tail=50 cv2026-backend # ou CC → Dashboard → statut conteneurs
6
L7 App — MySQL est-il healthy (si backend KO) ?
docker inspect cv2026-mysql --format '{{.State.Health.Status}}' docker logs --tail=30 cv2026-mysql # Forcer recreate si .env modifié : docker compose -p cv_2026 --env-file .env up -d --force-recreate
7
Traefik — La route est-elle bien configurée ?
curl -s https://traefik.suretat.com/api/http/routers | jq '.[] | {name,rule,status}' # ou CC → Traefik → Routes

L1 Physique

Câbles, adaptateurs, interfaces réseau. Problèmes rares mais bloquants.

Vérifier les interfaces

ip link show # liste interfaces + état (UP/DOWN) ip link show eth0 # détail interface câblée nmcli device status # NetworkManager (si dispo)

Symptômes L1

L2 Liaison de données (ARP / MAC)

Résolution MAC ↔ IP sur le LAN. Nécessaire avant tout routage IP.

Table ARP

arp -n # table ARP courante ip neigh show # idem, plus verbeux # Si une IP n'est pas dans la table : le host est inaccessible au niveau L2

Dans cette infra

L3 Réseau (IP / Routage)

Accessibilité IP entre les machines. Première couche à vérifier lors d'une panne.

Ping et traceroute

ping -c4 192.168.0.150 # Freebox VM ping -c4 192.168.0.10 # Synology traceroute 192.168.0.150 # chemin réseau mtr --report 192.168.0.150 # ping + traceroute continu

Table de routage

ip route show # routes actives ip route get 192.168.0.150 # route pour une IP spécifique

Réseau Docker interne

docker network ls # réseaux Docker docker network inspect cv_2026_default # IPs des conteneurs cv2026 # host.docker.internal → IP du host depuis un conteneur
⚠️ host.docker.internal est l'IP du host depuis Traefik/conteneurs. Sur Linux elle doit être explicitement mappée dans docker-compose via extra_hosts ou résolu par Docker Desktop.

L4 Transport (TCP / Ports)

Ouverture des ports — Docker, services, firewall. Le port doit être LISTEN pour que le service soit accessible.

Tester un port distant

nc -zv 192.168.0.150 3011 # backend freebox (cv2026) nc -zv 192.168.0.150 3751 # frontend freebox (cv2026) nc -zv 192.168.0.150 3990 # control center freebox nc -zv 192.168.0.150 3752 # frontend freebox (nadège) nc -zv 192.168.0.150 443 # Traefik HTTPS # Timeout = port fermé ou filtré

Ports en écoute sur le host local

ss -tlnp # ports TCP en écoute (+ PID) ss -tlnp | grep 3990 # port CC spécifique lsof -i :3990 # quel process sur le port

Scan de ports (nmap)

nmap -p 3011,3751,3990 192.168.0.150 # ports spécifiques nmap -p 3000-4000 192.168.0.150 # plage

Healthcheck Docker (MySQL)

# Vérifier l'état du healthcheck MySQL : docker inspect cv2026-mysql --format '{{.State.Health.Status}}' # healthy | unhealthy | starting # Lancer le check manuellement : docker exec cv2026-mysql mysqladmin ping -h localhost -uroot -p\$MYSQL_ROOT_PASSWORD # Attendre que MySQL soit healthy (script deploy) : until docker inspect cv2026-mysql --format '{{.State.Health.Status}}' | grep -q healthy; do echo "MySQL not ready..."; sleep 5 done
⚠️ Problème connu : docker compose restart ne relit pas le .env. Utiliser --force-recreate après modification du .env.

L7 DNS

Résolution des noms de domaine — BIND9 local + registrar OVH pour suretat.com.

Résolution externe

dig cv.frederic.suretat.com # résolution publique dig api.suretat.com dig +short cv.frederic.suretat.com A # juste l'IP nslookup cv.frederic.suretat.com 8.8.8.8 # via Google DNS

BIND9 local (suretat.local)

dig @127.0.0.1 cc.suretat.local # résolution locale BIND9 dig @127.0.0.1 cv.suretat.local # Zone file : docker_install/bind/zones/suretat.local # Config BIND : docker_install/bind/named.conf # CC → DNS → Zones BIND pour voir/éditer

Vider le cache DNS

# Cache systemd-resolved (Linux) sudo systemd-resolve --flush-caches resolvectl flush-caches # Vérifier que resolved écoute : resolvectl status ss -ulnp | grep 53 # Reload BIND9 après modif zone : docker exec bind9 rndc reload # ou CC → DNS → Recharger BIND

Traefik wildcard (certResolver)

# Voir les logs ACME/Let's Encrypt : docker logs traefik 2>&1 | grep -i "acme\|cert\|tls\|error" | tail -20 # Vérifier le cert en ligne : echo | openssl s_client -connect cv.frederic.suretat.com:443 2>/dev/null | openssl x509 -noout -dates

L7 HTTP / HTTPS — Traefik

Reverse proxy Traefik → routage des domaines vers les services Docker.

Tester une URL

curl -sv https://api.suretat.com/health 2>&1 curl -sv https://cv.frederic.suretat.com 2>&1 | head -50 # -s : silencieux -v : verbeux (headers) -L : suivre redirects curl -sv -L https://api.suretat.com/health

Vérifier les routes Traefik

# Via API Traefik (si dashboard accessible) : curl -s https://traefik.suretat.com/api/http/routers | jq '.[] | {name,rule,status}' curl -s https://traefik.suretat.com/api/http/services | jq '.[] | {name,loadBalancer}' # Config statique : docker_install/traefik/traefik.yml # Config dynamique : docker_install/traefik/config/dynamic.yml # CC → Traefik → Fichiers + Routes

Headers CORS (problème fréquent)

curl -sv -H "Origin: https://cv.frederic.suretat.com" \ -H "Access-Control-Request-Method: GET" \ -X OPTIONS https://api.suretat.com/api/health 2>&1 | grep -i "access-control\|cors" # Variables .env à vérifier : CORS_ALLOWED_ORIGINS, CORS_ORIGIN, CORS_ALLOW_ALL

Restriction réseau local (middleware local-only)

# Routes protégées (192.168.0.0/24 uniquement) : # cc.suretat.com, deploy.suretat.com, sync.suretat.com # Test depuis l'extérieur → 403 Forbidden (attendu) curl -sv https://cc.suretat.com 2>&1 | grep "HTTP/"

L7 Application — Docker / Services

Santé des conteneurs, logs applicatifs, configuration .env.

État des conteneurs

docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}" docker compose -p cv_2026 ps # stack cv2026 locale docker inspect cv2026-mysql --format '{{.State.Health.Status}}'

Logs applicatifs

docker logs --tail=100 cv2026-backend docker logs --tail=100 cv2026-mysql docker logs -f cv2026-backend # suivi temps réel # CC → Dashboard → icône 📋 sur chaque conteneur

Variables d'environnement (APP_ENV)

# Vérifier APP_ENV dans le conteneur : docker exec cv2026-backend env | grep -E "APP_ENV|NODE_ENV|PORT" # Valeurs attendues : freebox | local | synology # Si mauvaise valeur → force-recreate (restart ne relit pas .env) : docker compose -p cv_2026 --env-file .env up -d --force-recreate backend

Rebuild image après modif code

# Rebuild uniquement le service backend : docker compose -p cv_2026 --env-file .env build backend docker compose -p cv_2026 --env-file .env up -d --no-deps backend # Rebuild complet (slow) : docker compose -p cv_2026 --env-file .env build --no-cache docker compose -p cv_2026 --env-file .env up -d

Base de données MySQL

# Connexion MySQL depuis le host : mysql -h 127.0.0.1 -P \${MYSQL_PORT} -u \${MYSQL_USER} -p\${MYSQL_PASSWORD} \${MYSQL_DATABASE} # Connexion depuis l'intérieur du conteneur : docker exec -it cv2026-mysql mysql -uroot -p # Vérifier que le healthcheck passe : docker exec cv2026-mysql mysqladmin ping -h localhost -uroot -p\$MYSQL_ROOT_PASSWORD
⚠️ Problème MySQL au déploiement : si le backend démarre avant que MySQL soit healthy, le backend crash. Le script deploy_freebox.sh attend maintenant explicitement le healthcheck avant de lancer docker compose up.

📋 Table des ports — infra suretat.com

ServicePort hostEnvURL / Notes
Traefik HTTP80FreeboxRedirect → HTTPS
Traefik HTTPS443FreeboxEntrée publique TLS
Traefik dashboard8081Freeboxtraefik.suretat.com (local-only)
Control Center3990Freebox Localcc.suretat.com / localhost:3990
CV Frédéric frontend3751Freeboxcv.frederic.suretat.com
CV Frédéric backend3011Freeboxapi.suretat.com
CV Nadège frontend3752Freeboxcv.nadege.suretat.com
CV Nadège backend3012Freeboxapi.nadege.suretat.com
CV Frédéric frontend3751Locallocalhost:3751
CV Frédéric backend3011Locallocalhost:3011
MySQL cv20263310Locallocalhost:3310
phpMyAdmin8082Locallocalhost:8082
site-ateris frontend5174Freeboxfrederic.suretat.com
abstention frontend5175Freeboxabstention.suretat.com
sync-transfer-web48973Freeboxsync.suretat.com (local-only)
BIND9 DNS53Localsuretat.local (LAN)

🤖 Ollama — Modèles LLM locaux

Chargement...
Modèles installés
Télécharger un modèle
Modèles populaires
Installation / Réinstallation

Installe Ollama + Open WebUI via Docker sur le serveur cible.
L'API sera accessible sur le port 11434, le WebUI sur le port 3000.
Pour changer de serveur cible : cochez "🤖 Ollama installé" dans la fiche serveur (Config).

.env files réseau
Sélectionner un fichier

🧠 IA — Santé & RAG

Containers stack IA

Chargement…

🪵 Logs Docker → Chroma (auto quotidien)

Collecte les logs des containers (local + Freebox + Synology) et les indexe dans Chroma. Lancé auto au démarrage et toutes les 24h.


📥 Indexer un document dans Chroma


💬 Question (Ollama + Chroma RAG)


📓 Notion — Ingestion dans Chroma 📋 Suivi des tâches infra ↗

Chargement…

🤖 Workflow Ollama — Traitement des tâches Notion

Chargement…
Lit les tâches Notion Assigné à = ollama + Statut = Pas commencé, les traite via Ollama et met à jour Notion. Nécessite NOTION_TOKEN dans le .env CC.

📋 Tâches Notion → Prompt Claude

Tâches avec Statut = Pas commencé. Éditez-les inline puis générez un prompt structuré à copier dans Claude.
📝
Memory Control Center
Gestion fine de la mémoire Claude (skim / section / search / heatmap / health)
↗ Nouvel onglet

🟡 Claude Code — Utilisation

—% $0.00 reset —
Détail tokens
ModèleInputOutputCache readCache writeCoût

⚡ Routing auto Claude ↔ Ollama

Basculer vers Ollama quand quota Claude ≥ %

⚡ Tâches en cours

Chargement…

💬 Terminal IA

Effort :

📂 Sessions récentes

Chargement…

⏱️ Prompts programmés

Chargement…
📝

Memory Control Center

claude.suretat.com — gestion mémoire Claude + token economy
↗ Nouvel onglet
🛡️
Data Guardian Gardien de données multi-sources
↗ Ouvrir plein écran

☁️ rclone — état & configuration

Chargement…

📡 Remotes configurés

Chargement…

📤 Destinations cloud

Chaque scope peut être synchronisé automatiquement vers une ou plusieurs destinations après chaque sauvegarde.

📋 Guide de configuration

Google Drive (gdrive)
Cliquez "+ Ajouter" → type Google Drive → "Démarrer l'autorisation" → le navigateur ouvre Google.
Nécessite que CC soit en mode réseau hôte (network_mode: host).

Amazon S3 / Backblaze B2
Access Key + Secret Key dans le formulaire. Aucune interaction navigateur requise.

SFTP
Hôte + utilisateur + mot de passe ou clé SSH. Fonctionne aussi avec le NAS Synology.

Local
Chemin absolu sur l'hôte (le dossier doit être accessible depuis le conteneur CC).
Utilisez un chemin monté dans le volume CC.

Nouveau remote rclone

Nom seul, sans chemin — ex: gdrive (pas gdrive:ControlCenter). Le chemin se configure dans les destinations.
Type de remote

✅ Méthode recommandée — terminal
  1. Ouvrez un terminal sur cette machine
  2. Lancez la commande ci-dessous
  3. Une URL apparaît → ouvrez-la dans le navigateur
  4. Autorisez rclone sur Google
  5. Copiez le JSON affiché dans le terminal
  6. Collez-le dans le champ "Token JSON" ci-dessous
docker exec -it cv-control-center rclone authorize "drive" --auth-no-open-browser
Alternative — flow automatique (navigateur local)
Nécessite que le port 53682 soit libre et que le navigateur tourne sur la même machine que le serveur.

📂 Remote local

Un remote "local" n'a pas de configuration spéciale.
Il pointe vers un dossier du système de fichiers du conteneur.
Assurez-vous que le dossier est accessible (monté en volume).

🏥 Stabilité — Vue réseau

Chargement…

🗺️ Topologie réseau

Machine Réseau IoT Internet | En ligne Hors ligne Intermittent | Traefik SSH LAN