> ## Documentation Index
> Fetch the complete documentation index at: https://docs.replit.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Configurer les Tunnels

> Configurez les Tunnels Replit pour connecter des projets à des services TCP privés, déployez un connecteur avec Docker ou Helm, vérifiez les endpoints et gérez les clés d'enrôlement.

## Ce que cela permet

> [!NOTE]
>
> Les Tunnels doivent être activés pour votre espace de travail. Si les Tunnels ne sont pas disponibles dans les paramètres de votre espace de travail, contactez Replit pour confirmer leur disponibilité et leur activation.

Un tunnel permet à un environnement de développement Replit pris en charge d'atteindre une destination TCP approuvée de votre réseau privé via un connecteur que vous exploitez. Il s'agit d'une approche de connectivité alternative à l'autorisation des adresses IP de sortie du sandbox dans votre réseau.

Exécutez le connecteur dans un réseau où il peut résoudre et atteindre vos services TCP privés. Vous pouvez utiliser la commande Docker générée ou déployer le connecteur sur Kubernetes avec le chart Helm ci-dessous. Replit exploite le plan de contrôle des tunnels. Le chart ci-dessous ne déploie que votre connecteur.

Chemin de connexion : projet Replit → infrastructure de tunnels Replit → votre connecteur → service TCP privé. L'authentification du service et TLS restent indépendants de l'enrôlement du tunnel.

## 1. Créer le tunnel dans Replit

1. Dans Replit, utilisez le sélecteur d'espace de travail pour choisir l'espace de travail qui possède vos projets. Ouvrez Paramètres → Vue d'ensemble de l'espace de travail et faites défiler jusqu'à Tunnels.

