Je suis parti sur un Raspberry Pi 5 avec un Hats qui fait Nvme 2230

1. Autoriser le routage

net.ipv4.ip_forward = 1 //dans le /etc/sysctl.conf

par défaut le net.ipv4.ip_forward est a 0

2. Trouver les interfaces

ip a

Les interfaces sont generalement ensXX ethX

Penser a autoriser le ssh avant de mettre en places vos regles

3. Iptables ou Nftables

Sur Ubuntu LTS 24/26, nftables est le successeur moderne d’iptables : il unifie IPv4/IPv6, simplifie la syntaxe et améliore la performance et la gestion des règles. iptables reste surtout présent pour la compatibilité, souvent via une couche de traduction, donc les anciennes commandes peuvent encore fonctionner. (pour mon plus grand desarois, je me suis rendu compte que c'etais nftables apres 10h de recherche).

4.1 Generalité

Depuis le noyau 2.4 de linux (aujourd'hui superieur a 6.XX). Le routage du noyau linux est basé sur netfilter un FrameWork de parefeu. Le routage peut se faire:
- PREROUTING : avant la décision de routage. Plus orienté DNAT conntrack
- POSTROUTING : après la décision de routage, juste avant la sortie. Plus orienté Snat masq
avant le routage(prerouting qui contient DNAT/conntrack) ou apres(postrouting qui contient SNAT/Masq) Netfilter est un cadriciel du noyau Linux permettant le filtrage réseau, le NAT et le suivi des connexions. Il est intégré au noyau Linux à partir de la version 2.4. Le projet netfilter/iptables a été lancé en 1998 par Rusty Russell.

4.1.1 Definitions utiles

DNAT = Destination Nat SNAT = Sources Nat

4.2 Iptables

Iptables utilise des tables pour ses diferente chaines (des lignes de passage pour l'image) qui sont de plusieurs type:

Table	Role	Chaine Disponibles
filter	Filtre	INPUT,OUTPUT,FORWARD
nat	Translation d'adress	PREROUTING, OUTPUT, POSTROUTING
mangle	Modification	TOUT
raw	Bypass de conntrack	PREROUTING, OUTPUT

Iptables utilise des cibles(targets) dans sa gestions de règles du style

• Accept - Laisse passer
• Drop - jeter sans reponse
• Reject - Jeter avec reponse
• Log - Logger dans le syslog
• Masquerade - SNAT dynamique
• DNAT - Reecriture de la Destination (IP dest)

Pour chaque regles il faut une table uen chain un match puis un target voici les match

• INPUT
• OUTPUT
• FORWARD
• PREROUTING
• POSTROUTING

4.2.1 Syntaxe

iptables -t [table] -A [chain] [match] -j [target]
# -A = Append -I = Insert (en tête) -D = Delete

4.2.2 Exemples

# Autoriser SSH entrant
iptables -A INPUT -p tcp --dport 22 -j ACCEPT

# Bloquer une IP
iptables -A INPUT -s 192.168.1.50 -j DROP

# Voir les connexions
iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT

4.2.3 Commandes importantes

# Afficher les règles avec numéros
iptables -L -n -v --line-numbers


# Sauvegarder / restaurer
# faut installer l'outils iptables-persistent
apt install iptables-persistent
netfilter-persistent save # premiere sauvegarde
iptables-save > /etc/iptables/rules.v4
iptables-restore < /etc/iptables/rules.v4


4.3 Nftables

nftables est le remplaçant moderne d’iptables et il est installé/activé par défaut sur de nombreuses distributions récentes (dont Ubuntu 22.04 et suivantes). Il fournit une CLI unique (nft) qui unifie IPv4/IPv6 et simplifie la gestion des règles.
nftables a une hierarchie qui est Table => chain => rules
Par défaut, il n'y a pas de règles pre remplis il faut les creer sois meme (certain service ou distribution le font par default)
Contrairement à iptables où il y a plusieurs commandes distinctes (iptables, ip6tables, arptables, ebtables), nftables gère tout depuis la même interface
La tables la plus courante pour nftables est inet elle gere IPV4 et IPV6

4.3.1 Regles de base

# Créer une table
nft add table inet filter

# Créer une chain (type filter, hook input, priorité 0)
nft add chain inet filter input { type filter hook input priority 0 \; policy drop \; }

# Ajouter une règle
nft add rule inet filter input tcp dport 22 accept



#!/usr/sbin/nft -f
flush ruleset

table inet filter {
    chain input {
        type filter hook input priority 0; policy drop;

        # Loopback
        iif "lo" accept

        # Connexions établies
        ct state established,related accept

        # SSH
        tcp dport 22 accept

        # HTTP/S
        tcp dport { 80, 443 } accept

        # Ping
        icmp type echo-request accept
        icmpv6 type echo-request accept

        # Tout le reste = drop (policy)
    }

    chain forward {
        type filter hook forward priority 0; policy drop;
    }

    chain output {
        type filter hook output priority 0; policy accept;
    }
}

table ip nat {
    chain postrouting {
        type nat hook postrouting priority 100;
        oif "eth0" masquerade
    }
}

4.3.2 Appiquer les regles

nft -f /etc/nftables.conf #pour charger le code
systemctl enable --now nftables

4.3.3 commandes utiles

                                                nft list ruleset              # Voir tout
nft list table inet filter    # Une table
nft flush ruleset             # Tout effacer
nft -f /etc/nftables.conf     # Charger un fichier

# Supprimer une règle par handle
nft list ruleset -a           # Affiche les handles
nft delete rule inet filter input handle 5

Penser a mettre en place un dhcp pour la simplicité

1. Prérequis

# Un VPS (Hetzner recommandé car EU, ou Oracle pour du gratuit)
# Une machine locale avec les services à exposer

Hetzner CX23 (Intel®/AMD, 4.48€/mois) suffit largement pour ce rôle de point d'entrée.

J'ai choisi Hetzner car je prevois de faire un serveur de Mail.

2. Relier le VPS au homelab via WireGuard

# Sur le VPS et la machine locale : apt install wireguard
# Voir section WireGuard de la documentation

Le VPS devient la passerelle publique — le homelab reste injoignable directement depuis internet.

3. Installer HAProxy sur le VPS

apt install haproxy
# Voir section HAProxy de la documentation

HAProxy reçoit les requêtes publiques et les redirige vers le homelab via le tunnel WireGuard.

4. Activer le forward dans HAProxy

# /etc/haproxy/haproxy.cfg
frontend web_public
bind *:80
bind *:443 ssl crt /etc/haproxy/certs/example.pem
default_backend homelab

backend homelab
server nas 10.0.0.2:80 check  # IP WireGuard du homelab

L'IP 10.0.0.2 est l'adresse WireGuard de la machine locale — pas l'IP publique.

5. Sécuriser le VPS avec UFW

ufw default deny incoming
ufw allow 22/tcp    # SSH
ufw allow 80/tcp    # HTTP
ufw allow 443/tcp   # HTTPS
ufw allow 51820/udp # WireGuard
ufw enable

Ajouter le port 22 a UFW avant de l'activer.

6. Certificat SSL avec Certbot

apt install certbot
certbot certonly --standalone -d example.com
# Voir section Certbot de la documentation

Le certificat est généré sur le VPS — c'est lui qui termine le TLS, le homelab reçoit du HTTP en clair via WireGuard.

1. Prérequis

# Un serveur ou NAS sous Ubuntu LTS (22.04 ou 24.04)
# Au minimum 2 disques pour le RAID
# Docker et Docker Compose installés

Ubuntu 24.04 LTS recommandé — nftables remplace iptables, à garder en tête pour les règles firewall.

2. Vérifier l'état du RAID mdadm

# Voir l'état général
cat /proc/mdstat

# Détail de l'array
mdadm --detail /dev/md0

S'assurer que l'array est en état "clean" avant de continuer. Un array "degraded" signifie qu'un disque est absent ou défaillant.

3. Monter le RAID

# Créer le point de montage
mkdir -p /mnt/raid

# Montage manuel
mount /dev/md0 /mnt/raid

# Montage automatique au boot — ajouter dans /etc/fstab
/dev/md0  /mnt/raid  ext4  defaults,nofail  0  2

L'option nofail évite un blocage au boot si le RAID n'est pas disponible.

4. Préparer le dossier de données Nextcloud

mkdir -p /mnt/raid/nextcloud/data
mkdir -p /mnt/raid/nextcloud/db
chown -R www-data:www-data /mnt/raid/nextcloud/data

Les données Nextcloud et la base de données sont stockées directement sur le RAID.

5. Installer Nextcloud via Docker Compose

# /opt/nextcloud/docker-compose.yml
services:
db:
    image: mariadb:11
    restart: always
    volumes:
    - /mnt/raid/nextcloud/db:/var/lib/mysql
    environment:
    MYSQL_ROOT_PASSWORD: rootpasswd
    MYSQL_DATABASE: nextcloud
    MYSQL_USER: nextcloud
    MYSQL_PASSWORD: nextcloudpasswd

nextcloud:
    image: nextcloud:apache
    restart: always
    ports:
    - "8080:80"
    volumes:
    - /mnt/raid/nextcloud/data:/var/www/html
    environment:
    MYSQL_HOST: db
    MYSQL_DATABASE: nextcloud
    MYSQL_USER: nextcloud
    MYSQL_PASSWORD: nextcloudpasswd
    depends_on:
    - db

L'image nextcloud:apache inclut Apache — pas besoin de l'installer séparément.

6. Démarrer les conteneurs

cd /opt/nextcloud
docker compose up -d

# Vérifier que tout tourne
docker compose ps

7. Configurer le reverse proxy Apache sur l'hôte

# /etc/apache2/sites-available/nextcloud.conf
<VirtualHost *:80>
    ServerName cloud.example.com
    ProxyPass        / http://localhost:8080/
    ProxyPassReverse / http://localhost:8080/
</VirtualHost>

a2enmod proxy proxy_http
a2ensite nextcloud
systemctl reload apache2

Apache sur l'hôte fait office de reverse proxy vers le conteneur Nextcloud sur le port 8080.

8. Vérification

# Logs Nextcloud
docker compose logs -f nextcloud

# Vérifier l'état du RAID pendant l'utilisation
watch -n 5 'cat /proc/mdstat'