

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.

# Création d'un appareil virtuel avec Amazon EC2
<a name="creating-a-virtual-thing"></a>

Dans ce didacticiel, vous allez créer une instance Amazon EC2 qui servira d'appareil virtuel dans le cloud.

Pour terminer ce didacticiel, vous avez besoin d'un Compte AWS. Si vous n'en avez pas, effectuez les étapes décrites dans la section [Configurez Compte AWS](setting-up.md) avant de continuer.

**Topics**
+ [Configurer une instance Amazon EC2](#set-up-ec2)
+ [Installez Git, Node.js et configurez AWS CLI](#install-git-node)
+ [Créez AWS IoT des ressources pour votre appareil virtuel](#ec2-create-certificate)
+ [Installez le SDK du AWS IoT périphérique pour JavaScript](#ec2-sdk)
+ [Exécuter les exemples d'applications](#ec2-run-app)
+ [Afficher les messages de l'exemple d'application dans la AWS IoT console](#ec2-view-msg)

## Configurer une instance Amazon EC2
<a name="set-up-ec2"></a>

Les étapes suivantes vous montrent comment créer une instance Amazon EC2 qui fera office de périphérique virtuel à la place d'un appareil physique.

Si c'est la première fois que vous créez une instance Amazon EC2, vous trouverez peut-être les instructions de la section [Commencer avec les instances Amazon EC2 Linux](https://docs.aws.amazon.com//AWSEC2/latest/UserGuide/EC2_GetStarted.html) plus utiles.

**Pour lancer une instance**

1. Ouvrez la console Amazon EC2 à l’adresse [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. Dans le menu de la console sur la gauche, développez la section **Instances** et choisissez **Instances**. Dans le tableau de bord **Instances**, choisissez **Lancer les instances** sur la droite pour afficher une liste des configurations de base. 

1. Dans la section **Nom et balises**, entrez le nom de l'instance et ajoutez éventuellement des balises.

1. Dans la section **Images d'applications et de systèmes d'exploitation (Amazon Machine Image)**, choisissez un modèle d'AMI pour votre instance, tel que l'*AMI Amazon Linux 2 (HVM)*. Notez que cette AMI est indiquée comme « Éligible à l'offre gratuite ».

1. Dans la section **Type d'instance**, vous pouvez sélectionner la configuration matérielle de votre instance. Sélectionnez le type `t2.micro` qui est sélectionné par défaut. Notez que ce type d'instance est éligible pour l'offre gratuite.

1. Dans la section **Key pair (Paire de clés [login])**, choisissez un nom de paire de clés dans la liste déroulante ou choisissez **Create a new key pair (Créer une paire** de clés) pour en créer une. Lorsque vous créez une nouvelle paire de clés, assurez-vous de télécharger le fichier de clé privée et de l'enregistrer dans un endroit sûr, car c'est votre seule chance de le télécharger et de l'enregistrer. Vous devez fournir le nom de votre paire de clés quand vous lancez une instance, ainsi que la clé privée correspondante chaque fois que vous vous connectez à l'instance.
**Avertissement**  
Ne choisissez pas l'option **Continuer sans paire de clés**. Si vous lancez votre instance sans une paire de clés, vous ne pourrez pas vous y connecter.

1. Dans les sections **Paramètres réseau** et **Configuration du stockage**, vous pouvez conserver les paramètres par défaut. Une fois que vous êtes prêt, choisissez **Lancer les instances**.

1. Une page de confirmation indique que l'instance est en cours de lancement. Sélectionnez **View Instances** pour fermer la page de confirmation et revenir à la console.

1. Sur l'écran **Instances**, vous pouvez afficher le statut du lancement. Il suffit de peu de temps pour lancer une instance. Lorsque vous lancez une instance, son état initial est `pending`. Une fois que l’instance a démarré, son état devient `running` et elle reçoit un nom DNS public. (Si la colonne **DNS public (IPv4)** est masquée, choisissez **Afficher/Masquer les colonnes** (icône en forme d'engrenage) dans le coin supérieur droit de la page, puis sélectionnez **DNS public** ().) IPv4

1. Cela peut prendre quelques minutes avant que l'instance soit prête pour que vous puissiez vous y connecter. Vérifiez que votre instance a réussi ses contrôles de statut ; vous pouvez voir cette information dans la colonne **Status Checks**.

   Une fois que le statut de votre nouvelle instance a été vérifié, passez à la procédure suivante et connectez-vous à celle-ci.

**Pour vous connecter à votre instance**

Vous pouvez vous connecter à une instance à l'aide du client basé sur un navigateur en sélectionnant l'instance dans la console Amazon EC2 et en choisissant de vous connecter à l'aide d'Amazon EC2 Instance Connect. Instance Connect gère les autorisations et fournit une connexion réussie.

1. Ouvrez la console Amazon EC2 à l’adresse [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. Dans le menu de gauche, choisissez **Instances**.

1. Sélectionnez l’instance, puis choisissez **Connect (Connexion)**.

1. Choisissez **Amazon EC2 Instance Connect**, **Connect**.

Vous devriez maintenant avoir une fenêtre **Amazon EC2 Instance Connect** connectée à votre nouvelle instance Amazon EC2.

## Installez Git, Node.js et configurez AWS CLI
<a name="install-git-node"></a>

Dans cette section, vous allez installer Git et Node.js sur votre instance Linux.

**Pour installer Git**

1. Dans votre fenêtre **Amazon EC2 Instance Connect**, mettez à jour votre instance à l'aide de la commande suivante.

   ```
   sudo yum update -y
   ```

1. Dans votre fenêtre **Amazon EC2 Instance Connect**, installez Git à l’aide de la commande suivante.

   ```
   sudo yum install git -y
   ```

1. Pour vérifier si Git a été installé et si la version actuelle de Git est installée, exécutez la commande suivante :

   ```
   git --version
   ```

**Pour installer Node.js**

1. Dans votre fenêtre **Amazon EC2 Instance Connect**, installez le gestionnaire de versions de nœud (nvm) à l'aide de la commande suivante.

   ```
   curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.34.0/install.sh | bash
   ```

   Nous allons utiliser nvm pour installer Node.js, car il peut installer plusieurs versions de Node.js et vous permettre de passer de l'une à l'autre. 

1. Dans votre fenêtre **Amazon EC2 Instance Connect**, activez nvm à l'aide de cette commande.

   ```
   . ~/.nvm/nvm.sh
   ```

1. Dans votre fenêtre **Amazon EC2 Instance Connect**, utilisez nvm pour installer la dernière version de Node.js à l'aide de cette commande.

   ```
   nvm install 16
   ```
**Note**  
Cela installe la dernière version LTS de Node.js.

   L'installation de Node.js installe également le gestionnaire de package de nœud (npm), ce qui vous permet d'installer des modules supplémentaires si besoin.

1. Dans votre fenêtre **Amazon EC2 Instance Connect**, vérifiez que Node.js est installé et s'exécute correctement à l'aide de cette commande.

   ```
   node -e "console.log('Running Node.js ' + process.version)"
   ```

    Ce didacticiel nécessite Nœud v10.0 ou une version ultérieure. Pour plus d'informations, consultez [Tutoriel : Configuration de Node.js sur une instance Amazon EC2](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/setting-up-node-on-ec2-instance.html).

**Pour configurer AWS CLI**

Votre instance Amazon EC2 est préchargée avec le AWS CLI. Cependant, vous devez compléter votre AWS CLI profil. Pour plus d’informations sur la configuration de votre CLI, consultez [Configuration du AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html).

1. L’exemple suivant montre des exemples de valeurs. Remplacez les par vos propres valeurs. Vous pouvez trouver ces valeurs dans votre [AWS console, dans les informations de votre compte sous **Identifiants de sécurité**](https://console.aws.amazon.com//iam/home#/security_credentials).

   Dans votre fenêtre **Amazon EC2 Instance Connect**, saisissez cette commande :

   ```
   aws configure
   ```

   Entrez ensuite les valeurs de votre compte en suivant les instructions affichées.

   ```
   AWS Access Key ID [None]: AKIAIOSFODNN7EXAMPLE
   AWS Secret Access Key [None]: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
   Default region name [None]: us-west-2
   Default output format [None]: json
   ```

1. Vous pouvez tester votre AWS CLI configuration à l'aide de cette commande :

   ```
   aws iot describe-endpoint --endpoint-type iot:Data-ATS
   ```

   Si vous êtes correctement AWS CLI configuré, la commande doit renvoyer une adresse de point de terminaison provenant de votre Compte AWS.

## Créez AWS IoT des ressources pour votre appareil virtuel
<a name="ec2-create-certificate"></a>

Cette section décrit comment utiliser le AWS CLI pour créer l'objet objet et ses fichiers de certificat directement sur le périphérique virtuel. Cela se fait directement sur l'appareil afin d'éviter les complications potentielles qui pourraient découler de leur copie à partir d'un autre ordinateur. Dans cette section, vous allez créer les ressources suivantes pour votre appareil virtuel :
+ Un objet dans lequel représenter votre appareil virtuel AWS IoT.
+ Un certificat pour authentifier votre appareil virtuel.
+ Document de politique autorisant votre appareil virtuel à se connecter aux messages AWS IoT, à les publier, à les recevoir et à s'y abonner.

**Pour créer un AWS IoT objet dans votre instance Linux**

Les appareils connectés AWS IoT sont représentés par *des objets* dans le AWS IoT registre. Un *objet* représente un appareil spécifique ou une entité logique. Dans ce cas, votre *objet* représentera votre appareil virtuel, cette instance Amazon EC2.

1. Dans votre fenêtre **Amazon EC2 Instance Connect**, exécutez la commande suivante pour créer votre objet.

   ```
   aws iot create-thing --thing-name "MyIotThing"
   ```

1. La réponse JSON devrait ressembler à ceci :

   ```
   {
       "thingArn": "arn:aws:iot:your-region:your-aws-account:thing/MyIotThing", 
       "thingName": "MyIotThing",
       "thingId": "6cf922a8-d8ea-4136-f3401EXAMPLE"
   }
   ```

**Pour créer et joindre AWS IoT des clés et des certificats dans votre instance Linux**

La commande **[create-keys-and-certificate](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot/create-keys-and-certificate.html)** crée des certificats clients signés par l'autorité de certification Amazon Root. Ce certificat est utilisé pour authentifier l'identité de votre appareil virtuel.

1. Dans votre fenêtre **Amazon EC2 Instance Connect**, créez un répertoire pour stocker vos fichiers de certificat et de clé.

   ```
   mkdir ~/certs
   ```

1. Dans votre fenêtre **Amazon EC2 Instance Connect**, téléchargez une copie du certificat de l'autorité de certification Amazon (CA) à l'aide de cette commande.

   ```
   curl -o ~/certs/Amazon-root-CA-1.pem \
       https://www.amazontrust.com/repository/AmazonRootCA1.pem
   ```

1. Dans votre fenêtre **Amazon EC2 Instance Connect**, exécutez la commande suivante pour créer vos fichiers de clé privée, de clé publique et de certificat X.509. Cette commande enregistre et active également le certificat avec AWS IoT.

   ```
   aws iot create-keys-and-certificate \
       --set-as-active \
       --certificate-pem-outfile "~/certs/device.pem.crt" \
       --public-key-outfile "~/certs/public.pem.key" \
       --private-key-outfile "~/certs/private.pem.key"
   ```

   La réponse se présente comme suit. Enregistrez le `certificateArn` afin de pouvoir l'utiliser dans les commandes suivantes. Vous en aurez besoin pour joindre votre certificat à votre objet et pour associer la politique au certificat ultérieurement.

   ```
   {
       "certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/9894ba17925e663f1d29c23af4582b8e3b7619c31f3fbd93adcb51ae54b83dc2",
       "certificateId": "9894ba17925e663f1d29c23af4582b8e3b7619c31f3fbd93adcb51ae54b83dc2",
       "certificatePem": "
   -----BEGIN CERTIFICATE-----
   MIICiTCCEXAMPLE6m7oRw0uXOjANBgkqhkiG9w0BAQUFADCBiDELMAkGA1UEBhMC
   VVMxCzAJBgNVBAgEXAMPLEAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBbWF6
   b24xFDASBgNVBAsTC0lBTSEXAMPLE2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMxHzAd
   BgkqhkiG9w0BCQEWEG5vb25lQGFtYEXAMPLEb20wHhcNMTEwNDI1MjA0NTIxWhcN
   MTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBhMCEXAMPLEJBgNVBAgTAldBMRAwDgYD
   VQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDAEXAMPLEsTC0lBTSBDb25z
   b2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEXAMPLE25lQGFt
   YXpvbi5jb20wgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAMaK0dn+aEXAMPLE
   EXAMPLEfEvySWtC2XADZ4nB+BLYgVIk60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9T
   rDHudUZEXAMPLELG5M43q7Wgc/MbQITxOUSQv7c7ugFFDzQGBzZswY6786m86gpE
   Ibb3OhjZnzcvQAEXAMPLEWIMm2nrAgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4
   nUhVVxYUntneD9+h8Mg9qEXAMPLEyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0Fkb
   FFBjvSfpJIlJ00zbhNYS5f6GuoEDEXAMPLEBHjJnyp378OD8uTs7fLvjx79LjSTb
   NYiytVbZPQUQ5Yaxu2jXnimvw3rrszlaEXAMPLE=
   -----END CERTIFICATE-----\n",
       "keyPair": {
           "PublicKey": "-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkEXAMPLEQEFAAOCAQ8AMIIBCgKCAQEAEXAMPLE1nnyJwKSMHw4h\nMMEXAMPLEuuN/dMAS3fyce8DW/4+EXAMPLEyjmoF/YVF/gHr99VEEXAMPLE5VF13\n59VK7cEXAMPLE67GK+y+jikqXOgHh/xJTwo+sGpWEXAMPLEDz18xOd2ka4tCzuWEXAMPLEahJbYkCPUBSU8opVkR7qkEXAMPLE1DR6sx2HocliOOLtu6Fkw91swQWEXAMPLE\GB3ZPrNh0PzQYvjUStZeccyNCx2EXAMPLEvp9mQOUXP6plfgxwKRX2fEXAMPLEDa\nhJLXkX3rHU2xbxJSq7D+XEXAMPLEcw+LyFhI5mgFRl88eGdsAEXAMPLElnI9EesG\nFQIDAQAB\n-----END PUBLIC KEY-----\n",
           "PrivateKey": "-----BEGIN RSA PRIVATE KEY-----\nkey omitted for security reasons\n-----END RSA PRIVATE KEY-----\n"
       }
   }
   ```

1. Dans votre fenêtre **Amazon EC2 Instance Connect**, attachez votre objet au certificat que vous venez de créer à l'aide de la commande suivante et de la *certificateArn* réponse de la commande précédente.

   ```
   aws iot attach-thing-principal \
       --thing-name "MyIotThing" \
       --principal "certificateArn"
   ```

   En cas de succès, cette commande n'affiche aucune sortie.

**Pour créer et attacher une politique**

1. Dans votre fenêtre **Amazon EC2 Instance Connect**, créez le fichier de politique en copiant et en collant ce document de politique dans un fichier nommé **\$1/policy.json**.

   Si vous n'en avez pas, vous pouvez ouvrir **nano** à l'aide de cette commande.

   ```
   nano ~/policy.json
   ```

   Collez-y le document de politique pour `policy.json`. Faites ctrl-x pour quitter l'éditeur **nano** et enregistrer le fichier.

   Contenu du document de politique pour `policy.json`.  
****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "iot:Publish",
                   "iot:Subscribe",
                   "iot:Receive",
                   "iot:Connect"
               ],
               "Resource": [
                   "*"
               ]
           }
       ]
   }
   ```

1. Dans votre fenêtre **Amazon EC2 Instance Connect**, créez votre politique à l’aide de la commande suivante.

   ```
   aws iot create-policy \
       --policy-name "MyIotThingPolicy" \
       --policy-document "file://~/policy.json"
   ```

   Sortie :  
****  

   ```
   {
       "policyName": "MyIotThingPolicy",
       "policyArn": "arn:aws:iot:us-east-1:your-aws-account:policy/MyIotThingPolicy",
       "policyDocument": "{
           \"Version\": \"2012-10-17\",
           \"Statement\": [
               {
                   \"Effect\": \"Allow\",
                   \"Action\": [
                       \"iot:Publish\",
                       \"iot:Receive\",
                       \"iot:Subscribe\",
                       \"iot:Connect\"
                   ],
                   \"Resource\": [
                       \"*\"
                   ]
           }
           ]
       }",
       "policyVersionId": "1"
   }
   ```

1. Dans votre fenêtre **Amazon EC2 Instance Connect**, attachez la politique au certificat de votre appareil virtuel à l’aide de la commande suivante.

   ```
   aws iot attach-policy \
       --policy-name "MyIotThingPolicy" \
       --target "certificateArn"
   ```

   En cas de succès, cette commande n'affiche aucune sortie.

## Installez le SDK du AWS IoT périphérique pour JavaScript
<a name="ec2-sdk"></a>

Dans cette section, vous allez installer le SDK du AWS IoT périphérique JavaScript, qui contient le code avec lequel les applications peuvent communiquer, AWS IoT ainsi que des exemples de programmes. Pour plus d'informations, consultez le [SDK du AWS IoT périphérique pour le JavaScript GitHub référentiel](https://github.com/aws/aws-iot-device-sdk-js-v2).

**Pour installer le SDK du AWS IoT périphérique JavaScript sur votre instance Linux**

1. Dans votre fenêtre **Amazon EC2 Instance Connect**, clonez le SDK du AWS IoT périphérique pour le JavaScript référentiel dans le `aws-iot-device-sdk-js-v2` répertoire de votre répertoire personnel à l'aide de cette commande.

   ```
   cd ~
   git clone https://github.com/aws/aws-iot-device-sdk-js-v2.git
   ```

1. Accédez au répertoire `aws-iot-device-sdk-js-v2` que vous avez créé à l'étape précédente.

   ```
   cd aws-iot-device-sdk-js-v2
   ```

1. Utilisez npm pour installer le kit SDK.

   ```
   npm install
   ```

## Exécuter les exemples d'applications
<a name="ec2-run-app"></a>

 Les commandes des sections suivantes supposent que vos fichiers de clé et de certificat sont stockés sur votre appareil virtuel comme indiqué dans ce tableau.


**Noms des fichiers de certificat**  

|  Fichier  |  Chemin d'accès du fichier  | 
| --- | --- | 
|  Clé privée  |  `~/certs/private.pem.key`  | 
|  Certificat de l'appareil  |  `~/certs/device.pem.crt`  | 
|  Certificat racine de l'autorité de certification  |  `~/certs/Amazon-root-CA-1.pem`  | 

Dans cette section, vous allez installer et exécuter l'`pub-sub.js`exemple d'application qui se trouve dans le `aws-iot-device-sdk-js-v2/samples/node` répertoire du SDK du AWS IoT périphérique pour JavaScript. Cette application montre comment un appareil, votre instance Amazon EC2, utilise la bibliothèque MQTT pour publier des messages MQTT et s'y abonner. L'exemple d'application `pub-sub.js` s'abonne à une rubrique, `topic_1`, publie 10 messages sur cette rubrique et affiche les messages au fur et à mesure qu'ils sont reçus de l’agent de messages.

**Pour installer et exécuter l'exemple d'application**

1. Dans votre fenêtre **Amazon EC2 Instance Connect**, accédez au `aws-iot-device-sdk-js-v2/samples/node/pub_sub` répertoire créé par le SDK et installez l'exemple d'application à l'aide de ces commandes.

   ```
   cd ~/aws-iot-device-sdk-js-v2/samples/node/pub_sub
   npm install
   ```

1. Dans votre fenêtre **Amazon EC2 Instance Connect**, accédez *your-iot-endpoint* à partir de AWS IoT en utilisant cette commande.

   ```
   aws iot describe-endpoint --endpoint-type iot:Data-ATS
   ```

1. Dans votre fenêtre **Amazon EC2 Instance Connect**, insérez *your-iot-endpoint* comme indiqué et exécutez cette commande.

   ```
   node dist/index.js --topic topic_1 --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint
   ```

Exemple d'application :

1. Se connecte AWS IoT Core à votre compte.

1. S'abonne à la rubrique du message, **topic\$11**, et affiche les messages qu'il reçoit à cette rubrique.

1. Publie 10 messages dans la rubrique **topic\$11**.

1. Affiche une sortie similaire à celle-ci :

   ```
   Publish received. topic:"topic_1" dup:false qos:1 retain:false
   {"message":"Hello world!","sequence":1}
   Publish received. topic:"topic_1" dup:false qos:1 retain:false
   {"message":"Hello world!","sequence":2}
   Publish received. topic:"topic_1" dup:false qos:1 retain:false
   {"message":"Hello world!","sequence":3}
   Publish received. topic:"topic_1" dup:false qos:1 retain:false
   {"message":"Hello world!","sequence":4}
   Publish received. topic:"topic_1" dup:false qos:1 retain:false
   {"message":"Hello world!","sequence":5}
   Publish received. topic:"topic_1" dup:false qos:1 retain:false
   {"message":"Hello world!","sequence":6}
   Publish received. topic:"topic_1" dup:false qos:1 retain:false
   {"message":"Hello world!","sequence":7}
   Publish received. topic:"topic_1" dup:false qos:1 retain:false
   {"message":"Hello world!","sequence":8}
   Publish received. topic:"topic_1" dup:false qos:1 retain:false
   {"message":"Hello world!","sequence":9}
   Publish received. topic:"topic_1" dup:false qos:1 retain:false
   {"message":"Hello world!","sequence":10}
   ```

Si vous rencontrez des difficultés en exécutant l'exemple d'application, veuillez consulter [Résoudre les problèmes liés à l'exemple d'application](gs-device-troubleshoot.md).

Vous pouvez également ajouter le paramètre `--verbosity debug` sur la ligne de commande afin que l'exemple d'application affiche des messages détaillés sur ce qu'elle fait. Ces informations peuvent vous fournir l'aide dont vous avez besoin pour corriger le problème.

## Afficher les messages de l'exemple d'application dans la AWS IoT console
<a name="ec2-view-msg"></a>

Vous pouvez voir les messages de l'application d'exemple lorsqu'ils passent par l’agent de messages en utilisant le **client de test MQTT** dans la **AWS IoT console**.

**Pour afficher les messages MQTT publiés par l'exemple d'application**

1. Consultez [Afficher les messages MQTT avec le client AWS IoT MQTT](view-mqtt-messages.md). Cela vous permet d'apprendre à utiliser le **client de test MQTT** dans la **AWS IoT console** pour afficher les messages MQTT lorsqu'ils transitent par l’agent de messages.

1. Ouvrez le **client de test MQTT** dans la **AWS IoT console**.

1. Dans **S'abonner à une rubrique**, S'abonner à la rubrique, **topic\$11**.

1. Dans votre fenêtre **Amazon EC2 Instance Connect**, réexécutez l'exemple d'application et regardez les messages du **client de test MQTT** dans la **AWS IoT console**.

   ```
   cd ~/aws-iot-device-sdk-js-v2/samples/node/pub_sub
   node dist/index.js --topic topic_1 --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint
   ```

Pour plus d'informations sur le MQTT et sur la manière dont le protocole est pris AWS IoT Core en charge, consultez [MQTT](https://docs.aws.amazon.com//iot/latest/developerguide/mqtt.html).