Modifications entre les versions 58 et 60 (s'étendant sur 2 versions)
Version 58 à la date du 2008-03-04 13:02:12
Taille: 8313
Éditeur: ThomasNoël
Commentaire:
Version 60 à la date du 2008-03-27 21:30:48
Taille: 9050
Éditeur: MoussaNombre
Commentaire:
Texte supprimé. Texte ajouté.
Ligne 27: Ligne 27:
# git init (ou "git init-db" sur une Debian Etch, git version 1.4)
# chmod u=rwx,go= /.git
# git init-db <--- Ou "git init" sur Git 1.5 (Debian Lenny, Ubuntu Gutsy)
# chmod u=rwx,go= /.git <--- important ! Seul "root" doit pouvoir accéder au dépôt
Ligne 31: Ligne 31:
 3. Pour éviter d'avoir des "saletés" directement à la racine (`/`), on déplace le dépôt. Le répertoire `/.git` à la racine ne sera en fait qu'un lien symbolique vers le véritable emplacement du dépôt :  3. Pour éviter d'avoir des "saletés" directement à la racine (`/`), on déplace le dépôt vers `/var/lib/git`. Le répertoire `/.git` à la racine ne sera en fait qu'un lien symbolique vers le véritable emplacement du dépôt :
Ligne 40: Ligne 40:
# Le fichier /var/lib/git/root/info/exclude :
# Par défaut, on exclut tout, sauf /etc
# Le fichier /var/lib/git/root/info/exclude à modifier ou créer
# Par défaut, on exclut tout sauf /etc
Ligne 45: Ligne 45:
# cf "find /etc -not -perm /004 -ls"
Ligne 64: Ligne 63:
 5. On fait les premiers ajouts et le premier ''commit'' :  5. On fait le premier ajout de tous les fichiers à suivre (sauf les exclus indiqués ci-dessus), puis le premier ''commit'' :
Ligne 68: Ligne 67:
# git commit -m "mise en route du suivi : /etc et /usr/local" --author "moi <email@auf.org>" # git commit -m "mise en route du suivi : /etc et /usr/local" --author "Prenom NOM <prenom.nom@auf.org>"
Ligne 71: Ligne 70:
 6. On configure `sudo` pour qu'il ne supprime pas les variables d'environnement de `git` :  6. On utilisera surtout `git` avec `sudo`. Il faut donc dire à `sudo` de ne pas supprimer les variables d'environnement utiles à `git` :
Ligne 73: Ligne 72:
# (... extrait de /etc/sudoers ...)
Ligne 79: Ligne 79:
 * A ajouter dans son `~/.bash_profile` (puis le « sourcer » ou se reloger pour activation) :  * '''Préliminaire''' : ajouter dans son `~/.bashrc` (puis se reloger pour activation) :
Ligne 81: Ligne 81:
# à ajouter à la fin de son fichier ~/.bash_profile : # à ajouter à la fin de son fichier ~/.bashrc :
Ligne 83: Ligne 83:
export GIT_AUTHOR_EMAIL="prenom.nom@auf.org"}}} export GIT_AUTHOR_EMAIL="prenom.nom@auf.org"
}}}
Ligne 85: Ligne 86:
 * Pour voir les modifications :  * Pour voir les modifications avant de les envoyer dans le dépôt :
Ligne 91: Ligne 92:
 * Pour enregistrer les modifications :  * Pour envoyer les modifications dans le dépôt, on lance un ''commit''. Il y a plusieurs façons de faire, parmis lesquelles :
Ligne 94: Ligne 95:
$ sudo git commit -a # on enregistre *toutes* les modifications}}} $ sudo git commit -a # on enregistre *toutes* les modifications
}}}
Ligne 96: Ligne 98:
 * Pour suivre un nouveau fichier :  * Pour suivre un nouveau fichier ou tous les nouveaux fichiers d'un répertoire, par exemple suite à l'installation de nouveaux fichier de configuration :
