Intro:

Dans cet article, je vous guide pas à pas pour mettre en place une sauvegarde automatique de votre configuration Home Assistant vers un dépôt GitHub.

L’objectif est simple : conserver un historique propre de ses fichiers de configuration, retrouver facilement une ancienne version et sécuriser son installation domotique en cas de mauvaise manipulation.

Cette méthode ne remplace pas les sauvegardes complètes de Home Assistant, mais elle est très pratique pour suivre les modifications des fichiers YAML, des scripts, des automatisations, des tableaux de bord ou des fichiers personnalisés.

Prérequis

Avant de commencer, il faut disposer de :

• Home Assistant OS ou Home Assistant Supervised avec accès au dossier /config.
• L’add-on Terminal & SSH ou un accès SSH équivalent.
• Éventuellement l’add-on Studio Code Server pour modifier les fichiers plus confortablement.
• Un compte GitHub.
• Un dépôt GitHub, privé de préférence.
• Quelques notions de base en ligne de commande.

L’accès au terminal est indispensable, car nous allons initialiser un dépôt Git directement dans le dossier de configuration de Home Assistant.

Créer un dépôt GitHub

Connectez-vous à GitHub, puis créez un nouveau dépôt.

Je conseille de choisir un dépôt privé, afin d’éviter d’exposer publiquement des fichiers liés à votre installation domotique.

Lors de la création du dépôt, vous pouvez le laisser vide :

• sans README ;
• sans fichier .gitignore ;
• sans licence.

Cela évite les conflits lors du premier envoi depuis Home Assistant.

Exemple d’URL SSH du dépôt :

git@github.com:VOTRE_COMPTE/VOTRE_DEPOT.git

Remplacez bien VOTRE_COMPTE et VOTRE_DEPOT par vos propres informations GitHub.

Préparer l’accès SSH vers GitHub

Pour que Home Assistant puisse envoyer automatiquement les modifications vers GitHub, le plus propre est d’utiliser une clé SSH dédiée.

Dans le terminal Home Assistant, exécutez :

mkdir -p /config/.ssh
chmod 700 /config/.ssh

ssh-keygen -t ed25519 -C "homeassistant-github" -f /config/.ssh/id_ed25519 -N ""

chmod 600 /config/.ssh/id_ed25519
chmod 644 /config/.ssh/id_ed25519.pub

Affichez ensuite la clé publique :

cat /config/.ssh/id_ed25519.pub

Copiez tout le contenu affiché, puis ajoutez cette clé dans GitHub.

Deux possibilités existent :

• l’ajouter dans les clés SSH de votre compte GitHub ;
• l’ajouter dans les Deploy keys du dépôt, avec l’option Allow write access activée.

Pour un usage dédié à Home Assistant, la solution Deploy key est généralement plus propre, car elle limite cette clé à un seul dépôt.

Créer le fichier .gitignore

Dans le dossier /config, créez un fichier nommé .gitignore.

Ce fichier permet d’exclure les fichiers sensibles, volumineux ou inutiles.

Voici une base adaptée à Home Assistant :

# On ignore tout par défaut
*

# On garde l'arborescence des dossiers
!*/

# Fichiers de configuration et scripts utiles
!*.yaml
!*.yml
!*.md
!*.sh
!*.py
!*.js
!*.css
!*.html
!*.csv
!*.dash
!*.png
!*.jpg
!*.jpeg
!.gitignore

# Fichiers sensibles
/secrets.yaml
/.storage/
/.ssh/
/.cloud/

# Bases de données et fichiers temporaires
*.db
*.db-*
*.log
*.log.*
home-assistant.log*
OZW_Log.txt

# Fichiers générés ou caches
/deps/
/tts/
/__pycache__/

Le point le plus important est de ne pas envoyer secrets.yaml sur GitHub.

Ce fichier contient souvent des mots de passe, des tokens, des adresses IP, des clés API ou d’autres informations sensibles.

Initialiser le dépôt Git dans Home Assistant

Placez-vous dans le dossier /config :

cd /config

Initialisez le dépôt Git :

git init
git branch -M main

Configurez l’identité utilisée pour les commits :

git config user.email "votre_email@gmail.com"
git config user.name "Votre Nom"

Ajoutez le dépôt GitHub distant :

git remote add origin git@github.com:VOTRE_COMPTE/VOTRE_DEPOT.git

Vérifiez que le dépôt distant est bien configuré :

git remote -v

Faire le premier commit manuel

Avant d’automatiser la sauvegarde, il faut faire un premier envoi à la main.

cd /config
git add -A
git status
git commit -m "Premier commit Home Assistant"
git push -u origin main

Si tout est correctement configuré, les fichiers autorisés par le .gitignore apparaissent maintenant dans votre dépôt GitHub.

Vérifier qu’aucun fichier sensible n’est suivi

Avant d’aller plus loin, il est important de vérifier que les fichiers sensibles ne sont pas suivis par Git.

Exécutez :

git ls-files | grep -E 'secrets.yaml|\.storage|\.ssh|\.db|\.log'

Si la commande ne retourne rien, c’est parfait.

Si un fichier sensible apparaît, retirez-le du suivi Git sans le supprimer du disque :

git rm --cached secrets.yaml
git rm -r --cached .storage
git commit -m "Suppression des fichiers sensibles du suivi Git"
git push origin main

Créer le script automatique gitpush.sh

Créez maintenant un fichier /config/gitpush.sh.

nano /config/gitpush.sh

