Tailscale : Créez votre VPN Mesh Zero-Config en 5 Minutes

Introduction

Connecter des machines entre elles de manière sécurisée a toujours été un défi. Les VPN traditionnels — OpenVPN, IPsec, WireGuard en configuration manuelle — sont puissants mais complexes à configurer et à maintenir. Gestion des certificats, configuration des tunnels, règles de routage, NAT traversal : chaque étape est une source potentielle d'erreurs et de frustrations.

Tailscale change radicalement la donne. Basé sur WireGuard, il permet de créer un réseau mesh privé en quelques minutes, sans configuration réseau complexe, sans ouvrir de ports sur votre firewall, et sans serveur VPN central. En 2026, Tailscale est devenu l'outil de référence pour des milliers d'équipes, de développeurs individuels et d'entreprises, avec des cas d'usage allant du homelab au multi-site d'entreprise.

Architecture en un coup d'œil

Cet article vous guide pas à pas dans la découverte et l'utilisation de Tailscale, de l'installation à la configuration avancée, en passant par les alternatives self-hosted.

Qu'est-ce que Tailscale ?

Tailscale est un service de réseau mesh (ou overlay network) qui crée des connexions peer-to-peer chiffrées entre vos appareils. Il est construit sur le protocole WireGuard, reconnu pour sa simplicité, ses performances et sa sécurité cryptographique.

Les principes fondamentaux

• Zero-config : pas de fichiers de configuration à écrire, pas de certificats à gérer.
• Mesh networking : chaque appareil communique directement avec les autres, sans passer par un serveur central.
• NAT traversal automatique : fonctionne derrière les pare-feu, les NAT et les réseaux d'entreprise sans ouvrir de ports.
• Chiffrement de bout en bout : utilise WireGuard pour chiffrer tout le trafic entre les nœuds.
• Identity-based networking : l'accès est basé sur l'identité de l'utilisateur (SSO), pas sur les adresses IP.

Architecture mesh vs hub-and-spoke

Les VPN traditionnels utilisent une architecture hub-and-spoke (étoile) : tout le trafic passe par un serveur VPN central. Cela crée un goulot d'étranglement, un point unique de défaillance, et ajoute de la latence.

Tailscale utilise une architecture mesh : chaque appareil établit des connexions directes avec les autres appareils du réseau. Le trafic entre deux machines ne passe par aucun intermédiaire. Le serveur de coordination de Tailscale (appelé control plane) ne fait que distribuer les clés publiques et les métadonnées — il ne voit jamais le trafic.

Analogie : imaginez un réseau téléphonique. Un VPN classique est comme un standard téléphonique où tous les appels passent par un opérateur central. Tailscale est comme un réseau de téléphones directs entre chaque poste — l'opérateur ne fait que distribuer l'annuaire.

Le rôle du serveur DERP

