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 d'actions à distance (tâches) avec le client du AWS IoT périphérique
Dans ces didacticiels, vous allez configurer et déployer des tâches sur votre Raspberry Pi pour montrer comment envoyer des opérations à distance à vos appareils IoT.
**Pour démarrer ce didacticiel :**
+ Configurez un Raspberry Pi sur votre ordinateur hôte local comme indiqué dans [la section précédente](iot-dc-testconn.md).
+ Si vous n'avez pas terminé le didacticiel de la section précédente, vous pouvez essayer ce didacticiel en utilisant le Raspberry Pi avec une carte microSD contenant l'image que vous avez enregistrée après avoir installé le client du AWS IoT périphérique. [(Facultatif) Enregistrez l'image de la carte microSD](iot-dc-install-download.md#iot-dc-install-dc-save)
+ 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 utiliser le AWS IoT Core pour exécuter des opérations à distance gérées par AWS IoT .
**Matériel requis :**
+ Votre environnement de développement et de test local dans lequel vous avez testé [dans la section précédente](iot-dc-install-dc.md)
+ Le Raspberry Pi que vous avez testé dans [la section précédente](iot-dc-install-dc.md)
+ La carte mémoire microSD du Raspberry Pi que vous avez testée dans [la section précédente](iot-dc-install-dc.md)
**Topics**
+ [Préparez le Raspberry Pi pour exécuter des tâches](iot-dc-runjobs-prepare.md)
+ [Créez et exécutez le job AWS IoT avec AWS IoT Device Client](iot-dc-runjobs-prepare-define.md)
# Préparez le Raspberry Pi pour exécuter des tâches
Les procédures décrites dans cette section décrivent comment préparer votre Raspberry Pi à exécuter des tâches à l'aide du AWS IoT Device Client.
**Note**
Ces procédures sont spécifiques à l'appareil. Si vous souhaitez exécuter les procédures décrites dans cette section avec plusieurs appareils à la fois, chaque appareil aura besoin de sa propre politique, d'un certificat et d'un nom d'objet uniques et spécifiques à l'appareil. Pour attribuer à chaque appareil ses ressources uniques, effectuez cette procédure une fois pour chaque appareil tout en modifiant les éléments spécifiques au appareil comme décrit dans les procédures.
**Topics**
+ [Provisionnez votre Raspberry Pi pour présenter des jobs](#iot-dc-runjobs-prepare-provision)
+ [Configurer le AWS IoT Device Client pour exécuter l'agent de tâches](#iot-dc-runjobs-prepare-config)
## Provisionnez votre Raspberry Pi pour présenter des jobs
Les procédures décrites dans cette section approvisionnent votre Raspberry Pi en AWS IoT créant AWS IoT des ressources et des certificats d'appareil pour celui-ci.
**Topics**
+ [Créez et téléchargez des fichiers de certificat d'appareil pour illustrer les AWS IoT tâches](#iot-dc-runjobs-prepare-cert)
+ [Créer AWS IoT des ressources pour présenter les AWS IoT emplois](#iot-dc-runjobs-prepare-iot)
### Créez et téléchargez des fichiers de certificat d'appareil pour illustrer les AWS IoT tâches
Cette procédure crée les fichiers de certificat de l'appareil pour cette démonstration.
Si vous préparez plusieurs appareils, cette procédure doit être exécutée sur chaque appareil.
**Pour créer et télécharger les fichiers de certificat d'appareil pour votre Raspberry Pi :**
Dans la fenêtre du terminal sur votre ordinateur hôte local connecté à votre Raspberry Pi :
1. Entrez la commande suivante pour créer les fichiers de certificat de l'appareil pour votre appareil.
```
aws iot create-keys-and-certificate \
--set-as-active \
--certificate-pem-outfile "~/certs/jobs/device.pem.crt" \
--public-key-outfile "~/certs/jobs/public.pem.key" \
--private-key-outfile "~/certs/jobs/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/jobs
chmod 644 ~/certs/jobs/*
chmod 600 ~/certs/jobs/private.pem.key
```
1. Exécutez cette commande pour vérifier les autorisations sur vos répertoires et fichiers de certificats.
```
ls -l ~/certs/jobs
```
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
```
Après avoir téléchargé les fichiers de certificat de l'appareil sur votre Raspberry Pi, vous êtes prêt à continuer [Provisionnez votre Raspberry Pi pour présenter des jobs](#iot-dc-runjobs-prepare-provision).
### Créer AWS IoT des ressources pour présenter les AWS IoT emplois
Créez les AWS IoT ressources pour cet appareil.
Si vous préparez plusieurs appareils, cette procédure doit être exécutée pour chaque appareil.
**Pour approvisionner votre appareil en AWS IoT :**
Dans la fenêtre du terminal sur votre ordinateur hôte local connecté à votre Raspberry Pi :
1. Saisissez la commande suivante pour obtenir l'adresse du point de terminaison de 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 la dernière exécution de cette commande. La réexécution de la commande ici facilite la recherche et le collage de la valeur du point de terminaison de données dans le fichier de configuration utilisé dans ce didacticiel.
La commande **describe-endpoint** 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. *uniqueThingName*Remplacez-le par un nom unique pour votre appareil. Si vous souhaitez exécuter ce didacticiel avec plusieurs appareils, attribuez à chaque appareil son propre nom. Par exemple, **TestDevice01**, **TestDevice02**, et ainsi de suite.
Entrez cette commande pour créer une nouvelle ressource d' AWS IoT objets pour votre Raspberry Pi.
```
aws iot create-thing --thing-name "uniqueThingName"
```
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.
**Note**
Lorsque vous souhaitez sécuriser la politique pour plusieurs appareils, vous pouvez utiliser `${iot:Thing.ThingName}` à la place du nom d'objet statique `uniqueThingName`.
Ces didacticiels n'utiliseront qu'une seule ressource à la fois par appareil. 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 les démos 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. Enregistrez la valeur `thingArn` pour une utilisation ultérieure lorsque vous créerez le job à exécuter sur cet appareil.
```
{
"thingName": "uniqueThingName",
"thingArn": "arn:aws:iot:us-west-2:57EXAMPLE833:thing/uniqueThingName",
"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/uniqueThingName"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Publish"
],
"Resource": [
"arn:aws:iot:us-west-2:123456789012:topic/test/dc/pubtopic",
"arn:aws:iot:us-west-2:123456789012:topic/$aws/events/job/*",
"arn:aws:iot:us-west-2:123456789012:topic/$aws/events/jobExecution/*",
"arn:aws:iot:us-west-2:123456789012:topic/$aws/things/uniqueThingName/jobs/*"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Subscribe"
],
"Resource": [
"arn:aws:iot:us-west-2:123456789012:topicfilter/test/dc/subtopic",
"arn:aws:iot:us-west-2:123456789012:topic/$aws/events/jobExecution/*",
"arn:aws:iot:us-west-2:123456789012:topicfilter/$aws/things/uniqueThingName/jobs/*"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Receive"
],
"Resource": [
"arn:aws:iot:us-west-2:123456789012:topic/test/dc/subtopic",
"arn:aws:iot:us-west-2:123456789012:topic/$aws/things/uniqueThingName/jobs/*"
]
},
{
"Effect": "Allow",
"Action": [
"iot:DescribeJobExecution",
"iot:GetPendingJobExecutions",
"iot:StartNextPendingJobExecution",
"iot:UpdateJobExecution"
],
"Resource": [
"arn:aws:iot:us-west-2:123456789012:topic/$aws/things/uniqueThingName"
]
}
]
}
```
1. Dans l'éditeur, dans la `Resource` section de chaque déclaration de politique, remplacez *us-west-2:57EXAMPLE833* par le vôtre Région AWS, le caractère deux-points (:)) et votre Compte AWS numéro à 12 chiffres.
1. Dans l'éditeur, dans chaque déclaration de politique, remplacez-le *uniqueThingName* par le nom que vous avez donné à cette ressource.
1. Enregistrez le fichier dans votre éditeur de texte sous le nom **\$1/policies/jobs\$1test\$1thing\$1policy.json**
Si vous exécutez cette procédure pour plusieurs appareils, enregistrez le fichier sous ce nom sur chaque appareil.
1. *uniqueThingName*Remplacez-le par le nom de l'objet du périphérique, puis exécutez cette commande pour créer une AWS IoT politique adaptée à cet appareil.
```
aws iot create-policy \
--policy-name "JobTestPolicyForuniqueThingName" \
--policy-document "file://~/policies/jobs_test_thing_policy.json"
```
Si la politique est créée, la commande renvoie une réponse comme celle-ci.
****
```
{
"policyName": "JobTestPolicyForuniqueThingName",
"policyArn": "arn:aws:iot:us-west-2:57EXAMPLE833:policy/JobTestPolicyForuniqueThingName",
"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. Remplacez-le *uniqueThingName* par le nom de l'objet du périphérique et `certificateArn` par la `certificateArn` valeur que vous avez enregistrée précédemment dans cette section pour ce périphérique, puis exécutez cette commande pour associer la politique au certificat de l'appareil.
```
aws iot attach-policy \
--policy-name "JobTestPolicyForuniqueThingName" \
--target "certificateArn"
```
Si elle aboutit, cette commande ne renvoie rien.
1. Remplacez *uniqueThingName* par le nom de l'objet pour le périphérique, remplacez `certificateArn` par la `certificateArn` valeur que vous avez enregistrée précédemment dans cette section, puis exécutez cette commande pour associer le certificat du périphérique à la ressource de l' AWS IoT objet.
```
aws iot attach-thing-principal \
--thing-name "uniqueThingName" \
--principal "certificateArn"
```
Si elle aboutit, cette commande ne renvoie rien.
Une fois que vous avez correctement configuré votre Raspberry Pi, vous êtes prêt à répéter cette section pour un autre Raspberry Pi lors de votre test ou, si tous les appareils ont été configurés, continuer à [Configurer le AWS IoT Device Client pour exécuter l'agent de tâches](#iot-dc-runjobs-prepare-config).
## Configurer le AWS IoT Device Client pour exécuter l'agent de tâches
Cette procédure crée un fichier de configuration pour que le client du AWS IoT périphérique exécute l'agent de tâches :.
Remarque : si vous préparez plusieurs appareils, cette procédure doit être effectuée sur chaque appareil.
**Pour créer le fichier de configuration permettant de 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/jobs/device.pem.crt",
"key": "~/certs/jobs/private.pem.key",
"root-ca": "~/certs/AmazonRootCA1.pem",
"thing-name": "uniqueThingName",
"logging": {
"enable-sdk-logging": true,
"level": "DEBUG",
"type": "STDOUT",
"file": ""
},
"jobs": {
"enabled": true,
"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": false,
"publish-topic": "",
"publish-file": "",
"subscribe-topic": "",
"subscribe-file": ""
}
},
"config-shadow": {
"enabled": false
},
"sample-shadow": {
"enabled": false,
"shadow-name": "",
"shadow-input-file": "",
"shadow-output-file": ""
}
}
```
1. Remplacez la *endpoint* valeur par la valeur du point de terminaison des données de l'appareil Compte AWS que vous avez trouvée dans[Approvisionnez votre appareil en AWS IoT Core](iot-dc-install-provision.md#iot-dc-install-dc-provision).
1. *uniqueThingName*Remplacez-le par le nom de l'objet que vous avez utilisé pour cet appareil.
1. Enregistrez le fichier dans votre éditeur de texte sous le nom **\$1/dc-configs/dc-jobs-config.json**
1. Exécutez cette commande pour définir les autorisations de fichier du nouveau fichier de configuration.
```
chmod 644 ~/dc-configs/dc-jobs-config.json
```
Vous n'utiliserez pas le **client de test MQTT** pour cette rubrique. Alors que l'appareil échange des messages MQTT relatifs aux tâches AWS IoT, les messages de progression des tâches ne sont échangés qu'avec l'appareil exécutant la tâche. Les messages de progression des tâches étant échangés uniquement avec l'appareil exécutant la tâche, vous ne pouvez pas vous y abonner depuis un autre appareil, tel que la AWS IoT console.
Après avoir enregistré le fichier de configuration, vous êtes prêt à continuer [Créez et exécutez le job AWS IoT avec AWS IoT Device Client](iot-dc-runjobs-prepare-define.md).
# Créez et exécutez le job AWS IoT avec AWS IoT Device Client
Les procédures décrites dans cette section créent un document de travail et une ressource de AWS IoT travail. Une fois que vous avez créé la ressource de tâche, AWS IoT envoie le document de tâche aux cibles de tâche spécifiées sur lesquelles un agent de tâches applique le document de tâche à l'appareil ou au client.
**Topics**
+ [Créez et stockez le document de travail pour la tâche IoT](#iot-dc-runjobs-prepare-define-jobdoc)
+ [Exécuter une tâche AWS IoT pour un appareil IoT](#iot-dc-runjobs-prepare-define-job)
## Créez et stockez le document de travail pour la tâche IoT
Cette procédure crée un document de travail simple à inclure dans une ressource de AWS IoT travail. Ce document job affiche « Hello world \$1 » sur l'objectif du job.
**Pour créer et stocker un document job, procédez comme suit :**
1. Sélectionnez le compartiment Amazon S3 dans lequel vous allez enregistrer votre document job. Si vous n'avez pas de compartiment Amazon S3 à utiliser à cette fin, vous aurez besoin d'en créer. Pour plus d'informations sur la création de compartiments Amazon S3, consultez les rubriques [Démarrage avec Amazon S3](https://docs.aws.amazon.com//AmazonS3/latest/userguide/GetStartedWithS3.html).
1. Créer et enregistrer le document job pour cette tâche
1. Sur votre ordinateur hôte local, ouvrez un éditeur de texte.
1. Copiez et collez ce texte dans l'éditeur.
```
{
"operation": "echo",
"args": ["Hello world!"]
}
```
1. Sur l'ordinateur hôte local, enregistrez le contenu de l'éditeur dans un fichier nommé **hello-world-job.json**.
1. Vérifiez que le fichier a été correctement enregistré. Certains éditeurs de texte ajoutent automatiquement `.txt` au nom du fichier lorsqu'ils enregistrent un fichier texte. Si votre éditeur a ajouté `.txt` au nom du fichier, corrigez-le avant de continuer.
1. Remplacez le *path\$1to\$1file* par le chemin vers**hello-world-job.json**, s'il ne figure pas dans votre répertoire actuel, remplacez-le *s3\$1bucket\$1name* par le chemin du compartiment Amazon S3 vers le compartiment que vous avez sélectionné, puis exécutez cette commande pour placer votre document de travail dans le compartiment Amazon S3.
```
aws s3api put-object \
--key hello-world-job.json \
--body path_to_file/hello-world-job.json --bucket s3_bucket_name
```
L'URL du document de travail qui identifie le document de travail que vous avez stocké dans Amazon S3 est déterminée en remplaçant le *s3\$1bucket\$1name* et *AWS\$1region* dans l'URL suivante. Enregistrez l'URL résultante pour l'utiliser ultérieurement en tant que *job\$1document\$1path*
```
https://s3_bucket_name.s3.AWS_Region.amazonaws.com/hello-world-job.json
```
**Note**
AWS la sécurité vous empêche d'ouvrir cette URL en dehors de la vôtre Compte AWS, par exemple à l'aide d'un navigateur. L'URL est utilisée par le moteur de AWS IoT tâches, qui a accès au fichier par défaut. Dans un environnement de production, vous devez vous assurer que vos services AWS IoT sont autorisés à accéder aux documents job stockés dans Amazon S3.
Après avoir enregistré l'URL du document job, passez à [Exécuter une tâche AWS IoT pour un appareil IoT](#iot-dc-runjobs-prepare-define-job).
## Exécuter une tâche AWS IoT pour un appareil IoT
Les procédures décrites dans cette section démarrent le client de AWS IoT périphérique sur votre Raspberry Pi pour exécuter l'agent de tâches sur le périphérique afin d'attendre l'exécution des tâches. Cela crée également une ressource de travail dans AWS IoT, qui enverra la tâche et s'exécutera sur votre appareil IoT.
**Note**
Cette procédure exécute une job sur un seul appareil.
**Pour démarrer l'agent de jobs sur votre Raspberry Pi :**
1. Dans la fenêtre du terminal de votre ordinateur hôte local connecté à votre Raspberry Pi, exécutez cette commande pour démarrer le AWS IoT Device Client.
```
cd ~/aws-iot-device-client/build
./aws-iot-device-client --config-file ~/dc-configs/dc-jobs-config.json
```
1. Dans la fenêtre du terminal, vérifiez que le client du AWS IoT périphérique affiche ces messages
```
2021-11-15T18:45:56.708Z [INFO] {Main.cpp}: Jobs is enabled
.
.
.
2021-11-15T18:45:56.708Z [INFO] {Main.cpp}: Client base has been notified that Jobs has started
2021-11-15T18:45:56.708Z [INFO] {JobsFeature.cpp}: Running Jobs!
2021-11-15T18:45:56.708Z [DEBUG] {JobsFeature.cpp}: Attempting to subscribe to startNextPendingJobExecution accepted and rejected
2021-11-15T18:45:56.708Z [DEBUG] {JobsFeature.cpp}: Attempting to subscribe to nextJobChanged events
2021-11-15T18:45:56.708Z [DEBUG] {JobsFeature.cpp}: Attempting to subscribe to updateJobExecutionStatusAccepted for jobId +
2021-11-15T18:45:56.738Z [DEBUG] {JobsFeature.cpp}: Ack received for SubscribeToUpdateJobExecutionAccepted with code {0}
2021-11-15T18:45:56.739Z [DEBUG] {JobsFeature.cpp}: Attempting to subscribe to updateJobExecutionStatusRejected for jobId +
2021-11-15T18:45:56.753Z [DEBUG] {JobsFeature.cpp}: Ack received for SubscribeToNextJobChanged with code {0}
2021-11-15T18:45:56.760Z [DEBUG] {JobsFeature.cpp}: Ack received for SubscribeToStartNextJobRejected with code {0}
2021-11-15T18:45:56.776Z [DEBUG] {JobsFeature.cpp}: Ack received for SubscribeToStartNextJobAccepted with code {0}
2021-11-15T18:45:56.776Z [DEBUG] {JobsFeature.cpp}: Ack received for SubscribeToUpdateJobExecutionRejected with code {0}
2021-11-15T18:45:56.777Z [DEBUG] {JobsFeature.cpp}: Publishing startNextPendingJobExecutionRequest
2021-11-15T18:45:56.785Z [DEBUG] {JobsFeature.cpp}: Ack received for StartNextPendingJobPub with code {0}
2021-11-15T18:45:56.785Z [INFO] {JobsFeature.cpp}: No pending jobs are scheduled, waiting for the next incoming job
```
1. Dans la fenêtre du terminal, après avoir vu ce message, passez à la procédure suivante et créez la ressource job. Notez qu'il ne s'agit peut-être pas de la dernière entrée de la liste.
```
2021-11-15T18:45:56.785Z [INFO] {JobsFeature.cpp}: No pending jobs are scheduled, waiting for the next incoming job
```
**Pour créer une ressource AWS IoT d'emploi**
1. Sur votre ordinateur hôte local :
1. Remplacez *job\$1document\$1url* par l'URL du document de travail provenant de[Créez et stockez le document de travail pour la tâche IoT](#iot-dc-runjobs-prepare-define-jobdoc).
1. *thing\$1arn*Remplacez-le par l'ARN de la ressource d'objet que vous avez créée pour votre appareil, puis exécutez cette commande.
```
aws iot create-job \
--job-id hello-world-job-1 \
--document-source "job_document_url" \
--targets "thing_arn" \
--target-selection SNAPSHOT
```
En cas de succès, la commande renvoie un résultat comme celui-ci.
```
{
"jobArn": "arn:aws:iot:us-west-2:57EXAMPLE833:job/hello-world-job-1",
"jobId": "hello-world-job-1"
}
```
1. Dans la fenêtre du terminal, vous devriez voir une sortie du client de AWS IoT périphérique comme celle-ci.
```
2021-11-15T18:02:26.688Z [INFO] {JobsFeature.cpp}: No pending jobs are scheduled, waiting for the next incoming job
2021-11-15T18:10:24.890Z [DEBUG] {JobsFeature.cpp}: Job ids differ
2021-11-15T18:10:24.890Z [INFO] {JobsFeature.cpp}: Executing job: hello-world-job-1
2021-11-15T18:10:24.890Z [DEBUG] {JobsFeature.cpp}: Attempting to update job execution status!
2021-11-15T18:10:24.890Z [DEBUG] {JobsFeature.cpp}: Not including stdout with the status details
2021-11-15T18:10:24.890Z [DEBUG] {JobsFeature.cpp}: Not including stderr with the status details
2021-11-15T18:10:24.890Z [DEBUG] {JobsFeature.cpp}: Assuming executable is in PATH
2021-11-15T18:10:24.890Z [INFO] {JobsFeature.cpp}: About to execute: echo Hello world!
2021-11-15T18:10:24.890Z [DEBUG] {Retry.cpp}: Retryable function starting, it will retry until success
2021-11-15T18:10:24.890Z [DEBUG] {JobsFeature.cpp}: Created EphermalPromise for ClientToken 3TEWba9Xj6 in the updateJobExecution promises map
2021-11-15T18:10:24.890Z [DEBUG] {JobEngine.cpp}: Child process now running
2021-11-15T18:10:24.890Z [DEBUG] {JobEngine.cpp}: Child process about to call execvp
2021-11-15T18:10:24.890Z [DEBUG] {JobEngine.cpp}: Parent process now running, child PID is 16737
2021-11-15T18:10:24.891Z [DEBUG] {16737}: Hello world!
2021-11-15T18:10:24.891Z [DEBUG] {JobEngine.cpp}: JobEngine finished waiting for child process, returning 0
2021-11-15T18:10:24.891Z [INFO] {JobsFeature.cpp}: Job exited with status: 0
2021-11-15T18:10:24.891Z [INFO] {JobsFeature.cpp}: Job executed successfully!
2021-11-15T18:10:24.891Z [DEBUG] {JobsFeature.cpp}: Attempting to update job execution status!
2021-11-15T18:10:24.891Z [DEBUG] {JobsFeature.cpp}: Not including stdout with the status details
2021-11-15T18:10:24.891Z [DEBUG] {JobsFeature.cpp}: Not including stderr with the status details
2021-11-15T18:10:24.892Z [DEBUG] {Retry.cpp}: Retryable function starting, it will retry until success
2021-11-15T18:10:24.892Z [DEBUG] {JobsFeature.cpp}: Created EphermalPromise for ClientToken GmQ0HTzWGg in the updateJobExecution promises map
2021-11-15T18:10:24.905Z [DEBUG] {JobsFeature.cpp}: Ack received for PublishUpdateJobExecutionStatus with code {0}
2021-11-15T18:10:24.905Z [DEBUG] {JobsFeature.cpp}: Removing ClientToken 3TEWba9Xj6 from the updateJobExecution promises map
2021-11-15T18:10:24.905Z [DEBUG] {JobsFeature.cpp}: Success response after UpdateJobExecution for job hello-world-job-1
2021-11-15T18:10:24.917Z [DEBUG] {JobsFeature.cpp}: Ack received for PublishUpdateJobExecutionStatus with code {0}
2021-11-15T18:10:24.918Z [DEBUG] {JobsFeature.cpp}: Removing ClientToken GmQ0HTzWGg from the updateJobExecution promises map
2021-11-15T18:10:24.918Z [DEBUG] {JobsFeature.cpp}: Success response after UpdateJobExecution for job hello-world-job-1
2021-11-15T18:10:25.861Z [INFO] {JobsFeature.cpp}: No pending jobs are scheduled, waiting for the next incoming job
```
1. Pendant que le AWS IoT Device Client est en cours d'exécution et attend une tâche, vous pouvez en soumettre une autre en modifiant la `job-id` valeur et en la réexécutant **create-job** depuis l'étape 1.
Lorsque vous avez terminé d'exécuter les tâches, dans la fenêtre du terminal, entrez ^C (Control-C) pour arrêter le AWS IoT Device Client.