Ligne 98: Ligne 100:
$ sudo git add le/chemin/relatif/vers/le/fichier/ou/repertoire $ cd /
$ sudo git add le/chemin/relatif/vers/le/fichier/ou/repertoire        <-- il faut indiquer le chemin en "relatif" (sans / au début)
Ligne 103: Ligne 106:
 * Pour ne plus suivre un fichier :  * Pour ne plus suivre un fichier ou un répertoire :
Ligne 105: Ligne 108:
$ sudo vi /.git/info/exclude <--- on ajoute dans les excludes (exemple : /etc/ldap.secret)
$ sudo git rm le/chemin/relatif/du/fichier/a/ne/plus/suivre
$ sudo vi /.git/info/exclude                        <-- on ajoute le nom du fichier dans les excludes (exemple : /etc/ldap.secret)
$ cd /
$
sudo git rm le/chemin/du/fichier/a/ne/plus/suivre  <-- on le retire du dépôt (nb : le chemin est relatif, sans / au début)
Ligne 111: Ligne 115:
$ sudo tig <-- à installer avec aptitude install tig $ sudo tig            <-- petit logiciel très sympa, à installer avec aptitude install tig
Ligne 130: Ligne 134:
 * Pour lancer un "status" à chaque connexion sur le serveur (très très utile) : Pour lancer un "status" à chaque connexion sur le serveur (très très utile) :
Ligne 132: Ligne 136:
  1. Permettre aux gens du groupe "admin" de lancer git status sans mot de passe :  1. Permettre aux gens du groupe "admin" de lancer git status sans mot de passe :
Ligne 135: Ligne 139:
%admin ALL=(ALL) /usr/bin/git status -a %admin ALL=(ALL) NOPASSWD: /usr/bin/git status -a
Ligne 138: Ligne 142:
  1. Lancer le `git status` (via `sudo`) dans le `/etc/profile`, et configurer un peu les variables GIT :  1. Lancer le `git status` (via `sudo`) dans le `/etc/profile`, et configurer un peu les variables GIT :
Ligne 158: Ligne 162:
 * Pour envoyer un mail à chaque commit : Pour envoyer un mail à chaque commit :
Ligne 160: Ligne 164:
  1. Créer un script `/.git/hooks/post-commit` :  1. Créer un script `/.git/hooks/post-commit` :
Ligne 175: Ligne 179:

 
1. Activer le script :
 1. Activer le script :
Ligne 180: Ligne 183:

 
1. Eventuellement faire un commit de test afin de vérifier ça marche, notamment que `sendmail` (Postfix, Exim, ...) envoie bien le message.
 1. Faire un petit commit de test afin de vérifier ça marche, notamment que `sendmail` (Postfix, Exim, ...) envoie bien le message.

Git est un système de gestion de versions. Voir sa page wikipédia

Suivre la config' d'une machine avec git

On veut pouvoir documenter les modifications faites dans /etc et dans /usr/local, qui sont grosso modo les deux répertoires permettant de décrire comment fonctionne un serveur. Cette documentation est indispensable en cas d'administration à plusieurs, mais elle est également très utile quand on est seul à gérer : c'est un aide-mémoire indispensable vu la vitesse à laquelle évoluent les technologies et donc les configurations.

Pour cela, on utilise un logiciel de gestion de version. Ce logiciel va nous permettre de documenter chaque modification effectuée sur un fichier ou un ensemble de fichier. On pourra ensuite retrouver à quel moment à été faite une modification, par qui et pour quelle raison.

Il existe différents logiciels de ce type, parmis lesquels on peut citer l'ancètre CVS, son fils Subversion (svn), et dans une famille différente git. C'est ce dernier logiciel que nous avons choisi car il est moins bavard, moins intrusif dans le code à surveiller, et surtout très bien documenté.

A écrire : petites explications sur la notion de dépôt, orientée git et surveillance de /etc

Notre objectif ici est d'installer git sur un serveur pour que son ou ses administrateurs, et uniquement eux, puissent aisément faire le suivi de sa configuration.