Dans les cas où une connexion directe est impossible (NAT très restrictif, réseaux d'entreprise avec inspection profonde des paquets), Tailscale utilise des serveurs DERP (Designated Encrypted Relay for Packets) comme relais. Le trafic reste chiffré de bout en bout — le serveur DERP ne peut pas déchiffrer les données. C'est un plan B transparent, et Tailscale bascule automatiquement vers une connexion directe dès que possible.

Installation de Tailscale

Tailscale est disponible sur pratiquement toutes les plateformes. Voici les méthodes d'installation pour les systèmes les plus courants.

Linux (Debian/Ubuntu)

# Installation via le script officiel
curl -fsSL https://tailscale.com/install.sh | sh

# Ou manuellement via APT
curl -fsSL https://pkgs.tailscale.com/stable/ubuntu/jammy.noarmor.gpg | \
  sudo tee /usr/share/keyrings/tailscale-archive-keyring.gpg >/dev/null
curl -fsSL https://pkgs.tailscale.com/stable/ubuntu/jammy.tailscale-keyring.list | \
  sudo tee /etc/apt/sources.list.d/tailscale.list
sudo apt-get update
sudo apt-get install tailscale

# Démarrer Tailscale
sudo tailscale up

# Un lien d'authentification s'affiche dans le terminal
# Ouvrez-le dans votre navigateur pour vous connecter

Linux (Fedora/RHEL)

# Installation via DNF
sudo dnf config-manager --add-repo https://pkgs.tailscale.com/stable/fedora/tailscale.repo
sudo dnf install tailscale

# Activer et démarrer le service
sudo systemctl enable --now tailscaled

# Se connecter
sudo tailscale up

macOS

# Via Homebrew (version CLI)
brew install tailscale

# Ou via le Mac App Store (version GUI avec menu bar)
# Chercher "Tailscale" dans l'App Store

# Démarrer
sudo tailscale up

Windows

# Via winget
winget install Tailscale.Tailscale

# Ou télécharger l'installeur depuis https://tailscale.com/download/windows

# Tailscale s'installe comme un service Windows avec une icône dans la barre système

Docker

# Exécuter Tailscale dans un conteneur Docker
docker run -d \
  --name tailscale \
  --hostname mon-conteneur \
  --cap-add NET_ADMIN \
  --cap-add NET_RAW \
  -v tailscale-state:/var/lib/tailscale \
  -v /dev/net/tun:/dev/net/tun \
  -e TS_AUTHKEY=tskey-auth-xxxxx \
  -e TS_STATE_DIR=/var/lib/tailscale \
  tailscale/tailscale:latest

Vérification de l'installation

# Vérifier le statut de Tailscale
tailscale status

# Affiche quelque chose comme :
# 100.64.0.1   mon-laptop       wettayeb@  linux   -
# 100.64.0.2   mon-serveur      wettayeb@  linux   -
# 100.64.0.3   mon-telephone    wettayeb@  iOS     -

# Voir l'adresse IP Tailscale de cette machine
tailscale ip -4
# 100.64.0.1

# Tester la connexion vers un autre appareil
ping 100.64.0.2
# ou, grâce à MagicDNS :
ping mon-serveur

Premier réseau : tailscale up

La commande tailscale up est tout ce qu'il faut pour rejoindre un réseau Tailscale. Voici le workflow complet :

1. Installez Tailscale sur deux machines (ou plus).
2. Exécutez sudo tailscale up sur chaque machine.
3. Authentifiez-vous via le lien qui s'affiche (Google, Microsoft, GitHub, OIDC ou email).
4. C'est terminé. Les machines peuvent maintenant communiquer entre elles, quel que soit leur emplacement réseau.

# Sur la machine 1 (serveur)
sudo tailscale up
# To authenticate, visit: https://login.tailscale.com/a/xxxxx

# Sur la machine 2 (laptop)
sudo tailscale up
# To authenticate, visit: https://login.tailscale.com/a/yyyyy

# Les deux machines sont maintenant sur le même réseau privé
# Depuis le laptop, accéder au serveur :
ssh user@mon-serveur  # MagicDNS résout automatiquement
curl http://mon-serveur:3000  # Accéder à un service web

# Lister tous les appareils du réseau
tailscale status

MagicDNS

MagicDNS est le service DNS intégré à Tailscale. Il permet de résoudre les noms de vos appareils automatiquement, sans configurer de serveur DNS.

# Sans MagicDNS, il faut utiliser les adresses IP Tailscale
ssh user@100.64.0.2
curl http://100.64.0.3:8080

# Avec MagicDNS (activé par défaut), utilisez les noms
ssh user@mon-serveur
curl http://raspberry-pi:8080
ping nas-maison

# Les noms sont au format : nom-machine.tailnet-name.ts.net
# Exemple : mon-serveur.tail1234.ts.net
# Mais le nom court "mon-serveur" fonctionne aussi dans le réseau Tailscale

# Configurer un DNS personnalisé (dans l'admin console)
# Vous pouvez ajouter des serveurs DNS split pour résoudre
# les noms internes de votre entreprise via Tailscale

Tailscale SSH

Tailscale SSH est une fonctionnalité qui remplace la gestion traditionnelle des clés SSH. Au lieu de distribuer et gérer des clés SSH sur chaque machine, Tailscale SSH utilise l'identité Tailscale de l'utilisateur pour authentifier les connexions SSH.

# Activer Tailscale SSH sur un serveur
sudo tailscale up --ssh

# Se connecter depuis un autre appareil Tailscale
ssh user@mon-serveur
# Pas besoin de clé SSH ! L'authentification utilise votre identité Tailscale

# Avantages :
# - Pas de clés SSH à gérer, distribuer ou révoquer
# - L'accès est contrôlé par les ACLs Tailscale
# - Les sessions sont enregistrées dans les logs Tailscale
# - La rotation des clés est automatique

Tailscale SSH supporte aussi l'enregistrement des sessions (session recording), ce qui permet d'auditer toutes les commandes exécutées via SSH — une fonctionnalité précieuse pour la conformité.

ACLs : Access Control Lists

Les ACLs (Access Control Lists) sont le mécanisme de contrôle d'accès de Tailscale. Elles permettent de définir précisément qui peut accéder à quoi dans votre réseau. Par défaut, tous les appareils d'un même tailnet peuvent communiquer entre eux. Les ACLs permettent de restreindre ce comportement.

Structure d'une ACL Tailscale

Les ACLs sont définies en JSON (ou HuJSON, une variante avec commentaires) dans la console d'administration Tailscale ou via l'API.

{
  // Définition des groupes d'utilisateurs
  "groups": {
    "group:devs": [
      "alice@codeclan.fr",
      "bob@codeclan.fr"
    ],
    "group:ops": [
      "charlie@codeclan.fr",
      "diana@codeclan.fr"
    ],
    "group:management": [
      "eve@codeclan.fr"
    ]
  },

  // Définition des tags (pour les machines)
  "tagOwners": {
    "tag:server": ["group:ops"],
    "tag:database": ["group:ops"],
    "tag:monitoring": ["group:ops"],
    "tag:dev": ["group:devs"]
  },

  // Définition des hosts (alias pour des IPs ou des groupes)
  "hosts": {
    "prod-db": "100.64.0.10",
    "staging-db": "100.64.0.11"
  },

  // Règles d'accès
  "acls": [
    // Les ops ont accès à tout
    {
      "action": "accept",
      "src": ["group:ops"],
      "dst": ["*:*"]
    },

    // Les devs peuvent accéder aux serveurs de dev sur tous les ports
    {
      "action": "accept",
      "src": ["group:devs"],
      "dst": ["tag:dev:*"]
    },

    // Les devs peuvent accéder aux serveurs de prod uniquement en SSH
    {
      "action": "accept",
      "src": ["group:devs"],
      "dst": ["tag:server:22"]
    },

    // Les devs peuvent accéder au staging DB sur le port PostgreSQL
    {
      "action": "accept",
      "src": ["group:devs"],
      "dst": ["staging-db:5432"]
    },

    // Le management peut accéder au monitoring
    {
      "action": "accept",
      "src": ["group:management"],
      "dst": ["tag:monitoring:80", "tag:monitoring:443"]
    },

    // Tous les serveurs peuvent communiquer entre eux
    {
      "action": "accept",
      "src": ["tag:server"],
      "dst": ["tag:server:*"]
    },

    // Les serveurs peuvent accéder aux bases de données
    {
      "action": "accept",
      "src": ["tag:server"],
      "dst": ["tag:database:5432", "tag:database:3306"]
    }
  ],

  // Configuration SSH
  "ssh": [
    {
      "action": "accept",
      "src": ["group:ops"],
      "dst": ["tag:server"],
      "users": ["root", "admin"]
    },
    {
      "action": "accept",
      "src": ["group:devs"],
      "dst": ["tag:dev"],
      "users": ["deploy"]
    }
  ]
}

Appliquer les ACLs

# Les ACLs sont gérées via la console web de Tailscale :
# https://login.tailscale.com/admin/acls

# Ou via l'API Tailscale
curl -X POST "https://api.tailscale.com/api/v2/tailnet/codeclan.fr/acl" \
  -H "Authorization: Bearer tskey-api-xxxxx" \
  -H "Content-Type: application/json" \
  -d @acl.json

# Tester les ACLs avant de les appliquer (dry-run)
curl -X POST "https://api.tailscale.com/api/v2/tailnet/codeclan.fr/acl/validate" \
  -H "Authorization: Bearer tskey-api-xxxxx" \
  -H "Content-Type: application/json" \
  -d @acl.json

# Vérifier l'accès d'un appareil
tailscale ping mon-serveur
# pong from mon-serveur (100.64.0.2) via DERP(par) in 12ms
# ou
# pong from mon-serveur (100.64.0.2) via 82.45.123.1:41641 in 3ms

Subnet Routers : accéder à un réseau local distant

Les subnet routers (routeurs de sous-réseau) permettent d'accéder à un réseau local complet via Tailscale, sans installer Tailscale sur chaque machine de ce réseau. C'est particulièrement utile pour accéder à des appareils qui ne supportent pas Tailscale (imprimantes, caméras IP, NAS anciens, équipements réseau).

# Sur la machine qui servira de subnet router
# (doit être sur le réseau local cible ET avoir Tailscale installé)

# Activer le routage IP sur Linux
echo 'net.ipv4.ip_forward = 1' | sudo tee -a /etc/sysctl.d/99-tailscale.conf
echo 'net.ipv6.conf.all.forwarding = 1' | sudo tee -a /etc/sysctl.d/99-tailscale.conf
sudo sysctl -p /etc/sysctl.d/99-tailscale.conf

# Annoncer le sous-réseau local via Tailscale
sudo tailscale up --advertise-routes=192.168.1.0/24,192.168.2.0/24

# Ensuite, approuver les routes dans la console d'administration Tailscale
# https://login.tailscale.com/admin/machines
# Cliquer sur la machine > "Edit route settings" > Approuver les routes

# Depuis n'importe quel appareil Tailscale, accéder au réseau local distant
ping 192.168.1.100  # Imprimante sur le réseau distant
ssh admin@192.168.1.1  # Routeur sur le réseau distant
curl http://192.168.2.50:8080  # Service web sur le réseau distant

Cas d'usage concret : accéder à son homelab depuis n'importe où

# Sur le Raspberry Pi du homelab (réseau 192.168.1.0/24)
sudo tailscale up --advertise-routes=192.168.1.0/24

# Depuis votre laptop en déplacement :
# Accéder au NAS Synology
open http://192.168.1.50:5000

# Accéder à Home Assistant
open http://192.168.1.60:8123

# Accéder à la caméra IP
open http://192.168.1.70

# Tout cela sans ouvrir un seul port sur la box internet !

Exit Nodes : utiliser un appareil comme passerelle internet

Un exit node est un appareil Tailscale qui sert de passerelle internet pour les autres appareils. Tout le trafic internet est alors routé via cet appareil, comme un VPN classique. C'est utile pour :

• Sécuriser votre trafic sur un Wi-Fi public
• Accéder à des ressources géo-restreintes
• Centraliser la sortie internet pour l'audit ou le filtrage

# Sur le serveur qui servira d'exit node (ex: un VPS à Paris)
sudo tailscale up --advertise-exit-node

# Approuver l'exit node dans la console d'administration

# Depuis un autre appareil, utiliser l'exit node
sudo tailscale up --exit-node=mon-vps
# ou
sudo tailscale set --exit-node=mon-vps

# Tout le trafic internet passe maintenant par le VPS
curl ifconfig.me
# Affiche l'IP du VPS, pas votre IP locale

# Désactiver l'exit node
sudo tailscale set --exit-node=

Taildrop : partage de fichiers instantané

Taildrop est la fonctionnalité de partage de fichiers intégrée à Tailscale. Elle permet d'envoyer des fichiers directement entre appareils, en peer-to-peer, sans passer par un service cloud.

# Envoyer un fichier vers un autre appareil
tailscale file cp mon-fichier.zip mon-serveur:

# Envoyer plusieurs fichiers
tailscale file cp *.pdf mon-laptop:

# Envoyer un dossier (tar automatique)
tailscale file cp mon-dossier/ mon-serveur:

# Recevoir les fichiers (sur l'appareil destinataire)
tailscale file get .
# Les fichiers sont déposés dans le répertoire courant

# Sur mobile (iOS/Android), les fichiers apparaissent
# directement dans l'application Tailscale

Funnel : exposer un service sur internet

Tailscale Funnel permet d'exposer un service local sur internet, avec un certificat HTTPS valide, sans configurer de reverse proxy, de DNS ou de certificat Let's Encrypt. C'est l'inverse d'un VPN : au lieu de se connecter à un réseau privé, vous rendez un service privé accessible publiquement.

# Exposer un service local sur internet
tailscale funnel 8080
# Votre service est maintenant accessible à :
# https://mon-laptop.tail1234.ts.net/
# Avec un certificat HTTPS valide !

# Exposer un service sur un chemin spécifique
tailscale funnel --set-path /api 3000

# Exposer en arrière-plan
tailscale funnel --bg 8080

# Arrêter l'exposition
tailscale funnel --bg off

# Cas d'usage :
# - Partager un environnement de développement avec un collègue
# - Recevoir des webhooks en développement local
# - Démo rapide d'un projet à un client
# - Exposer temporairement un service pour du debugging

Tailscale Serve : servir du contenu local

# Servir un répertoire local via HTTPS (accessible uniquement sur le tailnet)
tailscale serve /chemin/vers/mon-site

# Proxy vers un service local
tailscale serve http://localhost:3000

# Proxy avec HTTPS local
tailscale serve https://localhost:8443 --set-path /app

# Rendre accessible sur internet (via Funnel)
tailscale serve --funnel http://localhost:3000

Headscale : l'alternative self-hosted

Si vous ne souhaitez pas dépendre du control plane de Tailscale (pour des raisons de souveraineté, de conformité ou simplement de préférence), Headscale est une implémentation open-source du serveur de coordination Tailscale.

Qu'est-ce que Headscale ?

Headscale est un projet open-source qui réimplémente le control plane de Tailscale. Il est compatible avec les clients Tailscale officiels sur toutes les plateformes. Vous hébergez vous-même le serveur de coordination, et tout le reste fonctionne de la même manière.

Installation de Headscale

# Installation via le binaire
HEADSCALE_VERSION="0.23.0"
wget "https://github.com/juanfont/headscale/releases/download/v${HEADSCALE_VERSION}/headscale_${HEADSCALE_VERSION}_linux_amd64.deb"
sudo dpkg -i "headscale_${HEADSCALE_VERSION}_linux_amd64.deb"

# Ou via Docker
docker run -d \
  --name headscale \
  -v /etc/headscale:/etc/headscale \
  -v /var/lib/headscale:/var/lib/headscale \
  -p 8080:8080 \
  -p 9090:9090 \
  headscale/headscale:latest serve

Configuration de Headscale

# /etc/headscale/config.yaml
server_url: https://headscale.codeclan.fr:8080
listen_addr: 0.0.0.0:8080
metrics_listen_addr: 0.0.0.0:9090

private_key_path: /var/lib/headscale/private.key
noise:
  private_key_path: /var/lib/headscale/noise_private.key

ip_prefixes:
  - 100.64.0.0/10
  - fd7a:115c:a1e0::/48

derp:
  server:
    enabled: true
    region_id: 999
    region_code: "custom"
    region_name: "Mon DERP"
    stun_listen_addr: "0.0.0.0:3478"
  urls: []
  auto_update_enabled: true
  update_frequency: 24h

dns:
  magic_dns: true
  base_domain: codeclan.fr
  nameservers:
    global:
      - 1.1.1.1
      - 8.8.8.8

database:
  type: sqlite
  sqlite:
    path: /var/lib/headscale/db.sqlite

# Créer un utilisateur (namespace)
headscale users create codeclan

# Générer une clé d'authentification
headscale preauthkeys create --user codeclan --reusable --expiration 24h

# Connecter un client Tailscale à Headscale
tailscale up --login-server=https://headscale.codeclan.fr:8080

# Lister les machines
headscale nodes list

# Lister les routes
headscale routes list

Headscale vs Tailscale SaaS

Tarification de Tailscale

Plan gratuit (Personal)

• Jusqu'à 100 appareils
• 3 utilisateurs
• Toutes les fonctionnalités de base (mesh, MagicDNS, Taildrop, subnet routers)
• Tailscale SSH
• Funnel
• Parfait pour un usage personnel ou un homelab

Plans payants

• Starter : pour les petites équipes, avec plus d'utilisateurs et de fonctionnalités d'administration.
• Premium : pour les entreprises, avec SSO SAML, enregistrement des sessions, logs avancés, support prioritaire.
• Enterprise : sur mesure, avec SLA, support dédié, déploiement personnalisé.

Le plan gratuit est exceptionnellement généreux et suffisant pour la majorité des utilisateurs individuels et des petites équipes.

Intégration avec Docker et Kubernetes

Tailscale comme sidecar Docker

# docker-compose.yml avec Tailscale sidecar
services:
  tailscale:
    image: tailscale/tailscale:latest
    hostname: mon-service
    cap_add:
      - NET_ADMIN
      - NET_RAW
    volumes:
      - tailscale-state:/var/lib/tailscale
      - /dev/net/tun:/dev/net/tun
    environment:
      - TS_AUTHKEY=tskey-auth-xxxxx
      - TS_STATE_DIR=/var/lib/tailscale
      - TS_SERVE_CONFIG=/config/serve.json
      - TS_USERSPACE=false
    restart: unless-stopped

  web:
    image: nginx:latest
    network_mode: "service:tailscale"
    # Le conteneur web utilise le réseau du conteneur Tailscale
    # Il est accessible via le nom Tailscale "mon-service"

volumes:
  tailscale-state:

Tailscale Operator pour Kubernetes

# Installation du Tailscale Operator via Helm
# helm repo add tailscale https://pkgs.tailscale.com/helmcharts
# helm install tailscale-operator tailscale/tailscale-operator \
#   --set oauth.clientId=xxxxx \
#   --set oauth.clientSecret=xxxxx

# Exposer un service Kubernetes sur Tailscale
apiVersion: v1
kind: Service
metadata:
  name: mon-api
  annotations:
    tailscale.com/expose: "true"
    tailscale.com/hostname: "mon-api-k8s"
spec:
  type: ClusterIP
  selector:
    app: mon-api
  ports:
    - port: 80
      targetPort: 8080

# Ingress Tailscale pour Kubernetes
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: mon-ingress
  annotations:
    tailscale.com/funnel: "true"
spec:
  ingressClassName: tailscale
  rules:
    - host: mon-api-k8s
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: mon-api
                port:
                  number: 80
  tls:
    - hosts:
        - mon-api-k8s

Cas d'usage concrets

1. Homelab : accéder à ses services depuis partout

C'est le cas d'usage le plus populaire de Tailscale. Vous avez un serveur à la maison (NAS, Raspberry Pi, PC dédié) avec des services comme Jellyfin, Home Assistant, Nextcloud, Pi-hole. Avec Tailscale :

# Sur le serveur homelab
sudo tailscale up --advertise-routes=192.168.1.0/24

# Depuis votre téléphone en 4G/5G :
# Ouvrir Jellyfin
open http://jellyfin.tail1234.ts.net:8096

# Accéder à Home Assistant
open http://homeassistant.tail1234.ts.net:8123

# Utiliser Pi-hole comme DNS (exit node partiel)
sudo tailscale up --exit-node=pihole --exit-node-allow-lan-access

# Avantages :
# - Aucun port ouvert sur la box internet
# - Chiffrement de bout en bout
# - Fonctionne sur tous les réseaux (4G, Wi-Fi public, bureau)

2. Remote work : connecter les développeurs aux ressources internes

# Architecture :
# - Subnet router dans le datacenter (accès au réseau interne)
# - ACLs basées sur les groupes d'utilisateurs
# - Tailscale SSH pour l'accès aux serveurs

# Sur le subnet router du datacenter
sudo tailscale up \
  --advertise-routes=10.0.0.0/8 \
  --advertise-tags=tag:datacenter

# Les développeurs ont accès aux serveurs de dev et staging
# Les ops ont accès à tout
# Le management a accès au monitoring
# Tout est contrôlé par les ACLs (voir section ACLs ci-dessus)

3. Multi-site : connecter plusieurs bureaux

# Bureau Paris (réseau 192.168.1.0/24)
# Sur le routeur Tailscale du bureau Paris
sudo tailscale up --advertise-routes=192.168.1.0/24 --hostname=router-paris

# Bureau Lyon (réseau 192.168.2.0/24)
# Sur le routeur Tailscale du bureau Lyon
sudo tailscale up --advertise-routes=192.168.2.0/24 --hostname=router-lyon

# Bureau Remote (réseau 10.0.1.0/24)
# Sur le routeur Tailscale du bureau remote
sudo tailscale up --advertise-routes=10.0.1.0/24 --hostname=router-remote

# Résultat : tous les réseaux sont interconnectés
# Paris peut accéder à Lyon et vice versa
# Les ACLs contrôlent finement les accès inter-sites

# Depuis n'importe quel appareil Tailscale :
ping 192.168.1.100  # Imprimante Paris
ping 192.168.2.50   # Serveur Lyon
ssh admin@10.0.1.1  # Routeur Remote

4. Accéder à des services cloud privés

# Installer Tailscale sur une instance EC2 dans un VPC privé
sudo tailscale up --advertise-routes=10.0.0.0/16

# Maintenant, depuis votre laptop, accéder aux services du VPC :
# RDS (base de données)
psql -h 10.0.1.50 -U admin -d myapp

# ElastiCache (Redis)
redis-cli -h 10.0.2.30

# Service interne
curl http://10.0.3.10:8080/api/health

# Plus besoin de bastion host ou de VPN AWS !

Bonnes pratiques de sécurité

• Activez les ACLs : ne laissez pas le réseau ouvert à tous. Définissez des règles strictes basées sur le principe du moindre privilège.
• Utilisez les tags : taguez vos machines par rôle (server, database, monitoring) pour simplifier les ACLs.
• Activez Tailscale SSH : éliminez la gestion des clés SSH et centralisez le contrôle d'accès.
• Activez l'enregistrement des sessions : pour la conformité et l'audit.
• Rotation des auth keys : utilisez des clés d'authentification éphémères ou à courte durée de vie.
• Appareils éphémères : configurez les conteneurs et les instances cloud comme appareils éphémères pour qu'ils soient automatiquement supprimés du réseau à leur arrêt.
• Auditez régulièrement : vérifiez les appareils connectés et les ACLs dans la console d'administration.

# Créer une auth key éphémère (l'appareil est supprimé à la déconnexion)
# Via l'API Tailscale
curl -X POST "https://api.tailscale.com/api/v2/tailnet/codeclan.fr/keys" \
  -H "Authorization: Bearer tskey-api-xxxxx" \
  -H "Content-Type: application/json" \
  -d '{
    "capabilities": {
      "devices": {
        "create": {
          "reusable": false,
          "ephemeral": true,
          "preauthorized": true,
          "tags": ["tag:server"]
        }
      }
    },
    "expirySeconds": 86400
  }'