![Ouvrez la section Tunnels dans les paramètres de votre espace de travail.](https://mintcdn.com/replit/tf-DypNXeTHeMPj_/images/tunnels/tunnels-create.png?fit=max\&auto=format\&n=tf-DypNXeTHeMPj_\&q=85\&s=074526eae05d0445b5277ce23d8d62f5)

Ouvrez la section Tunnels dans les paramètres de votre espace de travail.

2. Cliquez sur Créer un tunnel et saisissez un nom descriptif.

![Créer un tunnel.](https://mintcdn.com/replit/tf-DypNXeTHeMPj_/images/tunnels/create-dialog.png?fit=max\&auto=format\&n=tf-DypNXeTHeMPj_\&q=85\&s=b3d3ae820d6cf213aef88dfa12be42c7)

Créer un tunnel.

3. Dans la boîte de dialogue Enregistrez votre clé d'enrôlement, utilisez les boutons de copie à côté de ID du tunnel et Clé d'enrôlement. Enregistrez la clé d'enrôlement dans votre gestionnaire de secrets approuvé avant de cliquer sur J'ai enregistré ma clé. La clé n'est affichée qu'une seule fois et ne peut plus être consultée après la fermeture de cette boîte de dialogue.

![La boîte de dialogue de la clé d'enrôlement à usage unique. La clé est volontairement masquée dans cette capture d'écran.](https://mintcdn.com/replit/tf-DypNXeTHeMPj_/images/tunnels/save-key.png?fit=max\&auto=format\&n=tf-DypNXeTHeMPj_\&q=85\&s=37e69ca9e1702744b64a7c7de8530ca6)

La boîte de dialogue de la clé d'enrôlement à usage unique. La clé est volontairement masquée dans cette capture d'écran.

4. Ouvrez Paramètres → Vue d'ensemble de l'espace de travail → Tunnels et sélectionnez votre tunnel. Son ID apparaît sous le nom du tunnel avec un bouton de copie. Tant que le connecteur n'est pas en ligne, le panneau Terminer la configuration du tunnel affiche la commande Docker. Remplacez l'espace réservé de la clé d'enrôlement par la clé que vous avez enregistrée.

![Copiez la commande Docker depuis Terminer la configuration du tunnel.](https://mintcdn.com/replit/tf-DypNXeTHeMPj_/images/tunnels/setup.png?fit=max\&auto=format\&n=tf-DypNXeTHeMPj_\&q=85\&s=bf1e6b498d5f788a606142f93e2f21a9)

Copiez la commande Docker depuis Terminer la configuration du tunnel.

Pour Helm, copiez les valeurs complètes de `RPTUN_TUNNEL_REF` et `RPTUN_ENROLL_ADDR` de la commande de configuration dans `tunnelRef` et `enrollAddr`. Copiez l'image du conteneur depuis la dernière ligne de la commande dans `image`. La référence complète du tunnel est différente de l'ID court du tunnel affiché sous son nom. La clé d'enrôlement provient de la boîte de dialogue de clé à usage unique, et non de la commande de configuration.

Exécutez la commande Docker sur un hôte capable de résoudre et d'atteindre votre service privé. Pour Kubernetes, utilisez le chart Helm ci-dessous.

## 2. Déployer le connecteur avec Helm

Cet exemple de chart exécute le connecteur côté client sur Kubernetes. Adaptez-le aux standards de votre cluster et validez-le dans un environnement hors production avant de le déployer.

### Créer les fichiers du chart

Créez cette structure de répertoires :

```txt theme={null}
replit-tunnel-connector/
  Chart.yaml
  values.yaml
  templates/
    deployment.yaml
customer-values.yaml
```

```bash theme={null}
mkdir -p replit-tunnel-connector/templates
```

`replit-tunnel-connector/Chart.yaml`

```yaml theme={null}
apiVersion: v2
name: replit-tunnel-connector
description: Example customer-side Replit tunnel connector.
type: application
version: 0.1.0
```

`replit-tunnel-connector/values.yaml`

```yaml theme={null}
# Use the image and connection settings from your own tunnel's setup panel.
# Do not put enrollment keys in Helm values or --set arguments.
image: ""
tunnelRef: ""
enrollAddr: ""
existingSecret: replit-tunnel-enrollment
secretKey: enrollment-key
resources: {}
nodeSelector: {}
tolerations: []
affinity: {}
```

`replit-tunnel-connector/templates/deployment.yaml`

```yaml theme={null}
apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ .Release.Name }}
  labels:
    app.kubernetes.io/name: replit-tunnel-connector
    app.kubernetes.io/instance: {{ .Release.Name }}
spec:
  replicas: 1
  strategy:
    type: Recreate
  selector:
    matchLabels:
      app.kubernetes.io/name: replit-tunnel-connector
      app.kubernetes.io/instance: {{ .Release.Name }}
  template:
    metadata:
      labels:
        app.kubernetes.io/name: replit-tunnel-connector
        app.kubernetes.io/instance: {{ .Release.Name }}
    spec:
      automountServiceAccountToken: false
      containers:
        - name: connector
          image: {{ required "Set image to the connector image from your tunnel setup panel" .Values.image | quote }}
          imagePullPolicy: IfNotPresent
          env:
            - name: RPTUN_ENROLLMENT_KEY
              valueFrom:
                secretKeyRef:
                  name: {{ required "Set existingSecret" .Values.existingSecret | quote }}
                  key: {{ required "Set secretKey" .Values.secretKey | quote }}
            - name: RPTUN_TUNNEL_REF
              value: {{ required "Set tunnelRef from your tunnel setup panel" .Values.tunnelRef | quote }}
            - name: RPTUN_ENROLL_ADDR
              value: {{ required "Set enrollAddr from your tunnel setup panel" .Values.enrollAddr | quote }}
          resources:
            {{- toYaml .Values.resources | nindent 12 }}
      nodeSelector:
        {{- toYaml .Values.nodeSelector | nindent 8 }}
      tolerations:
        {{- toYaml .Values.tolerations | nindent 8 }}
      affinity:
        {{- toYaml .Values.affinity | nindent 8 }}
```

### Configurer votre tunnel

Créez le namespace et provisionnez la clé d'enrôlement via votre processus approuvé de gestion des secrets. L'exemple attend un Secret nommé `replit-tunnel-enrollment` avec un champ nommé `enrollment-key` dans le namespace `replit-tunnels`. Ne placez pas la clé d'enrôlement dans les valeurs Helm, le contrôle de source ou les arguments `--set`.

`customer-values.yaml` — remplacez les trois espaces réservés en utilisant la commande de configuration générée pour votre propre tunnel :

```yaml theme={null}
# Replace all three placeholders using your own tunnel's setup command.
image: "CONNECTOR_IMAGE_FROM_REPLIT"
tunnelRef: "TUNNEL_REFERENCE_FROM_REPLIT"
enrollAddr: "ENROLLMENT_ADDRESS_FROM_REPLIT"
existingSecret: replit-tunnel-enrollment
secretKey: enrollment-key
```

En production, utilisez si possible un digest d'image de connecteur immuable approuvé. Le chart conserve le point d'entrée de l'image et transmet les variables d'environnement indiquées dans la commande Docker générée. Validez la compatibilité avec votre image exacte.

### Générer et installer

Avec Helm et `kubectl` configurés pour le cluster Kubernetes visé, exécutez ces commandes depuis le répertoire contenant `customer-values.yaml` et le répertoire du chart. Le namespace et le Secret doivent déjà exister :

```bash theme={null}
helm lint ./replit-tunnel-connector -f customer-values.yaml
helm template replit-tunnel ./replit-tunnel-connector \
  --namespace replit-tunnels -f customer-values.yaml
helm upgrade --install replit-tunnel ./replit-tunnel-connector \
  --namespace replit-tunnels -f customer-values.yaml \
  --wait --timeout 5m
kubectl -n replit-tunnels rollout status deployment/replit-tunnel
kubectl -n replit-tunnels get pods -l app.kubernetes.io/instance=replit-tunnel
```

Le chart exécute une seule réplique avec la stratégie `Recreate` ; les mises à jour entraînent donc une interruption de service. Il ne crée ni Service public ni LoadBalancer et ne définit aucune sonde de santé. L'état « prêt » de Kubernetes ne prouve pas à lui seul la connectivité du tunnel : confirmez **En ligne** dans Replit et effectuez les tests Shell du projet ci-dessous.

Avant toute utilisation en production, validez les ressources, l'architecture CPU, les besoins d'état inscriptible, le contexte de sécurité, le comportement au redémarrage et les exigences réseau sortantes. Le connecteur doit pouvoir atteindre le nom d'hôte DNS et le port TCP de votre service privé. Obtenez auprès de Replit les exigences complètes de sortie réseau du connecteur.

Pour le dépannage, consultez les journaux localement et supprimez les identifiants et les informations privées avant de les partager :

```bash theme={null}
kubectl -n replit-tunnels logs deployment/replit-tunnel --tail=100
```

## 3. Confirmer que le connecteur est en ligne

Revenez à Paramètres → Vue d'ensemble de l'espace de travail → Tunnels et sélectionnez votre tunnel. Attendez que la carte Statut affiche En ligne. S'il reste hors ligne, vérifiez la configuration d'enrôlement, l'accès réseau sortant, les événements du pod et les journaux du connecteur.

![En ligne signifie que le connecteur est connecté. Jamais est normal avant tout trafic applicatif.](https://mintcdn.com/replit/tf-DypNXeTHeMPj_/images/tunnels/online-empty.png?fit=max\&auto=format\&n=tf-DypNXeTHeMPj_\&q=85\&s=7930e84bdab9e71e80c25dee819bb7cd)

En ligne signifie que le connecteur est connecté. Jamais est normal avant tout trafic applicatif.

## 4. Enregistrer un endpoint privé

1. Sur la page de détails du tunnel, cliquez sur Ajouter un endpoint dans la section Endpoints.
2. Saisissez un nom descriptif et le nom d'hôte de destination privé avec son port TCP, par exemple database.internal.example:5432.
3. Utilisez un nom d'hôte résolvable depuis le réseau du connecteur. L'interface actuelle ne prend pas en charge les destinations par adresse IP.
4. Sélectionnez Tester la connexion. Une coche verte signifie que le connecteur peut atteindre la destination.
5. Ajoutez l'endpoint et vérifiez qu'il apparaît dans le tableau.

![Test de connexion réussi : la coche verte à côté de Destination confirme que le connecteur peut atteindre le service.](https://mintcdn.com/replit/tf-DypNXeTHeMPj_/images/tunnels/endpoint-connection-test-success.png?fit=max\&auto=format\&n=tf-DypNXeTHeMPj_\&q=85\&s=05866622a7ec96e3fd06c80010bb9373)

Test de connexion réussi : la coche verte à côté de Destination confirme que le connecteur peut atteindre le service.

L'endpoint apparaît dans le tableau, où vous pouvez copier sa destination ou ouvrir son menu d'actions à trois points.

![Endpoint Redis enregistré, avec le connecteur En ligne et la destination Accessible.](https://mintcdn.com/replit/tf-DypNXeTHeMPj_/images/tunnels/endpoint.png?fit=max\&auto=format\&n=tf-DypNXeTHeMPj_\&q=85\&s=b957c4f84856b532d427d558b723b7e2)

Endpoint Redis enregistré, avec le connecteur En ligne et la destination Accessible.

## 5. Vérifier la résolution de l'endpoint dans le Shell d'un projet Replit

Utilisez le sélecteur d'espace de travail pour revenir à l'espace de travail qui possède le tunnel, ouvrez-y un projet et ouvrez l'onglet **Shell** dans l'éditeur du projet. Exécutez les vérifications suivantes dans ce Shell, et non dans un chat autonome.

### Confirmer que le nom d'hôte est résolu

Utilisez le nom d'hôte du champ Destination de l'endpoint, sans le port ni le schéma d'URL :

```bash theme={null}
getent hosts YOUR_ENDPOINT_HOSTNAME
```

Une résolution réussie affiche une adresse IP et le nom d'hôte. La résolution DNS seule ne confirme pas la connectivité au service ; exécutez ensuite le test de service ci-dessous.

### Tester la connexion au service

Utilisez le client natif de votre service pour une requête légère, avec ses exigences habituelles en matière de TLS et d'authentification. Pour Redis :

```bash theme={null}
redis-cli -h YOUR_ENDPOINT_HOSTNAME -p 6379 PING
```

`6379` est le port par défaut de Redis. Remplacez-le si nécessaire pour correspondre au port de votre endpoint enregistré.

Résultat attendu : `PONG`. Il s'agit du `PING` applicatif de Redis, et non d'un ping réseau ICMP.

![Résolution du nom d'hôte et PONG Redis réussi dans le Shell du projet.](https://mintcdn.com/replit/tf-DypNXeTHeMPj_/images/tunnels/shell-proof.png?fit=max\&auto=format\&n=tf-DypNXeTHeMPj_\&q=85\&s=0cac629de7d995bb6424d2b0d84a1a22)

Résolution du nom d'hôte et PONG Redis réussi dans le Shell du projet.

Après une requête réussie, le tableau de bord du tunnel affiche désormais les horodatages du trafic récent.

![Activité du tunnel après la requête Redis réussie.](https://mintcdn.com/replit/tf-DypNXeTHeMPj_/images/tunnels/traffic.png?fit=max\&auto=format\&n=tf-DypNXeTHeMPj_\&q=85\&s=089a5eed1d316701d3ac49647e7c15b5)

Activité du tunnel après la requête Redis réussie.

## 6. Gérer les clés d'enrôlement

De retour dans le tableau de bord des tunnels, ouvrez le menu à trois points à côté du nom du tunnel et sélectionnez **Gérer la clé d'enrôlement**.

![Ouvrez la gestion des clés d'enrôlement.](https://mintcdn.com/replit/tf-DypNXeTHeMPj_/images/tunnels/key-menu.png?fit=max\&auto=format\&n=tf-DypNXeTHeMPj_\&q=85\&s=bb6c5735f27d191245ea425601f8f4fe)

Ouvrez la gestion des clés d'enrôlement.

![Liste des clés actives et actions disponibles.](https://mintcdn.com/replit/tf-DypNXeTHeMPj_/images/tunnels/keys.png?fit=max\&auto=format\&n=tf-DypNXeTHeMPj_\&q=85\&s=bb4515355377b012c9b7f0d59a46a436)

Liste des clés actives et actions disponibles.

### Ajouter une clé d'enrôlement

Choisissez Ajouter une clé d'enrôlement lorsqu'un emplacement est disponible. Cela ouvre la même boîte de dialogue Enregistrez votre clé d'enrôlement que lors de la configuration initiale. Copiez immédiatement la nouvelle clé et enregistrez-la en lieu sûr : elle n'est affichée qu'une seule fois.

Si les deux emplacements de clé sont occupés, identifiez la clé à révoquer ou à remplacer avant de continuer. Ne révoquez pas une clé à l'aveugle. La nouvelle tentative de livraison de la clé sert à une requête interrompue, et non à afficher de nouveau une clé déjà livrée.

### Révoquer une clé d'enrôlement

Choisissez **Révoquer** sur la clé concernée, vérifiez les détails de la clé sélectionnée, puis choisissez **Confirmer la révocation de la clé sélectionnée**. Cela bloque tout futur enrôlement avec cette clé.

> [!WARNING]
>
> La révocation d'une clé ne déconnecte pas les sessions de connecteur déjà établies. Redémarrez le connecteur avec une nouvelle clé pour mettre fin aux sessions existantes.

![Vérifiez et confirmez la révocation de la clé sélectionnée.](https://mintcdn.com/replit/tf-DypNXeTHeMPj_/images/tunnels/revoke.png?fit=max\&auto=format\&n=tf-DypNXeTHeMPj_\&q=85\&s=6d448ab1dc83729ef72f0678341b4360)

Vérifiez et confirmez la révocation de la clé sélectionnée.

![Après la révocation, le nombre de clés actives est mis à jour. Le connecteur établi peut toujours être En ligne.](https://mintcdn.com/replit/tf-DypNXeTHeMPj_/images/tunnels/revoked.png?fit=max\&auto=format\&n=tf-DypNXeTHeMPj_\&q=85\&s=02695158c64bb5c4155f35864888255f)

Après la révocation, le nombre de clés actives est mis à jour. Le connecteur établi peut toujours être En ligne.

### Mettre à jour un connecteur après le changement de sa clé

Provisionnez la nouvelle clé via votre gestionnaire de secrets approuvé. Redémarrez le déploiement du connecteur après la mise à jour du Secret :

```bash theme={null}
kubectl -n replit-tunnels rollout restart deployment/replit-tunnel
kubectl -n replit-tunnels rollout status deployment/replit-tunnel
```

Confirmez **En ligne** et répétez la requête de service dans le Shell du projet. Prévoyez une interruption de service avec la stratégie `Recreate` à réplique unique de cet exemple. Ne supposez pas que la révocation seule met fin à une connexion existante.

## 7. Déconnecter et nettoyer

Lorsque le connecteur s'arrête, le tunnel passe Hors ligne et l'endpoint ne doit pas être considéré comme accessible.

![Tunnel Hors ligne et endpoint Inaccessible après la déconnexion du connecteur.](https://mintcdn.com/replit/tf-DypNXeTHeMPj_/images/tunnels/offline.png?fit=max\&auto=format\&n=tf-DypNXeTHeMPj_\&q=85\&s=6deb9a3547a92b22a887feb6179614da)

Tunnel Hors ligne et endpoint Inaccessible après la déconnexion du connecteur.

Pour supprimer la release Helm du connecteur :

```bash theme={null}
helm uninstall replit-tunnel --namespace replit-tunnels
```

Le chart ne gère ni le Secret, ni le namespace, ni le tunnel Replit, ni les endpoints. Supprimez-les séparément uniquement lorsqu'ils ne sont plus nécessaires. Ne supprimez jamais un namespace partagé ni l'endpoint d'une autre application.

## Dépannage

### Tunnels indisponibles

Demandez à Replit de vérifier l'activation de l'espace de travail et la disponibilité du service avant de modifier la configuration de votre connecteur ou de votre réseau.

### Échec du pod du connecteur

Inspectez les erreurs de téléchargement d'image, de planification, de références de Secret et de démarrage du conteneur.

### Tunnel hors ligne

Inspectez la configuration d'enrôlement et la connectivité sortante du connecteur.

### Endpoint inaccessible

Vérifiez le DNS privé, le service cible et le port, le routage, les règles de pare-feu et les éventuelles NetworkPolicies Kubernetes depuis le réseau du connecteur.

### Le test de connexion réussit mais la requête échoue

Vérifiez le TLS de la base de données, les identifiants, les autorisations de la base de données et le chemin de routage pris en charge du sandbox Replit.

### Destination en double

Vérifiez les endpoints existants dans l'ensemble de l'espace de travail avant de créer un autre enregistrement.

### Le nom d'hôte n'est pas résolu

Confirmez que vous êtes dans le **Shell** d'un projet Replit, dans le même espace de travail que l'endpoint enregistré. Vérifiez le nom d'hôte exact de la destination et l'état du tunnel.

Si le problème persiste, contactez Replit en indiquant l'espace de travail/le projet et l'erreur. **Ne partagez jamais la clé d'enrôlement.**