Configurer Tailscale pour créer un réseau privé en 2026

Tailscale crée en 5 minutes un réseau privé (tailnet) chiffré de bout en bout entre vos appareils, sans ouvrir de port ni configurer de VPN traditionnel. Version 1.98.1 (mai 2026) — documentation officielle.

Ce que vous allez construire et pourquoi en 2026

Un tailnet Tailscale connecte vos serveurs, ordinateurs et téléphones via un maillage WireGuard automatique. Chaque appareil reçoit une IP stable 100.x.y.z et communique directement avec les autres, même derrière un pare-feu ou une box NAT. Le plan Personnel gratuit couvre jusqu'à 6 utilisateurs avec un nombre illimité d'appareils — idéal pour un projet personnel, une startup ou une petite équipe.

Pourquoi Tailscale plutôt qu'un VPN classique en 2026: pas de port à ouvrir, pas de certificat à gérer, pas de serveur central. Tailscale gère la découverte des pairs, le NAT traversal et la rotation des clés WireGuard automatiquement. Le chiffrement est de bout en bout — même Tailscale ne peut pas lire votre trafic.

Installation: commandes exactes à copier

Inscrivez-vous sur tailscale.com avec un compte Google, Microsoft ou GitHub (SSO gratuit). Puis installez le client sur chaque appareil:

Linux (Ubuntu 24.04 / Debian 12+)

# Ajouter le dépôt Tailscale
curl -fsSL https://pkgs.tailscale.com/stable/ubuntu/noble.noGpg.key | sudo tee /usr/share/keyrings/tailscale-archive-keyring.gpg >/dev/null
curl -fsSL https://pkgs.tailscale.com/stable/ubuntu/noble.tailscale-keyring.list | sudo tee /etc/apt/sources.list.d/tailscale.list # Installer et démarrer
sudo apt update && sudo apt install -y tailscale
sudo tailscale up # Vérifier la connexion
tailscale status
tailscale ip

macOS

# Via Homebrew
brew install --cask tailscale # Ou télécharger depuis https://tailscale.com/download/mac

Windows

Téléchargez l'installateur sur tailscale.com/download/windows. Après installation, connectez-vous avec le même compte SSO que votre premier appareil.

Vérifier que les appareils communiquent

# Sur l'appareil A, récupérez son IP Tailscale
tailscale ip -4
# Exemple: 100.64.0.1 # Depuis l'appareil B, pingez l'appareil A
ping 100.64.0.1 # Ou utilisez MagicDNS (nom d'hôte automatique)
ssh user@mon-serveur.tailnet-name.ts.net

Configuration: fichiers et variables à définir

ACL (Access Control Lists)

Les ACL définissent qui peut accéder à quoi. Sur la console Tailscale (login.tailscale.com/admin/acls), modifiez le fichier hujson:

// Exemple: autoriser tout le monde à tout accéder
{ "grants": [{ "src": ["autogroup:member"], "dst": ["autogroup:self:*"], "action": "accept" }]
} // Exemple plus restrictif: séparer les groupes
{ "groups": { "group:dev": ["alice@gmail.com", "bob@gmail.com"], "group:ops": ["charlie@gmail.com"] }, "grants": [{ "src": ["group:dev"], "dst": ["tag:dev-servers:*"], "action": "accept" }, { "src": ["group:ops"], "dst": ["tag:prod-servers:22,443"], "action": "accept" }]
}

Exit Node (utiliser un serveur comme passerelle internet)

# Sur le serveur qui servira de passerelle
sudo tailscale up --advertise-exit-node # Sur le client, activer l'exit node
tailscale up --exit-node=mon-serveur.tailnet-name.ts.net

Subnet Router (exposer un réseau local)

# Sur la machine connectée au réseau local 192.168.1.0/24
sudo tailscale up --advertise-routes=192.168.1.0/24 # Les autres appareils du tailnet pourront accéder à 192.168.1.x

Auth Key (pour les serveurs headless)

# Créer une clé dans https://login.tailscale.com/admin/settings/keys
# Puis sur le serveur:
sudo tailscale up --authkey=tskey-auth-xxxxx --tag=tag:dev-servers