Dépannage courant

# Vérifier le statut détaillé
tailscale status --json | jq .

# Vérifier la connectivité avec un pair
tailscale ping mon-serveur
# Affiche si la connexion est directe ou via DERP

# Voir le type de connexion (direct vs relayed)
tailscale netcheck
# Affiche les résultats des tests de connectivité :
# - UDP disponible ?
# - STUN fonctionne ?
# - Latence vers les serveurs DERP

# Débugger les problèmes réseau
tailscale debug netmap
tailscale debug portmap

# Vérifier les logs
sudo journalctl -u tailscaled -f

# Réinitialiser Tailscale (en cas de problème grave)
sudo tailscale down
sudo tailscale logout
sudo tailscale up

Comparaison avec les alternatives

Conclusion

Tailscale a réussi un pari ambitieux : rendre le networking sécurisé aussi simple que possible sans sacrifier la sécurité ou les performances. En s'appuyant sur WireGuard pour le chiffrement et en ajoutant une couche d'orchestration intelligente (NAT traversal, MagicDNS, ACLs, SSO), il transforme une tâche traditionnellement complexe en une opération de quelques minutes.

Que vous soyez un développeur individuel avec un homelab, une startup en full remote, ou une entreprise multi-site, Tailscale offre une solution adaptée. Le plan gratuit est suffisamment généreux pour la plupart des usages personnels, et les plans payants ajoutent les fonctionnalités d'entreprise nécessaires à grande échelle.

L'existence de Headscale comme alternative self-hosted garantit que vous n'êtes pas enfermé dans le SaaS de Tailscale. Et la compatibilité avec les clients officiels signifie que la migration entre les deux est transparente.

Si vous n'avez pas encore essayé Tailscale, c'est le moment. En 5 minutes, vous aurez un réseau mesh privé, chiffré, zero-config, qui connecte tous vos appareils. C'est aussi simple que tailscale up.