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.
# Configurer votre appareil
Cette section décrit comment configurer votre appareil pour qu'il se connecte à AWS IoT Core. Si vous souhaitez commencer AWS IoT Core mais que vous n'avez pas encore d'appareil, vous pouvez créer un appareil virtuel à l'aide d'Amazon EC2 ou utiliser votre PC ou Mac Windows comme appareil IoT.
Sélectionnez l'option d'appareil qui vous convient le mieux AWS IoT Core. Bien sûr, vous pouvez tous les essayer, mais n'en essayez qu'un à la fois. Si vous ne savez pas quelle option d'appareil vous convient le mieux, découvrez comment choisir [la meilleure option d'appareil](iot-gs-first-thing.md#choosing-a-gs-system), puis revenez à cette page.
**Options de l'appareil**
+ [Création d'un appareil virtuel avec Amazon EC2](creating-a-virtual-thing.md)
+ [Utilisez votre PC ou Mac Windows ou Linux comme AWS IoT appareil](using-laptop-as-device.md)
+ [Connectez un Raspberry Pi ou un autre appareil](connecting-to-existing-device.md)
# Création d'un appareil virtuel avec Amazon EC2
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
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
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
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
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
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
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).
# Utilisez votre PC ou Mac Windows ou Linux comme AWS IoT appareil
Dans ce didacticiel, vous allez configurer un ordinateur personnel à utiliser avec AWS IoT. Ces instructions sont compatibles avec Windows, Linux PCs et Mac. Pour ce faire, vous devez installer des logiciels sur votre ordinateur. Si vous ne souhaitez pas installer de logiciel sur votre ordinateur, vous pouvez essayer [Création d'un appareil virtuel avec Amazon EC2](creating-a-virtual-thing.md), ce qui permet d'installer tous les logiciels sur une machine virtuelle.
**Topics**
+ [Configuration de votre ordinateur personnel](#gs-pc-prereqs)
+ [Installation de Git, Python et du SDK AWS IoT Device pour Python](#gs-pc-sdk-node)
+ [Configuration de la politique et exécution de l'exemple d'application](#gs-pc-python-app-run)
+ [Afficher les messages de l'exemple d'application dans la AWS IoT console](#gs-pc-view-msg)
+ [Exécutez l'exemple d'abonnement partagé dans Python](#gs-pc-shared-subscription-example)
## Configuration de votre ordinateur personnel
Pour suivre ce didacticiel, vous devez disposer d'un PC Windows ou Linux ou d'un Mac connecté à Internet.
Avant de passer à l'étape suivante, assurez-vous de pouvoir ouvrir une fenêtre de ligne de commande sur votre ordinateur. Utiliser **cmd.exe** sur un PC Windows. Sur un PC Linux ou un Mac, utilisez **Terminal**.
## Installation de Git, Python et du SDK AWS IoT Device pour Python
Dans cette section, vous allez installer Python et le AWS IoT Device SDK for Python sur votre ordinateur.
### Installez la dernière version de Git et Python
Cette procédure explique comment installer la dernière version de Git et Python sur votre ordinateur personnel.
**Pour télécharger et installer Git et Python sur votre ordinateur**
1. Vérifier si Git est installé sur votre ordinateur. Entrez cette commande dans la ligne de commande.
```
git --version
```
Si la commande affiche la version de Git, Git est installé et vous pouvez passer à l'étape suivante.
Si la commande affiche une erreur, ouvrez [https://git-scm.com/download](https://git-scm.com/download)et installez Git sur votre ordinateur.
1. Vérifiez si vous avez déjà installé Python. Entrez la commande dans la ligne de commande.
```
python -V
```
**Note**
Si cette commande renvoie une erreur : `Python was not found`, cela peut être dû au fait que votre système d'exploitation appelle l'exécutable Python v3.x en tant que `Python3`. Dans ce cas, remplacez toutes les instances de `python` par `python3` et poursuivez le reste de ce didacticiel.
Si la commande affiche la version de Python, c’est que Python est déjà installé. Ce didacticiel nécessite Python v3.7 ou version ultérieure.
1. Si Python est installé, vous pouvez ignorer le reste des étapes de cette section. Si ce n'est pas le cas, continuez.
1. Ouvrez [https://www.python.org/downloads/](https://www.python.org/downloads/) et téléchargez le programme d'installation pour votre ordinateur.
1. Si le téléchargement ne démarre pas automatiquement, lancez le programme téléchargé pour installer Python.
1. Vérifier l'installation de Python.
```
python -V
```
Vérifiez que la commande affiche la version de Python. Si la version de Python n'est pas affichée, réessayez de télécharger et d'installer Python.
### Installation du SDK du AWS IoT périphérique pour Python
**Pour installer le AWS IoT Device SDK pour Python sur votre ordinateur**
1. Installez la version 2 du SDK AWS IoT Device pour Python.
```
python3 -m pip install awsiotsdk
```
1. Clonez le référentiel AWS IoT Device SDK for Python dans le répertoire aws-iot-device-sdk -python-v2 de votre répertoire personnel. Cette procédure fait référence au répertoire de base des fichiers que vous installez*home*.
L'emplacement réel du *home* répertoire dépend de votre système d'exploitation.
------
#### [ Linux/macOS ]
Dans macOS et Linux, le *home* répertoire est`~`.
```
cd ~
git clone https://github.com/aws/aws-iot-device-sdk-python-v2.git
```
------
#### [ Windows ]
Sous Windows, vous pouvez trouver le chemin du *home* répertoire en exécutant cette commande dans la `cmd` fenêtre.
```
echo %USERPROFILE%
cd %USERPROFILE%
git clone https://github.com/aws/aws-iot-device-sdk-python-v2.git
```
------
**Note**
Si vous utilisez Windows PowerShell au lieu de**cmd.exe**, utilisez la commande suivante.
```
echo $home
```
Pour plus d'informations, consultez le [ GitHub référentiel AWS IoT Device SDK pour Python](https://github.com/aws/aws-iot-device-sdk-python-v2).
### Se préparer à exécuter les exemples d'applications
**Pour préparer votre système à exécuter l'exemple d'application**
+ Créez le répertoire `certs`. Dans le répertoire `certs`, copiez les fichiers de clé privée, de certificat de l’appareil et de certificat d'autorité de certification racine que vous avez enregistrés lorsque vous avez créé et enregistré l'objet dans [Créez des AWS IoT ressources](create-iot-resources.md). Les noms de chaque fichier du répertoire de destination doivent correspondre à ceux du tableau.
Les commandes figurant dans la section suivante supposent que vos fichiers de clé et de certificat sont stockés sur votre appareil, comme indiqué dans ce tableau.
------
#### [ Linux/macOS ]
Exécutez cette commande pour créer le sous-répertoire `certs` que vous utiliserez lorsque vous exécuterez les exemples d'applications.
```
mkdir ~/certs
```
Dans le nouveau sous-répertoire, copiez les fichiers vers les chemins de fichiers de destination indiqués dans le tableau suivant.
**Noms des fichiers de certificat**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/iot/latest/developerguide/using-laptop-as-device.html)
Exécutez cette commande pour répertorier les fichiers du répertoire `certs` et les comparer à ceux répertoriés dans le tableau.
```
ls -l ~/certs
```
------
#### [ Windows ]
Exécutez cette commande pour créer le sous-répertoire `certs` que vous utiliserez lorsque vous exécuterez les exemples d'applications.
```
mkdir %USERPROFILE%\certs
```
Dans le nouveau sous-répertoire, copiez les fichiers vers les chemins de fichiers de destination indiqués dans le tableau suivant.
**Noms des fichiers de certificat**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/iot/latest/developerguide/using-laptop-as-device.html)
Exécutez cette commande pour répertorier les fichiers du répertoire `certs` et les comparer à ceux répertoriés dans le tableau.
```
dir %USERPROFILE%\certs
```
------
## Configuration de la politique et exécution de l'exemple d'application
Dans cette section, vous allez configurer votre politique et exécuter l'exemple de script `pubsub.py` qui se trouve dans le `aws-iot-device-sdk-python-v2/samples` répertoire du Kit SDK des appareils AWS IoT pour Python. Ce script montre comment votre appareil utilise la bibliothèque MQTT pour publier et s'abonner aux messages MQTT.
L'exemple d'application `pubsub.py` s'abonne à une rubrique, `test/topic`, 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 exécuter l'exemple de script `pubsub.py`, vous avez besoin des informations suivantes :
**Valeurs des paramètres de l'application**
| Paramètre | Où trouver la valeur |
| --- | --- |
| your-iot-endpoint | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/iot/latest/developerguide/using-laptop-as-device.html) |
La *your-iot-endpoint* valeur a le format suivant :`endpoint_id-ats.iot.region.amazonaws.com`, par exemple,`a3qj468EXAMPLE-ats.iot.us-west-2.amazonaws.com`.
Avant d'exécuter le script, assurez-vous que la politique de votre objet autorise l'exemple de script à se connecter, à s'abonner, à publier et à recevoir.
**Pour rechercher et consulter le document de politique d'une ressource d'objet**
1. Dans la [AWS IoT console](https://console.aws.amazon.com//iot/home#/thinghub), dans la liste des **Objets**, recherchez la ressource d'objets qui représente votre appareil.
1. Cliquez sur le lien **Nom** de la ressource d'objet qui représente votre appareil pour ouvrir la page des **détails de l'objet**.
1. Sur la page **Détails de l'objet**, dans l'onglet **Certificats**, choisissez le certificat attaché à la ressource d'objet. Il ne doit y avoir qu'un seul certificat dans la liste. S'il y en a plusieurs, choisissez le certificat dont les fichiers sont installés sur votre appareil et auquel vous souhaitez vous connecter AWS IoT Core.
Sur la page **Détails du certificat**, dans l'onglet **Politiques**, choisissez la politique attachée au certificat. Il ne doit y en avoir qu'un. S'il y en a plusieurs, répétez l'étape suivante pour chacune afin de vous assurer qu'au moins une politique accorde l'accès requis.
1. Sur la page d'aperçu de la **politique**, recherchez l'éditeur JSON et choisissez **Modifier le document de politique** pour consulter et modifier le document de politique selon les besoins.
1. La politique JSON est affichée dans l'exemple suivant. Dans l'`"Resource"`élément, remplacez `region:account` par votre Région AWS et Compte AWS dans chacune des `Resource` valeurs.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Publish",
"iot:Receive"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/test/topic"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Subscribe"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topicfilter/test/topic"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:client/test-*"
]
}
]
}
```
------
#### [ Linux/macOS ]
**Pour exécuter l'exemple de script sous Linux/MacOs**
1. Dans votre fenêtre de ligne de commande, accédez au répertoire `~/aws-iot-device-sdk-python-v2/samples/node/pub_sub` créé par le SDK à l'aide de ces commandes.
```
cd ~/aws-iot-device-sdk-python-v2/samples
```
1. Dans votre fenêtre de ligne de commande, remplacez *your-iot-endpoint* comme indiqué et exécutez cette commande.
```
python3 pubsub.py --endpoint your-iot-endpoint --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key
```
------
#### [ Windows ]
**Pour exécuter l'exemple d'application sur un PC Windows**
1. Dans votre fenêtre de ligne de commande, accédez au répertoire `%USERPROFILE%\aws-iot-device-sdk-python-v2\samples` créé par le SDK et installez l’exemple d’application à l’aide de ces commandes.
```
cd %USERPROFILE%\aws-iot-device-sdk-python-v2\samples
```
1. Dans votre fenêtre de ligne de commande, remplacez *your-iot-endpoint* comme indiqué et exécutez cette commande.
```
python3 pubsub.py --endpoint your-iot-endpoint --ca_file %USERPROFILE%\certs\Amazon-root-CA-1.pem --cert %USERPROFILE%\certs\device.pem.crt --key %USERPROFILE%\certs\private.pem.key
```
------
Exemple de script :
1. Se connecte AWS IoT Core à votre compte.
1. S'abonne à la rubrique du message, **topic/test**, et affiche les messages qu'il reçoit à cette rubrique.
1. Publie 10 messages dans la rubrique **topic/test**.
1. Affiche une sortie similaire à celle-ci :
```
Connected!
Subscribing to topic 'test/topic'...
Subscribed with QoS.AT_LEAST_ONCE
Sending 10 message(s)
Publishing message to topic 'test/topic': Hello World! [1]
Received message from topic 'test/topic': b'"Hello World! [1]"'
Publishing message to topic 'test/topic': Hello World! [2]
Received message from topic 'test/topic': b'"Hello World! [2]"'
Publishing message to topic 'test/topic': Hello World! [3]
Received message from topic 'test/topic': b'"Hello World! [3]"'
Publishing message to topic 'test/topic': Hello World! [4]
Received message from topic 'test/topic': b'"Hello World! [4]"'
Publishing message to topic 'test/topic': Hello World! [5]
Received message from topic 'test/topic': b'"Hello World! [5]"'
Publishing message to topic 'test/topic': Hello World! [6]
Received message from topic 'test/topic': b'"Hello World! [6]"'
Publishing message to topic 'test/topic': Hello World! [7]
Received message from topic 'test/topic': b'"Hello World! [7]"'
Publishing message to topic 'test/topic': Hello World! [8]
Received message from topic 'test/topic': b'"Hello World! [8]"'
Publishing message to topic 'test/topic': Hello World! [9]
Received message from topic 'test/topic': b'"Hello World! [9]"'
Publishing message to topic 'test/topic': Hello World! [10]
Received message from topic 'test/topic': b'"Hello World! [10]"'
10 message(s) received.
Disconnecting...
Disconnected!
```
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 aider à corriger le problème.
## Afficher les messages de l'exemple d'application dans la AWS IoT console
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**, abonnez-vous à la rubrique, **test/topic**.
1. Dans votre fenêtre de ligne de commande, exécutez à nouveau l'exemple d'application et observez les messages du **client MQTT** dans la **AWS IoT console**.
------
#### [ Linux/macOS ]
```
cd ~/aws-iot-device-sdk-python-v2/samples
python3 pubsub.py --topic test/topic --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint
```
------
#### [ Windows ]
```
cd %USERPROFILE%\aws-iot-device-sdk-python-v2\samples
python3 pubsub.py --topic test/topic --ca_file %USERPROFILE%\certs\Amazon-root-CA-1.pem --cert %USERPROFILE%\certs\device.pem.crt --key %USERPROFILE%\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).
## Exécutez l'exemple d'abonnement partagé dans Python
AWS IoT Core prend en charge les [abonnements partagés](mqtt.md#mqtt5-shared-subscription) pour MQTT 3 et MQTT 5. Les abonnements partagés permettent à plusieurs clients de partager un abonnement à une rubrique et un seul client recevra les messages publiés sur cette rubrique selon une distribution aléatoire. Pour utiliser les abonnements partagés, les clients s'abonnent au [filtre de rubrique](https://docs.aws.amazon.com//iot/latest/developerguide/topics.html#topicfilters) d'un abonnement partagé :`$share/{ShareName}/{TopicFilter}`.
**Pour configurer la politique et exécuter l'exemple d'abonnement partagé**
1. Pour exécuter l'exemple d'abonnement partagé, vous devez configurer la politique de votre objet, comme indiqué dans [Abonnement partagé MQTT 5](https://github.com/aws/aws-iot-device-sdk-python-v2/blob/main/samples/mqtt5_shared_subscription.md#mqtt5-shared-subscription).
1. Pour exécuter l'exemple d'abonnement partagé, exécutez les commandes suivantes.
------
#### [ Linux/macOS ]
**Pour exécuter l'exemple de script sous Linux/MacOs**
1. Dans votre fenêtre de ligne de commande, accédez au répertoire `~/aws-iot-device-sdk-python-v2/samples` créé par le SDK à l'aide de ces commandes.
```
cd ~/aws-iot-device-sdk-python-v2/samples
```
1. Dans votre fenêtre de ligne de commande, remplacez *your-iot-endpoint* comme indiqué et exécutez cette commande.
```
python3 mqtt5_shared_subscription.py --endpoint your-iot-endpoint --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --group_identifier consumer
```
------
#### [ Windows ]
**Pour exécuter l'exemple d'application sur un PC Windows**
1. Dans votre fenêtre de ligne de commande, accédez au répertoire `%USERPROFILE%\aws-iot-device-sdk-python-v2\samples` créé par le SDK et installez l’exemple d’application à l’aide de ces commandes.
```
cd %USERPROFILE%\aws-iot-device-sdk-python-v2\samples
```
1. Dans votre fenêtre de ligne de commande, remplacez *your-iot-endpoint* comme indiqué et exécutez cette commande.
```
python3 mqtt5_shared_subscription.py --endpoint your-iot-endpoint --ca_file %USERPROFILE%\certs\Amazon-root-CA-1.pem --cert %USERPROFILE%\certs\device.pem.crt --key %USERPROFILE%\certs\private.pem.key --group_identifier consumer
```
------
**Note**
Vous pouvez éventuellement spécifier un identifiant de groupe en fonction de vos besoins lorsque vous exécutez l'échantillon (par exemple,`--group_identifier consumer`). Si vous n’en spécifiez pas, `python-sample` est l’identifiant de groupe par défaut.
1. Le résultat de votre ligne de commande peut ressembler à ce qui suit :
```
Publisher]: Lifecycle Connection Success
[Publisher]: Connected
Subscriber One]: Lifecycle Connection Success
[Subscriber One]: Connected
Subscriber Two]: Lifecycle Connection Success
[Subscriber Two]: Connected
[Subscriber One]: Subscribed to topic 'test/topic' in shared subscription group 'consumer'.
[Subscriber One]: Full subscribed topic is: '$share/consumer/test/topic' with SubAck code: []
[Subscriber Two]: Subscribed to topic 'test/topic' in shared subscription group 'consumer'.
[Subscriber Two]: Full subscribed topic is: '$share/consumer/test/topic' with SubAck code: []
[Publisher]: Sent publish and got PubAck code:
[Subscriber Two] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [1]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber One] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [2]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber Two] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [3]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber One] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [4]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber Two] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [5]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber One] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [6]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber Two] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [7]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber One] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [8]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber Two] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [9]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber One] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [10]"'
[Subscriber One]: Unsubscribed to topic 'test/topic' in shared subscription group 'consumer'.
[Subscriber One]: Full unsubscribed topic is: '$share/consumer/test/topic' with UnsubAck code: []
[Subscriber Two]: Unsubscribed to topic 'test/topic' in shared subscription group 'consumer'.
[Subscriber Two]: Full unsubscribed topic is: '$share/consumer/test/topic' with UnsubAck code []
Publisher]: Lifecycle Disconnected
[Publisher]: Lifecycle Stopped
[Publisher]: Fully stopped
Subscriber One]: Lifecycle Disconnected
[Subscriber One]: Lifecycle Stopped
[Subscriber One]: Fully stopped
Subscriber Two]: Lifecycle Disconnected
[Subscriber Two]: Lifecycle Stopped
[Subscriber Two]: Fully stopped
Complete!
```
1. Ouvrez **client de test MQTT** dans la **AWS IoT console**. Dans **S'abonner à un sujet**, abonnez-vous au sujet de l'abonnement partagé tel que :`$share/consumer/test/topic`. Vous pouvez spécifier un identifiant de groupe en fonction de vos besoins lorsque vous exécutez l'échantillon (par exemple,`--group_identifier consumer`). Si vous ne spécifiez pas d'identifiant de groupe, la valeur par défaut est `python-sample`. Pour plus d'informations, consultez [l'exemple Python d'abonnement partagé MQTT 5](https://github.com/aws/aws-iot-device-sdk-python-v2/blob/main/samples/mqtt5_shared_subscription.md#mqtt5-shared-subscription) et le *guide AWS IoT Core du développeur* sur [les abonnements partagés](mqtt.md#mqtt5-shared-subscription).
Dans votre fenêtre de ligne de commande, exécutez à nouveau l'exemple d'application et observez la distribution des messages dans votre **Client de test MQTT** de la **AWS IoT console** et de la ligne de commande.
![\[La page de sortie des abonnements partagés.\]](http://docs.aws.amazon.com/fr_fr/iot/latest/developerguide/images/shared-subscription-output.png)
# Connectez un Raspberry Pi ou un autre appareil
Dans cette section, nous allons configurer un Raspberry Pi à utiliser avec AWS IoT. Si vous souhaitez connecter un autre appareil, les instructions du Raspberry Pi incluent des références qui peuvent vous aider à adapter ces instructions à votre appareil.
Cela prend normalement environ 20 minutes, mais cela peut prendre plus de temps si vous devez installer de nombreuses mises à niveau du logiciel système.
**Topics**
+ [Configurez votre appareil](#gs-device-prereqs)
+ [Installez les outils et bibliothèques requis pour le SDK du AWS IoT périphérique](#gs-device-sdk-tools)
+ [Installer le SDK AWS IoT du périphérique](#gs-device-install-sdk)
+ [Installez et exécutez l'exemple d'application](#gs-device-node-app-run)
+ [Afficher les messages de l'exemple d'application dans la AWS IoT console](#gs-device-view-msg)
**Important**
L'adaptation de ces instructions à d'autres appareils et systèmes d'exploitation peut s'avérer difficile. Vous devez avoir une connaissance suffisante de votre appareil pour être en mesure d'interpréter ces instructions et de les appliquer.
Si vous rencontrez des difficultés lors de la configuration de votre appareil pour AWS IoT, vous pouvez essayer l'une des autres options de l'appareil comme alternative, telle que [Création d'un appareil virtuel avec Amazon EC2](creating-a-virtual-thing.md) ou[Utilisez votre PC ou Mac Windows ou Linux comme AWS IoT appareil](using-laptop-as-device.md).
## Configurez votre appareil
L'objectif de cette étape est de collecter les informations dont vous aurez besoin pour configurer votre appareil afin qu'il puisse démarrer le système d'exploitation (OS), se connecter à Internet et vous permettre d'interagir avec celui-ci via une interface de ligne de commande.
Pour suivre ce didacticiel, vous aurez besoin des éléments suivants :
+ Un Compte AWS. Si vous n'en avez pas, effectuez les étapes décrites dans [Configurez Compte AWS](setting-up.md) avant de continuer.
+ Un [Raspberry Pi 3 modèle B](https://www.raspberrypi.com/products/) ou un modèle plus récent. Cela peut fonctionner sur les versions antérieures du Raspberry Pi, mais elles n'ont pas été testées.
+ [Système d'exploitation Raspberry Pi (32 bits)](https://www.raspberrypi.com/software/operating-systems/) ou version ultérieure. Nous vous recommandons d'utiliser la dernière version du système d'exploitation Raspberry Pi. Les versions antérieures du système d'exploitation peuvent fonctionner, mais elles n'ont pas été testées.
Pour exécuter cet exemple, vous n'avez pas besoin d'installer le bureau avec l'interface utilisateur graphique (GUI) ; cependant, si vous êtes nouveau sur le Raspberry Pi et que votre matériel Raspberry Pi le prend en charge, l’utilisation du bureau avec l'interface graphique peut être plus facile.
+ Une WiFi connexion ou une connexion Ethernet.
+ Clavier, souris, écran, câbles, blocs d'alimentation et autres équipements nécessaires à votre appareil.
**Important**
Avant de passer à l'étape suivante, le système d'exploitation de votre appareil doit être installé, configuré et en cours d'exécution. L'appareil doit être connecté à Internet et vous devez pouvoir y accéder à l'aide de son interface en ligne de commande. L'accès à la ligne de commande peut se faire via un clavier, une souris et un moniteur directement connectés, ou en utilisant une interface distante de terminal SSH.
Si vous exécutez un système d'exploitation sur votre Raspberry Pi doté d'une interface utilisateur graphique (GUI), ouvrez une fenêtre de terminal sur l'appareil et suivez les instructions suivantes dans cette fenêtre. Sinon, si vous vous connectez à votre appareil à l'aide d'un terminal distant, tel que PuTTY, ouvrez un terminal distant sur votre appareil et utilisez-le.
## Installez les outils et bibliothèques requis pour le SDK du AWS IoT périphérique
Avant d'installer le SDK du AWS IoT périphérique et un exemple de code, assurez-vous que votre système est à jour et qu'il dispose des outils et bibliothèques nécessaires pour installer le SDKs.
1.
**Mise à jour du système d'exploitation et installation des bibliothèques requises**
Avant d'installer un SDK de AWS IoT périphérique, exécutez ces commandes dans une fenêtre de terminal de votre appareil pour mettre à jour le système d'exploitation et installer les bibliothèques requises.
```
sudo apt-get update
```
```
sudo apt-get upgrade
```
```
sudo apt-get install cmake
```
```
sudo apt-get install libssl-dev
```
1.
**Installez Git**
Si Git n'est pas installé sur le système d'exploitation de votre appareil, vous devez l'installer pour installer le SDK du AWS IoT périphérique pour JavaScript.
1. Vérifiez si Git est déjà installé en exécutant cette commande.
```
git --version
```
1. Si la commande précédente renvoie la version de Git, cela signifie que Git est déjà installé et vous pouvez passer à l'étape 3.
1. Si une erreur s'affiche lorsque vous exécutez la commande **git**, installez Git en exécutant cette commande.
```
sudo apt-get install git
```
1. Testez à nouveau pour voir si Git est installé en exécutant cette commande.
```
git --version
```
1. Si Git est installé, passez à la section suivante. Si ce n'est pas le cas, dépannez et corrigez l'erreur avant de continuer. Vous avez besoin de Git pour installer le AWS IoT Device SDK pour JavaScript.
## Installer le SDK AWS IoT du périphérique
Installez le SDK du AWS IoT périphérique.
------
#### [ Python ]
Dans cette section, vous allez installer Python, ses outils de développement et le AWS IoT Device SDK pour Python sur votre appareil. Ces instructions concernent un Raspberry Pi exécutant le dernier système d’exploitation Raspberry Pi. Si vous avez un autre appareil ou utilisez un autre système d'exploitation, vous devrez peut-être adapter ces instructions à votre appareil.
1.
**Installer Python et ses outils de développement**
Le AWS IoT Device SDK pour Python nécessite l'installation de Python v3.5 ou version ultérieure sur votre Raspberry Pi.
Dans une fenêtre de terminal sur votre appareil, exécutez ces commandes.
1. Exécutez cette commande pour déterminer la version de Python installée sur votre appareil.
```
python3 --version
```
Si Python est installé, il affichera sa version.
1. Si la version affichée est `Python 3.5` ou supérieure, vous pouvez passer à l'étape 2.
1. Si la version affichée est inférieure à `Python 3.5`, vous pouvez installer la bonne version en exécutant cette commande.
```
sudo apt install python3
```
1. Exécutez cette commande pour vérifier que la bonne version de Python est désormais installée.
```
python3 --version
```
1.
**Test pour pip3**
Dans une fenêtre de terminal sur votre appareil, exécutez ces commandes.
1. Exécutez cette commande pour voir si **pip3** est installée.
```
pip3 --version
```
1. Si la commande renvoie un numéro de version, **pip3** est installée et vous pouvez passer à l'étape 3.
1. Si la commande précédente renvoie une erreur, exécutez cette commande pour effectuer l'installation de **pip3**.
```
sudo apt install python3-pip
```
1. Exécutez cette commande pour voir si **pip3** est installée.
```
pip3 --version
```
1.
**Installez le SDK AWS IoT Device actuel pour Python**
Installez le SDK AWS IoT Device pour Python et téléchargez les exemples d'applications sur votre appareil.
Sur votre appareil, exécutez ces commandes.
```
cd ~
python3 -m pip install awsiotsdk
```
```
git clone https://github.com/aws/aws-iot-device-sdk-python-v2.git
```
------
#### [ JavaScript ]
Dans cette section, vous allez installer Node.js, le gestionnaire de packages npm et le AWS IoT Device SDK for JavaScript sur votre appareil. Ces instructions concernent un Raspberry Pi exécutant le système d’exploitation Raspberry Pi. Si vous avez un autre appareil ou utilisez un autre système d'exploitation, vous devrez peut-être adapter ces instructions à votre appareil.
1.
**Installer la dernière version de Node.js**
Le SDK du AWS IoT périphérique pour JavaScript nécessite l'installation de Node.js et du gestionnaire de packages npm sur votre Raspberry Pi.
1. Téléchargez la dernière version du référentiel Nœud en entrant cette commande.
```
cd ~
curl -sL https://deb.nodesource.com/setup_12.x | sudo -E bash -
```
1. Installez Nœud et npm.
```
sudo apt-get install -y nodejs
```
1. Vérifier l'installation de Nœud.
```
node -v
```
Confirmez que la commande affiche la version du Nœud. Ce didacticiel nécessite Nœud v10.0 ou une version ultérieure. Si la version de Nœud n'est pas affichée, essayez de télécharger à nouveau le référentiel Nœud.
1. Vérifiez l'installation de npm.
```
npm -v
```
Confirmez que la commande affiche la version du Nœud npm. Si la version npm n'est pas affichée, réessayez d'installer Nœud et npm.
1. Redémarrez le périphérique.
```
sudo shutdown -r 0
```
Continuez après le redémarrage de l'appareil.
1.
**Installez le SDK du AWS IoT périphérique pour JavaScript**
Installez le SDK du AWS IoT périphérique pour JavaScript votre Raspberry Pi.
1. 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 *home* répertoire. Sur le Raspberry Pi`~/`, le *home* répertoire est, qui est utilisé comme *home* répertoire dans les commandes suivantes. Si votre appareil utilise un chemin différent pour le *home* répertoire, vous devez le `~/` remplacer par le chemin correct pour votre appareil dans les commandes suivantes.
Ces commandes créent le répertoire `~/aws-iot-device-sdk-js-v2` et y copient le code du SDK.
```
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 et lancez-le `npm install` pour installer le SDK. La commande `npm install` invoque la compilation de la bibliothèque `aws-crt`, qui peut prendre quelques minutes.
```
cd ~/aws-iot-device-sdk-js-v2
npm install
```
------
## Installez et exécutez l'exemple d'application
Dans cette section, vous allez installer et exécuter l'`pubsub`exemple d'application qui se trouve dans le SDK de l' AWS IoT appareil. Cette application montre comment votre appareil utilise la bibliothèque MQTT pour publier et s'abonner aux messages MQTT. L'exemple d'application 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.
**Installez les fichiers de certificat**
L'exemple d'application nécessite que les fichiers de certificat authentifiant l'appareil soient installés sur celui-ci.
**Pour installer les fichiers de certificat de l'appareil pour l'exemple d'application**
1. Créez un `certs` sous-répertoire dans votre *home* répertoire en exécutant ces commandes.
```
cd ~
mkdir certs
```
1. Dans le répertoire `~/certs`, copiez la clé privée, le certificat de périphérique et le certificat d'autorité de certification racine que vous avez créés précédemment dans [Créez des AWS IoT ressources](create-iot-resources.md).
La façon dont vous copiez les fichiers de certificat sur votre appareil dépend de l'appareil et du système d'exploitation et n'est pas décrite ici. Toutefois, si votre appareil prend en charge une interface utilisateur graphique (GUI) et dispose d'un navigateur Web, vous pouvez suivre la procédure décrite dans le navigateur Web de votre appareil [Créez des AWS IoT ressources](create-iot-resources.md) pour télécharger les fichiers obtenus directement sur votre appareil.
Les commandes figurant dans la section suivante supposent que vos fichiers de clé et de certificat sont stockés sur l'appareil, comme indiqué dans ce tableau.
**Noms des fichiers de certificat**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/iot/latest/developerguide/connecting-to-existing-device.html)
Pour exécuter cet exemple d'application, vous avez besoin des informations suivantes :
**Valeurs des paramètres de l'application**
| Paramètre | Où trouver la valeur |
| --- | --- |
| your-iot-endpoint | Dans la [AWS IoT console](https://console.aws.amazon.com/iot/home), choisissez **Tous les appareils**, puis **Objets**. Sur la page **Paramètres** du AWS IoT menu. Votre point de terminaison est affiché dans la **section Point de terminaison des données** de l'appareil. |
La *your-iot-endpoint* valeur a le format suivant :`endpoint_id-ats.iot.region.amazonaws.com`, par exemple,`a3qj468EXAMPLE-ats.iot.us-west-2.amazonaws.com`.
------
#### [ Python ]
**Pour installer et exécuter l'exemple d'application**
1. Accédez au répertoire de l’exemple d’application.
```
cd ~/aws-iot-device-sdk-python-v2/samples
```
1. Dans la fenêtre de ligne de commande, remplacez *your-iot-endpoint* comme indiqué et exécutez cette commande.
```
python3 pubsub.py --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
```
1. Notez que l'exemple d'application :
1. Se connecte au AWS IoT service associé à 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 :
```
Connecting to a3qEXAMPLEffp-ats.iot.us-west-2.amazonaws.com with client ID 'test-0c8ae2ff-cc87-49d2-a82a-ae7ba1d0ca5a'...
Connected!
Subscribing to topic 'topic_1'...
Subscribed with QoS.AT_LEAST_ONCE
Sending 10 message(s)
Publishing message to topic 'topic_1': Hello World! [1]
Received message from topic 'topic_1': b'Hello World! [1]'
Publishing message to topic 'topic_1': Hello World! [2]
Received message from topic 'topic_1': b'Hello World! [2]'
Publishing message to topic 'topic_1': Hello World! [3]
Received message from topic 'topic_1': b'Hello World! [3]'
Publishing message to topic 'topic_1': Hello World! [4]
Received message from topic 'topic_1': b'Hello World! [4]'
Publishing message to topic 'topic_1': Hello World! [5]
Received message from topic 'topic_1': b'Hello World! [5]'
Publishing message to topic 'topic_1': Hello World! [6]
Received message from topic 'topic_1': b'Hello World! [6]'
Publishing message to topic 'topic_1': Hello World! [7]
Received message from topic 'topic_1': b'Hello World! [7]'
Publishing message to topic 'topic_1': Hello World! [8]
Received message from topic 'topic_1': b'Hello World! [8]'
Publishing message to topic 'topic_1': Hello World! [9]
Received message from topic 'topic_1': b'Hello World! [9]'
Publishing message to topic 'topic_1': Hello World! [10]
Received message from topic 'topic_1': b'Hello World! [10]'
10 message(s) received.
Disconnecting...
Disconnected!
```
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.
------
#### [ JavaScript ]
**Pour installer et exécuter l'exemple d'application**
1. Dans votre fenêtre de ligne de commande, accédez au répertoire `~/aws-iot-device-sdk-js-v2/samples/node/pub_sub` créé par le SDK et installez l’exemple d’application à l’aide de ces commandes. La commande `npm install` invoque la compilation de la bibliothèque `aws-crt`, qui peut prendre quelques minutes.
```
cd ~/aws-iot-device-sdk-js-v2/samples/node/pub_sub
npm install
```
1. Dans la fenêtre de ligne de commande, remplacez *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
```
1. Notez que l'exemple d'application :
1. Se connecte au AWS IoT service associé à 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 on topic topic_1
{"message":"Hello world!","sequence":1}
Publish received on topic topic_1
{"message":"Hello world!","sequence":2}
Publish received on topic topic_1
{"message":"Hello world!","sequence":3}
Publish received on topic topic_1
{"message":"Hello world!","sequence":4}
Publish received on topic topic_1
{"message":"Hello world!","sequence":5}
Publish received on topic topic_1
{"message":"Hello world!","sequence":6}
Publish received on topic topic_1
{"message":"Hello world!","sequence":7}
Publish received on topic topic_1
{"message":"Hello world!","sequence":8}
Publish received on topic topic_1
{"message":"Hello world!","sequence":9}
Publish received on topic topic_1
{"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
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. S'abonner à la rubrique, **topic\$11**.
1. Dans votre fenêtre de ligne de commande, exécutez à nouveau l'exemple d'application et observez les messages du **client MQTT** dans la **AWS IoT console**.
------
#### [ Python ]
```
cd ~/aws-iot-device-sdk-python-v2/samples
python3 pubsub.py --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
```
------
#### [ JavaScript ]
```
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
```
------
# Résoudre les problèmes liés à l'exemple d'application
Si vous rencontrez une erreur lorsque vous essayez d'exécuter l'exemple d'application, voici quelques points à vérifier.
## Vérifiez le certificat
Si le certificat n'est pas actif, AWS IoT il n'acceptera aucune tentative de connexion l'utilisant à des fins d'autorisation. Lorsque vous créez votre certificat, il est facile d'oublier le bouton **Activer**. Heureusement, vous pouvez activer votre certificat depuis la [AWS IoT console](https://console.aws.amazon.com/iot/home).
**Pour vérifier l'activation de votre certificat**
1. Dans la [AWS IoT console](https://console.aws.amazon.com/iot/home), dans le menu de gauche, choisissez **Sécurisé**, puis **Certificats**.
1. Dans la liste des certificats, recherchez le certificat que vous avez créé pour l'exercice et vérifiez son statut dans la colonne **État**.
Si vous ne vous souvenez pas du nom du certificat, vérifiez s'il est **inactif** pour voir s'il s'agit bien de celui que vous utilisez.
Choisissez le certificat dans la liste pour ouvrir sa page de détail. Sur la page détaillée, vous pouvez voir sa **date de création** pour vous aider à identifier le certificat.
1. **Pour activer un certificat inactif**, sur la page détaillée du certificat, sélectionnez **Actions**, puis sélectionnez **Activer**.
Si vous avez trouvé le bon certificat et qu'il est actif, mais que vous rencontrez toujours des problèmes lors de l'exécution de l'exemple d'application, vérifiez sa politique comme décrit à l'étape suivante.
Vous pouvez également essayer de créer un nouvel objet et un nouveau certificat en suivant les étapes décrites dans [Créez un objet](create-iot-resources.md#create-aws-thing). Si vous créez un nouvel objet, vous devrez lui attribuer un nouveau nom et télécharger les nouveaux fichiers de certificat sur votre appareil.
## Vérifiez la politique attachée au certificat
Les politiques autorisent les actions dans AWS IoT. Si le certificat utilisé pour se connecter à AWS IoT n'a pas de politique ou n'a pas de politique lui permettant de se connecter, la connexion sera refusée, même si le certificat est actif.
**Pour vérifier les politiques attachées à un certificat**
1. Recherchez le certificat comme décrit dans l'article précédent et ouvrez sa page de détails.
1. Dans le menu de gauche de la page de détails du certificat, choisissez **Politiques** pour voir les politiques attachées au certificat.
1. Si aucune politique n'est attachée au certificat, ajoutez-en une en choisissant le menu **Actions**, puis en choisissant **Attacher une politique**.
Choisissez la politique que vous avez créée précédemment dans [Créez des AWS IoT ressources](create-iot-resources.md).
1. Si une politique est jointe, sélectionnez la vignette de politique pour ouvrir sa page de détails.
Sur la page de détails, consultez le **document de politique** pour vous assurer qu'il contient les mêmes informations que celles que vous avez créées dans [Création d'une AWS IoT politique](create-iot-resources.md#create-iot-policy).
## Vérifiez la ligne de commande
Assurez-vous d'avoir utilisé la bonne ligne de commande pour votre système. Les commandes utilisées sur les systèmes Linux et MacOs sont souvent différentes de celles utilisées sur les systèmes Windows.
## Vérifiez l'adresse du point de terminaison
Passez en revue la commande que vous avez saisie et vérifiez que l'adresse du point de terminaison indiquée dans votre commande correspond à celle de votre [AWS IoT console](https://console.aws.amazon.com/iot/home).
## Vérifiez les noms des fichiers de certificat
Comparez les noms de fichiers figurant dans la commande que vous avez saisie aux noms de fichiers des certificats du répertoire `certs`.
Certains systèmes peuvent nécessiter que les noms de fichiers soient entre guillemets pour fonctionner correctement.
## Vérifiez l'installation du SDK
Assurez-vous que l'installation du SDK est complète et correcte.
En cas de doute, réinstallez le SDK sur votre appareil. Dans la plupart des cas, il suffit de trouver la section du didacticiel intitulée **Installer le SDK du AWS IoT périphérique pour **SDK language**** et de suivre à nouveau la procédure.
Si vous utilisez le **SDK du AWS IoT périphérique pour JavaScript**, n'oubliez pas d'installer les exemples d'applications avant d'essayer de les exécuter. L'installation du SDK n'installe pas automatiquement les exemples d'applications. Les exemples d'applications doivent être installés manuellement après l'installation du SDK.