Le code du projet: construire la fonctionnalité principale

Nous allons déployer un serveur web accessible uniquement via Tailscale, puis y connecter un service de monitoring Uptime Kuma en 3 étapes.

Étape 1: Déployer un serveur web accessible uniquement via Tailscale

# Sur votre serveur Ubuntu
sudo apt install -y nginx
echo "<h1>Hello depuis le tailnet</h1>" | sudo tee /var/www/html/index.html # Lier Nginx uniquement à l'IP Tailscale
# Éditez /etc/nginx/sites-available/default:
# server { listen 100.64.0.1:80;. } sudo systemctl restart nginx # Vérifier depuis un autre appareil du tailnet
curl http://100.64.0.1

Étape 2: Déployer Uptime Kuma avec Tailscale

# Installer Docker si nécessaire
curl -fsSL https://get.docker.com | sh # Lancer Uptime Kuma
docker run -d --restart=unless-stopped -p 100.64.0.1:3001:3001 -v uptime-kuma:/app/data --name uptime-kuma louislam/uptime-kuma:1 # Accessible uniquement via Tailscale
# http://100.64.0.1:3001 depuis un appareil du tailnet

Étape 3: Configurer Tailscale SSH pour l'accès sans mot de passe

# Activer Tailscale SSH dans les ACL
{ "grants": [{ "src": ["autogroup:member"], "dst": ["autogroup:self:*"], "action": {"accept": {"ssh": {"action": "accept"}}} }]
} # Se connecter en SSH sans clé ni mot de passe
ssh user@mon-serveur.tailnet-name.ts.net

Tester et valider que ça fonctionne

# 1. Vérifier le statut de Tailscale
tailscale status
# Doit afficher tous vos appareils avec leur IP 100.x.y.z # 2. Tester la connectivité directe (pair à pair)
tailscale ping mon-serveur
# Doit afficher "via DERP" ou "via direct" avec la latence # 3. Vérifier les ACL actives
tailscale whois --self
# Affiche votre identité et vos groupes # 4. Tester l'exit node
curl --exit-node=mon-serveur https://ifconfig.me
# Doit afficher l'IP publique du serveur, pas la vôtre # 5. Vérifier MagicDNS
ping mon-serveur.tailnet-name.ts.net
# Doit résoudre automatiquement l'IP 100.x.y.z

Déployer et utiliser en production

Pour un déploiement production en 2026, suivez ces bonnes pratiques:

• Activez Tailnet Lock (GA depuis mai 2025) pour empêcher l'ajout non autorisé de nœuds: tailscale lock init
• Utilisez des tags plutôt que des adresses email dans les ACL — les tags survivent au turnover des collaborateurs
• Activez les auth keys pré-approuvées avec --tag pour automatiser le provisioning des serveurs
• Configurez les logs de flux réseau (plan Premium, 18$/utilisateur/mois) pour la conformité
• Définissez des politiques système (AlwaysOn, DNS) pour les appareils gérés par MDM

# Verrouiller le tailnet (irréversible sans les clés de déverrouillage!)
tailscale lock init
# Sauvegardez les clés de déverrouillage affichées! # Activer le pare-feu du tailnet
# Dans les ACL, restreindre les ports:
{ "grants": [{ "src": ["group:dev"], "dst": ["tag:prod-servers:22,443"], "action": "accept" }]
}

Aller plus loin: 3 extensions concrètes

1. Tailscale Funnel — Exposez un service local sur l'internet public via tailscale funnel 8080. Idéal pour partager un prototype sans configurer de DNS ni de certificat TLS. Inclus dans le plan gratuit.
2. Intégration Kubernetes — Le Tailscale Kubernetes Operator (GA depuis avril 2025) gère automatiquement les Ingress, les ProxyGroups et le multi-cluster. Déployez avec kubectl apply -f https://raw.githubusercontent.com/tailscale/tailscale/main/cmd/k8s-operator/deploy.yaml.
3. Peer Relays auto-hébergés — Depuis février 2026 (v1.96.2), déployez vos propres relais pour garantir la connectivité quand DERP ne suffit pas: tailscale up --relay=mon-relay.example.com.