# Linux

# Linux en général



# LINUX - ajouter/modifier SWAP

Si un fichier de swap existe déjà et qu'il faut en modifier la taille, commencer par le désactiver

```shell
swapoff /swapfile
```

Ensuite créer ou modifier le fichier (ex : 4G)

```shell
dd if=/dev/zero of=/swapfile bs=1024 count=4194304
sync
mkswap /swapfile
chmod 600 /swapfile
swapon /swapfile
swapon --show
```

Ajouter le fichier à fstab

```shell
vi /etc/fstab
   /swapfile swap swap defaults 0 0
```

# CentOS en mode Rescue + xfs_repair

1\. Boot grub, edit your default command line ("e")  
2\. Remove "rhgb" and "quiet" from the "linux" command line so you can see boot messages  
3\. Add "rescue" in their place  
4\. System boots to rescue mode (Ctrl-X)  
5\. Enter your root PW when prompted  
6\. execute the command "mount -o remount,ro /" to remount root as read only  
7\. execute the command "xfs\_repair -d /dev/"  
8\. cross fingers, wait and reboot immediately when complete  
  
Peut nécessiter d'être lancé 2 fois pour tout réparer. Si on ne passe pas en mode "rescue", on ne peut pas remonter / en RO car il est verrouillé par des process.

# Tunnel SSH via un serveur intermédiaire

A partir d'un poste, on veut atteindre un serveur externe, sur un port exotique (222, 81, 444, ...) ou standard (25, 443, ...) mais fermé en sortie par un proxy.

### <span class="mw-headline" id="bkmrk-la-syntaxe%C2%A0%3A-0">La syntaxe :</span>

```
ssh -C -N -f -L port-local:serveur-cible:port-du-serveur-cible user@serveur-intermediaire
```

Un tunnel est ouvert entre le poste local et le serveur intermédiaire par SSH. Serveur-intermediaire redirige les requêtes vers serveur-cible.  
En toutes lettres : *en allant sur port-local* ("**-L port-local**") *du poste local* (**127.0.0.1**, par défaut) *on accède à serveur-intermediaire en ssh* (**user@serveur-intermediaire**) *qui renvoie les requêtes vers serveur-cible sur le port port-du-serveur-cible* (**serveur-cible:port-du-serveur-cible**)

**Pour utiliser un certificat** (par exemple une connexion root entre le poste et serveur-intermediaire sans mot de passe, avec échange de clés DSA) reprendre les options standards de ssh :

```
ssh -C -N -f -L port-local:ip-du-serveur-final:port-du-serveur-cible user@serveur-intermediaire -i /<chemin>/<du>/<certificat>/<dsa>
```

En général, les certificats générés par ssh-keygen sont conservés sous $HOME/.ssh/id\_dsa.

**De même pour utiliser un port ssh alternatif** sur serveur intermediaire :

```
ssh -C -N -f -L port-local:ip-du-serveur-final:port-du-serveur-cible user@serveur-intermediaire -p <port-alternatif>
```

Toutes ces options sont évidemment combinables entre elles.

### <span class="mw-headline" id="bkmrk-exemples-0">Exemples</span>

Si on veut atteindre le port 443 (HTTPS) d'un serveur-cible, mais les seuls ports disponibles pour notre poste (sur un réseau derrière un proxy, par exemple) sont le 80 (HTTP) et le 22 (SSH) :

```
ssh -C -N -f -L 80:www.serveur-cible.tld:443 user@serveur-intermediaire
```

"user" doit avoir le droit de se connecter sur serveur-intermediaire. Dans un navigateur, l'URL :

```
https://localhost:80
```

accèdera par le tunnel au HTTPS (443) de serveur-cible, en utilisant uniquement le port 22.

<div class="mw-body-content" id="bkmrk-"><div class="mw-body-content"><div class="mw-content-ltr" dir="ltr" lang="fr"><div class="mw-parser-output">---

</div></div></div></div>Autre exemple : on veut ouvrir une connexion RDP (3389) vers un serveur qui n'autorise qu'une seule adresse IP en entrée, celle d'un serveur linux, et pas celle du poste qui lancera le client RDP.

```
ssh -C -N -f -L 3389:serveur-cible:3389 user@serveur-intermediaire
```

"serveur-cible" recevra une requête 3389 (RDP) provenant de "serveur-intermediaire" dont l'IP est autorisée. Dans le client RDP, en mettant "localhost" comme nom de serveur, on accède au bureau à distance ou à TSE de serveur-cible, par le tunnel.

### <span class="mw-headline" id="bkmrk-en-enlevant-l%E2%80%99interm-0">En enlevant l’intermédiaire !</span>

Et oui, ce n'était pas l'objet initial de ce tuto, mais si le réseau le permet (pas de proxy ou firewall) on peut directement créer le tunnel vers le serveur final. On ouvre un port sur le poste local (localhost) relié par ssh à un port d'un serveur distant. Exemple avec Mysql :

```
ssh -L 3306:localhost:3306 -f -N root@dbserver.domain.com
```

Puis on peut s'y connecter directement :

```
mysql -h 127.0.0.1 -u root -p
```

"-h 127.0.0.1" est obligatoire ici pour dire au client mysql ne se connecter en TCP au port 3306 local (par défaut), et non pas en socket unix local.

# Extension disque virtuel + LVM + XFS

##### Préalable

Extension du disque virtuel et reboot (arrêt physique/redémarrage) de la VM pour la prendre en compte.

Alternative à tester pour éviter le reboot : echo 1 &gt; /sys/class/block/sda/device/rescan

#### 1. CREATION D'UNE NOUVELLE PARTITION (parted &lt; 3.1)

`parted /dev/sda`

