Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Multiplexez les flux de données et utilisez des connexions TCP simultanées dans un tunnel sécurisé
Vous pouvez utiliser plusieurs flux de données par tunnel en utilisant la fonction de multiplexage par tunneling sécurisé. Le multiplexage vous permet de dépanner des appareils utilisant plusieurs flux de données. Vous pouvez également réduire votre charge opérationnelle en éliminant le besoin de créer, de déployer et de démarrer plusieurs proxys locaux ou d'ouvrir plusieurs tunnels vers le même appareil. Par exemple, le multiplexage peut être utilisé dans le cas d'un navigateur Web qui nécessite l'envoi de plusieurs flux de données HTTP et SSH.
Pour chaque flux de données, le tunneling AWS IoT sécurisé prend en charge les connexions TCP simultanées. L'utilisation de connexions simultanées réduit le risque de temporisation en cas de demandes multiples du client. Par exemple, cela peut réduire le temps de chargement lors de l'accès à distance à un serveur Web local à l'appareil de destination.
Les sections suivantes expliquent plus en détail le multiplexage et l'utilisation de connexions TCP simultanées, ainsi que leurs différents cas d'utilisation.
**Topics**
+ [Multiplexage de plusieurs flux de données dans un tunnel sécurisé](multiplexing-multiple-streams.md)
+ [Utilisation de connexions TCP simultanées dans un tunnel sécurisé](multiplexing-simultaneous-tcp.md)
# Multiplexage de plusieurs flux de données dans un tunnel sécurisé
Vous pouvez utiliser la fonction de multiplexage pour les appareils utilisant plusieurs connexions ou ports. Le multiplexage peut également être utilisé lorsque vous avez besoin de plusieurs connexions à un appareil distant pour résoudre des problèmes. Par exemple, il peut être utilisé dans le cas d'un navigateur Web qui nécessite l'envoi de plusieurs flux de données HTTP et SSH. Les données d'application provenant des deux flux sont envoyées au dispositif simultanément via le tunnel multiplexé.
## Exemple de cas d’utilisation
Supposons que vous deviez vous connecter à une application Web intégrée à l'appareil pour modifier certains paramètres réseau, tout en émettant simultanément des commandes shell via le terminal pour vérifier que le périphérique fonctionne correctement avec les nouveaux paramètres réseau. Dans ce scénario, vous devrez peut-être vous connecter à l'appareil via HTTP et SSH et transférer deux flux de données parallèles pour accéder simultanément à l'application Web et au terminal. Grâce à la fonction de multiplexage, ces deux flux indépendants peuvent être transférés simultanément sur le même tunnel.
![\[Schéma illustrant l'architecture cloud de l'IoT avec des appareils sources, des serveurs proxy et des appareils de destination pour le streaming de données via différents protocoles.\]](http://docs.aws.amazon.com/fr_fr/iot/latest/developerguide/images/tunnel-multiplexing.png)
## Configuration d'un tunnel multiplexé
La procédure suivante explique comment configurer un tunnel multiplexé pour le dépannage des périphériques à l'aide d'applications nécessitant des connexions à plusieurs ports. Vous allez configurer un tunnel avec deux flux multiplexés : un flux HTTP et un flux SSH.
1.
**(Facultatif) Créez des fichiers de configuration**
Vous pouvez éventuellement configurer le périphérique source et de destination à l'aide de fichiers de configuration. Utilisez des fichiers de configuration si vos mappages de ports sont susceptibles de changer fréquemment. Vous pouvez ignorer cette étape si vous préférez spécifier le mappage des ports de manière explicite à l'aide de la CLI, ou si vous n'avez pas besoin de démarrer le proxy local sur les ports d'écoute désignés. Pour plus d'informations sur l'utilisation des fichiers de configuration, voir [Options définies via --config](https://github.com/aws-samples/aws-iot-securetunneling-localproxy#options-set-via---config) dans GitHub.
1. Sur votre appareil source, dans le dossier où votre proxy local sera exécuté, créez un dossier de configuration appelé `Config`. Dans ce dossier, créez un fichier appelé `SSHSource.ini` avec le contenu suivant :
```
HTTP1 = 5555
SSH1 = 3333
```
1. Sur votre appareil de destination, dans le dossier où votre proxy local sera exécuté, créez un dossier de configuration appelé`Config`. Dans ce dossier, créez un fichier appelé `SSHDestination.ini` avec le contenu suivant :
```
HTTP1 = 80
SSH1 = 22
```
1.
**Ouvrir un tunnel**
Ouvrez un tunnel à l'aide de l'opération `OpenTunnel` API ou de la commande `open-tunnel` CLI. Configurez la destination en spécifiant `SSH1` et en `HTTP1` tant que services et le nom de l' AWS IoT objet correspondant à votre appareil distant. Vos applications SSH et HTTP s'exécutent sur cet appareil distant. Vous devez déjà avoir créé l'objet IoT dans le AWS IoT registre. Pour de plus amples informations, veuillez consulter [Gérer les choses avec le registre](thing-registry.md).
```
aws iotsecuretunneling open-tunnel \
--destination-config thingName=RemoteDevice1,services=HTTP1,SSH1
```
L'exécution de cette commande génère les jetons d'accès à la source et à la destination que vous utiliserez pour exécuter le proxy local.
```
{
"tunnelId": "b2de92a3-b8ff-46c0-b0f2-afa28b00cecd",
"tunnelArn": "arn:aws:iot:us-west-2:431600097591:tunnel/b2de92a3-b8ff-46c0-b0f2-afa28b00cecd",
"sourceAccessToken": source_client_access_token,
"destinationAccessToken": destination_client_access_token
}
```
1.
**Configuration et démarrage du proxy local**
Avant de pouvoir exécuter le proxy local, configurez le client du AWS IoT périphérique ou téléchargez le code source du proxy local [GitHub](https://github.com/aws-samples/aws-iot-securetunneling-localproxy)et créez-le pour la plate-forme de votre choix. Vous pouvez ensuite démarrer le proxy local de destination et de source pour vous connecter au tunnel sécurisé. Pour plus d'informations sur la configuration et l'utilisation du proxy local, voir [Comment utiliser le proxy local](how-use-local-proxy.md).
**Note**
Sur votre périphérique source, si vous n'utilisez aucun fichier de configuration ou si vous ne spécifiez pas le mappage des ports à l'aide de la CLI, vous pouvez toujours utiliser la même commande pour exécuter le proxy local. Le proxy local en mode source sélectionnera automatiquement les ports disponibles à utiliser et les mappages pour vous.
------
#### [ Start local proxy using configuration files ]
Exécutez les commandes suivantes pour exécuter le proxy local dans les modes source et destination à l'aide de fichiers de configuration.
```
// ----------------- Start the destination local proxy -----------------------
./localproxy -r us-east-1 -m dst -t destination_client_access_token
// ----------------- Start the source local proxy ----------------------------
// You also run the same command below if you want the local proxy to
// choose the mappings for you instead of using configuration files.
./localproxy -r us-east-1 -m src -t source_client_access_token
```
------
#### [ Start local proxy using CLI port mapping ]
Exécutez les commandes suivantes pour exécuter le proxy local dans les modes source et destination en spécifiant explicitement les mappages de ports à l'aide de la CLI.
```
// ----------------- Start the destination local proxy -----------------------------------
./localproxy -r us-east-1 -d HTTP1=80,SSH1=22 -t destination_client_access_token
// ----------------- Start the source local proxy ----------------------------------------
./localproxy -r us-east-1 -s HTTP1=5555,SSH1=33 -t source_client_access_token
```
------
Les données d'application issues des connexions SSH et HTTP peuvent désormais être transférées simultanément via le tunnel multiplexé. Comme le montre la carte ci-dessous, l'identifiant de service agit comme un format lisible pour traduire le mappage des ports entre le périphérique source et le périphérique de destination. Avec cette configuration, le tunneling sécurisé transmet tout trafic HTTP entrant du port du périphérique source *5555* au port *80* du périphérique de destination, et tout trafic SSH entrant d'un port *3333* à l'autre *22* sur le périphérique de destination.
![\[Un processus de traduction pour mapper les identifiants de service des proxys locaux source et de destination vers les mappages de ports traduits après le traitement.\]](http://docs.aws.amazon.com/fr_fr/iot/latest/developerguide/images/multiplexing-post-mapping-translation.png)
# Utilisation de connexions TCP simultanées dans un tunnel sécurisé
AWS IoT le tunneling sécurisé prend en charge plusieurs connexions TCP simultanément pour chaque flux de données. Vous pouvez utiliser cette fonctionnalité lorsque vous avez besoin de connexions simultanées à un appareil distant. L'utilisation de connexions TCP simultanées réduit le risque de temporisation en cas de demandes multiples du client. Par exemple, lorsque vous accédez à un serveur Web sur lequel plusieurs composants sont exécutés, les connexions TCP simultanées peuvent réduire le temps nécessaire au chargement du site.
**Note**
Les connexions TCP simultanées ont une limite de bande passante de 800 kilo-octets par seconde pour chacune. Compte AWS AWS IoT Secure Tunneling peut configurer cette limite pour vous en fonction du nombre de demandes entrantes.
## Exemple de cas d’utilisation
Supposons que vous deviez accéder à distance à un serveur Web local sur l'appareil de destination et sur lequel plusieurs composants sont exécutés. Avec une seule connexion TCP, lorsque vous essayez d'accéder au serveur Web, le chargement séquentiel peut augmenter le temps nécessaire au chargement des ressources sur le site. Les connexions TCP simultanées peuvent réduire le temps de chargement en répondant aux besoins en ressources du site, réduisant ainsi le temps d'accès. Le schéma suivant montre comment les connexions TCP simultanées sont prises en charge pour le flux de données vers l'application de serveur Web exécutée sur le périphérique distant.
**Note**
Si vous souhaitez accéder à plusieurs applications exécutées sur le périphérique distant à l'aide du tunnel, vous pouvez utiliser le multiplexage par tunnel. Pour de plus amples informations, veuillez consulter [Multiplexage de plusieurs flux de données dans un tunnel sécurisé](multiplexing-multiple-streams.md).
![\[Illustration illustrant la configuration du cloud IoT avec un appareil source, un proxy local, des serveurs proxy et un appareil de destination avec une application de serveur Web, connectés via les protocoles TCP et WSS.\]](http://docs.aws.amazon.com/fr_fr/iot/latest/developerguide/images/tcp-tunneling.png)
## Comment utiliser les connexions TCP simultanées
La procédure suivante explique comment utiliser des connexions TCP simultanées pour accéder au navigateur Web de l'appareil distant. Lorsque le client reçoit plusieurs demandes, le tunneling AWS IoT sécurisé configure automatiquement des connexions TCP simultanées pour traiter les demandes, réduisant ainsi le temps de chargement.
1.
**Ouvrir un tunnel**
Ouvrez un tunnel à l'aide de l'opération `OpenTunnel` API ou de la commande `open-tunnel` CLI. Configurez la destination `HTTP` en spécifiant le service et le nom de l' AWS IoT objet correspondant à votre appareil distant. Votre application de serveur Web est en cours d'exécution sur cet appareil distant. Vous devez déjà avoir créé l'objet IoT dans le AWS IoT registre. Pour de plus amples informations, veuillez consulter [Gérer les choses avec le registre](thing-registry.md).
```
aws iotsecuretunneling open-tunnel \
--destination-config thingName=RemoteDevice1,services=HTTP
```
L'exécution de cette commande génère les jetons d'accès à la source et à la destination que vous utiliserez pour exécuter le proxy local.
```
{
"tunnelId": "b2de92a3-b8ff-46c0-b0f2-afa28b00cecd",
"tunnelArn": "arn:aws:iot:us-west-2:431600097591:tunnel/b2de92a3-b8ff-46c0-b0f2-afa28b00cecd",
"sourceAccessToken": source_client_access_token,
"destinationAccessToken": destination_client_access_token
}
```
1.
**Configuration et démarrage du proxy local**
Avant de pouvoir exécuter le proxy local, téléchargez le code source du proxy local [GitHub](https://github.com/aws-samples/aws-iot-securetunneling-localproxy)et créez-le pour la plate-forme de votre choix. Vous pouvez ensuite démarrer le proxy local de destination et de source pour vous connecter au tunnel sécurisé et commencer à utiliser l'application de serveur Web distant.
**Note**
Pour que le tunneling AWS IoT sécurisé utilise des connexions TCP simultanées, vous devez passer à la dernière version du proxy local. Cette fonctionnalité n'est pas disponible si vous configurez le proxy local à l'aide du AWS IoT Device Client.
```
// Start the destination local proxy
./localproxy -r us-east-1 -d HTTP=80 -t destination_client_access_token
// Start the source local proxy
./localproxy -r us-east-1 -s HTTP=5555 -t source_client_access_token
```
Pour plus d'informations sur la configuration et l'utilisation du proxy local, voir [Comment utiliser le proxy local](how-use-local-proxy.md).
Vous pouvez désormais utiliser le tunnel pour accéder à l'application du serveur Web. AWS IoT le tunneling sécurisé configurera et gérera automatiquement les connexions TCP simultanées en cas de demandes multiples du client.