Installation

  1. On installe git :

    # aptitude install git-core
  2. On créée un dépôt général pour toute la machine. Attention à bien régler les droits : seul root doit pouvoir accéder au dépôt, sinon les fichiers du genre shadow seraient accessibles à tous.

    # cd /
    # git init-db                   <--- Ou "git init" sur Git 1.5 (Debian Lenny, Ubuntu Gutsy)
    # chmod u=rwx,go= /.git         <--- important ! Seul "root" doit pouvoir accéder au dépôt
  3. Pour éviter d'avoir des "saletés" directement à la racine (/), on déplace le dépôt vers /var/lib/git. Le répertoire /.git à la racine ne sera en fait qu'un lien symbolique vers le véritable emplacement du dépôt :

    # mkdir /var/lib/git
    # mv /.git /var/lib/git/root
    # ln -s /var/lib/git/root /.git
  4. On veut suivre /etc et /usr/local seulement, pour cela on modifie les exclusions au niveau du dépôt, dans le fichier /var/lib/git/root/info/exclude :

    # Le fichier /var/lib/git/root/info/exclude à modifier ou créer
    # Par défaut, on exclut tout sauf /etc
    /*
    !/etc
    # ... mais dans /etc on interdit certains fichiers :
    /etc/*shadow*
    /etc/ssh/ssh_host_*_key
    /etc/mtab
    /etc/adjtime
    /etc/ld.so.cache
    # On n'interdit pas non plus le parcours de /usr. Mais dans ce parcours,
    # on interdit tout sauf /usr/local. C'est la technique pour inclure /usr/local...
    !/usr
    /usr/*
    !/usr/local
    # quelques type fichiers à ne pas jamais considérer, globalement :
    *.dpkg-old
    *.dpkg-new
    .*.swp
    *~
    *#
  5. On fait le premier ajout de tous les fichiers à suivre (sauf les exclus indiqués ci-dessus), puis le premier commit :

    # cd /
    # git add etc usr/local
    # git commit -m "mise en route du suivi : /etc et /usr/local" --author "Prenom NOM <prenom.nom@auf.org>"
  6. On utilisera surtout git avec sudo. Il faut donc dire à sudo de ne pas supprimer les variables d'environnement utiles à git :

    # (... extrait de /etc/sudoers ...)
    # une ligne à ajouter au début de /etc/sudoers :
    Defaults env_keep += "GIT_COMMITTER_NAME GIT_COMMITTER_EMAIL GIT_AUTHOR_NAME GIT_AUTHOR_EMAIL"

Utilisation

  • Préliminaire : ajouter dans son ~/.bashrc (puis se reloger pour activation) :

    # à ajouter à la fin de son fichier ~/.bashrc :
    export GIT_AUTHOR_NAME="Prenom NOM"
    export GIT_AUTHOR_EMAIL="prenom.nom@auf.org"
  • Pour voir les modifications avant de les envoyer dans le dépôt :
    $ sudo git status -a      # affiche la ligne des fichiers modifiés, supprimés, nouveaux...
    $ sudo git diff           # affiche les différences entre la version stockée dans git et la version actuelle
  • Pour envoyer les modifications dans le dépôt, on lance un commit. Il y a plusieurs façons de faire, parmis lesquelles :

    $ sudo git commit un/seul/fichier/modifié   # pour un fichier : toujours en notation relative
    $ sudo git commit -a                        # on enregistre *toutes* les modifications
  • Pour suivre un nouveau fichier ou tous les nouveaux fichiers d'un répertoire, par exemple suite à l'installation de nouveaux fichier de configuration :
    $ cd /
    $ sudo git add le/chemin/relatif/vers/le/fichier/ou/repertoire        <-- il faut indiquer le chemin en "relatif" (sans / au début)
    $ sudo git commit
    • Attention : il faut éventuellement modifier le fichier /.git/info/exclude

  • Pour ne plus suivre un fichier ou un répertoire :
    $ sudo vi /.git/info/exclude                         <-- on ajoute le nom du fichier dans les excludes (exemple : /etc/ldap.secret) 
    $ cd /
    $ sudo git rm le/chemin/du/fichier/a/ne/plus/suivre  <-- on le retire du dépôt (nb : le chemin est relatif, sans / au début)
  • Pour revoir les modifications, plusieurs techniques en ligne de commande :
    $ sudo tig               <-- petit logiciel très sympa, à installer avec aptitude install tig
    $ sudo git whatchanged
    $ sudo git log -10
    $ sudo git show ...(le code du commit)...
  • Note : la plupart du temps, il est plus simple de prendre l'habitude de se placer à la racine pour faire les manipulations git. Un exemple typique :

    $ cd /etc                              |
    $ sudo vi profile                <-----| ici on travaille
    $ sudo vi postfix/main.cf              |
    $ cd /     
    $ sudo git status -a                   | on fait un cd /
    $ sudo git diff | less           <-----| puis on documente
    $ sudo git commit -a                   | son travail ...

Quelques automatisations quasi indispensables

Pour lancer un "status" à chaque connexion sur le serveur (très très utile) :

  1. Permettre aux gens du groupe "admin" de lancer git status sans mot de passe :
    # et à ajouter vers la fin de /etc/sudoers :
    %admin ALL=(ALL) NOPASSWD: /usr/bin/git status -a
  2. Lancer le git status (via sudo) dans le /etc/profile, et configurer un peu les variables GIT :

    # A ajouter à la fin de /etc/profile :
    if [ "$PS1" ]; then
      # on lance un git status sur l'utilisateur est dans le groupe
      # admin ou bien si c'est root
      if $(id -Gn | grep -qw admin) || [ $(id -u) -eq 0 ]; then
        [ -x /usr/bin/git -a -e /.git ] && (cd / && sudo /usr/bin/git status -a)
      fi
      # les lignes suivantes tentent de configurer les variables GIT_*
      # si les résultats ne sont pas bien "devinés", définir les bonnes valeurs dans .bashrc
      GIT_AUTHOR_NAME=${GIT_AUTHOR_NAME:=$(getent passwd $(id -un)|cut -d: -f5|cut -d, -f1)}
      GIT_AUTHOR_EMAIL=${GIT_AUTHOR_EMAIL:=$(id -un)@$(hostname -f)}
      GIT_COMMITTER_NAME=${GIT_COMMITTER_NAME:=$GIT_AUTHOR_NAME}
      GIT_COMMITTER_EMAIL=${GIT_COMMITTER_EMAIL:=$GIT_AUTHOR_EMAIL}
      export GIT_AUTHOR_NAME GIT_AUTHOR_EMAIL GIT_COMMITTER_NAME GIT_COMMITTER_EMAIL
    fi

Pour envoyer un mail à chaque commit :

  1. Créer un script /.git/hooks/post-commit :

    recipients="admins@XX.auf.org"   # adresse pour l'envoi du mail
    # On modifie un peu la sortie de git show :
    #   1) on ajoute "From git hostname" devant le nom en From
    #   2) on retire le [PATCH] dans le sujet, replacé par git-commit:
    #   3) on ajoute un champ To:
    # et on maile le tout via sendmail
    PATH=/usr/sbin:/usr/bin:/sbin:/bin
    git show --pretty=email | 
      sed '1,6s/^From: /From: git '`hostname -f`' - /;1,6s/^Subject: \[PATCH\]/Subject: git-commit:/;2iTo: '"${recipients}" | 
      head -c 16k | /usr/lib/sendmail ${recipients}
    exit 0
  2. Activer le script :
    # chmod +x /.git/hooks/post-commit
  3. Faire un petit commit de test afin de vérifier ça marche, notamment que sendmail (Postfix, Exim, ...) envoie bien le message.

Ca ressemble à quoi ?

Juste pour donner une idée, voici ce que donne le petit programme tig lorsqu'on le lance sur une machine bien suivie :

  • ce-que-montre-tig.png

Améliorations à trouver

Pour plus tard (Lenny) :

  • RCS keyword expansion pour les $Id$ et compagnies

  • git-stash pour relier apt et git correctement

  • Tini n'ose pas le dire, mais il a fait un paquet Debian git-etc-auf qui fait tout le boulot d'installation. Un jour il osera.

  • Chouette ! Maintenant qu'on a notre dépôt APT AuF (merci Moussa et Thomas) il va pouvoir l'y mettre pour qu'on en profite tous ! ;-) -- ProgFou

Git/SuiviDeConfiguration (dernière édition le 2013-09-02 03:50:32 par JeanChristopheAndré)