<p class="callout info">Utilisation de /dev/sda  
Bievenue sur GNU Parted ! Tapez 'help' pour voir la liste des commandes.  
(parted) print free  
Modèle: VMware Virtual disk (scsi)  
Disque /dev/sda : 387GB  
Taille des secteurs (logiques/physiques): 512B/512B  
Table de partitions : msdos  
Disk Flags:  
  
Numéro Début Fin Taille Type Système de fichiers Fanions  
32,3kB 1049kB 1016kB Espace libre  
1 1049kB 525MB 524MB primary xfs démarrage  
2 525MB 62,7GB 62,2GB primary lvm (gestionnaire de volumes logiques)  
3 62,7GB 322GB 259GB primary lvm (gestionnaire de volumes logiques)  
322GB 387GB 64,4GB Espace libre &lt;-------------  
  
(parted) mkpart  
Type de partition ? primary/primaire/extended/étendue? primary  
Type de système de fichiers ? \[ext2\]? xfs  
Début ? 322GB  
Fin ? 387GB  
  
set 4 lvm on  
  
(parted) print free  
Numéro Début Fin Taille Type Système de fichiers Fanions  
32,3kB 1049kB 1016kB Espace libre  
1 1049kB 525MB 524MB primary xfs démarrage  
2 525MB 62,7GB 62,2GB primary lvm (gestionnaire de volumes logiques)  
3 62,7GB 322GB 259GB primary lvm (gestionnaire de volumes logiques)  
4 322GB 387GB 64,4GB primary lvm (gestionnaire de volumes logiques)</p>

##### Ajout de la partition au groupe de volumes

`pvcreate /dev/sda4`  
`vgextend vg1 /dev/sda4`

#### 2. EXTENSION D'UNE PARTITION EXISTANTE (parted &gt;= 3.1)

*parted 3.1.0 n'a plus la commande resize, et pas encore resizepart qui semble revenir avec la 3.1.32*

##### Procédure 1 - Sans "resizepart"

 **SANS SORTIR DE PARTED !**  
on supprime la partition pour la recréer tout de suite à la taille maximum. On note le secteur de départ, il faudra redonner exactement le même.

`parted /dev/sda`

<p class="callout info">unit s *-&gt; (affichage en mode secteurs)*  
print all  
print free  
rm 4  
mkpart primary \[start\]s \[end\]s (ou : 100%)  
print all  
print free</p>

##### Procédure 2 - Avec "resizepart"

<p class="callout info">print *-&gt; (noter la taille max du disque, par ex 502GB)*  
resizepart 4  
Fin \[247GB\] : 502GB  
q</p>

##### Suite : Extension LVM (si nécessaire)

Affichage des informations et noms des groupes de volumes et volumes logiques

`# vgdisplay`

<p class="callout info">--- Volume group ---  
VG Name vg1  
.....</p>

`# lvdisplay`

<p class="callout info">--- Logical volume ---  
LV Path /dev/vg1/root  
.....  
--- Logical volume ---  
LV Path /dev/vg1/swap  
.....  
--- Logical volume ---  
LV Path /dev/vg1/u01  
....  
LV Size 241,63 GiB</p>

Prise en compte de l'extension dans LVM

`# pvscan`

`# pvresize /dev/sda4`

Extension du volume logique

```# lvresize -l +100%FREE /dev/rhel/u01`

`# lvdisplay`

<p class="callout info">...  
--- Logical volume ---  
LV Path /dev/rhel/u01  
...  
LV Size 301,62 GiB</p>

#### 3. EXTENSION DU SYSTEME DE FICHIERS XFS

`# xfs_growfs /u01`

# Restauration d'un VG si un disque perd son uuid

Booter en mode rescue (mode par défaut proposé par linux si une partition ne monte pas).

Remonter la racine en RW

```
# mount -o remount /
```

Voir le volume en cause :

```
# pvscan
 Couldn't find device with uuid yF12vQ-Pcsb-MDXA-D85j-02ci-ivJd-yR92mi
 PV /dev/sda2   VG VGRoot   lvm2 [24,59 GB / 0    free]
 Total: 1 [24,59 GB] / in use: 1 [24,59 GB] / in no VG: 0 [0   ]
 PV /dev/sdb1   VG VGData   lvm2 [249,88 GB / 0    free]
 Total: 1 [249,88 GB] / in use: 1 [249,88 GB] / in no VG: 0 [0   ]
```

Ici, bien qu'affiché tout de suite, le message concerne le second volume /dev/sdb1.

Lister les sauvegardes (automatiques) de la configuration LVM :

```
# vgcfgrestore --list VGData

 File:        /etc/lvm/archive/VGData_00000.vg
 VG name:     VGData
 Description: Created *before* executing '/sbin/vgs --noheadings -o name'
 Backup Time: Wed Oct  5 17:13:17 2011

 File:        /etc/lvm/backup/VGData
 VG name:     VGData
 Description: Created *after* executing '/sbin/vgs --noheadings -o name'
 Backup Time: Wed Oct  5 17:13:17 2011
```

On recrée le volume physique en forçant l'UUID. A priori, cette opération ne touche pas aux données de la partition, mais on ne peut jamais être sûr... C'est donc sans garantie.

```
# pvcreate /dev/sdb1 --uuid yF12vQ-Pcsb-MDXA-D85j-02ci-ivJd-yR92mi --restorefile /etc/lvm/backup/VGData 
 Couldn't find device with uuid yF12vQ-Pcsb-MDXA-D85j-02ci-ivJd-yR92mi.
 Writing physical volume data to disk "/dev/sdb1"
 Physical volume "/dev/sdb1" successfully created
```

On vérifie les UUIDs :

```
# pvs -o +uuid
 PV         VG        Fmt  Attr PSize   PFree   PV UUID                               
 /dev/sda2  VGRoot    lvm2 a--  25,59g 18,62g AYR30X-PoeE-4dZi-iexU-XqWw-I9OB-ewOdyx
 /dev/sdb1            lvm2 a--  250,48g 931,51g yF12vQ-Pcsb-MDXA-D85j-02ci-ivJd-yR92mi
```

