# Mode de secours PXE CentOS

{{INLINETOC}}

Cet article décrit comment mettre en oeuvre un environnement rescue sur le serveur DRBL.

# Mise en oeuvre du mode secours

## Description de l'environnement DRBL

Le serveur déployé comporte

  1. Un serveur TFTP fonctionnel
  2. Un serveur NFS opérationnel./tftpboot/node_root/etc/exports

### A propos du dossier TFPBOOT

Le dossier `/tftpboot` contient :
  * les exports NFS
  * un dossier `/tftpboot/nbi_img/` contenant le système d'ammorce PXE:
    * menu de boot `pxelinux.cfg/default` 
    * noyau linux `vmlinuz-pxe`
    * rootfs `initrd-pxe.img`

### A propos des exports NFS

Deux types d'export sont déclarés dans le fichier de configuration `/tftpboot/node_root/etc/exports`:
  * un export partagé `/tftpboot/node_root`
  * des imports individuels vers chaque nodes `/tftpboot/nodes/xxx.xxx.xxx.xxx`

## Préparation serveur PXE:

### Créer le système d'ammorce

Copier les fichiers du noyau rescue dans les répertoire d'ammorce:

```
cp /home/petra/txxa1/initramfs-0-rescue-20aa28ba84a14b598632dce463c0538f.img /tftpboot/nbi_img/initrd-rescue.img
cp /home/petra/txxa1/vmlinuz-0-rescue-20aa28ba84a14b598632dce463c0538f /tftpboot/nbi_img/vmlinuz-rescue
```

<WRAP tip> les fichiers initramfs & vmlinuz peuvent être générés pour le noyau de secours avec le noyau actuel du serveur à secourir:\\ \\ `/etc/kernel/postinst.d/51-dracut-rescue-postinst.sh  $(uname -r) /boot/vmlinuz-$(uname -r)`</WRAP>

### Créer le fichier kickstart

Créer un fichier de configuration kickstart (ks.cfg) et le placer dans l'un des sous répertoires de l'export partagé (par exemple `/tftpboot/node_root/tmp`) du serveur NFS.

```
# Fichier de configuration Kickstart en mode de secours CentOS 4.4
#
# Langue du système
#
lang fr_FR.UTF-8
#
# Modules de langue à installer
#
#langsupport --default=fr_FR.UTF-8 fr_FR.UTF-8
#
#Clavier système
#

keyboard fr

#
#Souris système
#
mouse none
#
# Récupérer le système de secours de NFS
#

nfs --server=xx.xxx.xxx.xx  --dir=/tftpboot/nodes_root/tmp

#
# Récupérer le système de secours de http
#

# url --url http://$yourwebserver/directory/that/contains/disc1/CentOS/RPMS/

#
Informations réseau
#
#network --bootproto=dhcp
```

Configurer l'entrée dans le menu PXE ainsi :

```
LABEL CentOS 7 Rescue via NFS
        KERNEL vmlinuz-rescue
        MENU LABEL CentOS 7 Rescue via NFS
        IPAPPEND 2
        APPEND initrd=initrd-rescue.img ramdisk_size=10000 text rescue ks=nfs:xx.xxx.xxx.xx:/tftpboot/node_root/tmp/ks.cfg
```


# Utilisation du mode rescue

Démarrer le système en mode rescue en utilisant l'entrée ajoutée dans le menu PXE **CentOS 7 Rescue via NFS**

## Récupérer l'environnement natif

Afin de réparer un système de fichier endommagé il faut le monter dans l'arbre du système de secours.

<WRAP info>Un environnement chrooté est nécessaire dans la pluspart des cas parcequ'on a besoins des bibliothèques dynamiques.</WRAP>

### Système de fichier LVM

Si l’on souhaite accéder à une partition LVM en mode secours, les manipulations suivantes sont nécessaires:

#### Création d’un répertoire en local 

pour monter les partitions logiques LVM 

```
mkdir /mnt/LVM
```

#### Récupération des partitions LVM

Récupérer les noms des volumes group de la partition LVM :

