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.
# Tutoriel : Démonstration de la communication des messages MQTT avec le client du AWS IoT périphérique
Ce didacticiel explique comment le AWS IoT Device Client peut s'abonner à des messages MQTT et les publier, qui sont couramment utilisés dans les solutions IoT.
**Pour démarrer ce didacticiel :**
+ Faites configurer votre ordinateur hôte local et votre Raspberry Pi comme utilisés dans [la section précédente](iot-dc-install-dc.md).
Si vous avez enregistré l'image de la carte microSD après avoir installé le client du AWS IoT périphérique, vous pouvez utiliser une carte microSD avec cette image avec votre Raspberry Pi.
+ Si vous avez déjà lancé cette démo, vérifiez si vous [Étape 2 : Nettoyage de vos démos Compte AWS après la création avec le AWS IoT Device Client](iot-dc-cleanup.md#iot-dc-cleanup-cloud) souhaitez supprimer toutes les AWS IoT ressources que vous avez créées lors des exécutions précédentes afin d'éviter les erreurs liées aux ressources dupliquées.
Ce didacticiel vous prendra environ 45 minutes.
**Lorsque vous avez terminé avec cette rubrique :**
+ Vous aurez démontré les différentes manières dont votre appareil IoT peut s'abonner à des messages MQTT AWS IoT et publier des messages MQTT vers. AWS IoT
**Matériel requis :**
+ Votre environnement de développement et de test local décrit [dans la section précédente](iot-dc-install-dc.md)
+ Le Raspberry Pi que vous avez utilisé dans [la section précédente](iot-dc-install-dc.md)
+ La carte mémoire microSD du Raspberry Pi que vous avez utilisée dans [la section précédente](iot-dc-install-dc.md)
**Topics**
+ [Préparez le Raspberry Pi pour démontrer la communication de messages MQTT](iot-dc-testconn-provision.md)
+ [Démonstration de la publication de messages avec le AWS IoT Device Client](iot-dc-testconn-publish.md)
+ [Démontrer l'abonnement aux messages avec le AWS IoT Device Client](iot-dc-testconn-subscribe.md)
# Préparez le Raspberry Pi pour démontrer la communication de messages MQTT
Cette procédure crée les ressources dans AWS IoT et dans le Raspberry Pi pour démontrer la communication de messages MQTT à l'aide du AWS IoT Device Client.
**Topics**
+ [Créez les fichiers de certificat pour démontrer la communication MQTT](#iot-dc-testconn-provision-certs)
+ [Provisionnez votre appareil pour démontrer la communication MQTT](#iot-dc-testconn-provision-aws)
+ [Configurer le fichier de configuration du client du AWS IoT périphérique et le client de test MQTT pour démontrer la communication MQTT](#iot-dc-testconn-provision-dc-config)
## Créez les fichiers de certificat pour démontrer la communication MQTT
Cette procédure crée les fichiers de certificat de l'appareil pour cette démonstration.
**Pour créer et télécharger les fichiers de certificat d'appareil pour votre Raspberry Pi**
1. Dans la fenêtre du terminal de votre ordinateur hôte local, entrez ces commandes pour créer les fichiers de certificat de périphérique pour votre appareil.
```
mkdir ~/certs/pubsub
aws iot create-keys-and-certificate \
--set-as-active \
--certificate-pem-outfile "~/certs/pubsub/device.pem.crt" \
--public-key-outfile "~/certs/pubsub/public.pem.key" \
--private-key-outfile "~/certs/pubsub/private.pem.key"
```
La commande renvoie une réponse comme celle-ci. Enregistrez la valeur `certificateArn` pour une utilisation ultérieure.
```
{
"certificateArn": "arn:aws:iot:us-west-2:57EXAMPLE833:cert/76e7e4edb3e52f52334be2f387a06145b2aa4c7fcd810f3aea2d92abc227d269",
"certificateId": "76e7e4edb3e52f5233EXAMPLE7a06145b2aa4c7fcd810f3aea2d92abc227d269",
"certificatePem": "-----BEGIN CERTIFICATE-----\nMIIDWTCCAkGgAwIBAgI_SHORTENED_FOR_EXAMPLE_Lgn4jfgtS\n-----END CERTIFICATE-----\n",
"keyPair": {
"PublicKey": "-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BA_SHORTENED_FOR_EXAMPLE_ImwIDAQAB\n-----END PUBLIC KEY-----\n",
"PrivateKey": "-----BEGIN RSA PRIVATE KEY-----\nMIIEowIBAAKCAQE_SHORTENED_FOR_EXAMPLE_T9RoDiukY\n-----END RSA PRIVATE KEY-----\n"
}
}
```
1. Entrez les commandes suivantes pour définir les autorisations sur le répertoire des certificats et ses fichiers.
```
chmod 700 ~/certs/pubsub
chmod 644 ~/certs/pubsub/*
chmod 600 ~/certs/pubsub/private.pem.key
```
1. Exécutez cette commande pour vérifier les autorisations sur vos répertoires et fichiers de certificats.
```
ls -l ~/certs/pubsub
```
Le résultat de la commande doit être identique à ce que vous voyez ici, sauf que les dates et heures du fichier seront différentes.
```
-rw-r--r-- 1 pi pi 1220 Oct 28 13:02 device.pem.crt
-rw------- 1 pi pi 1675 Oct 28 13:02 private.pem.key
-rw-r--r-- 1 pi pi 451 Oct 28 13:02 public.pem.key
```
1. Entrez ces commandes pour créer les répertoires des fichiers journaux.
```
mkdir ~/.aws-iot-device-client
mkdir ~/.aws-iot-device-client/log
chmod 745 ~/.aws-iot-device-client/log
echo " " > ~/.aws-iot-device-client/log/aws-iot-device-client.log
echo " " > ~/.aws-iot-device-client/log/pubsub_rx_msgs.log
chmod 600 ~/.aws-iot-device-client/log/*
```
## Provisionnez votre appareil pour démontrer la communication MQTT
Cette section crée les AWS IoT ressources qui approvisionnent votre Raspberry Pi AWS IoT.
**Pour approvisionner votre appareil en AWS IoT :**
1. Dans la fenêtre du terminal de votre ordinateur hôte local, entrez la commande suivante pour obtenir l'adresse du point de terminaison des données de l'appareil pour votre Compte AWS.
```
aws iot describe-endpoint --endpoint-type IoT:Data-ATS
```
La valeur du point de terminaison n’a pas changé depuis l’exécution de cette commande pour le didacticiel précédent. La réexécution de la commande ici est effectuée pour faciliter la recherche et le collage de la valeur du point de terminaison des données dans le fichier de configuration utilisé dans ce didacticiel.
La commande des étapes précédentes renvoie une réponse comme celle-ci. Enregistrez la valeur `endpointAddress` pour une utilisation ultérieure.
```
{
"endpointAddress": "a3qjEXAMPLEffp-ats.iot.us-west-2.amazonaws.com"
}
```
1. Entrez cette commande pour créer une nouvelle ressource d' AWS IoT objets pour votre Raspberry Pi.
```
aws iot create-thing --thing-name "PubSubTestThing"
```
Comme une AWS IoT ressource d'objets est une représentation *virtuelle* de votre appareil dans le cloud, nous pouvons créer plusieurs ressources d'objets AWS IoT à utiliser à différentes fins. Ils peuvent tous être utilisés par le même appareil IoT physique pour représenter différents aspects de l’appareil.
Ces didacticiels n'utiliseront qu'une seule ressource à la fois pour représenter le Raspberry Pi. Ainsi, dans ces didacticiels, ils représentent les différentes démos. Ainsi, après avoir créé les AWS IoT ressources pour une démonstration, vous pouvez revenir en arrière et répéter la démonstration en utilisant les ressources que vous avez créées spécifiquement pour chacune d'elles.
Si votre ressource d' AWS IoT objet a été créée, la commande renvoie une réponse comme celle-ci.
```
{
"thingName": "PubSubTestThing",
"thingArn": "arn:aws:iot:us-west-2:57EXAMPLE833:thing/PubSubTestThing",
"thingId": "8ea78707-32c3-4f8a-9232-14bEXAMPLEfd"
}
```
1. Dans la fenêtre du terminal :
1. Ouvrez un éditeur de texte comme `nano`.
1. Copiez ce document JSON et collez-le dans votre éditeur de texte ouvert.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
"arn:aws:iot:us-west-2:123456789012:client/PubSubTestThing"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Publish"
],
"Resource": [
"arn:aws:iot:us-west-2:123456789012:topic/test/dc/pubtopic"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Subscribe"
],
"Resource": [
"arn:aws:iot:us-west-2:123456789012:topicfilter/test/dc/subtopic"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Receive"
],
"Resource": [
"arn:aws:iot:us-west-2:123456789012:topic/test/dc/subtopic"
]
}
]
}
```
1. Dans l'éditeur, dans chaque `Resource` section du document de politique, remplacez *us-west-2:57EXAMPLE833* par votre Région AWS caractère deux-points (:)) et votre Compte AWS numéro à 12 chiffres.
1. Enregistrez le fichier dans votre éditeur de texte sous le nom **\$1/policies/pubsub\$1test\$1thing\$1policy.json**.
1. Exécutez cette commande pour utiliser le document de stratégie décrit dans les étapes précédentes afin de créer une AWS IoT stratégie.
```
aws iot create-policy \
--policy-name "PubSubTestThingPolicy" \
--policy-document "file://~/policies/pubsub_test_thing_policy.json"
```
Si la politique est créée, la commande renvoie une réponse comme celle-ci.
```
{
"policyName": "PubSubTestThingPolicy",
"policyArn": "arn:aws:iot:us-west-2:57EXAMPLE833:policy/PubSubTestThingPolicy",
"policyDocument": "{\n\"Version\": \"2012-10-17\", \n\"Statement\": [\n{\n\"Effect\": \"Allow\",\n\"Action\": [\n\"iot:Connect\"\n],\n\"Resource\": [\n\"arn:aws:iot:us-west-2:57EXAMPLE833:client/PubSubTestThing\"\n]\n},\n{\n\"Effect\": \"Allow\",\n\"Action\": [\n\"iot:Publish\"\n],\n\"Resource\": [\n\"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/pubtopic\"\n]\n},\n{\n\"Effect\": \"Allow\",\n\"Action\": [\n\"iot:Subscribe\"\n],\n\"Resource\": [\n\"arn:aws:iot:us-west-2:57EXAMPLE833:topicfilter/test/dc/subtopic\"\n]\n},\n{\n\"Effect\": \"Allow\",\n\"Action\": [\n\"iot:Receive\"\n],\n\"Resource\": [\n\"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/*\"\n]\n}\n]\n}\n",
"policyVersionId": "1"
}
```
1. Exécutez cette commande pour associer la politique au certificat de l'appareil. Remplacez `certificateArn` par la valeur `certificateArn` que vous avez enregistrée précédemment dans cette section.
```
aws iot attach-policy \
--policy-name "PubSubTestThingPolicy" \
--target "certificateArn"
```
Si elle aboutit, cette commande ne renvoie rien.
1. Exécutez cette commande pour associer le certificat de l'appareil à la ressource AWS IoT d'objet. Remplacez `certificateArn` par la valeur `certificateArn` que vous avez enregistrée précédemment dans cette section.
```
aws iot attach-thing-principal \
--thing-name "PubSubTestThing" \
--principal "certificateArn"
```
Si elle aboutit, cette commande ne renvoie rien.
Une fois que vous avez correctement configuré votre appareil AWS IoT, vous êtes prêt à continuer[Configurer le fichier de configuration du client du AWS IoT périphérique et le client de test MQTT pour démontrer la communication MQTT](#iot-dc-testconn-provision-dc-config).
## Configurer le fichier de configuration du client du AWS IoT périphérique et le client de test MQTT pour démontrer la communication MQTT
Cette procédure crée un fichier de configuration pour tester le client du AWS IoT périphérique.
**Pour créer le fichier de configuration pour tester le client du AWS IoT périphérique**
1. Dans la fenêtre du terminal sur votre ordinateur hôte local connecté à votre Raspberry Pi :
1. Ouvrez un éditeur de texte comme `nano`.
1. Copiez ce document JSON et collez-le dans votre éditeur de texte ouvert.
```
{
"endpoint": "a3qEXAMPLEaffp-ats.iot.us-west-2.amazonaws.com",
"cert": "~/certs/pubsub/device.pem.crt",
"key": "~/certs/pubsub/private.pem.key",
"root-ca": "~/certs/AmazonRootCA1.pem",
"thing-name": "PubSubTestThing",
"logging": {
"enable-sdk-logging": true,
"level": "DEBUG",
"type": "STDOUT",
"file": ""
},
"jobs": {
"enabled": false,
"handler-directory": ""
},
"tunneling": {
"enabled": false
},
"device-defender": {
"enabled": false,
"interval": 300
},
"fleet-provisioning": {
"enabled": false,
"template-name": "",
"template-parameters": "",
"csr-file": "",
"device-key": ""
},
"samples": {
"pub-sub": {
"enabled": true,
"publish-topic": "test/dc/pubtopic",
"publish-file": "",
"subscribe-topic": "test/dc/subtopic",
"subscribe-file": "~/.aws-iot-device-client/log/pubsub_rx_msgs.log"
}
},
"config-shadow": {
"enabled": false
},
"sample-shadow": {
"enabled": false,
"shadow-name": "",
"shadow-input-file": "",
"shadow-output-file": ""
}
}
```
1. Remplacez la *endpoint* valeur par le point de terminaison de données de l'appareil dans Compte AWS lequel vous l'avez trouvé[Approvisionnez votre appareil en AWS IoT Core](iot-dc-install-provision.md#iot-dc-install-dc-provision).
1. Enregistrez le fichier dans votre éditeur de texte sous le nom **\$1/dc-configs/dc-pubsub-config.json**.
1. Exécutez cette commande pour définir les autorisations sur le nouveau fichier de configuration.
```
chmod 644 ~/dc-configs/dc-pubsub-config.json
```
1. Pour préparer le **client de test MQTT** à s'abonner à tous les messages MQTT :
1. Sur votre ordinateur hôte local, dans la [AWS IoT console](https://console.aws.amazon.com//iot/home#/test), choisissez le **client de test MQTT**.
1. Dans l'onglet **S'abonner à une rubrique**, dans le **filtre de rubrique**, entrez **\$1** (un seul signe dièse), puis choisissez **S'abonner**.
1. Sous l'étiquette **Abonnements**, confirmez que vous voyez **\$1** (un seul signe dièse).
Laissez la fenêtre avec le **client de test MQTT** ouverte pendant que vous poursuivez ce didacticiel.
Après avoir enregistré le fichier et configuré le **client de test MQTT**, vous êtes prêt à continuer [Démonstration de la publication de messages avec le AWS IoT Device Client](iot-dc-testconn-publish.md).
# Démonstration de la publication de messages avec le AWS IoT Device Client
Les procédures décrites dans cette section montrent comment le client du AWS IoT périphérique peut envoyer des messages MQTT par défaut et personnalisés.
Les déclarations de politique que vous avez créées à l'étape précédente pour ces exercices autorisent le Raspberry Pi à effectuer les actions suivantes :
+
**`iot:Connect`**
Permet au client nommé`PubSubTestThing`, votre Raspberry Pi exécutant le AWS IoT Device Client, de se connecter.
```
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
"arn:aws:iot:us-west-2:57EXAMPLE833:client/PubSubTestThing"
]
}
```
+
**`iot:Publish`**
Permet au Raspberry Pi de publier des messages dont la rubrique MQTT est `test/dc/pubtopic`.
```
{
"Effect": "Allow",
"Action": [
"iot:Publish"
],
"Resource": [
"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/pubtopic"
]
}
```
L'action `iot:Publish` donne l'autorisation de publier dans les rubriques MQTT répertoriées dans le tableau de ressources. Le *contenu* de ces messages n'est pas contrôlé par la déclaration de politique.
## Publiez le message par défaut à l'aide du AWS IoT Device Client
Cette procédure exécute le client de AWS IoT périphérique afin qu'il publie un seul message MQTT par défaut que le **client de test MQTT** reçoit et affiche.
**Pour envoyer le message MQTT par défaut depuis le client du AWS IoT périphérique**
1. Assurez-vous que la fenêtre du terminal de votre ordinateur hôte local connecté à votre Raspberry Pi et la fenêtre avec le **client de test MQTT** sont visibles pendant que vous effectuez cette procédure.
1. Dans la fenêtre du terminal, entrez ces commandes pour exécuter le client de AWS IoT périphérique à l'aide du fichier de configuration créé dans[Créez le fichier de configuration](iot-dc-install-configure.md#iot-dc-install-dc-configure-step1).
```
cd ~/aws-iot-device-client/build
./aws-iot-device-client --config-file ~/dc-configs/dc-pubsub-config.json
```
Dans la fenêtre du terminal, le client du AWS IoT périphérique affiche les messages d'information et les éventuelles erreurs survenant lors de son exécution.
Si aucune erreur n'est affichée dans la fenêtre du terminal, passez en revue le **client de test MQTT**.
1. Dans le **client de test MQTT**, dans la fenêtre **Subscriptions**(Abonnements), consultez le *Hello World \$1* message envoyé à la rubrique `test/dc/pubtopic`.
1. Si le client de l' AWS IoT appareil n'affiche aucune erreur et que vous voyez *Hello World \$1* envoyé au `test/dc/pubtopic` message dans le **client de test MQTT**, vous avez démontré une connexion réussie.
1. Dans la fenêtre du terminal, entrez **^C** (Ctrl-C) pour arrêter le AWS IoT Device Client.
Après avoir démontré que le AWS IoT Device Client a publié le message MQTT par défaut, vous pouvez passer au[Publier un message personnalisé à l'aide du AWS IoT Device Client](#iot-dc-testconn-publish-custom).
## Publier un message personnalisé à l'aide du AWS IoT Device Client
Les procédures décrites dans cette section créent un message MQTT personnalisé, puis exécutent le client de périphérique AWS IoT afin qu'il publie le message MQTT personnalisé une fois pour que le **client de test MQTT** le reçoive et l'affiche.
### Créez un message MQTT personnalisé pour le client du AWS IoT périphérique
Effectuez ces étapes dans la fenêtre du terminal sur l'ordinateur hôte local connecté à votre Raspberry Pi.
**Pour créer un message personnalisé à publier par le AWS IoT Device Client**
1. Dans la fenêtre du terminal, ouvrez un éditeur de texte comme `nano`.
1. Dans l'éditeur de texte, copiez et collez le document JSON suivant. Il s'agira de la charge utile du message MQTT que le client du AWS IoT périphérique publiera.
```
{
"temperature": 28,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
1. Enregistrement du contenu de l'éditeur de texte avec **\$1/messages/sample-ws-message.json**.
1. Saisissez la commande suivante pour définir les autorisations du fichier de messages que vous venez de créer.
```
chmod 600 ~/messages/*
```
**Pour créer un fichier de configuration que le client du AWS IoT périphérique utilisera pour envoyer le message personnalisé**
1. Dans la fenêtre du terminal, dans un éditeur de texte tel que`nano`, ouvrez le fichier de configuration AWS IoT Device Client existant :**\$1/dc-configs/dc-pubsub-config.json**.
1. Modifiez l'objet `samples` pour qu'il ressemble à ceci. Aucune autre partie de ce fichier n'a besoin d'être modifiée.
```
"samples": {
"pub-sub": {
"enabled": true,
"publish-topic": "test/dc/pubtopic",
"publish-file": "~/messages/sample-ws-message.json",
"subscribe-topic": "test/dc/subtopic",
"subscribe-file": "~/.aws-iot-device-client/log/pubsub_rx_msgs.log"
```
1. Enregistrement du contenu de l'éditeur de texte avec **\$1/dc-configs/dc-pubsub-custom-config.json**.
1. Exécutez cette commande pour définir les autorisations sur le nouveau fichier de configuration.
```
chmod 644 ~/dc-configs/dc-pubsub-custom-config.json
```
### Publiez le message MQTT personnalisé à l'aide du AWS IoT Device Client
Cette modification n'affecte que le *contenu* de la charge utile des messages MQTT, de sorte que la politique actuelle continuera de fonctionner. Toutefois, si le *sujet MQTT* (tel que défini par la valeur `publish-topic` dans`~/dc-configs/dc-pubsub-custom-config.json`) était modifié, la déclaration de politique `iot::Publish` devrait également être modifiée pour permettre au Raspberry Pi de publier sur le nouveau sujet MQTT.
**Pour envoyer le message MQTT depuis le client du AWS IoT périphérique**
1. Assurez-vous que la fenêtre du terminal et la fenêtre avec le **client de test MQTT** sont visibles pendant que vous effectuez cette procédure. Assurez-vous également que votre **client de test MQTT** est toujours abonné au filtre **\$1 topic.** Si ce n'est pas le cas, abonnez-vous à nouveau au filtre de rubrique **\$1**.
1. Dans la fenêtre du terminal, entrez ces commandes pour exécuter AWS IoT Device Client à l'aide du fichier de configuration créé dans [Créez le fichier de configuration](iot-dc-install-configure.md#iot-dc-install-dc-configure-step1).
```
cd ~/aws-iot-device-client/build
./aws-iot-device-client --config-file ~/dc-configs/dc-pubsub-custom-config.json
```
Dans la fenêtre du terminal, le client du AWS IoT périphérique affiche les messages d'information et les éventuelles erreurs survenant lors de son exécution.
Si aucune erreur n'est affichée dans la fenêtre du terminal, passez en revue le client de test MQTT.
1. Dans le **client de test MQTT**, dans la fenêtre **Abonnements**, consultez la charge utile du message personnalisé envoyé à la rubrique du message `test/dc/pubtopic`.
1. Si le AWS IoT Device Client n'affiche aucune erreur et que vous voyez la charge utile du message personnalisé que vous avez publié sur le `test/dc/pubtopic` message dans le **client de test MQTT**, cela signifie que vous avez publié un message personnalisé avec succès.
1. Dans la fenêtre du terminal, entrez **^C** (Ctrl-C) pour arrêter le AWS IoT Device Client.
Après avoir démontré que le AWS IoT Device Client a publié une charge utile de messages personnalisée, vous pouvez continuer[Démontrer l'abonnement aux messages avec le AWS IoT Device Client](iot-dc-testconn-subscribe.md).
# Démontrer l'abonnement aux messages avec le AWS IoT Device Client
Dans cette section, vous allez présenter deux types d'abonnements aux messages :
+ Abonnement thématique unique
+ Abonnement à un sujet générique
Ces déclarations de politique dans la politique créée pour ces exercices autorisent le Raspberry Pi à effectuer ces actions :
+
**`iot:Receive`**
Permet au AWS IoT Device Client de recevoir des sujets MQTT qui correspondent à ceux nommés dans l'`Resource`objet.
```
{
"Effect": "Allow",
"Action": [
"iot:Receive"
],
"Resource": [
"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/subtopic"
]
}
```
+
**`iot:Subscribe`**
Permet au AWS IoT Device Client de s'abonner aux filtres de sujets MQTT qui correspondent à ceux nommés dans l'`Resource`objet.
```
{
"Effect": "Allow",
"Action": [
"iot:Subscribe"
],
"Resource": [
"arn:aws:iot:us-west-2:57EXAMPLE833:topicfilter/test/dc/subtopic"
]
}
```
## Abonnez-vous à un seul sujet de message MQTT
Cette procédure montre comment le client du AWS IoT périphérique peut s'abonner aux messages MQTT et les enregistrer.
Dans la fenêtre du terminal de votre ordinateur hôte local connecté à votre Raspberry Pi, listez le contenu du fichier **\$1/dc-configs/dc-pubsub-custom-config.json** ou ouvrez-le dans un éditeur de texte pour en vérifier le contenu. Localisez l'objet `samples`, qui devrait ressembler à ceci.
```
"samples": {
"pub-sub": {
"enabled": true,
"publish-topic": "test/dc/pubtopic",
"publish-file": "~/messages/sample-ws-message.json",
"subscribe-topic": "test/dc/subtopic",
"subscribe-file": "~/.aws-iot-device-client/log/pubsub_rx_msgs.log"
```
Notez que la valeur `subscribe-topic` est la rubrique MQTT auquel le AWS IoT Device Client s'abonnera lors de son exécution. Le client du AWS IoT périphérique écrit les charges utiles des messages qu'il reçoit dans le cadre de cet abonnement dans le fichier nommé dans la `subscribe-file` valeur.
**Pour s'abonner à un sujet de message MQTT depuis le AWS IoT Device Client**
1. Assurez-vous que la fenêtre du terminal et la fenêtre avec le client de test MQTT sont visibles pendant que vous effectuez cette procédure. Assurez-vous également que votre **client de test MQTT** est toujours abonné au filtre **\$1 topic.** Si ce n'est pas le cas, abonnez-vous à nouveau au filtre de rubrique **\$1**.
1. Dans la fenêtre du terminal, entrez ces commandes pour exécuter le client de AWS IoT périphérique à l'aide du fichier de configuration créé dans[Créez le fichier de configuration](iot-dc-install-configure.md#iot-dc-install-dc-configure-step1).
```
cd ~/aws-iot-device-client/build
./aws-iot-device-client --config-file ~/dc-configs/dc-pubsub-custom-config.json
```
Dans la fenêtre du terminal, le client du AWS IoT périphérique affiche les messages d'information et les éventuelles erreurs survenant lors de son exécution.
Si aucune erreur ne s'affiche dans la fenêtre du terminal, continuez dans la AWS IoT console.
1. Dans la AWS IoT console, dans le **client de test MQTT**, choisissez l'onglet **Publier dans une rubrique**.
1. Dans **Topic name (Nom de la rubrique)**, saisissez **test/dc/subtopic**.
1. Dans **Charge utile du message** , passez en revue le contenu du message.
1. Choisissez **Publish** pour publier le message MQTT.
1. Dans la fenêtre du terminal, recherchez le *message reçu* du client du AWS IoT périphérique qui ressemble à ceci.
```
2021-11-10T16:02:20.890Z [DEBUG] {samples/PubSubFeature.cpp}: Message received on subscribe topic, size: 45 bytes
```
1. Après avoir vu le *message reçu indiquant* que le message a été reçu, entrez **^C** (Ctrl-C) pour arrêter le client du AWS IoT périphérique.
1. Entrez cette commande pour afficher la fin du fichier journal des messages et voir le message que vous avez publié à partir du **client de test MQTT**.
```
tail ~/.aws-iot-device-client/log/pubsub_rx_msgs.log
```
En visualisant le message dans le fichier journal, vous avez démontré que le client du périphérique AWS IoT a reçu le message que vous avez publié à partir du client de test MQTT.
## Abonnez-vous à plusieurs sujets de message MQTT en utilisant des caractères génériques
Ces procédures montrent comment le client du AWS IoT périphérique peut s'abonner à des messages MQTT et les enregistrer à l'aide de caractères génériques. Pour ce faire, vous allez :
1. Mettez à jour le filtre de rubrique utilisé par le AWS IoT Device Client pour s'abonner aux rubriques MQTT.
1. Mettez à jour la politique utilisée par l'appareil pour autoriser les nouveaux abonnements.
1. Exécutez le AWS IoT Device Client et publiez des messages depuis la console de test MQTT.
**Pour créer un fichier de configuration permettant de s'abonner à plusieurs rubriques de messages MQTT à l'aide d'un filtre MQTT générique**
1. Dans la fenêtre du terminal de votre ordinateur hôte local connecté à votre Raspberry Pi, ouvrez **\$1/dc-configs/dc-pubsub-custom-config.json** pour le modifier et localisez l'objet `samples`.
1. Dans l'éditeur de texte, localisez l'`samples`objet et mettez à jour la valeur `subscribe-topic` pour qu'elle ressemble à ceci.
```
"samples": {
"pub-sub": {
"enabled": true,
"publish-topic": "test/dc/pubtopic",
"publish-file": "~/messages/sample-ws-message.json",
"subscribe-topic": "test/dc/#",
"subscribe-file": "~/.aws-iot-device-client/log/pubsub_rx_msgs.log"
```
La nouvelle valeur `subscribe-topic` est un [filtre thématique MQTT](topics.md#topicfilters) avec un caractère générique MQTT à la fin. Ceci décrit un abonnement à tous les sujets MQTT commençant par `test/dc/`. Le client du AWS IoT périphérique écrit les charges utiles des messages qu'il reçoit dans le cadre de cet abonnement dans le fichier indiqué dans`subscribe-file`.
1. Enregistrez le fichier de configuration modifié sous **\$1/dc-configs/dc-pubsub-wild-config.json**, et quittez l'éditeur.
**Pour modifier la politique utilisée par votre Raspberry Pi afin d'autoriser l'abonnement et la réception de plusieurs rubriques de messages MQTT**
1. Dans la fenêtre du terminal de votre ordinateur hôte local connecté à votre Raspberry Pi, dans votre éditeur de texte préféré, ouvrez **\$1/policies/pubsub\$1test\$1thing\$1policy.json** pour modification, puis recherchez les `iot::Subscribe` et les déclarations de politique `iot::Receive` dans le fichier.
1. Dans la déclaration de politique `iot::Subscribe`, mettez à jour la chaîne de l'objet Resource `subtopic` à remplacer par `*`, afin qu'elle ressemble à ceci.
```
{
"Effect": "Allow",
"Action": [
"iot:Subscribe"
],
"Resource": [
"arn:aws:iot:us-west-2:57EXAMPLE833:topicfilter/test/dc/*"
]
}
```
**Note**
Les [caractères génériques du filtre thématique MQTT](topics.md#topicfilters) sont le `+` (signe plus) et le `#` (signe dièse). Une demande d'abonnement avec un `#` à la fin permet de souscrire à tous les rubriques commençant par la chaîne qui précède le caractère `#` (par exemple, `test/dc/` dans ce cas).
La valeur de la ressource indiquée dans la déclaration de politique qui autorise cet abonnement doit toutefois utiliser un `*` (astérisque) à la place du `#` (signe dièse) dans l'ARN du filtre de rubrique. Cela est dû au fait que le processeur de politiques utilise un caractère générique différent de celui utilisé par MQTT.
Pour plus d'informations sur l'utilisation de caractères génériques pour les rubriques et de filtres de rubriques dans les politiques, consultez [Utilisation de caractères génériques dans le MQTT et les politiques AWS IoT Core](pub-sub-policy.md#pub-sub-policy-cert).
1. Dans la déclaration de politique `iot::Receive`, mettez à jour la chaîne de l'objet Resource `subtopic` à remplacer par `*`, afin qu'elle ressemble à ceci.
```
{
"Effect": "Allow",
"Action": [
"iot:Receive"
],
"Resource": [
"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/*"
]
}
```
1. Enregistrez le document de politique mis à jour et quittez l'éditeur **\$1/policies/pubsub\$1wild\$1test\$1thing\$1policy.json**.
1. Entrez cette commande pour mettre à jour la politique de ce didacticiel afin d'utiliser les nouvelles définitions de ressources.
```
aws iot create-policy-version \
--set-as-default \
--policy-name "PubSubTestThingPolicy" \
--policy-document "file://~/policies/pubsub_wild_test_thing_policy.json"
```
Si la commande réussit, elle renvoie une réponse comme celle-ci. Notez que `policyVersionId` est maintenant `2`, ce qui indique qu'il s'agit de la deuxième version de cette politique.
Si vous avez correctement mis à jour la politique, vous pouvez passer à la procédure suivante.
```
{
"policyArn": "arn:aws:iot:us-west-2:57EXAMPLE833:policy/PubSubTestThingPolicy",
"policyDocument": "{\n \"Version\": \"2012-10-17\", \n \"Statement\": [\n {\n \"Effect\": \"Allow\",\n \"Action\": [\n \"iot:Connect\"\n ],\n \"Resource\": [\n \"arn:aws:iot:us-west-2:57EXAMPLE833:client/PubSubTestThing\"\n ]\n },\n {\n \"Effect\": \"Allow\",\n \"Action\": [\n \"iot:Publish\"\n ],\n \"Resource\": [\n \"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/pubtopic\"\n ]\n },\n {\n \"Effect\": \"Allow\",\n \"Action\": [\n \"iot:Subscribe\"\n ],\n \"Resource\": [\n \"arn:aws:iot:us-west-2:57EXAMPLE833:topicfilter/test/dc/*\"\n ]\n },\n {\n \"Effect\": \"Allow\",\n \"Action\": [\n \"iot:Receive\"\n ],\n \"Resource\": [\n \"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/*\"\n ]\n }\n ]\n}\n",
"policyVersionId": "2",
"isDefaultVersion": true
}
```
Si vous recevez un message d'erreur indiquant qu'il existe trop de versions de politique pour en enregistrer une nouvelle, entrez cette commande pour répertorier les versions actuelles de la politique. Consultez la liste renvoyée par cette commande pour rechercher une version de politique que vous pouvez supprimer.
```
aws iot list-policy-versions --policy-name "PubSubTestThingPolicy"
```
Saisissez cette commande pour supprimer une version dont vous n'avez plus besoin. Notez que vous ne pouvez pas supprimer la version de politique par défaut. La version de politique par défaut est celle dont la valeur `isDefaultVersion` est de `true`.
```
aws iot delete-policy-version \
--policy-name "PubSubTestThingPolicy" \
--policy-version-id policyId
```
Après avoir supprimé une version de politique, réessayez cette étape.
Avec le fichier de configuration et la politique mis à jour, vous êtes prêt à démontrer les abonnements génériques avec le AWS IoT Device Client.
**Pour montrer comment le client du AWS IoT périphérique s'abonne à plusieurs sujets de messages MQTT et en reçoit**
1. Dans le **client de test MQTT**, vérifiez les abonnements. Si le **client de test MQTT** est abonné au filtre de rubrique **\$1**, passez à l'étape suivante. Sinon, dans le **client de test MQTT**, dans l'onglet **S'abonner à une rubrique**, dans le **filtre de rubrique**, entrez **\$1** (un signe dièse), puis choisissez **S'abonner** pour vous y abonner.
1. Dans la fenêtre du terminal de votre ordinateur hôte local connecté à votre Raspberry Pi, entrez ces commandes pour démarrer le AWS IoT Device Client.
```
cd ~/aws-iot-device-client/build
./aws-iot-device-client --config-file ~/dc-configs/dc-pubsub-wild-config.json
```
1. Tout en regardant la sortie du AWS IoT Device Client dans la fenêtre du terminal de l'ordinateur hôte local, retournez au **client de test MQTT**. Dans l'onglet **Publier dans une rubrique**, dans **Nom de rubrique**, entrez **test/dc/subtopic**, puis choisissez **Publier**.
1. Dans la fenêtre du terminal, vérifiez que le message a bien été reçu en recherchant un message tel que :
```
2021-11-10T16:34:20.101Z [DEBUG] {samples/PubSubFeature.cpp}: Message received on subscribe topic, size: 76 bytes
```
1. Tout en regardant la sortie du AWS IoT Device Client dans la fenêtre du terminal de l'ordinateur hôte local, retournez au **client de test MQTT**. Dans l'onglet **Publier dans une rubrique**, dans **Nom de rubrique**, entrez **test/dc/subtopic2**, puis choisissez **Publier**.
1. Dans la fenêtre du terminal, vérifiez que le message a bien été reçu en recherchant un message tel que :
```
2021-11-10T16:34:32.078Z [DEBUG] {samples/PubSubFeature.cpp}: Message received on subscribe topic, size: 77 bytes
```
1. Après avoir vu les messages confirmant la réception des deux messages, entrez **^C** (Ctrl-C) pour arrêter le AWS IoT Device Client.
1. Entrez cette commande pour afficher la fin du fichier journal des messages et voir le message que vous avez publié à partir du **client de test MQTT**.
```
tail -n 20 ~/.aws-iot-device-client/log/pubsub_rx_msgs.log
```
**Note**
Le fichier journal contient uniquement les charges utiles des messages. Les sujets des messages ne sont pas enregistrés dans le fichier journal des messages reçus.
Vous pouvez également voir le message publié par le AWS IoT Device Client dans le journal reçu. En effet, le filtre de sujet générique inclut ce sujet de message et, parfois, la demande d'abonnement peut être traitée par l’agent de messages avant que le message publié ne soit envoyé aux abonnés.
Les entrées du fichier journal indiquent que les messages ont été reçus. Vous pouvez répéter cette procédure en utilisant d'autres noms de rubrique. Tous les messages dont le nom de rubrique commence par `test/dc/` doivent être reçus et enregistrés. Les messages dont le nom de rubrique commence par un autre texte sont ignorés.
Après avoir démontré comment le AWS IoT Device Client peut publier des messages MQTT et s'y abonner, passez à[Tutoriel : Démonstration d'actions à distance (tâches) avec le client du AWS IoT périphérique](iot-dc-runjobs.md).