**(Attention : Avec un /30 en LAN, vous n’avez qu’une seule IP utilisable. Pour plus d’IPs, prenez un bloc plus grand, ex:** `/29`**. ou faites du NAT 1:1 ou attribution en /32)**
### **Configurations :** #### **Linux :** ``` # Assigner l’IP de la passerelle (votre routeur) ip addr add 198.51.100.1/30 dev eth1 ``` #### **MikroTik :** ``` /ip address add address=198.51.100.1/30 interface=ether1 ``` #### **Cisco :** ``` interface GigabitEthernet0/1 ip address 98.51.100.1 255.255.255.252 no shutdown ``` #### **Juniper :** ``` set interfaces ge-0/0/1 unit 0 family inet address 198.51.100.1/30 ``` --- ### **5.6. Méthode 3 : Routage en /32 (1 IP publique par machine)** **Avantages principaux :** Adressage propre, explicite, aucune perte d'IP **Inconvénients : N**on supporté par Windows, mal supporté par certains routeurs / OS, 100% du trafic passe par le routeur ### **Configurations :** #### **Linux :** ``` # Sur le routeur : ip route add 198.51.100.0/30 dev eth0 # eth0 = interface vers la Machine A # Sur la Machine A : ip addr add 203.0.113.1/32 dev eth0 ip route add default via 192.168.1.100 dev eth0 # IP de votre routeur local # Si error lors de l'ajout de la route, il faut ajouter une règle : # ip route add 192.168.1.100 dev eth0 ``` #### **MikroTik :** ``` /ip route add dst-address=198.51.100.0/30 interface=LAN # Sur la Machine A : # Pareil que pour Linux, IP : 198.51.100.1 Gateway 192.168.1.100 ``` #### **Cisco :** ``` ip route 198.51.100.0 255.255.255.252 GigabitEthernet0/0/1 ``` #### **Juniper :** ``` set routing-options static route 198.51.100.0/30 interface ge-0/0/1 ``` --- ### **5.7. Router le trafic sortant par le tunnel**Si vous ne faites pas cette étape, les IPs ne fonctionneront pas
#### **Linux (ip route + policy routing)** ```bash # Création d'une table de routage echo "142 tunnel" >> /etc/iproute2/rt_tables # Routage vers l'extérieur via l'IP locale de la plateforme ip route add default via 100.64.0.5 table tunnel # Tout le trafic en provenance de nos IPs publiques, sortent via le tunnel ip rule add from 198.51.100.0/30 table tunnel ``` **Effet :** Tout hôte du réseau `198.51.100.0/30` sort par le tunnel, les autres via la gateway par défaut.Si vous êtes à l'aise avec les VRF, il est aussi possible de faire avec :
```bash ip link add vrf-GRE type vrf table 142 # On créer la VRF ip link set dev tunnel0 master vrf-GRE # On ajoute le tunnel dans la VRF ip route add default via 100.64.0.5 table 142 # On ajoute la route par défaut ip link set dev eth0 master vrf-GRE # On ajoute notre interface LAN dans la VRF (Attention si elle est partagée avec votre réseau local, le réseau local ne marchera plus, pour cela vous pouvez créer une interface dummy ou utiliser une interface séparée) ``` --- #### MikroTik ```bash /routing/table/add name=GRE-OUT fib /routing/rule/add action=lookup-only-in-table table=GRE-OUT src-address=198.51.100.0/30 /ip route add dst-address=0.0.0.0/0 gateway=100.64.0.5 routing-table=GRE-OUT ```Si vous êtes à l'aise avec les VRF, il est aussi possible de faire avec :
```bash /ip/vrf add name=GRE-VRF interfaces=gre1,ether1 /ip route add routing-table=GRE-VRF dst-address=0.0.0.0/0 gateway=100.64.0.5 ``` --- #### Cisco ```fortran ip access-list extended GRE-OUT permit ip 198.51.100.0 0.0.0.3 any route-map GRE-ROUTE permit 10 match ip address GRE-OUT set ip next-hop 100.64.0.5 interface GigabitEthernet0/0 ip policy route-map GRE-ROUTE ``` 📌 On applique l’ACL sur l’interface LAN → tout ce bloc sort vers Tunnel0.Si vous êtes à l'aise avec les VRF, il est aussi possible de faire avec
```fortran vrf definition OUT-GRE rd 100:1 ! address-family ipv4 exit-address-family ! interface Tunnel0 vrf forwarding OUT-GRE ! interface GigabitEthernet0/0/1 vrf forwarding OUT-GRE ! ! Default route de la VRF vers le vrai Next-Hop ip route vrf OUT-GRE 0.0.0.0 0.0.0.0 100.64.0.5 ```La syntaxe Cisco peux varier selon les versions de l'OS
--- #### Arista ```bash ip access-list GRE-OUT 10 permit ip 198.51.100.0/30 any route-map GRE-PBR permit 10 match ip address GRE-OUT set ip next-hop 100.64.0.5 # IP tunnel remote interface Ethernet1 ip policy route-map GRE-PBR ```Si vous êtes à l'aise avec les VRF, il est aussi possible de faire avec
```bash vrf instance GRE-VRF interface Tunnel0 vrf GRE-VRF interface Eth1 vrf GRE-VRF ip route vrf GRE-VRF 0.0.0.0/0 10.64.0.5 ``` --- #### Juniper ```bash set routing-instances GRE-VRF instance-type virtual-router set routing-instances GRE-VRF interface gr-0/0/0.0 set routing-instances GRE-VRF routing-options static route 0.0.0.0/0 next-hop 100.64.0.5 set firewall family inet filter PBR term GRE from source-address 198.51.100.0/30 set firewall family inet filter PBR term GRE then routing-instance GRE-VRF set firewall family inet filter PBR term DEFAULT then accept set interfaces ge-0/0/1 unit 0 family inet filter input PBR ``` 📌 Le trafic matché bascule dans la VRF = sortie via GRE. ## **6. Commandes spécifiques par constructeur**| Constructeur | Commande pour vérifier le tunnel | Commande pour vérifier le routage |
|---|---|---|
| **Cisco** | `show interface Tunnel0` | `show ip route` |
| **Arista** | `show interface Tunnel0` | `show ip route` |
| **Juniper** | `show interfaces gr-0/0/0` | `show route` |
| **Linux** | `ip tunnel show` | `ip route` |
| **MikroTik** | `/interface gre print` | `/ip route print` |
| **Symptôme** | **Cause Possible** | **Solution** |
|---|---|---|
| Le tunnel ne répond pas | Port 47 bloqué | Vérifiez la redirection sur votre box |
| Les IPs publiques ne pingent pas | Route manquante ou NAT mal configuré | Vérifiez `ip route` ou `show ip route` |
| Latence élevée / Pertes de paquets | MTU trop grande | Réduisez la MTU : `ip link set mtu 1476 dev tunnel0` |
**(Attention : Avec un /30 en LAN, vous n'avez qu'une seule IP utilisable. Pour plus d'IPs, prenez un bloc plus grand, ex:** `/29`**. ou faites du NAT 1:1 ou attribution en /32)**
### **Configurations :** #### **Linux :** ```bash # Assigner l'IP de la passerelle (votre routeur) ip addr add 198.51.100.1/30 dev eth1 ``` #### **MikroTik :** ``` /ip address add address=198.51.100.1/30 interface=ether1 ``` #### **Cisco :** ``` interface GigabitEthernet0/1 ip address 198.51.100.1 255.255.255.252 no shutdown ``` #### **Juniper :** ```bash set interfaces ge-0/0/1 unit 0 family inet address 198.51.100.1/30 ``` --- ### **5.6. Méthode 3 : Routage en /32 (1 IP publique par machine)** **Avantages principaux :** Adressage propre, explicite, aucune perte d'IP **Inconvénients :** Non supporté par Windows, mal supporté par certains routeurs / OS, 100% du trafic passe par le routeur ### **Configurations :** #### **Linux :** ```bash # Sur le routeur : ip route add 198.51.100.0/30 dev eth0 # eth0 = interface vers la Machine A # Sur la Machine A : ip addr add 203.0.113.1/32 dev eth0 ip route add default via 192.168.1.100 dev eth0 # IP de votre routeur local # Si error lors de l'ajout de la route, il faut ajouter une règle : # ip route add 192.168.1.100 dev eth0 ``` #### **MikroTik :** ``` /ip route add dst-address=198.51.100.0/30 interface=LAN # Sur la Machine A : # Pareil que pour Linux, IP : 198.51.100.1 Gateway 192.168.1.100 ``` #### **Cisco :** ``` ip route 198.51.100.0 255.255.255.252 GigabitEthernet0/0/1 ``` #### **Juniper :** ```bash set routing-options static route 198.51.100.0/30 interface ge-0/0/1 ``` --- ### **5.7. Router le trafic sortant par le tunnel**Si vous ne faites pas cette étape, les IPs ne fonctionneront pas
#### **Linux (ip route + policy routing)** ```bash # Création d'une table de routage echo "143 tunnel" >> /etc/iproute2/rt_tables # Routage vers l'extérieur via l'IP locale de la plateforme ip route add default via 100.64.0.5 table tunnel # Tout le trafic en provenance de nos IPs publiques, sortent via le tunnel ip rule add from 198.51.100.0/30 table tunnel ``` **Effet :** Tout hôte du réseau `198.51.100.0/30` sort par le tunnel, les autres via la gateway par défaut.Si vous êtes à l'aise avec les VRF, il est aussi possible de faire avec :
```bash ip link add vrf-IPIP type vrf table 143 # On créer la VRF ip link set dev tunnel0 master vrf-IPIP # On ajoute le tunnel dans la VRF ip route add default via 100.64.0.5 table 143 # On ajoute la route par défaut ip link set dev eth0 master vrf-IPIP # On ajoute notre interface LAN dans la VRF (Attention si elle est partagée avec votre réseau local, le réseau local ne marchera plus, pour cela vous pouvez créer une interface dummy ou utiliser une interface séparée) ``` --- #### MikroTik ```bash /routing/table/add name=IPIP-OUT fib /routing/rule/add action=lookup-only-in-table table=IPIP-OUT src-address=198.51.100.0/30 /ip route add dst-address=0.0.0.0/0 gateway=100.64.0.5 routing-table=IPIP-OUT ```Si vous êtes à l'aise avec les VRF, il est aussi possible de faire avec :
```bash /ip/vrf add name=IPIP-VRF interfaces=ipip1,ether1 /ip route add routing-table=IPIP-VRF dst-address=0.0.0.0/0 gateway=100.64.0.5 ``` --- #### Cisco ```fortran ip access-list extended IPIP-OUT permit ip 198.51.100.0 0.0.0.3 any route-map IPIP-ROUTE permit 10 match ip address IPIP-OUT set ip next-hop 100.64.0.5 interface GigabitEthernet0/0 ip policy route-map IPIP-ROUTE ``` 📌 On applique l'ACL sur l'interface LAN → tout ce bloc sort vers Tunnel0.Si vous êtes à l'aise avec les VRF, il est aussi possible de faire avec :
```fortran vrf definition OUT-IPIP rd 100:1 ! address-family ipv4 exit-address-family ! interface Tunnel0 vrf forwarding OUT-IPIP ! interface GigabitEthernet0/0/1 vrf forwarding OUT-IPIP ! ! Default route de la VRF vers le vrai Next-Hop ip route vrf OUT-IPIP 0.0.0.0 0.0.0.0 100.64.0.5 ```La syntaxe Cisco peux varier selon les versions de l'OS
--- #### Arista ```bash ip access-list IPIP-OUT 10 permit ip 198.51.100.0/30 any route-map IPIP-PBR permit 10 match ip address IPIP-OUT set ip next-hop 100.64.0.5 # IP tunnel remote interface Ethernet1 ip policy route-map IPIP-PBR ```Si vous êtes à l'aise avec les VRF, il est aussi possible de faire avec :
```bash vrf instance IPIP-VRF interface Tunnel0 vrf IPIP-VRF interface Eth1 vrf IPIP-VRF ip route vrf IPIP-VRF 0.0.0.0/0 100.64.0.5 ``` --- #### Juniper ```bash set routing-instances IPIP-VRF instance-type virtual-router set routing-instances IPIP-VRF interface ip-0/0/0.0 set routing-instances IPIP-VRF routing-options static route 0.0.0.0/0 next-hop 100.64.0.5 set firewall family inet filter PBR term IPIP from source-address 198.51.100.0/30 set firewall family inet filter PBR term IPIP then routing-instance IPIP-VRF set firewall family inet filter PBR term DEFAULT then accept set interfaces ge-0/0/1 unit 0 family inet filter input PBR ``` 📌 Le trafic matché bascule dans la VRF = sortie via IPIP. ## **6. Commandes spécifiques par constructeur** | Constructeur | Commande pour vérifier le tunnel | Commande pour vérifier le routage | |---|---|---| | **Cisco** | `show interface Tunnel0` | `show ip route` | | **Arista** | `show interface Tunnel0` | `show ip route` | | **Juniper** | `show interfaces ip-0/0/0` | `show route` | | **Linux** | `ip tunnel show` | `ip route` | | **MikroTik** | `/interface ipip print` | `/ip route print` | ## **7. Vérification et Dépannage** ### **7.1. Tester la connectivité** - **Depuis votre routeur** : ```bash ping 100.64.0.5 # Ping de l'ip distante du tunnel ``` - **Depuis une machine locale** : ```bash ping 8.8.8.8 # Vérification internet curl -4 ifconfig.me # Vérification de l'IP sortante ``` ### **7.2. Problèmes courants** | **Symptôme** | **Cause Possible** | **Solution** | |---|---|---| | Le tunnel ne répond pas | Protocole 4 bloqué | Vérifiez la redirection sur votre box / configurez une DMZ | | Les IPs publiques ne pingent pas | Route manquante ou NAT mal configuré | Vérifiez `ip route` ou `show ip route` | | Latence élevée / Pertes de paquets | MTU trop grande | Réduisez la MTU : `ip link set mtu 1480 dev tunnel0` | --- ## **8. Bonnes Pratiques** 1. **Sécurité** : - Filtrez le trafic entrant avec un pare-feu (ex: `iptables` ou ACL Cisco). - IPIP n'offre aucun chiffrement. Envisagez IPsec si le chiffrement est nécessaire. 2. **Performance** : - Réduisez la MTU à `1480` pour éviter la fragmentation (overhead IPIP = 20 octets). - Activez le **keepalive** sur le tunnel (ex: `keepalive 10 3` sur Cisco). 3. **Redondance** : - Configurez un deuxième tunnel IPIP pour le failover. --- # Tunnel L3 - Wireguard ## **1. Introduction : Pourquoi utiliser Wireguard ?** ### **1.1. À quoi sert un tunnel Wireguard ?** Un tunnel **Wireguard** permet de créer un lien direct et sécurisé entre deux réseaux distants. Wireguard est un protocole VPN moderne, rapide et simple à configurer. **Exemple concret :** - Vous avez un réseau local derrière une box opérateur standard. - Vous voulez une IP publique sur une ou des machines sur votre réseau local ### **1.2. Avantages de Wireguard** - Extrêmement simple à configurer. - Chiffrement intégré (pas besoin d'IPsec en complément). - Connexion possible en IPv4 & IPv6. - Règles de routage ajoutées automatiquement. - Aucun port à ouvrir côté client (traverse le NAT nativement). - Protocole léger et performant. ### **1.3. Inconvénients** - Moins de support natif sur certains routeurs (Cisco, Juniper...). - Protocole plus récent que GRE ou IPIP. --- ## **2. Prérequis** ### **2.1. Ce dont vous avez besoin** - Un **routeur compatible Wireguard** (Linux, MikroTik, etc.). - Un **service Tunnel-IP**. ### **2.2. Ports et NAT** - Wireguard utilise **UDP** (port par défaut : 51820). - Contrairement à GRE et IPIP, **aucune redirection de port n'est nécessaire côté client**. Wireguard traverse le NAT nativement grâce au mécanisme de keepalive. --- ## **3. Étape 1 : Créer le tunnel sur Tunnel-IP.com** ### **3.1. Accéder au tableau de bord** 1. Connectez-vous à [panel.tunnel-ip.com](https://panel.tunnel-ip.com) 2. Allez dans **"Tunnels"** > **"Wireguard"**. 3. Remplissez les informations : - **Nom du tunnel** (ex : `Tunnel_X`). - **Endpoint** (IP publique du routeur / box, ex : `203.0.113.1`). 4. Validez. La plateforme s'occupera de choisir les IPs et de configurer le tunnel côté Tunnel-IP.com. 5. Attendez que le tunnel soit créé 6. Cliquez sur "Accéder" pour récupérer les détails du tunnel Il vous suffit de configurer votre wireguard avec les paramètres indiqués en **1**, pour linux vous pouvez suivre [ce tutoriel](https://www.malekal.com/utiliser-wg-quick-wireguard/) ### **3.2. Créer le subnet (Route côté plateforme)** 1\. Allez dans "Subnets" 2\. Copiez le bloc d'IP publique et collez le dans le formulaire 3\. Cliquez sur Créer 4\. Une fois son statut à "Actif", la route est correctement installée sur les routeurs de la plateforme, il ne vous reste plus qu'à configurer le tunnel --- ## **4. Étape 2 : Configurer le tunnel** ### **4.1. Exemple pour Linux (Ubuntu/Debian) avec wg-quick** #### **Étapes :** 1. **Installer Wireguard** : ``` apt update && apt install wireguard -y ``` 2. **Créer le fichier de configuration** : ``` nano /etc/wireguard/wg0.conf ``` Contenu du fichier (à adapter avec les paramètres fournis par la plateforme) : ``` [Interface] PrivateKey =Wireguard n'est pas nativement supporté sur la plupart des routeurs Cisco (IOS/XE), Arista (EOS) et Juniper (JunOS). Si vous devez utiliser l'un de ces équipements, vous pouvez :
- Utiliser un serveur Linux comme point de terminaison Wireguard, puis router le trafic vers votre routeur. - Utiliser un autre type de tunnel (GRE, IPIP, IPsec) nativement supporté par ces équipements. --- ## **5. Étape 3 : Router les IP publiques vers le tunnel** ### **5.1. Pourquoi ?** La plateforme vous route un bloc d'IP publiques (ex : `198.51.100.0/30`) sur votre IP interne du tunnel, afin que ces IPs fonctionnent correctement, vous devez router ce bloc d'IP sur votre réseau et le trafic sortant par le tunnel. Pour cela, 3 principales méthodes s'offrent à vous : - **NAT 1:1** (1 IP publique → 1 IP privée) - **LAN public** (utilisation directe des IPs publiques) - **Routage en /32** (1 IP publique par machine) --- ### **5.2. Rappel : Architecture du Tunnel** ``` Internet → [Infrastructure Tunnel-IP.com] → (Tunnel Wireguard) → [Votre Routeur] → [Votre Réseau] ``` - La plateforme vous route un bloc public (ex: `198.51.100.0/30`). - Votre routeur doit gérer ce bloc pour exposer vos services. --- ### **5.3. Cas d'Usage du Bloc /30** Un `/30` contient **4 adresses IP** : - `198.51.100.0` : Adresse réseau (inutilisable en LAN). - `198.51.100.1` : IP Utilisable - `198.51.100.2` : IP Utilisable - `198.51.100.3` : Adresse broadcast (inutilisable en LAN). --- ### **5.4. Méthode 1 : NAT 1:1 (Translation 1 IP publique → 1 IP privée)** **Avantages principaux :** Permet de ne pas avoir à modifier l'adressage privé de votre réseau, et permet d'utiliser l'IP de réseau et broadcast. **Inconvénients :** Adressage moins clair (Conversion IP publique -> privée), charge plus lourde sur le routeur (Le routeur est en charge de la translation NAT) ### **Schéma :** ``` Internet → Infrastructure Tunnel-IP.com → [Votre Routeur] 198.51.100.0 → 192.168.1.100 (Privée) ``` ### **Configurations :** #### **Linux :** ``` # Activer l'IP Forwarding echo 1 > /proc/sys/net/ipv4/ip_forward # Ajouter l'IP sur une interface (on utilise la loopback par exemple) ip a add 198.51.100.0/32 dev lo # 1:1 Static NAT iptables -t nat -A PREROUTING -d 198.51.100.0 -j DNAT --to-destination 192.168.1.100 iptables -t nat -A POSTROUTING -s 192.168.1.100 -j SNAT --to-source 198.51.100.0 ``` #### **MikroTik :** ``` /ip address add address=198.51.100.0/32 interface=eth0 /ip firewall nat add chain=dstnat dst-address=198.51.100.0 action=dst-nat to-addresses=192.168.1.100 /ip firewall nat add chain=srcnat src-address=192.168.1.100 action=src-nat to-addresses=198.51.100.0 ``` --- ### **5.5 Méthode 2 : LAN Public (Utilisation directe des IPs publiques)** **Avantages principaux :** Adressage propre, explicite **Inconvénients :** Perte de 2 IPs utilisables (IP de réseau et IP de broadcast) + 1 IP est forcément assignée au routeur.**(Attention : Avec un /30 en LAN, vous n'avez qu'une seule IP utilisable. Pour plus d'IPs, prenez un bloc plus grand, ex:** `/29`**. ou faites du NAT 1:1 ou attribution en /32)**
### **Configurations :** #### **Linux :** ``` # Assigner l'IP de la passerelle (votre routeur) ip addr add 198.51.100.1/30 dev eth1 ``` #### **MikroTik :** ``` /ip address add address=198.51.100.1/30 interface=ether1 ``` --- ### **5.6. Méthode 3 : Routage en /32 (1 IP publique par machine)** **Avantages principaux :** Adressage propre, explicite, aucune perte d'IP **Inconvénients :** Non supporté par Windows, mal supporté par certains routeurs / OS, 100% du trafic passe par le routeur ### **Configurations :** #### **Linux :** ``` # Sur le routeur : ip route add 198.51.100.0/30 dev eth0 # eth0 = interface vers la Machine A # Sur la Machine A : ip addr add 203.0.113.1/32 dev eth0 ip route add default via 192.168.1.100 dev eth0 # IP de votre routeur local # Si error lors de l'ajout de la route, il faut ajouter une règle : # ip route add 192.168.1.100 dev eth0 ``` #### **MikroTik :** ``` /ip route add dst-address=198.51.100.0/30 interface=LAN # Sur la Machine A : # Pareil que pour Linux, IP : 198.51.100.1 Gateway 192.168.1.100 ``` --- ### **5.7. Router le trafic sortant par le tunnel**Si vous ne faites pas cette étape, les IPs ne fonctionneront pas
Si vous avez configuré `AllowedIPs = 0.0.0.0/0` dans votre configuration Wireguard, tout le trafic passe déjà par le tunnel. Cependant, si vous souhaitez un routage plus fin (uniquement le trafic des IPs publiques), utilisez les méthodes ci-dessous :
#### **Linux (ip route + policy routing)** ``` # Création d'une table de routage echo "144 tunnel" >> /etc/iproute2/rt_tables # Routage vers l'extérieur via l'IP locale de la plateforme ip route add default via 100.64.0.5 table tunnel # Tout le trafic en provenance de nos IPs publiques, sortent via le tunnel ip rule add from 198.51.100.0/30 table tunnel ``` **Effet :** Tout hôte du réseau `198.51.100.0/30` sort par le tunnel, les autres via la gateway par défaut.Si vous êtes à l'aise avec les VRF, il est aussi possible de faire avec :
``` ip link add vrf-WG type vrf table 144 # On créer la VRF ip link set dev wg0 master vrf-WG # On ajoute le tunnel dans la VRF ip route add default via 100.64.0.5 table 144 # On ajoute la route par défaut ip link set dev eth0 master vrf-WG # On ajoute notre interface LAN dans la VRF (Attention si elle est partagée avec votre réseau local, le réseau local ne marchera plus, pour cela vous pouvez créer une interface dummy ou utiliser une interface séparée) ``` --- #### MikroTik ``` /routing/table/add name=WG-OUT fib /routing/rule/add action=lookup-only-in-table table=WG-OUT src-address=198.51.100.0/30 /ip route add dst-address=0.0.0.0/0 gateway=100.64.0.5 routing-table=WG-OUT ```Si vous êtes à l'aise avec les VRF, il est aussi possible de faire avec :
``` /ip/vrf add name=WG-VRF interfaces=wg0,ether1 /ip route add routing-table=WG-VRF dst-address=0.0.0.0/0 gateway=100.64.0.5 ``` --- ## **6. Commandes spécifiques par constructeur**| Constructeur | Commande pour vérifier le tunnel | Commande pour vérifier le routage |
|---|---|---|
| **Linux** | `wg show` | `ip route` |
| **MikroTik** | `/interface wireguard print` | `/ip route print` |
| **Symptôme** | **Cause Possible** | **Solution** |
|---|---|---|
| Le tunnel ne s'établit pas (pas de handshake) | Clé publique/privée incorrecte | Vérifiez les clés avec `wg show` et comparez avec la plateforme |
| Le tunnel ne s'établit pas | Endpoint incorrect ou port UDP bloqué | Vérifiez l'endpoint et que le port UDP est accessible |
| Les IPs publiques ne pingent pas | Route manquante ou NAT mal configuré | Vérifiez `ip route` ou `/ip route print` |
| Latence élevée / Pertes de paquets | MTU trop grande | Réduisez la MTU : `ip link set mtu 1420 dev wg0` |
| Connexion perdue derrière NAT | PersistentKeepalive non configuré | Ajoutez `PersistentKeepalive = 25` dans la configuration du peer |
Les tunnels L2 fonctionnent avec des **bridges** sur la plateforme. Un bridge est un switch virtuel qui regroupe vos tunnels L2 et vos subnets. Vous devez d'abord créer un bridge, puis créer le tunnel en l'associant à ce bridge.
### **3.1. Créer le bridge** 1. Connectez-vous à [panel.tunnel-ip.com](https://panel.tunnel-ip.com) 2. Allez dans **"Bridges"**. 3. Cliquez sur **"Ajouter un Bridge"** et donnez-lui un nom. 4. Validez. Le bridge sera créé sur la plateforme. ### **3.2. Créer le tunnel GRETAP** 1. Allez dans **"Tunnels"** > **"GRETAP"**. 2. Remplissez les informations : - **Nom du tunnel** (ex : `GRETAP_Tunnel`). - **Endpoint** (IP publique du routeur / box, ex : `203.0.113.1`). - **Bridge** : Sélectionnez le bridge créé précédemment. - **MTU** : Taille maximale des paquets (-1 pour laisser la plateforme choisir). - **Clé** (si applicable). 3. Validez. La plateforme s'occupera de configurer le tunnel côté Tunnel-IP.com. 4. Attendez que le tunnel soit créé 5. Cliquez sur "Accéder" pour récupérer les détails du tunnel ### **3.3. Créer le subnet** 1\. Allez dans **"Subnets"** 2\. Copiez le bloc d'IP publique et collez le dans le formulaire 3\. Sélectionnez le **bridge** (et non un tunnel directement) comme destination 4\. Cliquez sur Créer 5\. Une fois son statut à "Actif", la route est correctement installée sur les routeurs de la plateforme**Important :** La première IP du subnet sera utilisée comme **gateway** sur le bridge côté plateforme. Par exemple, pour le subnet `198.51.100.0/29`, la gateway sera `198.51.100.1`.
--- ## **4. Étape 2 : Configurer le tunnel**Contrairement au GRE classique (L3), GRETAP transporte des trames Ethernet (Layer 2). Côté client, vous devez créer l'interface GRETAP puis la **bridger** avec votre interface LAN (ou lui assigner directement une IP du subnet).
### **4.1. Exemple pour Linux (Ubuntu/Debian)** #### **Étapes :** 1. **Créer l'interface GRETAP** : ```bash ip link add gretap0 type gretap remote 172.16.126.33 ip link set gretap0 up ``` - `gretap0` : Nom de l'interface GRETAP. - `remote 172.16.126.33` : IP distante (Tunnel-IP.com). 2. **Option A : Assigner directement une IP publique** : Si vous souhaitez que le routeur lui-même ait une IP publique : ```bash ip addr add 198.51.100.2/29 dev gretap0 ip route add default via 198.51.100.1 dev gretap0 ``` - `198.51.100.2/29` : Une IP du subnet (la première IP .1 est la gateway côté plateforme). - `198.51.100.1` : Gateway (première IP du subnet, côté plateforme). 3. **Option B : Bridger avec une interface LAN** : Si vous souhaitez que des machines sur votre LAN aient directement les IPs publiques : ```bash ip link add br0 type bridge ip link set br0 up ip link set gretap0 master br0 ip link set eth1 master br0 # Interface LAN vers vos machines ``` Les machines connectées à `eth1` pourront alors utiliser les IPs du subnet directement, avec `198.51.100.1` comme gateway. 4. **Activer le forwarding** (si nécessaire) : ```bash echo 1 > /proc/sys/net/ipv4/ip_forward ``` **(Pour rendre permanent, ajoutez* `net.ipv4.ip_forward=1` *dans* `/etc/sysctl.conf`*.)** --- ### **4.2. Exemple pour MikroTik**MikroTik ne supporte pas nativement le GRETAP en tant que tel. Cependant, l'interface EoIP de MikroTik remplit la même fonction (tunnel GRE Layer 2). Si vous souhaitez interopérer avec un GRETAP Linux/Cisco, vous pouvez utiliser un EoIP côté MikroTik avec les mêmes paramètres, ou utiliser un bridge avec un tunnel GRE classique.
#### **Alternative avec EoIP :** 1. **Créer l'interface EoIP** : ```bash /interface/eoip/add remote-address=172.16.126.33 tunnel-id=100 name=eoip-tunnel ``` 2. **Bridger avec une interface LAN** : ```bash /interface/bridge/add name=br-gretap /interface/bridge/port/add bridge=br-gretap interface=eoip-tunnel /interface/bridge/port/add bridge=br-gretap interface=ether2 # Interface LAN ``` 3. **Option : Assigner une IP au bridge** : ```bash /ip/address/add address=198.51.100.2/29 interface=br-gretap /ip/route/add dst-address=0.0.0.0/0 gateway=198.51.100.1 ``` --- ### **4.3. Exemple pour Cisco (IOS/XE)** #### **Étapes :** 1. **Accéder au mode configuration** : ```bash enable configure terminal ``` 2. **Créer l'interface tunnel en mode GRETAP** : ```bash interface Tunnel0 tunnel source 192.168.1.1 # IP locale du routeur tunnel destination 172.16.126.33 # IP distante tunnel mode gre multipoint no shutdown ``` 3. **Créer le Bridge Domain et l'associer** : ```bash bridge-domain 100 member Tunnel0 service-instance 1 member Vlan100 ``` 4. **Configurer l'interface VLAN** : ```bash interface Vlan100 ip address 198.51.100.2 255.255.255.248 no shutdown ``` 5. **Sauvegarder la configuration** : ```bash write memory ```La configuration de bridge L2 sur Cisco varie fortement selon la plateforme (IOS, IOS-XE, NX-OS). Consultez la documentation de votre modèle.
--- ### **4.4. Exemple pour Arista (EOS)** #### **Étapes :** 1. **Accéder au mode configuration** : ```bash enable configure terminal ``` 2. **Créer l'interface tunnel GRE en mode bridge** : ```bash interface Tunnel0 tunnel source 192.168.1.1 tunnel destination 172.16.126.33 tunnel mode gre no shutdown ``` 3. **Bridger le tunnel avec un VLAN** : ```bash interface Tunnel0 switchport access vlan 100 interface Vlan100 ip address 198.51.100.2/29 no shutdown ``` 4. **Sauvegarder la configuration** : ```bash write memory ``` --- ### **4.5. Exemple pour Juniper (JunOS)** #### **Étapes :** 1. **Accéder au mode configuration** : ```bash edit ``` 2. **Créer l'interface GRE et le bridge domain** : ```bash set interfaces gr-0/0/0 tunnel source 192.168.1.1 set interfaces gr-0/0/0 tunnel destination 172.16.126.33 set interfaces gr-0/0/0 family bridge interface-mode trunk set interfaces gr-0/0/0 family bridge vlan-id-list 100 set bridge-domains GRETAP-BD vlan-id 100 set bridge-domains GRETAP-BD routing-interface irb.100 set interfaces irb unit 100 family inet address 198.51.100.2/29 ``` 3. **Appliquer la configuration** : ```bash commit ``` --- ## **5. Étape 3 : Configurer les IPs publiques** ### **5.1. Architecture L2** ``` Internet → [Infrastructure Tunnel-IP.com] → [Bridge plateforme] → (Tunnel GRETAP) → [Votre Bridge/Interface] → [Vos Machines] ``` - La plateforme met la première IP du subnet comme gateway sur le bridge (ex: `198.51.100.1`). - Vos machines utilisent les autres IPs du subnet. - Comme le tunnel est L2, les trames Ethernet passent directement, **pas besoin de NAT ni de routage complexe**. ### **5.2. Attribution des IPs** Un `/29` contient **8 adresses IP** : - `198.51.100.0` : Adresse réseau (inutilisable). - `198.51.100.1` : **Gateway plateforme** (réservée automatiquement). - `198.51.100.2` à `198.51.100.6` : IPs utilisables pour vos machines. - `198.51.100.7` : Adresse broadcast (inutilisable). ### **5.3. Configuration sur les machines** Sur chaque machine qui doit utiliser une IP publique : #### **Linux :** ```bash ip addr add 198.51.100.2/29 dev eth0 ip route add default via 198.51.100.1 ``` #### **MikroTik :** ``` /ip/address/add address=198.51.100.2/29 interface=ether1 /ip/route/add dst-address=0.0.0.0/0 gateway=198.51.100.1 ```Si vous avez bridgé l'interface GRETAP avec votre LAN, les machines peuvent être configurées directement avec les IPs publiques et la gateway `198.51.100.1`, comme si elles étaient sur un réseau local classique.
--- ## **6. Commandes spécifiques par constructeur** | Constructeur | Commande pour vérifier le tunnel | Commande pour vérifier le bridge | |---|---|---| | **Linux** | `ip -d link show gretap0` | `bridge link show` | | **MikroTik** | `/interface eoip print` | `/interface bridge port print` | | **Cisco** | `show interface Tunnel0` | `show bridge-domain` | | **Arista** | `show interface Tunnel0` | `show vlan` | | **Juniper** | `show interfaces gr-0/0/0` | `show bridge-domain` | ## **7. Vérification et Dépannage** ### **7.1. Tester la connectivité** - **Depuis votre routeur / machine** : ```bash ping 198.51.100.1 # Ping de la gateway plateforme ``` - **Vérifier l'interface GRETAP (Linux)** : ```bash ip -d link show gretap0 # Vérifier les paramètres bridge fdb show dev gretap0 # Vérifier la table MAC ``` - **Depuis une machine locale** : ```bash ping 8.8.8.8 # Vérification internet curl -4 ifconfig.me # Vérification de l'IP sortante ``` ### **7.2. Problèmes courants** | **Symptôme** | **Cause Possible** | **Solution** | |---|---|---| | Le tunnel ne répond pas | Protocole 47 bloqué | Vérifiez la redirection sur votre box / configurez une DMZ | | Pas de connectivité L2 | Clé GRE incorrecte | Vérifiez que la clé correspond à celle fournie par la plateforme | | La gateway ne répond pas | Subnet non associé au bridge | Vérifiez que le subnet est bien associé au bridge sur la plateforme | | Latence élevée / Pertes de paquets | MTU trop grande | Réduisez la MTU : `ip link set mtu 1462 dev gretap0` (overhead GRETAP = 38 octets) | | Les IPs publiques ne fonctionnent pas | Mauvaise gateway | Utilisez la première IP du subnet comme gateway (ex: `198.51.100.1`) | --- ## **8. Bonnes Pratiques** 1. **Sécurité** : - Filtrez le trafic entrant avec un pare-feu (ex: `iptables` ou ACL). - GRETAP n'offre aucun chiffrement natif. Envisagez IPsec ou Wireguard en complément si le chiffrement est nécessaire. 2. **Performance** : - Réduisez la MTU à `1462` pour éviter la fragmentation (overhead GRETAP = 38 octets). - Vérifiez que la MTU de votre lien WAN est suffisante pour encapsuler les trames. 3. **Bridging** : - Vous pouvez combiner plusieurs tunnels L2 (VXLAN, EoIP, GRETAP) sur le même bridge, aussi bien sur la plateforme que côté client. - Attention aux boucles de bridge : activez le STP si nécessaire. --- # Tunnel L2 - VXLAN ## **1. Introduction : Pourquoi utiliser VXLAN ?** ### **1.1. À quoi sert un tunnel VXLAN ?** Un tunnel **VXLAN (Virtual Extensible LAN)** permet de créer un réseau Ethernet virtuel (Layer 2) entre deux sites distants, comme s'ils étaient connectés au même switch. Contrairement aux tunnels L3 (GRE, IPIP), VXLAN transporte des **trames Ethernet complètes**, ce qui permet de bridger des réseaux distants. **Exemple concret :** - Vous avez un réseau local derrière une box opérateur standard. - Vous voulez une ou des IPs publiques directement accessibles sur vos machines, comme si elles étaient sur le même réseau que la plateforme. ### **1.2. Avantages de VXLAN** - Transport Layer 2 complet (trames Ethernet). - Supporte jusqu'à 16 millions de réseaux virtuels (VNI 24 bits). - Compatible avec la plupart des équipements réseau modernes. - Fonctionne en UDP, facilement NAT-able. - Peut être combiné avec d'autres tunnels L2 via un bridge. ### **1.3. Inconvénients** - Pas de chiffrement natif. - Overhead plus important que GRE/IPIP (50 octets d'en-tête). - Nécessite une configuration manuelle du bridging côté client. --- ## **2. Prérequis** ### **2.1. Ce dont vous avez besoin** - Une **IP publique** (ou une redirection de port si derrière une box). - Un **routeur ou serveur compatible VXLAN** (Linux, MikroTik, Cisco, Arista, Juniper, etc.). - Un **service Tunnel-IP**. ### **2.2. Ports et NAT** - VXLAN utilise **UDP** (port par défaut : **4789**). - Si le routeur final est derrière une box / NAT, il faut **rediriger le port UDP 4789** vers le routeur final. --- ## **3. Étape 1 : Créer le bridge et le tunnel sur Tunnel-IP.com**Les tunnels L2 fonctionnent avec des **bridges** sur la plateforme. Un bridge est un switch virtuel qui regroupe vos tunnels L2 et vos subnets. Vous devez d'abord créer un bridge, puis créer le tunnel en l'associant à ce bridge.
### **3.1. Créer le bridge** 1. Connectez-vous à [panel.tunnel-ip.com](https://panel.tunnel-ip.com) 2. Allez dans **"Bridges"**. 3. Cliquez sur **"Ajouter un Bridge"** et donnez-lui un nom. 4. Validez. Le bridge sera créé sur la plateforme. ### **3.2. Créer le tunnel VXLAN** 1. Allez dans **"Tunnels"** > **"VXLAN"**. 2. Remplissez les informations : - **Nom du tunnel** (ex : `VXLAN_Tunnel`). - **Endpoint** (IP publique du routeur / box, ex : `203.0.113.1`). - **Bridge** : Sélectionnez le bridge créé précédemment. - **MTU** : Taille maximale des paquets (-1 pour laisser la plateforme choisir). 3. Validez. La plateforme s'occupera de choisir le VNI et de configurer le tunnel côté Tunnel-IP.com. 4. Attendez que le tunnel soit créé 5. Cliquez sur "Accéder" pour récupérer les détails du tunnel ### **3.3. Créer le subnet** 1\. Allez dans **"Subnets"** 2\. Copiez le bloc d'IP publique et collez le dans le formulaire 3\. Sélectionnez le **bridge** (et non un tunnel directement) comme destination 4\. Cliquez sur Créer 5\. Une fois son statut à "Actif", la route est correctement installée sur les routeurs de la plateforme**Important :** La première IP du subnet sera utilisée comme **gateway** sur le bridge côté plateforme. Par exemple, pour le subnet `198.51.100.0/29`, la gateway sera `198.51.100.1`.
--- ## **4. Étape 2 : Configurer le tunnel**Contrairement aux tunnels L3, un tunnel VXLAN transporte des trames Ethernet (Layer 2). Côté client, vous devez créer l'interface VXLAN puis la **bridger** avec votre interface LAN (ou lui assigner directement une IP du subnet).
### **4.1. Exemple pour Linux (Ubuntu/Debian)** #### **Étapes :** 1. **Créer l'interface VXLAN** : ```bash ip link add vxlan0 type vxlan id 100 remote 172.16.126.33 dstport 4789 ip link set vxlan0 up ``` - `vxlan0` : Nom de l'interface VXLAN. - `id 100` : VNI (Virtual Network Identifier), fourni par la plateforme. - `remote 172.16.126.33` : IP distante (Tunnel-IP.com). - `dstport 4789` : Port UDP de destination. 2. **Option A : Assigner directement une IP publique** : Si vous souhaitez que le routeur lui-même ait une IP publique : ```bash ip addr add 198.51.100.2/29 dev vxlan0 ip route add default via 198.51.100.1 dev vxlan0 ``` - `198.51.100.2/29` : Une IP du subnet (la première IP .1 est la gateway côté plateforme). - `198.51.100.1` : Gateway (première IP du subnet, côté plateforme). 3. **Option B : Bridger avec une interface LAN** : Si vous souhaitez que des machines sur votre LAN aient directement les IPs publiques : ```bash ip link add br0 type bridge ip link set br0 up ip link set vxlan0 master br0 ip link set eth1 master br0 # Interface LAN vers vos machines ``` Les machines connectées à `eth1` pourront alors utiliser les IPs du subnet directement, avec `198.51.100.1` comme gateway. 4. **Activer le forwarding** (si nécessaire) : ```bash echo 1 > /proc/sys/net/ipv4/ip_forward ``` **(Pour rendre permanent, ajoutez* `net.ipv4.ip_forward=1` *dans* `/etc/sysctl.conf`*.)** --- ### **4.2. Exemple pour MikroTik** #### **Étapes :** 1. **Créer l'interface VXLAN** : ```bash /interface/vxlan/add name=vxlan0 vni=100 port=4789 ``` 2. **Ajouter le VTEP distant (Tunnel-IP.com)** : ```bash /interface/vxlan/vteps/add interface=vxlan0 remote-ip=172.16.126.33 port=4789 ``` 3. **Option A : Assigner une IP publique directement** : ```bash /ip/address/add address=198.51.100.2/29 interface=vxlan0 /ip/route/add dst-address=0.0.0.0/0 gateway=198.51.100.1 ``` 4. **Option B : Bridger avec une interface LAN** : ```bash /interface/bridge/add name=br-vxlan /interface/bridge/port/add bridge=br-vxlan interface=vxlan0 /interface/bridge/port/add bridge=br-vxlan interface=ether2 # Interface LAN ``` --- ### **4.3. Exemple pour Cisco (IOS/XE - NX-OS)** #### **Étapes :** 1. **Accéder au mode configuration** : ```bash enable configure terminal ``` 2. **Créer le NVE (Network Virtualization Edge)** : ```bash interface nve1 source-interface Loopback0 member vni 100 ingress-replication protocol static peer-ip 172.16.126.33 no shutdown ``` 3. **Créer le VLAN et l'associer au VNI** : ```bash vlan 100 vn-segment 100 interface Vlan100 ip address 198.51.100.2 255.255.255.248 no shutdown ``` 4. **Sauvegarder la configuration** : ```bash write memory ```La configuration VXLAN sur Cisco est principalement disponible sur **NX-OS** (Nexus). Sur IOS-XE, le support VXLAN est limité à certains modèles (CSR1000v, Catalyst 9000, etc.).
--- ### **4.4. Exemple pour Arista (EOS)** #### **Étapes :** 1. **Accéder au mode configuration** : ```bash enable configure terminal ``` 2. **Créer l'interface VXLAN** : ```bash interface Vxlan1 vxlan source-interface Loopback0 vxlan udp-port 4789 vxlan vlan 100 vni 100 vxlan flood vtep add 172.16.126.33 ``` 3. **Créer le VLAN et l'associer** : ```bash vlan 100 interface Vlan100 ip address 198.51.100.2/29 no shutdown ``` 4. **Sauvegarder la configuration** : ```bash write memory ``` --- ### **4.5. Exemple pour Juniper (JunOS)** #### **Étapes :** 1. **Accéder au mode configuration** : ```bash edit ``` 2. **Créer l'interface VXLAN et le bridge domain** : ```bash set bridge-domains VXLAN-BD vlan-id 100 set bridge-domains VXLAN-BD vxlan vni 100 set bridge-domains VXLAN-BD vxlan ingress-node-replication set interfaces lo0 unit 0 family inet address 10.0.0.1/32 set switch-options vtep-source-interface lo0.0 set switch-options remote-vtep 172.16.126.33 set bridge-domains VXLAN-BD routing-interface irb.100 set interfaces irb unit 100 family inet address 198.51.100.2/29 ``` 3. **Appliquer la configuration** : ```bash commit ``` --- ## **5. Étape 3 : Configurer les IPs publiques** ### **5.1. Architecture L2** ``` Internet → [Infrastructure Tunnel-IP.com] → [Bridge plateforme] → (Tunnel VXLAN) → [Votre Bridge/Interface] → [Vos Machines] ``` - La plateforme met la première IP du subnet comme gateway sur le bridge (ex: `198.51.100.1`). - Vos machines utilisent les autres IPs du subnet. - Comme le tunnel est L2, les trames Ethernet passent directement, **pas besoin de NAT ni de routage complexe**. ### **5.2. Attribution des IPs** Un `/29` contient **8 adresses IP** : - `198.51.100.0` : Adresse réseau (inutilisable). - `198.51.100.1` : **Gateway plateforme** (réservée automatiquement). - `198.51.100.2` à `198.51.100.6` : IPs utilisables pour vos machines. - `198.51.100.7` : Adresse broadcast (inutilisable). ### **5.3. Configuration sur les machines** Sur chaque machine qui doit utiliser une IP publique : #### **Linux :** ```bash ip addr add 198.51.100.2/29 dev eth0 ip route add default via 198.51.100.1 ``` #### **MikroTik :** ``` /ip/address/add address=198.51.100.2/29 interface=ether1 /ip/route/add dst-address=0.0.0.0/0 gateway=198.51.100.1 ```Si vous avez bridgé l'interface VXLAN avec votre LAN, les machines peuvent être configurées directement avec les IPs publiques et la gateway `198.51.100.1`, comme si elles étaient sur un réseau local classique.
--- ## **6. Commandes spécifiques par constructeur** | Constructeur | Commande pour vérifier le tunnel | Commande pour vérifier le bridge | |---|---|---| | **Linux** | `ip -d link show vxlan0` | `bridge link show` | | **MikroTik** | `/interface vxlan print` | `/interface bridge port print` | | **Cisco** | `show nve peers` | `show vlan` | | **Arista** | `show interfaces Vxlan1` | `show vlan` | | **Juniper** | `show bridge-domain` | `show interfaces irb` | ## **7. Vérification et Dépannage** ### **7.1. Tester la connectivité** - **Depuis votre routeur / machine** : ```bash ping 198.51.100.1 # Ping de la gateway plateforme ``` - **Vérifier l'interface VXLAN (Linux)** : ```bash ip -d link show vxlan0 # Vérifier les paramètres VXLAN bridge fdb show dev vxlan0 # Vérifier la table MAC ``` - **Depuis une machine locale** : ```bash ping 8.8.8.8 # Vérification internet curl -4 ifconfig.me # Vérification de l'IP sortante ``` ### **7.2. Problèmes courants** | **Symptôme** | **Cause Possible** | **Solution** | |---|---|---| | Le tunnel ne répond pas | Port UDP 4789 bloqué | Vérifiez la redirection du port sur votre box | | Pas de connectivité L2 | VNI incorrect | Vérifiez que le VNI correspond à celui fourni par la plateforme | | La gateway ne répond pas | Subnet non associé au bridge | Vérifiez que le subnet est bien associé au bridge sur la plateforme | | Latence élevée / Pertes de paquets | MTU trop grande | Réduisez la MTU : `ip link set mtu 1450 dev vxlan0` (overhead VXLAN = 50 octets) | | Les IPs publiques ne fonctionnent pas | Mauvaise gateway | Utilisez la première IP du subnet comme gateway (ex: `198.51.100.1`) | --- ## **8. Bonnes Pratiques** 1. **Sécurité** : - Filtrez le trafic entrant avec un pare-feu (ex: `iptables` ou ACL). - VXLAN n'offre aucun chiffrement natif. Envisagez IPsec ou Wireguard en complément si le chiffrement est nécessaire. 2. **Performance** : - Réduisez la MTU à `1450` pour éviter la fragmentation (overhead VXLAN = 50 octets). - Vérifiez que la MTU de votre lien WAN est suffisante pour encapsuler les paquets VXLAN. 3. **Bridging** : - Vous pouvez combiner plusieurs tunnels L2 (VXLAN, EoIP, GRETAP) sur le même bridge, aussi bien sur la plateforme que côté client. - Attention aux boucles de bridge : activez le STP si nécessaire. --- # Tunnel L2 - L2TPv3 ## **1. Introduction : Pourquoi utiliser L2TPv3 ?** ### **1.1. À quoi sert un tunnel L2TPv3 ?** Un tunnel **L2TPv3 (Layer 2 Tunneling Protocol version 3)** permet de créer un lien Ethernet virtuel (Layer 2) entre deux sites distants, transportant des **trames Ethernet complètes**. L2TPv3 est une évolution de L2TP, spécifiquement conçue pour le transport L2 avec de nombreuses options de configuration (encapsulation UDP ou IP, IDs de session/tunnel configurables). **Exemple concret :** - Vous avez un réseau local derrière une box opérateur standard. - Vous voulez une ou des IPs publiques directement accessibles sur vos machines, comme si elles étaient sur le même réseau que la plateforme. ### **1.2. Avantages de L2TPv3** - Transport Layer 2 complet (trames Ethernet). - Supporte l'encapsulation **UDP** (facilement NAT-able) ou **IP** (protocole 115, plus léger). - IDs de session et tunnel configurables, permettant plusieurs tunnels vers le même endpoint. - Compatible avec de nombreux équipements réseau (Linux, MikroTik, Cisco, Juniper). - Peut être combiné avec d'autres tunnels L2 via un bridge. ### **1.3. Inconvénients** - Pas de chiffrement natif. - Configuration plus complexe que VXLAN ou GRETAP (IDs de session/tunnel à configurer). - En mode IP (protocole 115), nécessite une DMZ si derrière un NAT. --- ## **2. Prérequis** ### **2.1. Ce dont vous avez besoin** - Une **IP publique** (ou une redirection de port si encapsulation UDP, ou une DMZ si encapsulation IP). - Un **routeur ou serveur compatible L2TPv3** (Linux, MikroTik, Cisco, Juniper, etc.). - Un **service Tunnel-IP**. ### **2.2. Ports et NAT** - **Encapsulation UDP** : L2TPv3 utilise un **port UDP configurable**. Si vous êtes derrière un NAT, il suffit de rediriger ce port. - **Encapsulation IP** : L2TPv3 utilise le **protocole 115**. Ce n'est ni UDP ni TCP, il faut donc configurer une DMZ si vous êtes derrière un NAT. --- ## **3. Étape 1 : Créer le bridge et le tunnel sur Tunnel-IP.com**Les tunnels L2 fonctionnent avec des **bridges** sur la plateforme. Un bridge est un switch virtuel qui regroupe vos tunnels L2 et vos subnets. Vous devez d'abord créer un bridge, puis créer le tunnel en l'associant à ce bridge.
### **3.1. Créer le bridge** 1. Connectez-vous à [panel.tunnel-ip.com](https://panel.tunnel-ip.com) 2. Allez dans **"Bridges"**. 3. Cliquez sur **"Ajouter un Bridge"** et donnez-lui un nom. 4. Validez. Le bridge sera créé sur la plateforme. ### **3.2. Créer le tunnel L2TPv3** 1. Allez dans **"Tunnels"** > **"L2TPv3"**. 2. Remplissez les informations : - **Endpoint** (IP publique du routeur / box, ex : `203.0.113.1`). - **Zone** : Zone géographique du serveur. - **Nom** (ex : `L2TPv3_Tunnel`). - **MTU** : Taille maximale des paquets (-1 pour laisser la plateforme choisir). - **Bridge** : Sélectionnez le bridge créé précédemment. - **Encapsulation** : Choisissez **UDP** ou **IP** selon votre configuration réseau. - **Peer session id** : ID de session du côté distant (votre côté). Doit correspondre au `session_id` que vous configurerez sur votre routeur. - **Peer tunnel id** : ID de tunnel du côté distant (votre côté). Doit correspondre au `tunnel_id` que vous configurerez sur votre routeur. - **Peer udp port** : Port UDP de l'autre côté du tunnel. Laisser vide si encapsulation IP. 3. Validez. La plateforme s'occupera de configurer le tunnel côté Tunnel-IP.com. 4. Attendez que le tunnel soit créé 5. Cliquez sur "Accéder" pour récupérer les détails du tunnel (vous y trouverez les IDs côté plateforme)**Important :** Les IDs de session et de tunnel doivent être **croisés** : le `peer_session_id` de la plateforme doit correspondre à votre `session_id` local, et inversement. Vérifiez bien les valeurs sur la page détails du tunnel.
### **3.3. Créer le subnet** 1\. Allez dans **"Subnets"** 2\. Copiez le bloc d'IP publique et collez le dans le formulaire 3\. Sélectionnez le **bridge** (et non un tunnel directement) comme destination 4\. Cliquez sur Créer 5\. Une fois son statut à "Actif", la route est correctement installée sur les routeurs de la plateforme**Important :** La première IP du subnet sera utilisée comme **gateway** sur le bridge côté plateforme. Par exemple, pour le subnet `198.51.100.0/29`, la gateway sera `198.51.100.1`.
--- ## **4. Étape 2 : Configurer le tunnel**L2TPv3 transporte des trames Ethernet (Layer 2). Côté client, vous devez créer l'interface L2TPv3 puis la **bridger** avec votre interface LAN (ou lui assigner directement une IP du subnet).
Dans les exemples ci-dessous, les valeurs suivantes sont utilisées. **Adaptez-les** avec les paramètres fournis par la plateforme :
- IP distante (plateforme) : `172.16.126.33`
- Session ID local : `1000` / Peer session ID : `2000`
- Tunnel ID local : `1000` / Peer tunnel ID : `2000`
- Port UDP (si encapsulation UDP) : `1701`
En encapsulation IP, aucun port UDP n'est utilisé. Le protocole 115 est utilisé directement. Assurez-vous que votre box / NAT le laisse passer (DMZ recommandée).
--- ### **4.3. Exemple pour MikroTik** #### **Étapes :** 1. **Créer l'interface L2TP client** :MikroTik supporte L2TPv3 à partir de **RouterOS v7**. Sur les versions antérieures, seul L2TP (v2) est disponible.
```bash /interface/l2tp-ether/add name=l2tp-ether1 \ local-address=192.168.1.1 remote-address=172.16.126.33 \ tunnel-id=1000 peer-tunnel-id=2000 \ session-id=1000 peer-session-id=2000 ``` 2. **Option A : Assigner une IP publique directement** : ```bash /ip/address/add address=198.51.100.2/29 interface=l2tp-ether1 /ip/route/add dst-address=0.0.0.0/0 gateway=198.51.100.1 ``` 3. **Option B : Bridger avec une interface LAN** : ```bash /interface/bridge/add name=br-l2tp /interface/bridge/port/add bridge=br-l2tp interface=l2tp-ether1 /interface/bridge/port/add bridge=br-l2tp interface=ether2 # Interface LAN ``` --- ### **4.4. Exemple pour Cisco (IOS/XE)** #### **Étapes :** 1. **Accéder au mode configuration** : ```bash enable configure terminal ``` 2. **Créer la pseudowire L2TPv3** : ```bash pseudowire-class L2TPv3-PW encapsulation l2tpv3 protocol none ip local interface GigabitEthernet0/0 ``` 3. **Créer l'interface xconnect** : ```bash interface GigabitEthernet0/1 xconnect 172.16.126.33 1000 encapsulation l2tpv3 pw-class L2TPv3-PW ``` - `172.16.126.33` : IP distante (Tunnel-IP.com). - `1000` : VC ID (doit correspondre aux IDs configurés sur la plateforme). 4. **Sauvegarder la configuration** : ```bash write memory ```La configuration L2TPv3 sur Cisco varie selon la plateforme (IOS, IOS-XE, NX-OS). La syntaxe `xconnect` est disponible sur IOS et IOS-XE. Consultez la documentation de votre modèle.
--- ### **4.5. Exemple pour Juniper (JunOS)** #### **Étapes :** 1. **Accéder au mode configuration** : ```bash edit ``` 2. **Créer le tunnel L2TPv3** : ```bash set protocols l2circuit neighbor 172.16.126.33 interface ge-0/0/1.0 \ virtual-circuit-id 1000 encapsulation-type ethernet set interfaces ge-0/0/1 encapsulation ethernet-bridge set interfaces ge-0/0/1 unit 0 family bridge ``` - `172.16.126.33` : IP distante (Tunnel-IP.com). - `virtual-circuit-id 1000` : ID du circuit (doit correspondre aux IDs de la plateforme). 3. **Créer le bridge domain** : ```bash set bridge-domains L2TPv3-BD interface ge-0/0/1.0 set bridge-domains L2TPv3-BD routing-interface irb.100 set interfaces irb unit 100 family inet address 198.51.100.2/29 ``` 4. **Appliquer la configuration** : ```bash commit ``` --- ### **4.6. Note pour Arista (EOS)**Arista EOS ne supporte pas nativement L2TPv3. Si vous devez utiliser un switch Arista, vous pouvez utiliser VXLAN comme alternative L2, ou placer un serveur Linux comme point de terminaison L2TPv3 devant votre switch Arista.
--- ## **5. Étape 3 : Configurer les IPs publiques** ### **5.1. Architecture L2** ``` Internet → [Infrastructure Tunnel-IP.com] → [Bridge plateforme] → (Tunnel L2TPv3) → [Votre Bridge/Interface] → [Vos Machines] ``` - La plateforme met la première IP du subnet comme gateway sur le bridge (ex: `198.51.100.1`). - Vos machines utilisent les autres IPs du subnet. - Comme le tunnel est L2, les trames Ethernet passent directement, **pas besoin de NAT ni de routage complexe**. ### **5.2. Attribution des IPs** Un `/29` contient **8 adresses IP** : - `198.51.100.0` : Adresse réseau (inutilisable). - `198.51.100.1` : **Gateway plateforme** (réservée automatiquement). - `198.51.100.2` à `198.51.100.6` : IPs utilisables pour vos machines. - `198.51.100.7` : Adresse broadcast (inutilisable). ### **5.3. Configuration sur les machines** Sur chaque machine qui doit utiliser une IP publique : #### **Linux :** ```bash ip addr add 198.51.100.2/29 dev eth0 ip route add default via 198.51.100.1 ``` #### **MikroTik :** ``` /ip/address/add address=198.51.100.2/29 interface=ether1 /ip/route/add dst-address=0.0.0.0/0 gateway=198.51.100.1 ```Si vous avez bridgé l'interface L2TPv3 avec votre LAN, les machines peuvent être configurées directement avec les IPs publiques et la gateway `198.51.100.1`, comme si elles étaient sur un réseau local classique.
--- ## **6. Commandes spécifiques par constructeur** | Constructeur | Commande pour vérifier le tunnel | Commande pour vérifier le bridge | |---|---|---| | **Linux** | `ip l2tp show tunnel` / `ip l2tp show session` | `bridge link show` | | **MikroTik** | `/interface l2tp-ether print` | `/interface bridge port print` | | **Cisco** | `show l2tun tunnel` / `show xconnect all` | `show bridge-domain` | | **Juniper** | `show l2circuit connections` | `show bridge-domain` | ## **7. Vérification et Dépannage** ### **7.1. Tester la connectivité** - **Depuis votre routeur / machine** : ```bash ping 198.51.100.1 # Ping de la gateway plateforme ``` - **Vérifier le tunnel L2TPv3 (Linux)** : ```bash ip l2tp show tunnel # Vérifier les tunnels ip l2tp show session # Vérifier les sessions ip -d link show l2tpeth0 # Vérifier l'interface ``` - **Depuis une machine locale** : ```bash ping 8.8.8.8 # Vérification internet curl -4 ifconfig.me # Vérification de l'IP sortante ``` ### **7.2. Problèmes courants** | **Symptôme** | **Cause Possible** | **Solution** | |---|---|---| | Le tunnel ne répond pas (encap UDP) | Port UDP bloqué | Vérifiez la redirection du port sur votre box | | Le tunnel ne répond pas (encap IP) | Protocole 115 bloqué | Configurez une DMZ sur votre box | | Pas de connectivité L2 | IDs session/tunnel inversés | Vérifiez que les IDs sont bien croisés : votre `session_id` = `peer_session_id` de la plateforme, et inversement | | La gateway ne répond pas | Subnet non associé au bridge | Vérifiez que le subnet est bien associé au bridge sur la plateforme | | Latence élevée / Pertes de paquets | MTU trop grande | Réduisez la MTU (overhead L2TPv3 UDP ≈ 36 octets, IP ≈ 12 octets) | | Les IPs publiques ne fonctionnent pas | Mauvaise gateway | Utilisez la première IP du subnet comme gateway (ex: `198.51.100.1`) | --- ## **8. Bonnes Pratiques** 1. **Sécurité** : - Filtrez le trafic entrant avec un pare-feu (ex: `iptables` ou ACL). - L2TPv3 n'offre aucun chiffrement natif. Envisagez IPsec en complément si le chiffrement est nécessaire. 2. **Performance** : - Ajustez la MTU en fonction de l'encapsulation choisie. - L'encapsulation **IP** est plus performante (moins d'overhead) mais moins compatible avec le NAT. - L'encapsulation **UDP** est recommandée si vous êtes derrière un NAT. 3. **Bridging** : - Vous pouvez combiner plusieurs tunnels L2 (VXLAN, EoIP, GRETAP, L2TPv3) sur le même bridge, aussi bien sur la plateforme que côté client. - Attention aux boucles de bridge : activez le STP si nécessaire. --- # Sessions BGP ## **1. Introduction : Pourquoi utiliser BGP ?** ### **1.1. À quoi sert une session BGP sur Tunnel-IP.com ?** Le protocole **BGP (Border Gateway Protocol)** est le protocole de routage utilisé sur Internet pour échanger des préfixes IP entre systèmes autonomes (AS). Sur Tunnel-IP.com, les sessions BGP vous permettent d'**annoncer vos propres préfixes IP** à travers notre infrastructure, offrant un contrôle total sur votre routage. **Cas d'usage :** - Vous possédez votre propre bloc d'IPs (PI/PA) et votre ASN. - Vous souhaitez annoncer vos préfixes via l'infrastructure Tunnel-IP.com. - Vous avez besoin d'un contrôle dynamique de vos routes (failover, multihoming, etc.). ### **1.2. Les deux types de sessions** Tunnel-IP.com propose **deux types** de sessions BGP : | | **Session normale** | **Session autogérée** | |---|---|---| | **Principe** | Session BGP classique à travers un tunnel L3. Vous configurez BGP sur votre routeur et échangez des préfixes avec la plateforme. | Routeur virtuel entièrement géré par Tunnel-IP.com. Nous annonçons vos préfixes avec votre ASN (ou le nôtre) et routons le trafic vers votre tunnel. | | **Configuration côté client** | Oui — vous devez configurer un démon BGP sur votre routeur. | Non — aucune configuration BGP nécessaire de votre côté. | | **Tunnel requis** | Oui — un tunnel L3 (GRE, IPIP, Wireguard, etc.) doit être configuré. La session BGP passe à travers le tunnel. | Non obligatoire pour le BGP lui-même — les subnets sont assignés directement à la session autogérée via le panel, puis routés statiquement vers le tunnel de votre choix. | | **ASN requis** | Oui — votre propre ASN, enregistré sur le panel. | Optionnel — vous pouvez utiliser votre ASN ou celui de Tunnel-IP.com. | | **Contrôle** | Total — vous choisissez quels préfixes annoncer et pouvez gérer le routage dynamiquement. | Limité — nous gérons l'annonce, vous gérez l'attribution des subnets via le panel. | | **Idéal pour** | Utilisateurs avancés, multihoming, failover BGP. | Utilisateurs qui veulent simplement annoncer leurs IPs sans gérer BGP. | --- ## **2. Prérequis** ### **2.1. Pour les deux types de sessions** - Un **service Tunnel-IP.com** actif. - Vos **préfixes IP** correctement enregistrés auprès d'un RIR (RIPE, ARIN, etc.). - Un **route object** correctement configuré dans la base IRR correspondante (RIPE DB, RADB, etc.) autorisant l'annonce de vos préfixes par votre ASN (ou celui de Tunnel-IP.com pour les sessions autogérées). - Une **LOA (Letter of Authorization)** si les préfixes ne vous appartiennent pas directement. ### **2.2. Spécifique à la session normale** - Un **tunnel L3 configuré et fonctionnel** (GRE, IPIP, Wireguard, OpenVPN, IPsec). - Votre **ASN** enregistré sur [panel.tunnel-ip.com/asn/](https://panel.tunnel-ip.com/asn/) avec votre **AS-SET**. - Un **routeur capable de faire du BGP** (Linux avec BIRD/FRR, MikroTik, Cisco, Juniper, etc.). ### **2.3. Spécifique à la session autogérée** - Si vous souhaitez utiliser **votre propre ASN** : l'enregistrer sur [panel.tunnel-ip.com/asn/](https://panel.tunnel-ip.com/asn/). - Si vous souhaitez utiliser **l'ASN de Tunnel-IP.com** : aucun ASN à enregistrer. - Une **demande de whitelist** de vos préfixes accompagnée de la LOA. --- ## **3. Enregistrer son ASN**Si vous souhaitez utiliser l'ASN de Tunnel-IP.com (uniquement pour les sessions autogérées), vous pouvez passer cette étape.
1. Connectez-vous à [panel.tunnel-ip.com](https://panel.tunnel-ip.com) 2. Allez dans **"ASN"** ([panel.tunnel-ip.com/asn/](https://panel.tunnel-ip.com/asn/)). 3. Cliquez sur **"Ajouter un ASN"**. 4. Renseignez : - **Votre numéro d'AS** (ex : `AS211615`). - **Votre AS-SET** (ex : `AS-EXAMPLE`). L'AS-SET est utilisé pour valider automatiquement les préfixes que vous êtes autorisé à annoncer. 5. Validez.**Important :** Assurez-vous que votre AS-SET est correctement maintenu dans une base IRR (RIPE, RADB, etc.) et qu'il contient bien les préfixes que vous souhaitez annoncer. Sans cela, vos annonces seront rejetées.
--- ## **4. Session autogérée** La session autogérée est la méthode la plus simple : **Tunnel-IP.com gère entièrement l'annonce BGP** de vos préfixes. Vous n'avez aucune configuration BGP à faire sur votre routeur. ### **4.1. Comment ça fonctionne ?** ``` Internet ← [Routeurs Tunnel-IP.com annoncent vos préfixes en BGP] ← Route statique → [Votre Tunnel] → [Votre Routeur] ``` 1. Vous nous fournissez vos préfixes et la LOA. 2. Nous créons la session autogérée et whitelistons vos préfixes. 3. Sur le panel, vous assignez vos subnets à la session autogérée. 4. Le trafic entrant arrive sur notre infrastructure et est routé statiquement vers le tunnel de votre choix. 5. Côté sortant, vous configurez votre routeur pour envoyer le trafic de vos préfixes via le tunnel (comme pour un tunnel L3 classique — voir les docs de [routage sortant](gre.md)). ### **4.2. Étapes** 1. **Ouvrir un ticket** pour demander la création d'une session autogérée. - Précisez les préfixes à annoncer. - Fournissez la LOA si nécessaire. - Précisez si vous souhaitez utiliser votre ASN ou celui de Tunnel-IP.com. 2. **Attendre la validation** : nous vérifions le route object, l'AS-SET et la LOA. 3. **Whitelist effectuée** : une fois vos préfixes whitelistés, vous pouvez les gérer depuis le panel. 4. **Assigner vos subnets** : - Allez dans **"Subnets"**. - Créez un subnet correspondant à vos préfixes whitelistés. - Assignez-le à la **session BGP autogérée**. 5. **Configurer le routage sortant** sur votre routeur (tables de routage / policy routing), comme pour un tunnel L3 classique.Avec une session autogérée, vous n'avez **pas** besoin de configurer un démon BGP. Le routage entrant est géré par la plateforme, et le routage sortant se fait via les méthodes classiques (policy routing, VRF) décrites dans les documentations des tunnels L3.
--- ## **5. Session normale (BGP à travers un tunnel L3)** La session normale vous donne un **contrôle total** sur vos annonces BGP. Vous configurez un démon BGP sur votre routeur qui établit une session avec les routeurs de Tunnel-IP.com à travers votre tunnel L3. ### **5.1. Comment ça fonctionne ?** ``` Internet ← [Routeurs Tunnel-IP.com] ← Session BGP via tunnel → [Votre Routeur BGP] → [Votre Réseau] 100.64.0.5 ←→ 100.64.0.6 ``` - La session BGP s'établit entre l'IP plateforme du tunnel (ex: `100.64.0.5`) et votre IP client du tunnel (ex: `100.64.0.6`). - Vous annoncez vos préfixes à la plateforme via BGP. - La plateforme annonce vos préfixes vers Internet. ### **5.2. Étapes de mise en place** 1. **Avoir un tunnel L3 fonctionnel** : configurez d'abord un tunnel GRE, IPIP, Wireguard, etc. et vérifiez que le ping fonctionne entre les deux côtés (ex: `ping 100.64.0.5`). 2. **Enregistrer votre ASN** sur [panel.tunnel-ip.com/asn/](https://panel.tunnel-ip.com/asn/) (voir section 3). 3. **Vérifier votre route object** : assurez-vous que vos préfixes sont correctement déclarés dans une base IRR et que votre AS-SET est à jour. 4. **Ouvrir un ticket** pour demander la création de la session BGP. - Précisez le tunnel sur lequel la session doit être établie. - Précisez votre ASN. - Précisez les préfixes que vous souhaitez annoncer. 5. **Attendre la création** : nous configurons la session côté plateforme et vous fournissons les détails. 6. **Configurer BGP sur votre routeur** (voir section 5.3). ### **5.3. Informations de la session** Une fois la session créée, vous retrouverez les informations suivantes sur la page **"Sessions BGP"** du panel : | Champ | Description | Exemple | |---|---|------------------------------------| | **Nom** | Identifiant de la session | `BGP-41` | | **ASN Client** | Votre ASN | `AS65000` | | **ASN Tunnel** | ASN utilisé sur le tunnel | `AS211615` | | **Zone** | Zone du serveur | `Default Zone V2` | | **IP Client** | Votre IP de peering (IP de votre côté du tunnel) | `100.64.0.6` | | **IP Plateforme** | IP de peering côté Tunnel-IP.com | `100.64.0.5` | | **Status** | État de la session BGP | `Connect`, `Established`, `Active` | | **Préfixes acceptés** | Nombre de préfixes que la plateforme accepte de votre part | `0`, `5`, etc. | ### **5.4. Configurer BGP sur votre routeur**Les exemples ci-dessous utilisent les valeurs suivantes. **Adaptez-les** avec les informations fournies sur le panel :
- Votre ASN : `65000`
- IP plateforme (neighbor) : `100.64.0.5`
- Votre IP tunnel : `100.64.0.6`
- Préfixe à annoncer : `203.0.113.0/24`