```
lvm vgscan
```

**Note**: Si les nodes n'aparaissent pas sous /dev relancer la commande avec `lvm vgscan --mknodes`

Activer les volumes group de la partition LVM :

```
lvm vgchange -ay <VolName>
```

Récupérer les noms dees volumes logiques de la partition LVM :

```
lvm lvs
```

#### Monter les volumes logiques 

Monter les volumes logiques de la partition LVM sur le répertoire local :

```
mount /dev/<VolName>/<LogName> /mnt/LVM
```

### Préparer le jail chroot

Afin de disposer d'un système de fichier autonome, monter le système de fichier racine sur le répertoire `/mnt`

```
mount -t xfs /dev/mapper/vg00-lvroot /mnt
mount -t xfs /dev/mapper/vg00-lvproduits /mnt/produits
mount -t xfs /dev/mapper/vg01-lvvar /mnt/var
mount -t xfs /dev/mapper/vg01-lvvar_log /mnt/var/log
mount -t proc proc proc/
mount --rbind /sys sys/
mount --rbind /dev dev/
```

Il faut maintenant pratiquer l'échange de clefs avec le serveur PXE afin de permmettre les sauvegardes restaurations avec l'authentification par clef (sans devoir saisir le mot de passe):

Générer le trousseau de clef dans l'environnment chrooté du serveur:

```
chroot /mnt
ssh-keygen
```

Implémenter la clef dans le fichier `authorized_keys` du serveur PXE:

```
ssh-copy-id -f -i /root/.ssh/id_rsa.pub <user>@<adresse-ip-serveur-pxe>
```

Tester une connexion sans mot de passse:

```
ssh <user>@<adresse-ip-serveur-pxe>
```

**Important**: après les opérations de secours penser à faire le ménage dans le fichier `authorized_keys` du serveur PXE

## Récupérer le chargeur d'amorçage GRUB

Le chargeur de démarrage GRUB peut parfois être endommagé, compromis ou supprimé en raison de divers problèmes, tels que des défaillances liées au matériel ou aux logiciels, ou peut parfois être remplacé par d'autres systèmes d'exploitation, en cas de double amorçage. Un chargeur de démarrage Grub corrompu empêche un système CentOS / RHEL de démarrer et de transférer le contrôle au noyau Linux.

La première étape du chargeur d'amorçage Grub est installée sur les 448 premiers octets au début de chaque disque dur, dans une zone généralement appelée enregistrement de démarrage principal (MBR).

La taille maximale du MBR est de 512 bytes. Si, pour une raison quelconque, les 448 premiers octets sont écrasés, CentOS ou Red Hat Enterprise Linux ne peuvent être chargés que si on démarre en mode de secours que l'on réinstalle le chargeur d'amorçage MBR GRUB.

Identifier le disque dur en exécutant la commande ci-dessous dans l'invite de secours.

```
# ls /dev/sd*
```

<WRAP info>Si l'ordinateur utilise un ancien contrôleur RAID physique sous-jacent, les disques porteront d'autres noms, tels que `/dev/cciss`. De plus, si le système CentOS est installé sur une machine virtuelle, les disques durs peuvent être nommés `/dev/vda` ou `/dev/xvda`.</WRAP>

Après avoir identifié le disque dur de la machine, on peut commencer à installer le chargeur de démarrage GRUB en lançant les commandes ci-dessous.

Dans le chroot installer grub sur le secteur d'ammorçage

```
/sbin/grub2-install /dev/sda
```

Redémarrer

```
reboot
```

## Sauvegarder le système de fichier


Dans le chroot faire un snapshot des dump xfs

```
$ xfsdump -l0 - <chemin-vers-le-fs-xfs> | gzip -c | ssh user@host dd of=/backup.dgz 
```


## Restaurer xfs depuis un hôte distant:

Dans le chroot faire `xfsrestore` des sauvegardes distantes:

```
$ ssh user@host "dd if=/somewhere/backup.dgz" | gunzip -c | xfsrestore - /
```