Browse Source

First commit

master
Romain de Laage 1 year ago
commit
4d342a316e
Signed by: rdelaage GPG Key ID: 534845FADDF0C329
  1. 2
      .gitignore
  2. 3
      .gitmodules
  3. 6
      archetypes/default.md
  4. 81
      config.yaml
  5. 41
      content/_index.md
  6. 7
      content/docs/hosting/_index.md
  7. 41
      content/docs/hosting/css.md
  8. 42
      content/docs/hosting/nginx.md
  9. 44
      content/docs/hosting/service.md
  10. 15
      content/docs/infra/_index.md
  11. 15
      content/docs/infra/dns.md
  12. 15
      content/docs/infra/laptop.md
  13. 27
      content/docs/infra/mail.md
  14. 41
      content/docs/infra/secu/2fa.md
  15. 7
      content/docs/infra/secu/_index.md
  16. 102
      content/docs/infra/secu/firewall.md
  17. 46
      content/docs/infra/setup.md
  18. 9
      content/docs/infra/smart.md
  19. 1
      themes/book

2
.gitignore

@ -0,0 +1,2 @@
resources/*
public/*

3
.gitmodules

@ -0,0 +1,3 @@
[submodule "themes/book"]
path = themes/book
url = https://github.com/alex-shpak/hugo-book

6
archetypes/default.md

@ -0,0 +1,6 @@
---
title: "{{ replace .Name "-" " " | title }}"
date: {{ .Date }}
draft: true
---

81
config.yaml

@ -0,0 +1,81 @@
# hugo server --minify --themesDir ... --baseURL=http://0.0.0.0:1313/theme/hugo-book/
baseURL: https://rdelaage.ovh/doc
title: Hugo Book
theme: book
# Book configuration
disablePathToLower: true
#enableGitInfo: true
# Needed for mermaid/katex shortcodes
markup:
goldmark:
renderer:
unsafe: true
tableOfContents:
startLevel: 1
menu:
# before: []
after:
- name: "Github"
url: "https://github.com/alex-shpak/hugo-book"
weight: 10
- name: "Hugo Themes"
url: "https://themes.gohugo.io/hugo-book/"
weight: 20
params:
# (Optional, default true) Controls table of contents visibility on right side of pages.
# Start and end levels can be controlled with markup.tableOfContents setting.
# You can also specify this parameter per page in front matter.
BookToC: true
# (Optional, default none) Set the path to a logo for the book. If the logo is
# /static/logo.png then the path would be logo.png
# BookLogo: /logo.png
# (Optional, default none) Set leaf bundle to render as side menu
# When not specified file structure and weights will be used
# BookMenuBundle: /menu
# (Optional, default docs) Specify root page to render child pages as menu.
# Page is resoled by .GetPage function: https://gohugo.io/functions/getpage/
# For backward compatibility you can set '*' to render all sections to menu. Acts same as '/'
BookSection: docs
# Set source repository location.
# Used for 'Last Modified' and 'Edit this page' links.
# BookRepo: https://github.com/alex-shpak/hugo-book
# Enable "Edit this page" links for 'doc' page type.
# Disabled by default. Uncomment to enable. Requires 'BookRepo' param.
# Edit path must point to root directory of repo.
# BookEditPath: edit/master/exampleSite
# Configure the date format used on the pages
# - In git information
# - In blog posts
BookDateFormat: "January 2, 2006"
# (Optional, default true) Enables search function with flexsearch,
# Index is built on fly, therefore it might slowdown your website.
# Configuration for indexing can be adjusted in i18n folder per language.
BookSearch: true
# (Optional, default true) Enables comments template on pages
# By default partals/docs/comments.html includes Disqus template
# See https://gohugo.io/content-management/comments/#configure-disqus
# Can be overwritten by same param in page frontmatter
BookComments: true
# /!\ This is an experimental feature, might be removed or changed at any time
# (Optional, experimental, default false) Enables portable links and link checks in markdown pages.
# Portable links meant to work with text editors and let you write markdown without {{< relref >}} shortcode
# Theme will print warning if page referenced in markdown does not exists.
BookPortableLinks: true
# /!\ This is an experimental feature, might be removed or changed at any time
# (Optional, experimental, default false) Enables service worker that caches visited pages and resources for offline use.
BookServiceWorker: true

41
content/_index.md

@ -0,0 +1,41 @@
---
title: Introduction
type: docs
---
# Acerbo datus maxime
{{< columns >}}
## Astris ipse furtiva
Est in vagis et Pittheus tu arge accipiter regia iram vocatur nurus. Omnes ut
olivae sensit **arma sorori** deducit, inesset **crudus**, ego vetuere aliis,
modo arsit? Utinam rapta fiducia valuere litora _adicit cursu_, ad facies
<--->
## Suis quot vota
Ea _furtique_ risere fratres edidit terrae magis. Colla tam mihi tenebat:
miseram excita suadent es pecudes iam. Concilio _quam_ velatus posset ait quod
nunc! Fragosis suae dextra geruntur functus vulgata.
{{< /columns >}}
## Tempora nisi nunc
Lorem **markdownum** emicat gestu. Cannis sol pressit ducta. **Est** Idaei,
tremens ausim se tutaeque, illi ulnis hausit, sed, lumina cutem. Quae avis
sequens!
var panel = ram_design;
if (backup + system) {
file.readPoint = network_native;
sidebar_engine_device(cell_tftp_raster,
dual_login_paper.adf_vci.application_reader_design(
graphicsNvramCdma, lpi_footer_snmp, integer_model));
}
## Locis suis novi cum suoque decidit eadem
Idmoniae ripis, at aves, ali missa adest, ut _et autem_, et ab?

7
content/docs/hosting/_index.md

@ -0,0 +1,7 @@
---
title: "Hébergement"
---
# Hébergement
Cette page regroupe l'ensemble des informations concernant l'hébergement de services

41
content/docs/hosting/css.md

@ -0,0 +1,41 @@
---
title: "Mettre en place un serveur CSS et de fontes"
---
# Mettre en place un serveur de CSS et de fontes
Cette documentation concerne d'une part la mise en place sur un serveur Apache et d'autre part la mise en place avec Nginx.
## Avec Apache
Nous allons mettre en place un server de polices et css. Pour Apache on ajoute un simple serveur comme pour un site statique puis on ajoute dans la racine le fichier .htaccess suivant :
```
AddType application/vnd.ms-fontobject .eot
AddType application/x-font-opentype .otf
AddType image/svg+xml .svg
AddType application/x-font-ttf .ttf
AddType application/font-woff .woff
AddType application/font-woff2 .woff2
<FilesMatch "\.(ttf|otf|eot|woff|woff2)$">
<IfModule mod_headers.c>
Header set Access-Control-Allow-Origin "*"
</IfModule>
</FilesMatch>
```
## Avec Nginx
Pour nginx on fait un site statique auquel on ajoute la directive suivante:
```
location ~* \.(eot|otf|ttf|woff|woff2)$ {
add_header Access-Control-Allow-Origin *;
}
```
il faut en plus ajouter ceci dans le fichier mime.types de la configuration nginx
```
font/ttf ttf;
font/otf otf;
font/woff woff;
font/woff2 woff2;
application/vnd.ms-fontobject eot;
```

42
content/docs/hosting/nginx.md

@ -0,0 +1,42 @@
---
title: "Installation d'un serveur NGINX"
---
# Installation d'un serveur NGINX
Nginx est un service qui permet de servir des fichiers via le protocole HTTP(S). C'est un équivalent au serveur Apache.
Pour l'installer il suffit de lancer `sudo apt install -y nginx`. On va ensuite créer le dossier `/DATA/nginx` afin de stocker les fichiers de configuration des sites et les logs.
Il faut créer un lien symbolique des fichiers de config dans `/DATA/nginx` vers `/etc/nginx/sites-enabled` pour activer le site. On fait `sudo ln -s /DATA/nginx/<fichier> /etc/nginx/sites-enabled/<fichier>` puis on recharche le serveur `sudo systemctl reload nginx`.
A chaque modification de la configuration il faut lancer sudo systemctl reload nginx pour prendre en compte les modification.
Ci-après il y a un exemple de configuration simple pour les sites statiques avec https :
```
server {
listen 80;
listen [::]:80;
server_name example.com;
return 301 https://$server_name$request_uri;
}
server {
listen 443 ssl http2;
listen [::]:443 ssl http2;
ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;
server_name example.com;
root /DATA/root;
index index.html;
location / {
try_files $uri $uri/ =404;
}
}
```
Pour obtenir le certificat ssl il faut stopper le service nginx et lancer sudo certbot certonly --standalone -d example.com

44
content/docs/hosting/service.md

@ -0,0 +1,44 @@
---
title: "Mettre en place un nouveau service avec systemd"
---
# Les services avec systemd
Ce logiciel permet entre autre de gérer les différents services sur votre serveur en se chargeant de les démarrer, stopper, recharger, ...
Nous aborderons ici la création et la gestion d'un service simple.
## Création d'un service
Il y a plusieurs types de services nous intéresserons aux services `simples`.
Pour créer un service il faut éditer un fichier `<service>.service` et y placer le code suivant :
```
[Unit]
Description=<description du service>
[Service]
Type=simple
User=<username>
Group=<grpname>
#RemainAfterExit=yes
ExecStart=/usr/libexec/iptables.init start
#ExecStop=/usr/libexec/iptables.init stop
Restart=on-failure
[Install]
WantedBy=multi-user.target
```
Le champ `ExecStart` correspond à la commande à lancer pour démarrer le service. La ligne `RemainAfterExit=yes` indique à systemd que le service est toujours considéré comme lancé même si la commande `ExecStart` est terminée. Le champ `ExecStop` correspond à la commande à lancer pour stopper le service.
## Commandes
```
systemctl start <service>
systemctl stop <service>
systemctl restart <service>
systemctl reload <service>
systemctl enable [--now] <service>
systemctl disable <service>
systemctl status <service>
```

15
content/docs/infra/_index.md

@ -0,0 +1,15 @@
---
title: "Infrastructure"
---
# Mon infrastructure
Mon infrastructure n'est composée que d'une Raspberry PI 4 modèle 4 GB doté d'une carte microSD de 32 GB d'une alimentation USB C et d'une connexion à Internet par câble ethernet. La Raspberry PI est d'abord connectée à mon réseau local qui est connecté à Internet par ma *Livebox 5* via une connexion fibrée.
Pour l'instant aucun système de sauvegarde n'a été mis en place mais je prévois dans le futur de faire une synchronisation par jour des données avec ma Raspberry PI 2 sur un disque dur et de garder chasue sauvegarde entre 4 à 8 jours.
Il n'y a pas de redondance au niveau de la connexion Internet ni au niveau de l'alimentation et cela n'est pas prévu. Les services seront donc inaccessible en cas de coupure de courant ou d'Internet. De plus lors de la maintenance ou pour tout autre raison les services pourraient être coupés.
Mon infrastructure n'est pas optimisée pour une production de masse mais plutôt en tant que preuve de concept. Ainsi les logiciels sont dans des versions assez récentes généralement mais il n'y a pas de vrai test et les données peuvent être perdues à tout moment. Il n'y a aucune garantie sur vos données lors de l'utilisation de ces services.
Bien entendu la protection de la vie privée est pour moi un enjeux très important du dévelopement d'Internet et c'est en ce sens que cette infrastructure a été montée, il n'y a ainsi pas de pistage sur les instances hébergées ici et vos données vous appartiennent (il n'y aura aucune vente et vous pouvez consulter, récupérer ou supprimer par simple demande).

15
content/docs/infra/dns.md

@ -0,0 +1,15 @@
---
title: "Gestion du DNS"
---
# Gestion du DNS
L'infrastructure possède un nom de domaine *rdelaage.ovh* acheté chez **OVH**. Le tout pointe vers l'adresse publique IPv4 de ma box ainsi que vers l'adresse IPv6 publique de mon Raspberry PI.
Afin de rediriger les connexions aux différents services via ma box on établis des règles de redirection NAT et PAT pour le ssh le serveur web, ...
La gestion du DNS pour mon infrastructure se fait directement sur le panel de configuration OVH, on peut notament y retrouvet la configuration des zones DNS dans laquelle nous éditons des enregistrement.
* **A** : Ces enregistrements font correspondre un nom d'hôte à une adresse IPv4
* **AAAA** : Ces enregistrements font correspondre un nom d'hôte à une adresse IPv6
* **CNAME** : Ces enregistrements permettent de faire correspondre un domaine à un alias vers un autre domaine

15
content/docs/infra/laptop.md

@ -0,0 +1,15 @@
---
title: "Recycler son vieux laptop"
---
# Recycler son vieux laptop
Il peut être intéressant de recycler un vieux laptop qui traîne en serveur. Il est plus puissant que la raspberry PI, possède une architecture AMD64 qui peut être intéressante pour certains logiciels et a des fonctionnalités qui peuvent être plus poussées (boot sur usb, wakeonlan, ...). De plus sa forme et sa taille le rendent plus facile à caser dans un coin de la maison qu'une grosse tour.
Le gros problème est que quand on ferme l'écran le PC se met en vezille, heureusement avec systemd on peut changer ce comportement. Il faut télécharger la dernière version stable de Debian (ou autre distribution incluant systemd), l'installer sans environnement graphique avec un serveur ssh et les utilitaires de base puis pour éviter de mettre en veille lorsqu'on ferme l'écran il faut modifier le fichier /etc/systemd/logind.conf :
```
[Login]
HandleLidSwitch=ignore
HandleLidSwitchDocked=ignore
```

27
content/docs/infra/mail.md

@ -0,0 +1,27 @@
---
title: "Configurer les notifications par mail"
---
# Configurer les notifications par mail
Il peut être utile d'activer l'envoi d'email de la part de votre infrastructure pour vous dire lorsque quelque chose se passe mal. Dans ce cas il faut configurer un MTA (mail transfer agent).
## Configurer Exim4
Exim4 est un MTA, celui installé par défaut sur Raspberry PI, pour éviter des recherches je me suis basé dessus mais pourrai en changer par la suite si cela ne me convient pas.
Pour ouvrir l'utilitaire de configuration lancez `sudo dpkg-reconfigure exim4-config`, on peut recevoir simplement les mails en local et les consulter via la commande `mail`. Cependant le but ici sera de recevoir les mails directement dans la boîte mail dont je me sers au quotidien, pour cela on va configurer Exim4 en mode relais. Pour cela on sélectionne l'option smarthost et pas de courrier local.
Puis on édite /etc/exim4/passwd.client pour y ajouter les identifiants, puis on édite /etc/exim4/exim4.conf.template pour ajouter les lignes protocol = smtps et hosts_require_auth = ssl0.ovh.net et enfin on édite /etc/email-addresses selon le schéma décrit en en-tête de fichier.
[Sources](https://www.deltasight.fr/utiliser-ovh-smarthost-exim4/)
## Tester
Pour tester votre configuration vous pouvez utiliser la commande mail comme suit :
`echo "Votre message, le corps du mail" | mail -s "Sujet du mail" votre.nom@exemple.org`, si tout a été configuré correctement vous devriez voir apparaître un mail dans votre boîte de réception
## CRON
Si votre nom d'utilisateur sur la machine est différent de votre nom d'utilisateur par mail vous ne recevrez rien, il faut modifier le fichier crontab. Entrez `crontab -e` puis tout en haut du fichier ajoutez :
```
MAILTO=<mon adresse mail>
```

41
content/docs/infra/secu/2fa.md

@ -0,0 +1,41 @@
---
title: "Activer la 2FA"
---
# Activer la double authentification par TOTP sur un serveur SSH
[Sources](https://lab.yvesago.net/2015/09/Authentification-double-facteur-TOTP-openssh.html)
## Côté serveur
Le but est d'activer la double authentification pour ouvrir un session SSH lorsqu'une clé RSA (ou autre) ne peut pas être fournie. Cette technique s'appuie sur le TOTP (Time One Time Password), on génère un code temporaire toutes les minutes qui peut être récupéré à l'aide d'un logiciel ou d'un autre appareil.
Commençons par installer le nécessaire `sudo apt update && sudo apt upgrade && sudo apt install oathtool libpam-oath`. Puis on édite le fichier de configuration associé aux sessions SSH `sudo nano /etc/pam.d/sshd` :
```
...
#@include common-auth
auth requisite pam_unix.so
auth sufficient pam_oath.so usersfile=/etc/users.oath window=10 digits=6
auth required pam_deny.so
...
```
Puis on renseigne les informations sur le TOTP dans un fichier `sudo nano /etc/users.oath` où l'on place une ligne pour chaque utilisateur comme cela : `HOTP/T30/6 <user> - <30 characters hex string>`, par exemple `HOTP/T30/6 bob - 6ddc816bd8f5c4560e8801e464144f`, puis on protège ce fichier en lecture/écriture `sudo chmod 600 /etc/users.oath`. Enfin on autorise la saisie du deuxième facteur en modifier la configuration de SSHD `sudo nano /etc/ssh/sshd_config` :
```
...
#ChallengeResponseAuthentication no
ChallengeResponseAuthentication yes
...
```
Enfin on recharge la configuration du service sshd `sudo systemctl reload sshd`. Avant de fermer la session actuelle pensez à tester que tout fonctionne correctement afin d'éviter de rester coincé à l'extérieur sans pouvoir agir.
pour obtenir la chaîne en hexadécimal de trente caractères on peut lancer `head -10 /dev/urandom | md5sum | cut -b 1-30`.
## Côté client
Il existe plusieurs applications smartphone ou PC pour générer des TOTP. Je vais présenter comment obtenir des code via la commande `oathtool` puis comment l'intégrer au gestionnaire de mot de passe [pass](https://www.passwordstore.org/).
On lance la commande `oathtool --totp <30 characters hex string>` pour obtenir un code. Pour intégrer à pass la génération il faut avoir installé l'extension pass-otp puis ajouter dans le fichier correspondant au mot de passe une chaîne comme celle-ci `otpauth://totp/totp-secret?secret=<base32 string>`. On obtient cette chaîne en base 32 avec la commande `oathtool -v --totp <30 characters hex string>`.

7
content/docs/infra/secu/_index.md

@ -0,0 +1,7 @@
---
title: "Sécurité"
---
# Sécurité
Vous trouverez ici la documentation concernant la sécurité de l'infrastructure.

102
content/docs/infra/secu/firewall.md

@ -0,0 +1,102 @@
---
title: "Gestion du pare-feu"
---
# Gestion du pare-feu
Edit: on fera de même avec la commande ip6tables pour gérer les connexions IPv6
Le pare-feu permet de gérer les connexion au serveur, c'est à dire le réseau sur la machine. Pour cela j'utilise la commande `iptables` pour gérer les connexions IPv4 sur mon infrastructure.
On commencera par créer un fichier `firewall.sh` que l'on complètera au fur et à mesure.
On peut commencer par regarder les règles existantes grâce à la commande `iptables -L`. On remarquera que la chaîne `policy ACCEPT` revient souvent, cela veut dire que par défaut toutes les connexions sont acceptées sans restriction. C'est un comportement que nous voudrons changer.
On va commencer par ajouter dans notre fichier `firewall.sh` la commande `iptables -F` qui va effacer toutes les règles existentes pour partir sur des bases propres. Puis `iptables -X` pour effacer toutes les règles non prédéfinies.
Ensuite on renseigne les politiques par défaut, nous souhaitons rejeter pour l'entrée, la sortie, et la transmission :
```
iptables -P OUTPUT DROP
iptables -P INPUT DROP
iptables -P FORWARD DROP
```
Si on veut continuer à autoriser les connexions déjà établies on peut ajouter :
```
iptables -A INPUT -m conntrack --ctstate ESTABLISHED -j ACCEPT
iptables -A OUTPUT -m conntrack --ctstate ESTABLISHED -j ACCEPT
```
On peut aussi vouloir autoriser toutes les connexions entre les programmes s'exécutant sur la même machine :
```
iptables -A INPUT -i lo -j ACCEPT
iptables -A OUTPUT -o lo -j ACCEPT
```
ensuite il faut autoriser les connexions pour chaque service en entrée : `iptables -A INPUT -p tcp --dport <PORT> -j ACCEPT`, et en sortie : `iptables -A OUTPUT -p tcp --dport <PORT> -j ACCEPT`.
## Exemple de configuration
```
#!/bin/sh
########
# IPv4 #
########
# Flush
iptables -F
iptables -X
# Politics
iptables -P OUTPUT DROP
iptables -P INPUT DROP
iptables -P FORWARD DROP
# Established connexions
iptables -A INPUT -m conntrack --ctstate ESTABLISHED -j ACCEPT
iptables -A OUTPUT -m conntrack --ctstate ESTABLISHED -j ACCEPT
# Authorize loopback
iptables -A INPUT -i lo -j ACCEPT
iptables -A OUTPUT -o lo -j ACCEPT
# SSH
iptables -A INPUT -p tcp --dport 22 -j ACCEPT
# HTTP(S)
iptables -A INPUT -p tcp --dport 80 -j ACCEPT
iptables -A INPUT -p tcp --dport 443 -j ACCEPT
iptables -A OUTPUT -p tcp --dport 80 -j ACCEPT
iptables -A OUTPUT -p tcp --dport 443 -j ACCEPT
########
# IPv6 #
########
# Flush
ip6tables -F
ip6tables -X
# Politics
ip6tables -P OUTPUT DROP
ip6tables -P INPUT DROP
ip6tables -P FORWARD DROP
# Established connexions
ip6tables -A INPUT -m conntrack --ctstate ESTABLISHED -j ACCEPT
ip6tables -A OUTPUT -m conntrack --ctstate ESTABLISHED -j ACCEPT
# Authorize loopback
ip6tables -A INPUT -i lo -j ACCEPT
ip6tables -A OUTPUT -o lo -j ACCEPT
# SSH
ip6tables -A INPUT -p tcp --dport 22 -j ACCEPT
# HTTP(S)
ip6tables -A INPUT -p tcp --dport 80 -j ACCEPT
ip6tables -A INPUT -p tcp --dport 443 -j ACCEPT
ip6tables -A OUTPUT -p tcp --dport 80 -j ACCEPT
ip6tables -A OUTPUT -p tcp --dport 443 -j ACCEPT
```

46
content/docs/infra/setup.md

@ -0,0 +1,46 @@
---
title: "Mise en place de la Raspberry PI"
---
# Mise en place de la Raspberry PI
Nous détaillerons ici l'installation de notre serveur sur un sytème Raspbian qui n'est qu'en version 32 bits, pour certaines raisons vous pouvez vouloir un système 64 bits. Vous pouvez aussi vouloir utiliser une autre distribution plus spécialisée ou non débian. Certaines choses de ce tutos ne vous concernerons pas.
## Préparer le système
La première chose à faire est de trouver une carte micro SD que l'on vide afin d'y mettre l'image du système. Afin de récupérer l'image il suffit de se rendre sur le [site de la Raspberry PI fundation](https://raspberrypi.org) et de se rendre sur la page de [téléchargement de Raspbian](https://www.raspberrypi.org/downloads/raspbian/). Il vous faudra télécharger l'image Lite de Raspbian, en effet nous n'aurons pas besoin d'interface graphique donc il est inutile de s'encombrer de celle-ci.
Une fois que vous avez récupéré l'image il vous faudra la flasher sur votre carte micro SD, pour cela il y a plusieurs solutions, vous pouvez utiliser l'utilitaire *Gnome Disk* et choisir `Restaurer une image disque` ou plus simplement utiliser un logiciel comme [*Etcher*](https://www.balena.io/etcher/). Je vous laisse le soin de trouver comment fonctionnent ces logiciels.
Une fois ceci fait il faudra se rendre dans la partition *boot* de la carte micro SD et y créer un fichier vide nommé *ssh* afin d'activer la connexion par SSH à la machine, ceci permettra de s'y connecter de manière textuelle à distance.
Vous pouvez alors mettre la carte dans la Raspberry PI et l'allumer, normalement la LED rouge s'allume et celle verte clignote avant de s'éteindre.
## Accès SSH au système
Maintenant que le système est installé il faut y accéder. Les noms d'utilisateur et mots de passe par défaut pour Raspbian sont :
* Utilisateur : `pi`
* Mot de passe : `raspberry`
Pour accéder au système il vous faut un client ssh, sous Linux il est installé par défaut et sur Windows vous pouvez utiliser [Putty](https://www.putty.org/) ou installer [MinGW](http://www.mingw.org/) qui intègre les commandes GNU à l'invite de commande Windows.
La première chose à faire est de se connecter avec la commande `ssh <utilisateur>@<adresseIP>` l'invite de commande vous demandera d'entrer le mot de passe.
Vous êtes connecté ! Vous pouvez commencer par mettre à jour le système avec `sudo apt update && sudo apt upgrade -y`.
## Gestion des utilisateurs
Je vous conseille alors de vous créer un nouvel utilisateur en lançant `sudo useradd <nom d'utilisateur>` et de changer son mot de passe avec `sudo passwd <nom d'utilisateur>`. Enfin il faut ajouter l'utilisateur au groupe `sudo` pour avoir accès aux privilèges de super-utilisateur, il faut donc entrer `sudo adduser <nom d'utilisateur> sudo`.
Vous pouvez maintenant vous déconnecter avec `exit` et vous reconnecter avec votre nouvel utilisateur.
Maintenant supprimez l'utilisateur par défaut `sudo userdel -r pi` et créez votre répertoire par défaut avec `mkdir /home/$USER` et donnez-vous les droits avec `sudo chown $USER /home/$USER && sudo chgrp $USER /home/$USER`.
Vous pouvez si vous le souhaitez par soucis de confort désactiver la demande du mot de passe à chaque utilisation de sudo, sachez que si cette option est activée, celui qui arrive à accéder à un terminal de votre utilisateur a les accès super utilisateur. Pour cela entrez `sudo visudo` puis ajoutez à la fin `<nom d'utilisateur> ALL=(ALL) NOPASSWD: ALL`.
## TODO : sécurisation SSH
Nous allons à présent configurer ssh afin de le sécuriser. Le but sera de désactiver l'authentification par mot de passe et l'authentification au compte root à distance. Pour cela il faut modifier le fichier `/etc/ssh/sshd_config`, mettre `PasswordAuthentification` à no, `PubkeyAuthentification` à yes et `PermitRootLogin` à no. **/!\ Ne pas fermer votre session à ce moment sinon vous ne pourrez plus accéder à votre machine**
Il vous faudra ensuite générer une paire de clé SSH, pour cela sur une machine linux il suffit de lancer `ssh-keygen`. Il faut mettre sa clé publique ssh dans le dossier .ssh du home directory dans le fichier authorized_keys (copier le contenu de .ssh/id_rsa.pub). Puis faites `sudo systemctl restart sshd`.
## Alternatif
On accède à l'utilisateur root par ssh, il faut mettre la clé publique dans /root/.ssh/authorized_keys
on lance usermod -l <nom utilisateur> pi, mv /home/pi /home/<nom utilisateur>, usermod -d /home/<username> <username>, groupmod -n <username> pi et on change le mot de passe.

9
content/docs/infra/smart.md

@ -0,0 +1,9 @@
---
title: "Monitorer le matériel de stockage"
---
# Vérifier l'état des disques avec S.M.A.R.T.
[Sources](https://wiki.debian-fr.xyz/Smartmontools)
On utilise **smartmontools** qui utilise le protocole SMART afin de vérifier l'état des disques de notre infrastructure.
`sudo apt install smartmontools` pour installer l'utilitaire, `sudo smartctl -i /dev/sda` pour vérifier que le disque est compatible, `sudo smartctl -s on -o on -S on /dev/sda` pour activer les vérifications, `sudo smartctl -H /dev/sda` pour connaître l'état de santé des disques, `sudo smartctl -t short /dev/sda` pour lancer un test court, `sudo smartctl -t long /dev/sda` pour lancer un test long. `sudo smartctl -t selftest /dev/sda` pour voir les résultats des tests, `smartctl -A /dev/sda` pour voir la liste des attributs et leurs valeurs !

1
themes/book

@ -0,0 +1 @@
Subproject commit e91fa9024b072872dd069dbda08a094b7e2b647e
Loading…
Cancel
Save