Collez le contenu suivant :

#!/usr/bin/env bash
set -euo pipefail

LOG_FILE="/config/gitpush-debug.log"

{
  echo "----------------------------------------"
  echo "Sauvegarde GitHub Home Assistant"
  echo "Date : $(date +'%Y-%m-%d %H:%M:%S')"

  cd /config

  export HOME=/config
  export GIT_SSH_COMMAND="ssh -i /config/.ssh/id_ed25519 -o IdentitiesOnly=yes -o StrictHostKeyChecking=accept-new"

  git config user.email "votre_email@gmail.com"
  git config user.name "Votre Nom"

  git add -A

  if git diff --cached --quiet; then
    echo "Aucun changement à sauvegarder."
    exit 0
  fi

  git commit -m "Sauvegarde auto - $(date +'%Y-%m-%d %H:%M:%S')"
  git push origin main

  echo "Sauvegarde terminée avec succès."

} >> "$LOG_FILE" 2>&1

Rendez le script exécutable :

chmod +x /config/gitpush.sh

Testez-le manuellement :

/config/gitpush.sh

Consultez ensuite le fichier de log :

cat /config/gitpush-debug.log

Ce script présente plusieurs avantages :

• il journalise les actions dans /config/gitpush-debug.log ;
• il ne crée pas de commit vide s’il n’y a aucun changement ;
• il utilise explicitement la clé SSH dédiée ;
• il envoie les modifications vers la branche main.

Ajouter la commande dans Home Assistant

Dans configuration.yaml, ajoutez :

shell_command:
  gitpush: "bash /config/gitpush.sh"

Redémarrez Home Assistant ou rechargez la configuration YAML si votre installation le permet.

Créer l’automatisation Home Assistant

Vous pouvez maintenant créer une automatisation pour lancer la sauvegarde automatiquement.

Par exemple, pour exécuter la sauvegarde toutes les nuits à 03h30 :

alias: GitHub - Sauvegarde automatique Home Assistant
description: "Envoie automatiquement la configuration Home Assistant vers GitHub."
trigger:
  - platform: time
    at: "03:30:00"
condition: []
action:
  - service: shell_command.gitpush
mode: single

À chaque exécution, Home Assistant lancera le script, créera un commit si des fichiers ont changé, puis enverra les modifications vers GitHub.

Tester depuis Home Assistant

Pour tester sans attendre l’heure prévue, allez dans Outils de développement, puis dans l’onglet Services.

Recherchez le service :

shell_command.gitpush

Lancez le service, puis vérifiez le dépôt GitHub.

Vous pouvez également consulter le fichier de log :

cat /config/gitpush-debug.log

Gérer une erreur d’authentification SSH

Si le git push échoue avec une erreur de permission, testez la connexion SSH :

ssh -T -i /config/.ssh/id_ed25519 git@github.com

Si GitHub ne reconnaît pas la clé, vérifiez que la clé publique affichée avec cette commande :

cat /config/.ssh/id_ed25519.pub

est bien ajoutée dans GitHub.

Gérer une erreur non-fast-forward

Cette erreur peut arriver si vous avez modifié le dépôt directement depuis GitHub.

Au lieu de forcer immédiatement l’envoi, commencez par récupérer les modifications distantes :

cd /config
git pull --rebase origin main
git push origin main

Évitez autant que possible cette commande :

git push -f origin main

Elle force l’écrasement de l’historique distant et peut supprimer des modifications présentes sur GitHub.

Si vous devez vraiment forcer l’envoi, préférez :

git push --force-with-lease origin main

Cette commande reste à utiliser avec prudence, mais elle est plus sûre qu’un simple git push -f.

Réappliquer le .gitignore

Si un fichier était déjà suivi par Git avant l’ajout du .gitignore, il continuera à être suivi même s’il est ensuite ajouté dans les exclusions.

Pour réappliquer proprement le .gitignore, exécutez :

cd /config
git rm -r --cached .
git add -A
git commit -m "Réapplication du .gitignore"
git push origin main

Vérifiez ensuite les fichiers suivis :

git status
git ls-files

Bonnes pratiques

Quelques règles simples permettent d’éviter les mauvaises surprises :

• utilisez un dépôt GitHub privé ;
• n’envoyez jamais secrets.yaml ;
• n’envoyez jamais le dossier .storage ;
• n’envoyez jamais le dossier .ssh ;
• gardez une vraie sauvegarde Home Assistant en complément ;
• vérifiez régulièrement que les commits se font bien ;
• consultez /config/gitpush-debug.log en cas de doute ;
• évitez de modifier directement les fichiers sur GitHub si Home Assistant est la source principale.

GitHub est très pratique pour suivre l’évolution des fichiers de configuration, mais ce n’est pas une sauvegarde complète de Home Assistant.

Les sauvegardes natives restent indispensables pour restaurer rapidement l’ensemble du système.

Conclusion

Votre Home Assistant est maintenant capable d’envoyer automatiquement sa configuration vers GitHub.

À chaque modification importante, un commit permet de garder une trace claire de ce qui a changé. C’est particulièrement pratique après une mise à jour, une modification d’automatisation ou un gros nettoyage de configuration.

Cette méthode apporte une vraie sécurité supplémentaire : en cas d’erreur, il devient plus facile de comparer les versions, revenir en arrière ou simplement comprendre ce qui a été modifié.

C’est une solution simple, fiable et très utile pour garder une installation Home Assistant propre, suivie et maîtrisée.