On restore définitivement le groupe de volumes :

```
# vgcfgrestore VGData
 Restored volume group VGData
```

On vérifie que les groupes de volumes ne renvoient plus d'erreurs :

```
# vgscan
 Reading all physical volumes.  This may take a while...
 Found volume group "VGRoot" using metadata type lvm2
 Found volume group "VGData" using metadata type lvm2
```

On active le groupe de volumes qui vient d'être restauré :

```
# vgchange -ay
 1 logical volume(s) in volume group "VGRoot" now active
 3 logical volume(s) in volume group "VGData" now active
```

Il reste à remonter le ou les volumes logiques :

```
# mount /dev/mapper/VGData-LVData /data
```

# Anti-DDOS par iptables et sysctl.conf

#### ANTI-DDOS par les iptables

[https://javapipe.com/ddos/blog/iptables-ddos-protection/](https://javapipe.com/ddos/blog/iptables-ddos-protection/)

<p class="callout info">\### 1: Drop invalid packets ###  
/sbin/iptables -t mangle -A PREROUTING -m conntrack --ctstate INVALID -j DROP  
\### 2: Drop TCP packets that are new and are not SYN ###  
/sbin/iptables -t mangle -A PREROUTING -p tcp ! --syn -m conntrack --ctstate NEW -j DROP  
\### 3: Drop SYN packets with suspicious MSS value ###  
/sbin/iptables -t mangle -A PREROUTING -p tcp -m conntrack --ctstate NEW -m tcpmss ! --mss 536:65535 -j DROP  
\### 4: Block packets with bogus TCP flags ###  
/sbin/iptables -t mangle -A PREROUTING -p tcp --tcp-flags FIN,SYN,RST,PSH,ACK,URG NONE -j DROP  
/sbin/iptables -t mangle -A PREROUTING -p tcp --tcp-flags FIN,SYN FIN,SYN -j DROP  
/sbin/iptables -t mangle -A PREROUTING -p tcp --tcp-flags SYN,RST SYN,RST -j DROP  
/sbin/iptables -t mangle -A PREROUTING -p tcp --tcp-flags FIN,RST FIN,RST -j DROP  
/sbin/iptables -t mangle -A PREROUTING -p tcp --tcp-flags FIN,ACK FIN -j DROP  
/sbin/iptables -t mangle -A PREROUTING -p tcp --tcp-flags ACK,URG URG -j DROP  
/sbin/iptables -t mangle -A PREROUTING -p tcp --tcp-flags ACK,FIN FIN -j DROP  
/sbin/iptables -t mangle -A PREROUTING -p tcp --tcp-flags ACK,PSH PSH -j DROP  
/sbin/iptables -t mangle -A PREROUTING -p tcp --tcp-flags ALL ALL -j DROP  
/sbin/iptables -t mangle -A PREROUTING -p tcp --tcp-flags ALL NONE -j DROP  
/sbin/iptables -t mangle -A PREROUTING -p tcp --tcp-flags ALL FIN,PSH,URG -j DROP  
/sbin/iptables -t mangle -A PREROUTING -p tcp --tcp-flags ALL SYN,FIN,PSH,URG -j DROP  
/sbin/iptables -t mangle -A PREROUTING -p tcp --tcp-flags ALL SYN,RST,ACK,FIN,URG -j DROP  
\### 5: Block spoofed packets ###  
/sbin/iptables -t mangle -A PREROUTING -s 224.0.0.0/3 -j DROP  
/sbin/iptables -t mangle -A PREROUTING -s 169.254.0.0/16 -j DROP  
/sbin/iptables -t mangle -A PREROUTING -s 172.16.0.0/12 -j DROP  
/sbin/iptables -t mangle -A PREROUTING -s 192.0.2.0/24 -j DROP  
/sbin/iptables -t mangle -A PREROUTING -s 192.168.0.0/16 -j DROP  
/sbin/iptables -t mangle -A PREROUTING -s 10.0.0.0/8 -j DROP  
/sbin/iptables -t mangle -A PREROUTING -s 0.0.0.0/8 -j DROP  
/sbin/iptables -t mangle -A PREROUTING -s 240.0.0.0/5 -j DROP  
/sbin/iptables -t mangle -A PREROUTING -s 127.0.0.0/8 ! -i lo -j DROP  
\### 6: Drop ICMP (you usually don't need this protocol) ###  
/sbin/iptables -t mangle -A PREROUTING -p icmp -j DROP  
\### 7: Drop fragments in all chains ###  
/sbin/iptables -t mangle -A PREROUTING -f -j DROP  
\### 8: Limit connections per source IP ###  
/sbin/iptables -A INPUT -p tcp -m connlimit --connlimit-above 111 -j REJECT --reject-with tcp-reset  
\### 9: Limit RST packets ###  
/sbin/iptables -A INPUT -p tcp --tcp-flags RST RST -m limit --limit 2/s --limit-burst 2 -j ACCEPT  
/sbin/iptables -A INPUT -p tcp --tcp-flags RST RST -j DROP  
\### 10: Limit new TCP connections per second per source IP ###  
/sbin/iptables -A INPUT -p tcp -m conntrack --ctstate NEW -m limit --limit 60/s --limit-burst 20 -j ACCEPT  
/sbin/iptables -A INPUT -p tcp -m conntrack --ctstate NEW -j DROP  
\### 11: Use SYNPROXY on all ports (disables connection limiting rule) ###  
\### !!! EVITER SYNPROXY SUR TOUS LES PORTS ! PEUT BLOQUER SSH ET PLUS ! LIMITER AUX PORTS SENSIBLES ###  
\### you can just add --dport 80 to each of the rules if you want to use SYNPROXY on port 80 only  
iptables -t raw -A PREROUTING -p tcp -m tcp --syn -j CT --notrack  
iptables -A INPUT -p tcp -m tcp -m conntrack --ctstate INVALID,UNTRACKED -j SYNPROXY --sack-perm --timestamp --wscale 7 --mss 1460  
iptables -A INPUT -m conntrack --ctstate INVALID -j DROP  
</p>

Bonus Rules :

<p class="callout info">\### SSH brute-force protection ###  
/sbin/iptables -A INPUT -p tcp --dport ssh -m conntrack --ctstate NEW -m recent --set  
/sbin/iptables -A INPUT -p tcp --dport ssh -m conntrack --ctstate NEW -m recent --update --seconds 60 --hitcount 10 -j DROP  
  
\### Protection against port scanning ###  
/sbin/iptables -N port-scanning  
/sbin/iptables -A port-scanning -p tcp --tcp-flags SYN,ACK,FIN,RST RST -m limit --limit 1/s --limit-burst 2 -j RETURN  
/sbin/iptables -A port-scanning -j DROP  
</p>

#### ANTI-DDOS par sysctl.conf

<p class="callout info">kernel.printk = 4 4 1 7  
kernel.panic = 10  
kernel.sysrq = 0  
kernel.shmmax = 4294967296  
kernel.shmall = 4194304  
kernel.core\_uses\_pid = 1  
kernel.msgmnb = 65536  
kernel.msgmax = 65536  
vm.swappiness = 20  
vm.dirty\_ratio = 80  
vm.dirty\_background\_ratio = 5  
fs.file-max = 2097152  
net.core.netdev\_max\_backlog = 262144  
net.core.rmem\_default = 31457280  
net.core.rmem\_max = 67108864  
net.core.wmem\_default = 31457280  
net.core.wmem\_max = 67108864  
net.core.somaxconn = 65535  
net.core.optmem\_max = 25165824  
net.ipv4.neigh.default.gc\_thresh1 = 4096  
net.ipv4.neigh.default.gc\_thresh2 = 8192  
net.ipv4.neigh.default.gc\_thresh3 = 16384  
net.ipv4.neigh.default.gc\_interval = 5  
net.ipv4.neigh.default.gc\_stale\_time = 120  
net.netfilter.nf\_conntrack\_max = 10000000  
net.netfilter.nf\_conntrack\_tcp\_loose = 0  
net.netfilter.nf\_conntrack\_tcp\_timeout\_established = 1800  
net.netfilter.nf\_conntrack\_tcp\_timeout\_close = 10  
net.netfilter.nf\_conntrack\_tcp\_timeout\_close\_wait = 10  
net.netfilter.nf\_conntrack\_tcp\_timeout\_fin\_wait = 20  
net.netfilter.nf\_conntrack\_tcp\_timeout\_last\_ack = 20  
net.netfilter.nf\_conntrack\_tcp\_timeout\_syn\_recv = 20  
net.netfilter.nf\_conntrack\_tcp\_timeout\_syn\_sent = 20  
net.netfilter.nf\_conntrack\_tcp\_timeout\_time\_wait = 10  
net.ipv4.tcp\_slow\_start\_after\_idle = 0  
net.ipv4.ip\_local\_port\_range = 1024 65000  
net.ipv4.ip\_no\_pmtu\_disc = 1  
net.ipv4.route.flush = 1  
net.ipv4.route.max\_size = 8048576  
net.ipv4.icmp\_echo\_ignore\_broadcasts = 1  
net.ipv4.icmp\_ignore\_bogus\_error\_responses = 1  
net.ipv4.tcp\_congestion\_control = htcp  
net.ipv4.tcp\_mem = 65536 131072 262144  
net.ipv4.udp\_mem = 65536 131072 262144  
net.ipv4.tcp\_rmem = 4096 87380 33554432  
net.ipv4.udp\_rmem\_min = 16384  
net.ipv4.tcp\_wmem = 4096 87380 33554432  
net.ipv4.udp\_wmem\_min = 16384  
net.ipv4.tcp\_max\_tw\_buckets = 1440000  
net.ipv4.tcp\_tw\_recycle = 0  
net.ipv4.tcp\_tw\_reuse = 1  
net.ipv4.tcp\_max\_orphans = 400000  
net.ipv4.tcp\_window\_scaling = 1  
net.ipv4.tcp\_rfc1337 = 1  
net.ipv4.tcp\_syncookies = 1  
net.ipv4.tcp\_synack\_retries = 1  
net.ipv4.tcp\_syn\_retries = 2  
net.ipv4.tcp\_max\_syn\_backlog = 16384  
net.ipv4.tcp\_timestamps = 1  
net.ipv4.tcp\_sack = 1  
net.ipv4.tcp\_fack = 1  
net.ipv4.tcp\_ecn = 2  
net.ipv4.tcp\_fin\_timeout = 10  
net.ipv4.tcp\_keepalive\_time = 600  
net.ipv4.tcp\_keepalive\_intvl = 60  
net.ipv4.tcp\_keepalive\_probes = 10  
net.ipv4.tcp\_no\_metrics\_save = 1  
net.ipv4.ip\_forward = 0  
net.ipv4.conf.all.accept\_redirects = 0  
net.ipv4.conf.all.send\_redirects = 0  
net.ipv4.conf.all.accept\_source\_route = 0  
net.ipv4.conf.all.rp\_filter = 1  
</p>

# RAID logiciel : mdadm

*Un article de Le wiki de 2 noisettes - noisette.ch.*

Mdadm est un logiciel de gestion de RAID logiciel. Il est très complet au point que je le conseille même pour un environnement de production.

Cet article explique comment créer un RAID, assembler plusieurs disques ayant déjà fait parti d'un array, ou comment réagir en cas de panne. Pour les commandes données en exemple, nous ferons du RAID1 avec 2 disques partitionnés en 4, respectivement /boot, swap, / et /home.

# <span class="mw-headline" id="bkmrk-cr%C3%A9ation-0">Création</span>

## <span class="mw-headline" id="bkmrk-configurer-les-disqu-0">Configurer les disques</span>

Une fois le logiciel mdadm installé sur l'ordinateur, il faut configurer les disques

```
fdisk /dev/sda
fdisk /dev/sdb
```

pour que les partitions qui vont accueillir du RAID soient de type Linux raid autodetect (fd). Puis on va les assembler avec mdadm pour finalement pouvoir les formater et installer le le system dessus.

La configuration des disques sera la suivante :

```
/dev/*1 --> /boot,  100MB
/dev/*2 --> swap, 1-2GB
```

/ dev/\*3 --&gt; /, 20GB

```
/dev/*4 --> /home, le reste (bien que mettre /var serait plus judicieux sur une gentoo.
```

## <span class="mw-headline" id="bkmrk-noyau-0">Noyau</span>

Compilez le noyau avec les options suivantes (et sélectionner un autre mode de RAID si souhaité)

```
Device Drivers  ---> 
   Multi-device support (RAID and LVM)  --->
       [*] Multiple devices driver support (RAID and LVM)
       [*]   RAID support 
       [*]     RAID-1 (mirroring) mode 
```

Si vous démarrez d'un live CD, il faut charger le module (raid1 par exemple) :

```
modprobe raid1
```

Créer les nodes /dev/mdX

```
mknod /dev/md1 b 9 1
mknod /dev/md3 b 9 3
mknod /dev/md4 b 9 4
```

## <span class="mw-headline" id="bkmrk-cr%C3%A9ation-des-arrays-0">Création des arrays</span>

Pour les assembler avec mdadm, la commande ressemble à la suivante

```
mdadm --create /dev/md1 --level=1 --raid-devices=2 /dev/sda1 /dev/sdb1
mdadm --create /dev/md3 --level=1 --raid-devices=2 /dev/sda3 /dev/sdb3
mdadm --create /dev/md4 --level=1 --raid-devices=2 /dev/sda4 /dev/sdb4
```

Une fois l'array créé, reste les formatage et le montage à l'endroit voulu.

```
mke2fs /dev/md1
mkreiserfs /dev/md3
mkreiserfs /dev/md4
mkswap /dev/sda2 && mkswap /dev/sdb2
swapon /dev/sda2 && swapon /dev/sdb2 
mount /dev/md3 /mnt
mkdir -p /mnt/boot && mount /dev/md1 /mnt/boot
mkdir -p /mnt/home && mount /dev/md4 /mnt/home
```

On peut maintenant consulter les informations sur les disques, et insérer ces informations dans /etc/mdadm.conf :

```
mdadm --detail --scan >> /etc/mdadm.conf
```

### <span class="mw-headline" id="bkmrk-cr%C3%A9er-un-raid10-0">Créer un raid10</span>

```
mdadm -v --create /dev/md2 --level=raid10 --raid-devices=12 /dev/sd[a-l]2
```

### <span class="mw-headline" id="bkmrk-cr%C3%A9er-un-raid-50-0">Créer un raid 50</span>

Commencer par créer 4 baies de trois disques en RAID5 :

```
mdadm --create /dev/md21 -v --raid-devices=3 --level=5 /dev/sd[a-c]2
mdadm --create /dev/md22 -v --raid-devices=3 --level=5 /dev/sd[d-f]2
mdadm --create /dev/md23 -v --raid-devices=3 --level=5 /dev/sd[g-i]2
mdadm --create /dev/md24 -v --raid-devices=3 --level=5 /dev/sd[j-l]2
```

Pour créer un raid 0 avec ces 4 RAID5 :

```
mdadm --create /dev/md2 -v --raid-devices=4 --level=0 /dev/md21 /dev/md22 /dev/md23 /dev/md24
```

Si par la suite on veut étendre le raid : Recréer une baie de raid5 :

```
mdadm --create /dev/md25 -v --raid-devices=3 --level=5 /dev/sd[l-n]2
```

L'ajouter daans le raid0 existant :

```
mdadm --manage /dev/md2 --add /dev/md25
```

Définir le nombre de Baies pour le raid0 :

```
mdadm --grow /dev/md2 --raid-devices=5
```

# <span class="mw-headline" id="bkmrk-%28r%C3%A9%29assemblage-0">(Ré)Assemblage</span>

Une fois le RAID créé et des données dessus, on ne veut plus nécessairement le reformater et le recréer quand on l'a démonté. La solution sera donc de le réassemblé avec mdadm.

La première étape conciste à examiner une partition pour contrôler si elle fait bien partie d'un RAID (pour ceux qui on une mauvaise mémoire à très court terme) :

```
mdadm --examine /dev/sda1
```

La sortie nous dit si oui ou non la partition fait partie d'un RAID, et si oui quels autres disques en font aussi partie. Une fois en possession de ces informations, il nous reste à assembler l'ARRAY :

```
mdadm --assemble /dev/md1 /dev/sda1 /dev/sdb1
mdadm --assemble /dev/md3 /dev/sda3 /dev/sdb3
mdadm --assemble /dev/md4 /dev/sda4 /dev/sdb4
```

Reste le montage à l'endroit voulu.

# <span class="mw-headline" id="bkmrk-reconstruction-0">Reconstruction</span>

J'ai fait des tests de tolérence sur le RAID logiciel. J'ai commencé par enlever des disques à chaud (et j'ai pu bien constater qu'IDE était hot-déswap mais pas hot-swap), puis en utilisant l'option --fail pour simuler une panne. Les résultat étaient assez intéressants, mais le problème était de reconstruire le raid après la panne simulée.

Une fois la panne détectée (une véritable panne ou une simulée), on identifie le disque défectueux (avec dmesg ou /proc/mdstat) et on le retire de l'array :

```
mdadm --manage /dev/md1 --remove /dev/sdb1
```

Si on n'a pas de SATA pour enlever et remettre un disque à chaud, on arrête la machine et on la redémarre avec le nouveau disque. Puis on ajoute le nouveau disque à l'array :

```
mdadm --manage /dev/md1 --add /dev/sdb1
```

# <span class="mw-headline" id="bkmrk-suppression-0">Suppression</span>

## <span class="mw-headline" id="bkmrk-supprimer-le-raid-ex-0">Supprimer le raid existant</span>

Passer le status des disques à fail :

```
mdadm --manage /dev/md2 --fail /dev/sd[a-l]2
```

Puis les retirer du raid :

```
mdadm --manage /dev/md2 --remove /dev/sd[a-l]2
```

Arrêter le raid :

```
mdadm --manage --stop /dev/md2
```

Commenter la ligne correspondant à md2 dans /etc/mdadm.conf

Initialiser les périphériques pour effacer toute trace et redémarrer la machine:

```
mdadm --zero-superblock /dev/sd[a-l]2
reboot
```

# <span class="mw-headline" id="bkmrk-monitoring-0">Monitoring</span>

Mdadm offre une option de monitoring des arrays : --monitor. Pouvant être directement lancé sur centos avec le daemon mdmonitor : service mdmonitor start chkconfig mdmonitor on

## <span class="mw-headline" id="bkmrk-notifications-de-bas-0">Notifications de base</span>

Ajouter dans /etc/mdadm.conf

```
MAILADDR youremail@domain.com
MAILFROM my-server-name
```

tester : mdadm --monitor --scan --test --oneshot

## <span class="mw-headline" id="bkmrk-notification-%C3%A0-l%27aid-0">Notification à l'aide d'un script</span>

Mdmonitor peut appeler un script externe lors d'un événement (bon ou mauvais). Pour cela rajouter dans /etc/mdadm.conf :

```
PROGRAM /opt/systools/handle-mdadm-events.sh
```

Les arguments passés au script seront les suivants :

```
   * $1 : une chaine de caractère qui décrit l'évènement qui s'est produit
         o 'SparesMissing' : une panne est détectée mais aucun disque de remplacement n'est présent
         o 'Fail' : un disque est détecté comme déféctueux
         o 'RebuildStarted' : un nouveau disque est ajouté à l'array et la reconstruction commence
         o 'Rebuild20' : la reconstruction est à 20%
         o 'Rebuild40' : la reconstruction est à 40%
         o 'Rebuild60' : la reconstruction est à 60%
         o 'Rebuild80' : la reconstruction est à 80%
         o 'RebuildFinished' : la reconstruction est terminée
         o 'SpareActive' : un disque de réserve est ajouté à un array 
   * $2 : le nom de la device md : /dev/mdX 
```

$1 et $2 étant le premier et le deuxième argument passé en paramètre.

Voici le script :

```
#!/bin/bash
CONFIG="/etc/mdadm.conf"

MAILADDR="pbrun@systea.net" # support@systea.net" #espace entre les mails

parse_event()
{
  echo "Hôte            : $HOSTNAME"
  if [ -z "$1" ]; then
    echo "Événement        : Test message"
  else
    echo "MD Device       : $2"
    echo "Événement           : $1"
    if [ -n "$3" ]; then
      echo "Élément en cause: $3"
    fi
  fi

  echo ""
  echo "/proc/mdstat dump:"
  FAIL=0
  DEGRADED=0
  while read LINE; do
    echo -n "$LINE"
    if [ -n "$(echo "$LINE" |grep 'active raid')" ]; then
      if [ -n "$(echo "$LINE" |grep '\(F\)')" ]; then
        FAIL=$(($FAIL + 1))
        echo -n " (ATTENTION: DISQUE(S) DÉFÉCTUEUX!)"
      fi

      if [ -n "$(echo "$LINE" |grep '\(S\)')" ]; then
        echo -n " (Hotspare(s) disponibles)"
      else
        echo -n " (NOTE: Pas de hotspare?!)"
     fi
    fi

    if [ -n "$(echo "$LINE" |grep 'blocks')" ]; then
      if [ -n "$(echo "$LINE" |grep '_')" ]; then
        DEGRADED=$(($DEGRADED + 1))
        echo -n " (DEGRADED!!!)"
      fi
    fi

    echo ""
  done < /proc/mdstat

  if [ $FAIL -gt 0 ]; then
    echo ""
    echo "** ATTENTION: Un ou plusieurs RAID ont un ou plusieurs disques déféctueux! **"
  fi

  if [ $DEGRADED -gt 0 ]; then
    echo ""
    echo "** ATTENTION: Un ou plusieurs RAID fonctionnent en mode dégradé! **"
  fi
}

# main line:

# Get MAILADDR from mdadm.conf config file, if not set already
if [ -z "$MAILADDR" ] && [ -f "$CONFIG" ]; then
  MAILADDR=`grep MAILADDR "$CONFIG" |cut -d' ' -f2`
  if [ -z "$MAILADDR" ]; then
    MAILADDR="root"
  fi
fi

# Call the parser and send it to the configured address
parse_event $* |mail -s"Événement RAID(MD) sur  $HOSTNAME" "$MAILADDR"

exit 0
```

Afin de ne pas recevoir deux mails pour chaque alerte il est conseillé de commenter les deux lignes :

```
MAILADDR youremail@domain.com
MAILFROM my-server-name - mdadm
```

## <span class="mw-headline" id="bkmrk-un-script-plus-simpl-0">Un script plus simple...</span>

```
#!/bin/bash
MAIL=admin@domain.com
if [ $(date +\%w) -ne 0 ]
then
   STATE=$(/sbin/mdadm --query --detail /dev/md1 | grep State | grep -v Major | awk '{print $3}')
   if [ "$STATE" != "clean" -a "$STATE" != "active" ]
   then
      (/sbin/mdadm --query --detail /dev/md1
      )| mail -s "PROBLEME RAID sur $(hostname) $(date +%d/%m)" $MAIL
   fi
fi
```

# <span class="mw-headline" id="bkmrk-notes-0">Notes</span>

<div class="mw-body-content" id="bkmrk-v%C3%A9rifier-d%27avoir-une"><div class="mw-content-ltr" dir="ltr" id="bkmrk-v%C3%A9rifier-d%27avoir-une-0" lang="fr"><div class="mw-parser-output">- Vérifier d'avoir une version &gt; 2.5.0, car elle souffre d'un gros memory leak quand mdadm est lancé en monitoring.

</div></div></div>

# Activation de X11 avec un poste Windows+putty, et sudo

Le premier problème est de pouvoir afficher les écran X11 venant de linux, sur un poste Windows. Pour ça on utilise [XMing](https://sourceforge.net/projects/xming/).

A partir du poste Windows, on se connecte au serveur linux avec [putty](https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html).

Sur le poste Windows :

Lancer XMing, éventuellement **ajouter "-ac"** au bout de la ligne de commande du raccourci pour avoir les ACLs.  
Activer X11 Forwarding dans Putty (sous SSH / X11)  
ouvrir le terminal en se connectant "root" (ce n'est évidemment pas recommandé mais c'est pour la bonne cause)

Dans le terminal (sur le serveur linux, donc)

```shell
# xauth list
 LINUXSRV.domaine.com:10 MIT-MAGIC-COOKIE-1 696c660216329786ae629df72781d43f
# echo $DISPLAY
 10.0.0.207:10.0
```

L'affichage X11 doit fonctionner à ce point. Tester en lançant soit l'horloge si elle est installée :

```shell
xclock
```

Soit, si Oracle est installé sur le serveur, on peut aussi utiliser les commandes :

```shell
xwininfo
xdpyinfo
```

pour connaitre la configuration X11, et tester l'échange client-serveur.

Passer sous un autre utilisateur avec su

```shell
su - user1
xauth list
```

si la réponse est "Xauthority not found", le créer

```shell
xauth add LINUXSRV.domaine.com:10 MIT-MAGIC-COOKIE-1 696c660216329786ae629df72781d43f
```

Sinon, et si le cookie "LINUXSRV.domaine.com:10 MIT-MAGIC-COOKIE..." affiché par "xauth list" est le même qu'avant "su - user1", il n'y aura plus besoin de relancer "xauth add" par la suite; **MAIS ATTENTION, IL PEUT CHANGER D'UNE SESSION A L'AUTRE**.

Il reste ensuite à déclarer la variable DISPLAY

```shell
export DISPLAY=10.0.0.207:10.0
```

Si X11 ne fonctionne pas, essayer de supprimer le .Xauthority, vérifier xauth list sur la session avant su, et relancer xauth add

# Network bonding sur linux

<div class="mw-body-content" id="bkmrk-%C2%A0%5Bmasquer%5D%C2%A0-1%C2%A0redond"><div class="mw-body-content"><div class="mw-content-ltr" dir="ltr" lang="fr"><div class="mw-parser-output"><div class="toc" id="bkmrk-%C2%A0%5Bmasquer%5D%C2%A0-1%C2%A0redond-0"></div></div></div></div></div># <span class="mw-headline" id="bkmrk-redonder-plusieurs-c-0">Redonder plusieurs cartes réseau sous Linux</span>

## <span class="mw-headline" id="bkmrk-modes-bonding-0">Modes bonding</span>

Les modes peuvent être indiqués numériquement ou par des mots clés

<div class="mw-body-content" id="bkmrk-mode%3D0-ou-mode%3Dbalan"><div class="mw-body-content"><div class="mw-content-ltr" dir="ltr" lang="fr"><div class="mw-parser-output">1. mode=0 ou mode=balance-rr : equilibrage de charge
2. mode=1 ou mode=active-backup : sauvegarde active
3. mode=2 ou mode=balance-xor : balance xor
4. mode=3 ou mode=broadcast : broadcast
5. mode=4 ou mode=802.3ad : Norme 802.3ad
6. mode=5 ou mode=balance-tlb : balance TLB
7. mode=6 ou mode=balance-alb : balance ALB

</div></div></div></div>Le paramètre "miimon" (fréquence de monitoring des 2 interfaces, en millisecondes) est le seul paramètre obligatoire.

## <span class="mw-headline" id="bkmrk-sur-debian-0">Sur Debian</span>

Sur Debian vérifier que le paquet ifenslave-2.6 (pour kernel 2.6) est installé.

### <span class="mw-headline" id="bkmrk-configurer-le-r%C3%A9seau-1">Configurer le réseau</span>

Editer /etc/network/interfaces :

```
# network interface settings
auto lo
iface lo inet loopback

auto bond0
iface bond0 inet static
address 192.168.37.110
netmask 255.255.255.0
network 192.168.37.0
broadcast 192.168.37.255
gateway 192.168.37.254
slaves eth0 eth1
```

### <span class="mw-headline" id="bkmrk-charger-le-module-de-1">Charger le module de « bonding » dans le kernel</span>

Ajouter un fichier de configuration pour le module bonding :

```
vi /etc/modprobe.d/aliases-bond
```

Y ajouter :

```
alias bond0 bonding
options bonding mode=1 miimon=100
```

Pour tester, charger le module de « bonding » puis redémarrer le service réseau :

```
# modprobe bonding
# /etc/init.d/networking restart
```

## <span class="mw-headline" id="bkmrk-sur-centos-0">Sur CentOS</span>

### <span class="mw-headline" id="bkmrk-configurer-le-r%C3%A9seau-2">Configurer le réseau</span>

Créer le fichier de configuration de la carte bond0 dans le fichier /etc/sysconfig/network-scripts/ifcfg-bond0 :

```
DEVICE=bond0
IPADDR=192.168.1.100 //votre adresse ip
NETWORK=192.168.1.0 //l’adresse ip de votre reseau
NETMASK=255.255.255.0 //votre masque de sous-réseau
USERCTL=no
BOOTPROTO=none
ONBOOT=yes
```

Editer les fichiers de configuration des différentes cartes réseau (/etc/sysconfig/network-scripts/ifcfg-XXXX).  
Remplacer ou rajouter les lignes suivantes aux fichiers :

```
DEVICE=XXXX //à modifier avec nom de votre carte « eth? »
USERCTL=no
ONBOOT=yes
MASTER=bond0
SLAVE=yes
BOOTPROTO=none
```

### <span class="mw-headline" id="bkmrk-charger-le-module-de-2">Charger le module de « bonding » dans le kernel</span>

Editer le fichier de configuration des modules de kernel /etc/modprobe.conf, y ajouter :

```
alias bond0 bonding
options bond0 mode=balance-alb miimon=100
```

Pour tester, charger le module de « bonding » puis redémarrer le service réseau :

```
# modprobe bonding
# service network restart
```

## <span class="mw-headline" id="bkmrk-v%C3%A9rifications-0">Vérifications</span>

Vérifier que la carte virtuelle est bien démarrée et que les cartes physique lui sont bien liées :

```
# less /proc/net/bonding/bond0
```

Qui retournera une sortie plus ou moins identique à ça :

```
Bonding Mode: load balancing (round-robin)
MII Status: up
MII Polling Interval (ms): 0
Up Delay (ms): 0
Down Delay (ms): 0

Slave Interface: eth0
MII Status: up
Link Failure Count: 0
Permanent HW addr: 00:50:56:c0:00:08

Slave Interface: eth1
MII Status: up
Link Failure Count: 0
Permanent HW addr: 00:50:56:c0:00:01

Slave Interface: eth2
MII Status: up
Link Failure Count: 0
Permanent HW addr: 00:50:56:c0:00:03
```

Débrancher les cartes une à une afin de vérifier que le serveur ne perd pas la connexion (en mode 1, active backup. En load balancing le poste client est connecté sur une seule carte à un instant T et il perd quand même la connexion si c'est cette carte-là qui est débranchée : il faudra relancer la connexion).

# Debian - Ubuntu

# RedHat - CentOS - Oracle Linux

# Outils linux en ligne de commande



# Top - trouver les processus "ininterruptibles"

Trouver les processus ininterruptible qui font monter le load average sans qu'il y ait de charge CPU ou mémoire apparente.

```shell
top -b -n 1 | awk '{if (NR <=7) print; else if ($8 == "D") {print; count++} } END {print "Total status D: "count}'
```

(ou option "i" dans top). Les processus qui refusent les interruptions CPU (donc empêche les autres de prendre la main) sont marqués "D" dans l'affichage de top.

# Trouver l'adresse IP externe avec ou sans curl

Pour un serveur NATté (adresse IP locale derrière un firewall), l'adresse de sortie est soit celle du firewall soit une adresse d'OUTBOUND qui lui a été affectée.

Pour la connaitre, divers site propose ce service :

```shell
curl ifconfig.me
curl ipaddr.pub
curl https://www.google.com/search?q=what+is+my+ip+address -s | grep -oE "\b([0-9]{1,3}.){3}[0-9]{1,3}\b" -m1
curl -s http://ipecho.net/plain
curl -s http://whatismyip.akamai.com
```

Si curl n'est pas disponible sur un serveur, si on ne peut pas l'installer, essayer :

```shell
wget -qO- ipaddr.pub/cli
wget -qO- http://ipecho.net/plain
wget -qO- icanhazip.com
```

```shell
dig @ns1.google.com TXT o-o.myaddr.l.google.com +short
dig +short myip.opendns.com @resolver1.opendns.com
```

```shell
host myip.opendns.com resolver1.opendns.com | grep -m2 -oE "\b([0-9]{1,3}.){3}[0-9]{1,3}\b" | tail -n1
```

```shell
nslookup -query=TXT o-o.myaddr.l.google.com ns1.google.com | grep -m2 -oE "\b([0-9]{1,3}.){3}[0-9]{1,3}\b" | tail -n1
nslookup myip.opendns.com resolver1.opendns.com | grep -m2 -oE "\b([0-9]{1,3}.){3}[0-9]{1,3}\b" | tail -n1
```

# Screen - retrouver le scrolling

Ajouter les lignes suivante à ~/.screenrc :

<p class="callout info">\# Enable mouse scrolling and scroll bar history scrolling  
termcapinfo xterm\* ti@:te@</p>

Magique !

# TLS 1.2 avec curl ou php-curl - SSL - Cipher

Problème : certains sites/API réclament TLS1.2 pour les échanges (exemple : Paypal à partir du 30/06/2018).  
Par défaut sur CentOS7, si openssl est à jour (&gt;1.0.1) ainsi que curl et libcurl, ils doivent utiliser tls 1.2 par défaut.  
Si ce n'est pas le cas (test : curl https://tlstest.paypal.com), les mettre à jour ainsi que NSS:

```
yum update nss curl libcurl
```

Quelques commandes utiles :

Valider les protocoles utilisés par curl :

```shell
curl -v https://www.howsmyssl.com/a/check
```

Vérifier les protocoles acceptés par un site :

```shell
openssl s_client -connect www.google.com:443
- ou -
nmap --script ssl-enum-ciphers -p 443 www.google.com
```