Esempi di AWS IoT con la AWS CLI

Come accettare un certificato di dispositivo trasferito da un altro account AWS

L’esempio accept-certificate-transfer seguente accetta il certificato di un dispositivo trasferito da un altro account AWS. Il certificato viene identificato mediante il rispettivo ID.

aws iot accept-certificate-transfer \
    --certificate-id 488b6a7f2acdeb00a77384e63c4e40b18bEXAMPLEe57b7272ba44c45e3448142

Il comando non produce output.

Per ulteriori informazioni, consulta Trasferire un certificato a un altro account nella Guida per gli sviluppatori di AWS IoT Core.

Esempio 1: per aggiungere un oggetto in base al nome a un gruppo di fatturazione

L’esempio add-thing-to-billing-group seguente aggiunge l’oggetto denominato MyLightBulb al gruppo di fatturazione denominato GroupOne.

aws iot add-thing-to-billing-group \
    --billing-group-name GroupOne \
    --thing-name MyLightBulb

Questo comando non produce alcun output.

Esempio 2: per aggiungere un oggetto in base all’ARN a un gruppo di fatturazione

L’esempio add-thing-to-billing-group seguente aggiunge un oggetto con un ARN specificato a un gruppo di fatturazione con l’ARN specificato. Specificare un ARN è utile se si lavora con Regioni o account AWS. Può aiutarti a verificare che tu stia aggiungendo risorse nella Regione e nell’account corretti.

aws iot add-thing-to-thing-group \
    --billing-group-arn "arn:aws:iot:us-west-2:123456789012:billinggroup/GroupOne" \
    --thing-arn "arn:aws:iot:us-west-2:123456789012:thing/MyOtherLightBulb"

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Gruppi di fatturazione nella Guida per gli sviluppatori di AWS IoT.

Come aggiungere un oggetto a un gruppo

L’esempio add-thing-to-thing-group seguente aggiunge l’oggetto specificato al gruppo di oggetti specificato.

aws iot add-thing-to-thing-group \
    --thing-name MyLightBulb \
    --thing-group-name LightBulbs

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Gruppi di oggetti nella Guida per gli sviluppatori di AWS IoT.

Come associare un gruppo di oggetti a un processo continuo

L’esempio associate-targets-with-job seguente associa il gruppo di oggetti specificato al processo continuo specificato.

aws iot associate-targets-with-job \
    --targets "arn:aws:iot:us-west-2:123456789012:thinggroup/LightBulbs" \
    --job-id "example-job-04"

Output:

{
    "jobArn": "arn:aws:iot:us-west-2:123456789012:job/example-job-04",
    "jobId": "example-job-04",
    "description": "example continuous job"
}

Per ulteriori informazioni, consulta Creazione e gestione di processi (CLI) nella Guida per gli sviluppatori di AWS IoT.

Esempio 1: per collegare una policy a un gruppo di oggetti

L’esempio attach-policy seguente collega la policy specificata a un gruppo di oggetti identificato dal relativo ARN.

aws iot attach-policy \
    --target "arn:aws:iot:us-west-2:123456789012:thinggroup/LightBulbs" \
    --policy-name "UpdateDeviceCertPolicy"

Il comando non produce output.

Per ulteriori informazioni, consulta Gruppi di oggetti nella Guida per gli sviluppatori di AWS IoT.

Esempio 2: per collegare una policy a un certificato

L’esempio attach-policy seguente collega la policy UpdateDeviceCertPolicy al principale specificato da un certificato.

aws iot attach-policy \
    --policy-name UpdateDeviceCertPolicy \
    --target "arn:aws:iot:us-west-2:123456789012:cert/4f0ba725787aa94d67d2fca420eca022242532e8b3c58e7465c7778b443fd65e"

Il comando non produce output.

Per ulteriori informazioni, consulta Collegamento di una policy AWS IoT a un certificato del dispositivo nella Guida per gli sviluppatori di AWS IoT.

Come associare un profilo di sicurezza a tutti i dispositivi non registrati

L’esempio attach-security-profile seguente associa il profilo di sicurezza AWS IoT Device Defender denominato Testprofile a tutti i dispositivi non registrati nella Regione us-west-2 di questo account AWS.

aws iot attach-security-profile \
    --security-profile-name Testprofile \
    --security-profile-target-arn "arn:aws:iot:us-west-2:123456789012:all/unregistered-things"

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Comandi di rilevamento nella Guida per gli sviluppatori di AWS IoT.

Come collegare un certificato a un oggetto

L’esempio attach-thing-principal seguente collega un certificato all’oggetto MyTemperatureSensor. Il certificato è identificato da un ARN. L’ARN di un certificato si trova nella console AWS IoT.

aws iot attach-thing-principal \
    --thing-name MyTemperatureSensor \
    --principal arn:aws:iot:us-west-2:123456789012:cert/2e1eb273792174ec2b9bf4e9b37e6c6c692345499506002a35159767055278e8

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Come gestire gli oggetti con il registro nella Guida per gli sviluppatori di AWS IoT.

Come annullare un’attività relativa alle azioni di mitigazione degli audit

L’esempio cancel-audit-mitigations-action-task seguente annulla l’applicazione delle azioni di mitigazione per l’attività specificata. Non è possibile annullare le attività già completate.

aws iot cancel-audit-mitigation-actions-task
    --task-id "myActionsTaskId"

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta CancelAuditMitigationActionsTask (Comandi delle operazioni di mitigazione) nella Guida per gli sviluppatori di AWS IoT.

Come annullare un’attività di audit

L’esempio cancel-audit-task seguente annulla un’attività di audit con l’ID di attività specificato. Non è possibile annullare un’attività completata.

aws iot cancel-audit-task \
    --task-id a3aea009955e501a31b764abe1bebd3d

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Comandi di auditing nella Guida per gli sviluppatori di AWS IoT.

Come annullare il trasferimento di un certificato in un altro account AWS

L’esempio cancel-certificate-transfer seguente annulla il trasferimento del certificato specificato. Il certificato viene identificato mediante il rispettivo ID. L’ID di un certificato si trova nella console AWS IoT.

aws iot cancel-certificate-transfer \
    --certificate-id f0f33678c7c9a046e5cc87b2b1a58dfa0beec26db78addd5e605d630e05c7fc8

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Trasferire un certificato a un altro account nella Guida per gli sviluppatori di AWS IoT Core.

Come annullare l’esecuzione di un processo su un dispositivo

L’esempio cancel-job-execution seguente annulla l’esecuzione del processo specificato su un dispositivo. Se il processo non è nello stato QUEUED, è necessario aggiungere il parametro --force.

aws iot cancel-job-execution \
    --job-id "example-job-03" \
    --thing-name "MyRPi"

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Creazione e gestione di processi (CLI) nella Guida per gli sviluppatori di AWS IoT.

Come annullare un processo

L’esempio cancel-job seguente annulla il processo specificato.

aws iot cancel-job \
    --job-job "example-job-03"

Output:

{
    "jobArn": "arn:aws:iot:us-west-2:123456789012:job/example-job-03",
    "jobId": "example-job-03",
    "description": "example job test"
}

Per ulteriori informazioni, consulta Creazione e gestione di processi (CLI) nella Guida per gli sviluppatori di AWS IoT.

Come annullare il sistema di autorizzazione predefinito

L’esempio clear-default-authorizer seguente annulla il sistema di autorizzazione personalizzato predefinito attualmente configurato. Dopo aver eseguito questo comando, non è presente alcun sistema di autorizzazione predefinito. In caso di utilizzo di un sistema di autorizzazione personalizzato, è necessario specificarlo in base al nome nelle intestazioni della richiesta HTTP.

aws iot clear-default-authorizer

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta ClearDefaultAuthorizer nella Documentazione di riferimento delle API AWS IoT.

Come confermare la destinazione di una regola dell’argomento

L’esempio confirm-topic-rule-destination seguente conferma la destinazione di una regola dell’argomento con un token di conferma ricevuto su un endpoint HTTP.

aws iot confirm-topic-rule-destination \
    --confirmation-token "AYADeIcmtq-ZkxfpiWIQqHWM5ucAXwABABVhd3MtY3J5cHRvLXB1YmxpYy1rZXkAREFxY1E0UmlGeDg0V21BZWZ1VjZtZWFRVUJJUktUYXJaN09OZlJOczJhRENSZmZYL3JHZC9PR3NNcis5T3ZlSitnQT09AAEAB2F3cy1rbXMAS2Fybjphd3M6a21zOnVzLWVhc3QtMTo5ODc5NTE4NTI0OTk6a2V5L2U4YmU3ODViLTU5NWMtNDcxYi1iOWJmLWQ2Y2I4ZjQxODlmNwC4AQIBAHhwz48UWTGWE1ua0P8U1hj27nsFzEaAdf6Hs2K_7wBheAF62zwMuk_A4dPiC6eyPGuMAAAAfjB8BgkqhkiG9w0BBwagbzBtAgEAMGgGCSqGSIb3DQEHATAeBglghkgBZQMEAS4wEQQM9vtRMpf9D3CiZ8sMAgEQgDuFd0Txy-aywpPqg8YEsa1lD4B40aJ2s1wEHKMybiF1RoOZzYisI0IvslzQY5UmCkqq3tV-3f7-nKfosgIAAAAADAAAEAAAAAAAAAAAAAAAAAAi9RMgy-V19V9m6Iw2xfbw_____wAAAAEAAAAAAAAAAAAAAAEAAAB1hw4SokgUcxiJ3gTO6n50NLJVpzyQR1UmPIj5sShqXEQGcOsWmXzpYOOx_PWyPVNsIFHApyK7Cc3g4bW8VaLVwOLkC83g6YaZAh7dFEl2-iufgrzTePl8RZYOWr0O6Aj9DiVzJZx-1iD6Pu-G6PUw1kaO7Knzs2B4AD0qfrHUF4pYRTvyUgBnMGUCMQC8ZRmhKqntd_c6Kgrow3bMUDBvNqo2qZr8Z8Jm2rzgseROlAnLgFLGpGShr99oSZkCMEd1v62NBRKX9HQXnybyF3fkg__-PIetJ803Z4IlIlF8xXlcdPGP-PV1dOXFemyL8g"

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Conferma della destinazione di una regola dell’argomento nella Guida per gli sviluppatori di AWS IoT.

Come creare una soppressione degli esiti di un audit

L’esempio create-audit-suppression seguente crea una soppressione degli esiti di un audit per una policy denominata “virtualMachinePolicy” contrassegnata come eccessivamente permissiva.

aws iot create-audit-suppression \
    --check-name IOT_POLICY_OVERLY_PERMISSIVE_CHECK \
    --resource-identifier policyVersionIdentifier={"policyName"="virtualMachinePolicy","policyVersionId"="1"} \
    --no-suppress-indefinitely \
    --expiration-date 2020-10-20

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Soppressioni della ricerca di audit nella Guida per gli sviluppatori di AWS IoT.

Come creare un sistema di autorizzazione personalizzato

L’esempio create-authorizer seguente crea un sistema di autorizzazione personalizzato che utilizza la funzione Lambda specificata come parte di un servizio di autenticazione personalizzato.

   aws iot create-authorizer \
       --authorizer-name "CustomAuthorizer" \
       --authorizer-function-arn "arn:aws:lambda:us-west-2:123456789012:function:CustomAuthorizerFunction" \
       --token-key-name "MyAuthToken" \
       --status ACTIVE \
       --token-signing-public-keys FIRST_KEY="-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA1uJOB4lQPgG/lM6ZfIwo
Z+7ENxAio9q6QD4FFqjGZsvjtYwjoe1RKK0U8Eq9xb5O3kRSmyIwTzwzm/f4Gf0Y
ZUloJ+t3PUUwHrmbYTAgTrCUgRFygjfgVwGCPs5ZAX4Eyqt5cr+AIHIiUDbxSa7p
zwOBKPeic0asNJpqT8PkBbRaKyleJh5oo81NDHHmVtbBm5A5YiJjqYXLaVAowKzZ
+GqsNvAQ9Jy1wI2VrEa1OfL8flDB/BJLm7zjpfPOHDJQgID0XnZwAlNnZcOhCwIx
50g2LW2Oy9R/dmqtDmJiVP97Z4GykxPvwlYHrUXY0iW1R3AR/Ac1NhCTGZMwVDB1
lQIDAQAB
-----END PUBLIC KEY-----"

Output:

{
    "authorizerName": "CustomAuthorizer",
    "authorizerArn": "arn:aws:iot:us-west-2:123456789012:authorizer/CustomAuthorizer2"
}

Per ulteriori informazioni, consulta CreateAuthorizer nella Documentazione di riferimento delle API AWS IoT.

Come creare un gruppo di fatturazione

L’esempio create-billing-group seguente crea un gruppo di fatturazione semplice denominato GroupOne.

aws iot create-billing-group \
    --billing-group-name GroupOne

Output:

{
    "billingGroupName": "GroupOne",
    "billingGroupArn": "arn:aws:iot:us-west-2:123456789012:billinggroup/GroupOne",
    "billingGroupId": "103de383-114b-4f51-8266-18f209ef5562"
}

Per ulteriori informazioni, consulta Gruppi di fatturazione nella Guida per gli sviluppatori di AWS IoT.

Come creare un certificato da una richiesta di firma del certificato (CSR)

L’esempio create-certificate-from-csr seguente crea un certificato di dispositivo da una CSR. È possibile utilizzare il comando openssl per creare una CSR.

aws iot create-certificate-from-csr \
    --certificate-signing-request=file://certificate.csr

Output:

{
    "certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/c0c57bbc8baaf4631a9a0345c957657f5e710473e3ddbee1428d216d54d53ac9",
        "certificateId": "c0c57bbc8baaf4631a9a0345c957657f5e710473e3ddbee1428d216d54d53ac9",
        "certificatePem": "<certificate-text>"
}

Per ulteriori informazioni, consulta CreateCertificateFromCSR nella Documentazione di riferimento delle API AWS IoT.

Come creare una metrica personalizzata pubblicata dai dispositivi su Device Defender

L’esempio create-custom-metric seguente crea una metrica personalizzata che misura la percentuale della batteria.

aws iot create-custom-metric \
    --metric-name "batteryPercentage" \
    --metric-type "number" \
    --display-name "Remaining battery percentage." \
    --region us-east-1 \
    --client-request-token "02ccb92b-33e8-4dfa-a0c1-35b181ed26b0"

Output:

{
    "metricName": "batteryPercentage",
    "metricArn": "arn:aws:iot:us-east-1:1234564789012:custommetric/batteryPercentage"
}

Per ulteriori informazioni, consulta Parametri personalizzati nella Guida per gli sviluppatori di AWS IoT Core.

Come creare una dimensione

L’esempio create-dimension seguente crea una dimensione con un singolo filtro di argomento denominato TopicFilterForAuthMessages.

aws iot create-dimension \
    --name TopicFilterForAuthMessages \
    --type TOPIC_FILTER \
    --string-values device/+/auth

Output:

{
    "name": "TopicFilterForAuthMessages",
    "arn": "arn:aws:iot:eu-west-2:123456789012:dimension/TopicFilterForAuthMessages"
}

Per ulteriori informazioni, consulta Comandi di rilevamento nella Guida per gli sviluppatori di AWS IoT.

Come creare una configurazione di dominio

L’esempio create-domain-configuration seguente crea una configurazione di dominio gestita da AWS con un tipo di servizio di DATA.

aws iot create-domain-configuration \
    --domain-configuration-name "additionalDataDomain" \
    --service-type "DATA"

Output:

{
    "domainConfigurationName": "additionalDataDomain",
    "domainConfigurationArn": "arn:aws:iot:us-west-2:123456789012:domainconfiguration/additionalDataDomain/dikMh"
}

Per ulteriori informazioni, consulta Endpoint configurabili nella Guida per gli sviluppatori di AWS IoT.

Come creare un gruppo di oggetti dinamico

L’esempio create-dynamic-thing-group seguente crea un gruppo di oggetti dinamico che contiene qualsiasi oggetto con un attributo di temperatura maggiore di 60 gradi. È necessario abilitare l’indicizzazione del parco AWS IoT prima di poter utilizzare gruppi di oggetti dinamici.

aws iot create-dynamic-thing-group \
    --thing-group-name "RoomTooWarm" \
    --query-string "attributes.temperature>60"

Output:

{
    "thingGroupName": "RoomTooWarm",
    "thingGroupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/RoomTooWarm",
    "thingGroupId": "9d52492a-fc87-43f4-b6e2-e571d2ffcad1",
    "indexName": "AWS_Things",
    "queryString": "attributes.temperature>60",
    "queryVersion": "2017-09-30"
}

Per ulteriori informazioni, consulta Gruppi di oggetti dinamici nella Guida per gli sviluppatori di AWS IoT.

Esempio 1: per creare un processo

L’esempio create-job seguente crea un semplice processo AWS IoT che invia un documento JSON al dispositivo MyRaspberryPi.

aws iot create-job \
    --job-id "example-job-01" \
    --targets "arn:aws:iot:us-west-2:123456789012:thing/MyRaspberryPi" \
    --document file://example-job.json \
    --description "example job test" \
    --target-selection SNAPSHOT

Output:

{
    "jobArn": "arn:aws:iot:us-west-2:123456789012:job/example-job-01",
    "jobId": "example-job-01",
    "description": "example job test"
}

Esempio 2: per creare un processo continuo

L’esempio create-job seguente crea un processo che continua a essere eseguito dopo che gli oggetti specificati come destinazioni hanno completato il processo. In questo esempio, la destinazione è un gruppo di oggetti e quindi, quando vengono aggiunti nuovi dispositivi al gruppo, il processo continuo viene eseguito su questi nuovi oggetti.

aws iot create-job --job-id "example-job-04" --targets "arn:aws:iot:us-west-2:123456789012:thinggroup/DeadBulbs" --document file://example-job.json --description "example continuous job" --target-selection CONTINUOUS

Output:

{
    "jobArn": "arn:aws:iot:us-west-2:123456789012:job/example-job-04",
    "jobId": "example-job-04",
    "description": "example continuous job"
}

Per ulteriori informazioni, consulta Creazione e gestione di processi (CLI) nella Guida per gli sviluppatori di AWS IoT.

Come creare una coppia di chiavi RSA e generare un certificato X.509

L’esempio create-keys-and-certificate seguente crea una coppia di chiavi RSA a 2.048 bit e genera un certificato X.509 utilizzando la chiave pubblica emessa. Poiché questa è l’unica occasione in cui AWS IoT fornisce la chiave privata per questo certificato, assicurati di conservarlo in un luogo sicuro.

aws iot create-keys-and-certificate \
    --certificate-pem-outfile "myTest.cert.pem" \
    --public-key-outfile "myTest.public.key" \
    --private-key-outfile "myTest.private.key"

Output:

{
    "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 omittted for security reasons\n-----END RSA PRIVATE KEY-----\n"
    }
}

Per ulteriori informazioni, consulta Creazione e registrazione di un certificato del dispositivo AWS IoT nella Guida per gli sviluppatori di AWS IoT.

Come creare un’azione di mitigazione

L’esempio create-mitigation-action seguente definisce un’azione di mitigazione denominata AddThingsToQuarantineGroup1Action che, una volta applicata, sposta gli oggetti nel gruppo di oggetti denominato QuarantineGroup1. Questa azione sostituisce i gruppi di oggetti dinamici.

aws iot create-mitigation-action --cli-input-json file::params.json

Contenuto di params.json.

{
    "actionName": "AddThingsToQuarantineGroup1Action",
    "actionParams": {
        "addThingsToThingGroupParams": {
            "thingGroupNames": [
                "QuarantineGroup1"
            ],
            "overrideDynamicGroups": true
        }
    },
    "roleArn": "arn:aws:iam::123456789012:role/service-role/MoveThingsToQuarantineGroupRole"
}

Output:

{
    "actionArn": "arn:aws:iot:us-west-2:123456789012:mitigationaction/AddThingsToQuarantineGroup1Action",
    "actionId": "992e9a63-a899-439a-aa50-4e20c52367e1"
}

Per ulteriori informazioni, consulta CreateMitigationAction (Comandi delle operazioni di mitigazione) nella Guida per gli sviluppatori di AWS IoT.

Come creare un aggiornamento OTA da utilizzare con Amazon FreeRTOS

L’esempio create-ota-update seguente crea un oggetto AWS IoT OTAUpdate in un gruppo di destinazione di oggetti o gruppi. Questo fa parte di un aggiornamento via etere di Amazon FreeRTOS che consente di implementare nuove immagini del firmware in un singolo dispositivo o un gruppo di dispositivi.

aws iot create-ota-update \
    --cli-input-json file://create-ota-update.json

Contenuto di create-ota-update.json.

{
    "otaUpdateId": "ota12345",
    "description": "A critical update needed right away.",
    "targets": [
        "device1",
        "device2",
        "device3",
        "device4"
    ],
    "targetSelection": "SNAPSHOT",
    "awsJobExecutionsRolloutConfig": {
        "maximumPerMinute": 10
    },
    "files": [
        {
          "fileName": "firmware.bin",
          "fileLocation": {
            "stream": {
              "streamId": "004",
              "fileId":123
            }
          },
          "codeSigning": {
            "awsSignerJobId": "48c67f3c-63bb-4f92-a98a-4ee0fbc2bef6"
          }
        }
    ]
    "roleArn": "arn:aws:iam:123456789012:role/service-role/my_ota_role"
}

Output:

{
     "otaUpdateId": "ota12345",
     "awsIotJobId": "job54321",
     "otaUpdateArn": "arn:aws:iot:us-west-2:123456789012:otaupdate/itsaupdate",
     "awsIotJobArn": "arn:aws:iot:us-west-2:123456789012:job/itsajob",
     "otaUpdateStatus": "CREATE_IN_PROGRESS"
}

Per ulteriori informazioni, consulta CreateOTAUpdate nella Documentazione di riferimento delle API AWS IoT.

Come aggiornare una policy con una nuova versione

L’esempio create-policy-version seguente aggiorna una definizione di policy, creando una nuova versione di policy. Questo esempio imposta inoltre la nuova versione come predefinita.

aws iot create-policy-version \
    --policy-name UpdateDeviceCertPolicy \
    --policy-document file://policy.json \
    --set-as-default

Contenuto di policy.json.

{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action":  "iot:UpdateCertificate",
            "Resource": "*"
        }
    ]
}

Output:

{
    "policyArn": "arn:aws:iot:us-west-2:123456789012:policy/UpdateDeviceCertPolicy",
    "policyDocument": "{ \"Version\": \"2012-10-17\", \"Statement\": [ { \"Effect\": \"Allow\", \"Action\":  \"iot:UpdateCertificate\", \"Resource\": \"*\" } ] }",
    "policyVersionId": "2",
    "isDefaultVersion": true
}

Per ulteriori informazioni, consulta Policy AWS IoT nella Guida per gli sviluppatori di AWS IoT.

Come creare una policy AWS IoT

L’esempio create-policy seguente crea una policy AWS IoT denominata TemperatureSensorPolicy. Il file policy.json contiene istruzioni che consentono azioni di policy AWS IoT.

aws iot create-policy \
    --policy-name TemperatureSensorPolicy \
    --policy-document file://policy.json

Contenuto di policy.json.

{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "iot:Publish",
                "iot:Receive"
            ],
            "Resource": [
                "arn:aws:iot:us-west-2:123456789012:topic/topic_1",
                "arn:aws:iot:us-west-2:123456789012:topic/topic_2"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
                "iot:Subscribe"
            ],
            "Resource": [
                "arn:aws:iot:us-west-2:123456789012:topicfilter/topic_1",
                "arn:aws:iot:us-west-2:123456789012:topicfilter/topic_2"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
                "iot:Connect"
            ],
            "Resource": [
                "arn:aws:iot:us-west-2:123456789012:client/basicPubSub"
            ]
        }
    ]
}

Output:

{
    "policyName": "TemperatureSensorPolicy",
    "policyArn": "arn:aws:iot:us-west-2:123456789012:policy/TemperatureSensorPolicy",
    "policyDocument": "{
        \"Version\": \"2012-10-17\",
        \"Statement\": [
            {
                \"Effect\": \"Allow\",
                \"Action\": [
                    \"iot:Publish\",
                    \"iot:Receive\"
                ],
                \"Resource\": [
                    \"arn:aws:iot:us-west-2:123456789012:topic/topic_1\",
                    \"arn:aws:iot:us-west-2:123456789012:topic/topic_2\"
                ]
            },
            {
                \"Effect\": \"Allow\",
                \"Action\": [
                    \"iot:Subscribe\"
                ],
                \"Resource\": [
                    \"arn:aws:iot:us-west-2:123456789012:topicfilter/topic_1\",
                    \"arn:aws:iot:us-west-2:123456789012:topicfilter/topic_2\"
                ]
            },
            {
                \"Effect\": \"Allow\",
                \"Action\": [
                    \"iot:Connect\"
                ],
                \"Resource\": [
                    \"arn:aws:iot:us-west-2:123456789012:client/basicPubSub\"
                ]
            }
        ]
    }",
    "policyVersionId": "1"
}

Per ulteriori informazioni, consulta Policy AWS IoT nella Guida per gli sviluppatori di AWS IoT.

Come creare un’attestazione di provisioning

L’esempio create-provisioning-claim seguente crea un’attestazione di provisioning da un modello di provisioning.

aws iot create-provisioning-claim \
    --template-name MyTestProvisioningTemplate

Output:

{
    "certificateId": "78de02184b2ce80cf8fb709bda59e62b19fb83513590483eb0434589476ab09f",
    "certificatePem": "-----BEGIN CERTIFICATE-----\nMIIDdzCCAl+gAwIBAgIUXSZhEBLztMLZ2fHG
14gV0NymYY0wDQYJKoZIhvcNAQEL\nBQAwfjELMAkGA1UEBhMCVVMxEzARBgNVBAgMCldhc2hpbmd0b24xEDAOBg
VBAcM\nB1NlYXR0bGUxGDAWBgNVBAoMD0FtYXpvbi5jb20gSW5jLjEgMB4GA1UECwwXQW1h\nem9uIElvVCBQcm9
2aXNpb25pbmcxDDAKBgNVBAUTAzEuMDAeFw0yMDA3MjgxNjQ0\nMDZaFw0yMDA3MjgxNjUxMDZaMEsxSTBHBgNVB
AMMQDFhNDEyM2VkNmIxYjU3MzE3\nZTgzMTJmY2MzN2FiNTdhY2MzYTZkZGVjOGQ5OGY3NzUwMWRlMjc0YjhmYTQ
xN2Iw\nggEiMA0GCSqGSIb3EXAMPLEAA4IBDwAwggEKAoIBAQDBhKI94ktKLqTwnj+ayOq1\nTAJt/N6s6IJDZvl
rYjkC0E7wzaeY3TprWk03S29vUzVuEOXHXQXZbihgpg2m6fza\nkWm9/wpjzE9ny5+xkPGVH4Wnwz7yK5m8S0agL
T96cRBSWnWmonOWdY0GKVzni0CA\n+iyGudgrFKm7Eae/v18oXrf82KtOAGO4xG0KE2WKYHsT1fx3c9xZhlXP/eX
Lhv00\n+lGp0WVw9PbhKfrxliKJ5q6sL5nVUaUHq6hlQPYwsATeOvAp3u0ak5zgTyL0fg7Y\nPyKk6VYwLW62r+V
YBSForEMOAhkq3LsP/rjxpEKmi2W4lPVS6oFZRKcD+H1Kyil5\nAgMBAAGjIDAeMAwGA1UdEwEB/wQCMAAwDgYDV
R0PAQH/BAQDAgeAMA0GCSqGSIb3\nDQEBCwUAA4IBAQAGgix2k6nVqbZFKq97/fZBzLGS0dyz5rT/E41cDIRX+1j
EPW41\nw0D+2sXheCZLZZnSkvIiP74IToNeXDrjdcaodeGFVHIElRjhMIq+4ZebPbRLtidF\nRc2hfcTAlqq9Z6v
5Vk6BeM1tu0RqH1wPoVUccLPya8EjNCbnJZUmGdOfrN/Y9pho\n5ikV+HPeZhG/k6dhE2GsQJyKFVHL/uBgKSily
1bRyWU1r6qcpWBNBHjUoD7HgOwD\nnzMh4XRb2FQDsqFalkCSYmeL8IVC49sgPD9Otyp5uteGMTy62usAAUQdq/f
ZvrWg\nOkFpwMVnGKVKT7Kg0kKOLzKWOBB2Jm4/gmrJ\n-----END CERTIFICATE-----\n",
    "keyPair": {
        "PublicKey": "-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCg
KCAQEAwYSiPeJLSi6k8J4/msjq\ntUwCbfzerOiCQ2b5a2I5AtBO8M2nmN06a1pNN0tvb1M1bhDlx10F2W4oYKYN
pun8\n2pFpvf8KY8xPZ8ufsZDxlR+Fp8M+8iuZvEtGoC0/enEQUlp1pqJzlnWNBilc54tA\ngPoshrnYKxSpuxGn
v79fKF63/NirTgBjuMRtChNlimEXAMPLE3PcWYZVz/3ly4b9\nNPpRqdFlcPT24Sn68ZYiieaurC+Z1VGlB6uoZU
D2MLAE3jrwKd7tGpOc4E8i9H4O\n2D8ipOlWMC1utq/lWAUhaKxDDgIZKty7D/648aRCpotluJT1UuqBWUSnA/h9
Ssop\neQIDAQAB\n-----END PUBLIC KEY-----\n",
        "PrivateKey": "-----BEGIN RSA PRIVATE KEY-----\nMIIEowIBAAKCAQEAwYSiPeJLSi6k8J4/
msjqtUwCbfzerOiCQ2b5a2I5AtBO8M2n\nmN06a1pNN0tvb1M1bhDlx10F2W4oYKYNpun82pFpvf8KY8xPZ8ufsZ
DxlR+Fp8M+\n8iuZvEtGoC0/enEQUlp1pqJzlnWNBilc54tAgPoshrnYKxSpuxGnv79fKF63/Nir\nTgBjuMRtCh
NlimB7E9X8d3PcWYZVz/3ly4b9NPpRqdFlcPT24Sn68ZYiieaurC+Z\n1VGlB6uoZUD2MLAE3jrwKd7tGpOc4E8i
9H4O2D8ipOlWMC1utq/lWAUhaKxDDgIZ\nKty7D/648aRCpotluJT1UuqBWUSnA/h9SsopeQIDAQABAoIBAEAybN
QUtx9T2/nK\ntZT2pA4iugecxI4dz+DmT0XVXs5VJmrx/nBSq6ejXExEpSIMO4RY7LE3ZdJcnd56\nF7tQkkY7yR
VzfxHeXFU1krOIPuxWebNOrRoPZr+1RSer+wv2aBC525+88pVuR6tM\nm3pgkrR2ycCj9FdOUoQxdjHBHaM5PDmJ
9aSxCKdg3nReepeGwsR2TQA+m2vVxWk7\nou0+91eTOP+/QfP7P8ZjOIkO2XivlRcVDyN/E4QXPKuIkM/8vS8VK+
E9pATQ0MtB\n2lw8R/YU5AJd6jlEXAMPLEGU2UzRzInNWiLtkPPPqgqXXhxOf+mxByjcMalVJk0L\nhOG2ROUCgY
EA+ROcHNHy/XbsP7FihOhEh+6Q2QxQ2ncBUPYbBazrR8Hn+7SCICQK\nVyYfd8Ajfq3e7RsKVL5SlMBp7Slidxak
bIn28fKfPn62DaemGCIoyDgLpF+eUxBx\ngzbCiBZga8brfurza43UZjKZLpg3hq721+FeAiXi1Nma4Yr9YWEHEN
8CgYEAxuWt\npzdWWmsiFzfsAw0sy9ySDA/xr5WRWzJyAqUsjsks6rxNzWebpufnYHcmtW7pLdqM\nkboHwN2pXa
kmZvrk2nKkEMq5brBYGDXuxDe+V369Bianx8aZFyIsckA7OwXW1w1h\ngRC5rQ4XOgp3+Jmw7eAO8LRYDjaN846+
QbtO2KcCgYAWS0UL51bijQR0ZwI0dz27\nFQVuCAYsp748aurcRTACCj8jbnK/QbqTNlxWsaH7ssBjZKo2D5sAqY
BRtASWODab\naHXsDhVm2Jye+ESLoHMaCLoyCkT3ll8yqXIcEDStMO7fO1Ryag164EiJvSIrMfny\nNL/fXVjCSH
/udCxdzPt+7QKBgQC+LAD7rxdr4J9538hTqpc4XK9vxRbrMXEH55XH\nHbMa2xONZXpmeTgEQBukyohCVceyRhK9
i0e6irZTjVXghOeoTpC8VXkzcnzouTiQ\neFQQSGfnp7Ioe6UIz23715pKduzSNkMSKrG924ktv7CyDBF1gBQI5g
aDoHnddJBJ\nPRTIZQKBgA8MASXtTxQntRwXXzR92U0vAighiuRkB/mx9jQpUcK1qiqHbkAMqgNF\nPFCBYIUbFT
iYKKKeJNbyJQvjfsJCkAnaFJ+RnTxk0Q6Wjm20peJ/ii4QiDdnigoE\nvdlc5cFQewWb4/zqAtPdinkPlN94ileI
79XQdc7RlJ0jpgTimL+V\n-----END RSA PRIVATE KEY-----\n"
    },
    "expiration": 1595955066.0
}

Per ulteriori informazioni, consulta Provisioning per utente attendibile nella Guida per gli sviluppatori di AWS IoT Core.

Come creare una versione per un modello di provisioning

L’esempio seguente crea una versione per il modello di provisioning specificato. Il corpo della nuova versione viene fornito nel file template.json.

aws iot create-provisioning-template-version \
    --template-name widget-template \
    --template-body file://template.json

Contenuto di template.json.

{
    "Parameters" : {
        "DeviceLocation": {
            "Type": "String"
        }
    },
    "Mappings": {
        "LocationTable": {
            "Seattle": {
                "LocationUrl": "https://example.aws"
            }
        }
    },
    "Resources" : {
        "thing" : {
            "Type" : "AWS::IoT::Thing",
            "Properties" : {
                "AttributePayload" : {
                    "version" : "v1",
                    "serialNumber" : "serialNumber"
                },
                "ThingName" : {"Fn::Join":["",["ThingPrefix_",{"Ref":"SerialNumber"}]]},
                "ThingTypeName" : {"Fn::Join":["",["ThingTypePrefix_",{"Ref":"SerialNumber"}]]},
                "ThingGroups" : ["widgets", "WA"],
                "BillingGroup": "BillingGroup"
            },
            "OverrideSettings" : {
                "AttributePayload" : "MERGE",
                "ThingTypeName" : "REPLACE",
                "ThingGroups" : "DO_NOTHING"
            }
        },
        "certificate" : {
            "Type" : "AWS::IoT::Certificate",
            "Properties" : {
                "CertificateId": {"Ref": "AWS::IoT::Certificate::Id"},
                "Status" : "Active"
            }
        },
        "policy" : {
            "Type" : "AWS::IoT::Policy",
            "Properties" : {
                "PolicyDocument" : {
                    "Version":"2012-10-17",		 	 	 
                    "Statement": [{
                        "Effect": "Allow",
                        "Action":["iot:Publish"],
                        "Resource": ["arn:aws:iot:us-east-1:123456789012:topic/foo/bar"]
                    }]
                }
            }
        }
    },
    "DeviceConfiguration": {
        "FallbackUrl": "https://www.example.com/test-site",
        "LocationUrl": {
            "Fn::FindInMap": ["LocationTable",{"Ref": "DeviceLocation"}, "LocationUrl"]}
        }
    }
}

Output:

{
    "templateArn": "arn:aws:iot:us-east-1:123456789012:provisioningtemplate/widget-template",
    "templateName": "widget-template",
    "versionId": 2,
    "isDefaultVersion": false
}

Per ulteriori informazioni, consulta Tunnel sicuro di AWS IoT nella Guida per gli sviluppatori di AWS IoT Core.

Come creare un modello di provisioning

L’esempio create-provisioning-template seguente crea un modello di provisioning come definito dal file template.json.

aws iot create-provisioning-template \
    --template-name widget-template \
    --description "A provisioning template for widgets" \
    --provisioning-role-arn arn:aws:iam::123456789012:role/Provision_role \
    --template-body file://template.json

Contenuto di template.json.

{
    "Parameters" : {
        "DeviceLocation": {
            "Type": "String"
        }
    },
    "Mappings": {
        "LocationTable": {
            "Seattle": {
                "LocationUrl": "https://example.aws"
            }
        }
    },
    "Resources" : {
        "thing" : {
            "Type" : "AWS::IoT::Thing",
            "Properties" : {
                "AttributePayload" : {
                    "version" : "v1",
                    "serialNumber" : "serialNumber"
                },
                "ThingName" : {"Fn::Join":["",["ThingPrefix_",{"Ref":"SerialNumber"}]]},
                "ThingTypeName" : {"Fn::Join":["",["ThingTypePrefix_",{"Ref":"SerialNumber"}]]},
                "ThingGroups" : ["widgets", "WA"],
                "BillingGroup": "BillingGroup"
            },
            "OverrideSettings" : {
                "AttributePayload" : "MERGE",
                "ThingTypeName" : "REPLACE",
                "ThingGroups" : "DO_NOTHING"
            }
        },
        "certificate" : {
            "Type" : "AWS::IoT::Certificate",
            "Properties" : {
                "CertificateId": {"Ref": "AWS::IoT::Certificate::Id"},
                "Status" : "Active"
            }
        },
        "policy" : {
            "Type" : "AWS::IoT::Policy",
            "Properties" : {
                "PolicyDocument" : {
                    "Version":"2012-10-17",		 	 	 
                    "Statement": [{
                        "Effect": "Allow",
                        "Action":["iot:Publish"],
                        "Resource": ["arn:aws:iot:us-east-1:504350838278:topic/foo/bar"]
                    }]
                }
            }
        }
    },
    "DeviceConfiguration": {
        "FallbackUrl": "https://www.example.com/test-site",
        "LocationUrl": {
            "Fn::FindInMap": ["LocationTable",{"Ref": "DeviceLocation"}, "LocationUrl"]}
        }
    }
}

Output:

{
    "templateArn": "arn:aws:iot:us-east-1:123456789012:provisioningtemplate/widget-template",
    "templateName": "widget-template",
    "defaultVersionId": 1
}

Per ulteriori informazioni, consulta Tunnel sicuro di AWS IoT nella Guida per gli sviluppatori di AWS IoT Core.

Come creare un alias di ruolo

L’esempio create-role-alias seguente crea un alias di ruolo denominato LightBulbRole per il ruolo specificato.

aws iot create-role-alias \
    --role-alias LightBulbRole \
    --role-arn arn:aws:iam::123456789012:role/lightbulbrole-001

Output:

{
    "roleAlias": "LightBulbRole",
    "roleAliasArn": "arn:aws:iot:us-west-2:123456789012:rolealias/LightBulbRole"
}

Per ulteriori informazioni, consulta CreateRoleAlias nella Documentazione di riferimento delle API AWS IoT.

Come creare un audit pianificato

L’esempio create-scheduled-audit seguente crea un audit pianificato eseguito settimanalmente, di mercoledì, per verificare se i certificati CA o di dispositivo sono in scadenza.

aws iot create-scheduled-audit \
    --scheduled-audit-name WednesdayCertCheck \
    --frequency WEEKLY \
    --day-of-week WED \
    --target-check-names CA_CERTIFICATE_EXPIRING_CHECK DEVICE_CERTIFICATE_EXPIRING_CHECK

Output:

{
    "scheduledAuditArn": "arn:aws:iot:us-west-2:123456789012:scheduledaudit/WednesdayCertCheck"
}

Per ulteriori informazioni, consulta Comandi di auditing nella Guida per gli sviluppatori di AWS IoT.

Come creare un profilo di sicurezza

L’esempio create-security-profile seguente crea un profilo di sicurezza che verifica se la larghezza di banda cellulare supera una soglia o se si verificano più di 10 errori di autorizzazione in un periodo di 5 minuti.

aws iot create-security-profile \
    --security-profile-name PossibleIssue \
    --security-profile-description "Check to see if authorization fails 10 times in 5 minutes or if cellular bandwidth exceeds 128"  \
    --behaviors "[{\"name\":\"CellularBandwidth\",\"metric\":\"aws:message-byte-size\",\"criteria\":{\"comparisonOperator\":\"greater-than\",\"value\":{\"count\":128},\"consecutiveDatapointsToAlarm\":1,\"consecutiveDatapointsToClear\":1}},{\"name\":\"Authorization\",\"metric\":\"aws:num-authorization-failures\",\"criteria\":{\"comparisonOperator\":\"less-than\",\"value\":{\"count\":10},\"durationSeconds\":300,\"consecutiveDatapointsToAlarm\":1,\"consecutiveDatapointsToClear\":1}}]"

Output:

{
    "securityProfileName": "PossibleIssue",
    "securityProfileArn": "arn:aws:iot:us-west-2:123456789012:securityprofile/PossibleIssue"
}

Per ulteriori informazioni, consulta Comandi di rilevamento nella Guida per gli sviluppatori di AWS IoT.

Come creare un flusso per la distribuzione di uno o più file di grandi dimensioni in blocchi su MQTT

L’esempio create-stream seguente crea un flusso per la distribuzione di uno o più file di grandi dimensioni in blocchi su MQTT. Un flusso trasporta byte di dati in blocchi o blocchi in pacchetti come messaggi MQTT da un'origine come S3. A un flusso possono essere associati uno o più file.

aws iot create-stream \
    --cli-input-json file://create-stream.json

Contenuto di create-stream.json.

{
    "streamId": "stream12345",
    "description": "This stream is used for Amazon FreeRTOS OTA Update 12345.",
    "files": [
        {
            "fileId": 123,
            "s3Location": {
                "bucket":"codesign-ota-bucket",
                "key":"48c67f3c-63bb-4f92-a98a-4ee0fbc2bef6"
            }
        }
    ],
    "roleArn": "arn:aws:iam:123456789012:role/service-role/my_ota_stream_role"
}

Output:

{
     "streamId": "stream12345",
     "streamArn": "arn:aws:iot:us-west-2:123456789012:stream/stream12345",
     "description": "This stream is used for Amazon FreeRTOS OTA Update 12345.",
     "streamVersion": "1"
}

Per ulteriori informazioni, consulta CreateStream nella Documentazione di riferimento delle API AWS IoT.

Esempio 1: per creare un gruppo di oggetti

L’esempio create-thing-group seguente crea un gruppo di oggetti denominato LightBulbs con una descrizione e due attributi.

aws iot create-thing-group \
    --thing-group-name LightBulbs \
    --thing-group-properties "thingGroupDescription=\"Generic bulb group\", attributePayload={attributes={Manufacturer=AnyCompany,wattage=60}}"

Output:

{
    "thingGroupName": "LightBulbs",
    "thingGroupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/LightBulbs",
    "thingGroupId": "9198bf9f-1e76-4a88-8e8c-e7140142c331"
}

Esempio 2: per creare un gruppo di oggetti che fa parte di un gruppo principale

L’esempio create-thing-group seguente crea un gruppo di oggetti denominato HalogenBulbs con un gruppo di oggetti principale denominato LightBulbs.

aws iot create-thing-group \
    --thing-group-name HalogenBulbs \
    --parent-group-name LightBulbs

Output:

{
    "thingGroupName": "HalogenBulbs",
    "thingGroupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/HalogenBulbs",
    "thingGroupId": "f4ec6b84-b42b-499d-9ce1-4dbd4d4f6f6e"
}

Per ulteriori informazioni, consulta Gruppi di oggetti nella Guida per gli sviluppatori di AWS IoT.

Come definire un tipo di oggetto

L’esempio create-thing-type seguente definisce un tipo di oggetto e gli attributi associati.

aws iot create-thing-type \
    --thing-type-name "LightBulb" \
    --thing-type-properties "thingTypeDescription=light bulb type, searchableAttributes=wattage,model"

Output:

{
    "thingTypeName": "LightBulb",
    "thingTypeArn": "arn:aws:iot:us-west-2:123456789012:thingtype/LightBulb",
    "thingTypeId": "ce3573b0-0a3c-45a7-ac93-4e0ce14cd190"
}

Per ulteriori informazioni, consulta Tipi di oggetti nella Guida per gli sviluppatori di AWS IoT.

Esempio 1: per creare un record di oggetti nel registro

L’esempio create-thing seguente crea una voce per un dispositivo nel registro di oggetti AWS IoT.

aws iot create-thing \
    --thing-name SampleIoTThing

Output:

{
    "thingName": "SampleIoTThing",
    "thingArn": "arn:aws:iot:us-west-2: 123456789012:thing/SampleIoTThing",
    "thingId": " EXAMPLE1-90ab-cdef-fedc-ba987EXAMPLE "
}

Esempio 2: per definire un oggetto associato a un tipo di oggetto

L’esempio create-thing seguente crea un oggetto con il tipo specificato e i relativi attributi.

aws iot create-thing \
    --thing-name "MyLightBulb" \
    --thing-type-name "LightBulb" \
    --attribute-payload "{"attributes": {"wattage":"75", "model":"123"}}"

Output:

{
    "thingName": "MyLightBulb",
    "thingArn": "arn:aws:iot:us-west-2:123456789012:thing/MyLightBulb",
    "thingId": "40da2e73-c6af-406e-b415-15acae538797"
}

Per ulteriori informazioni, consulta Come gestire gli oggetti con il registro e Tipi di oggetti nella Guida per gli sviluppatori di AWS IoT.

Come creare la destinazione di una regola dell’argomento

L’esempio create-topic-rule-destination seguente crea una destinazione di regole dell’argomento per un endpoint HTTP.

aws iot create-topic-rule-destination \
    --destination-configuration httpUrlConfiguration={confirmationUrl=https://example.com}

Output:

{
    "topicRuleDestination": {
        "arn": "arn:aws:iot:us-west-2:123456789012:ruledestination/http/a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
        "status": "IN_PROGRESS",
        "statusReason": "Awaiting confirmation. Confirmation message sent on 2020-07-09T22:47:54.154Z; no response received from the endpoint.",
        "httpUrlProperties": {
            "confirmationUrl": "https://example.com"
        }
    }
}

Per ulteriori informazioni, consulta Creazione della destinazione di una regola dell’argomento nella Guida per gli sviluppatori di AWS IoT.

Come creare una regola che invia un avviso Amazon SNS

L’esempio create-topic-rule seguente crea una regola che invia un messaggio Amazon SNS quando le letture del livello di umidità del terreno, rilevate in un device shadow, sono basse.

aws iot create-topic-rule \
    --rule-name "LowMoistureRule" \
    --topic-rule-payload file://plant-rule.json

L’esempio richiede il salvataggio del seguente codice JSON in un file denominato plant-rule.json:

{
    "sql": "SELECT * FROM '$aws/things/MyRPi/shadow/update/accepted' WHERE state.reported.moisture = 'low'\n",
    "description": "Sends an alert whenever soil moisture level readings are too low.",
    "ruleDisabled": false,
    "awsIotSqlVersion": "2016-03-23",
    "actions": [{
            "sns": {
                "targetArn": "arn:aws:sns:us-west-2:123456789012:MyRPiLowMoistureTopic",
                "roleArn": "arn:aws:iam::123456789012:role/service-role/MyRPiLowMoistureTopicRole",
                "messageFormat": "RAW"
            }
    }]
}

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Creating an AWS IoT Rule nella Guida per gli sviluppatori di AWS IoT.

Come disabilitare tutti i controlli di audit per l’account AWS

L’esempio delete-account-audit-configuration seguente ripristina le impostazioni predefinite per AWS IoT Device Defender per questo account, disabilitando tutti i controlli di audit e cancellando i dati di configurazione. Elimina inoltre tutti gli audit pianificati per questo account. Utilizza questo comando con cautela.

aws iot delete-account-audit-configuration \
    --delete-scheduled-audits

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Comandi di auditing nella Guida per gli sviluppatori di AWS IoT.

Come eliminare una soppressione degli esiti di un audit

L’esempio delete-audit-suppression seguente elimina una soppressione degli esiti di un audit per DEVICE_CERTIFICATE_EXPIRING_CHECK.

aws iot delete-audit-suppression \
    --check-name DEVICE_CERTIFICATE_EXPIRING_CHECK \
    --resource-identifier deviceCertificateId="c7691e<shortened>"

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Soppressioni della ricerca di audit nella Guida per gli sviluppatori di AWS IoT.

Come eliminare un sistema di autorizzazione personalizzato

L’esempio delete-authorizer seguente elimina il sistema di autorizzazione denominato CustomAuthorizer. Un sistema di autorizzazione personalizzato deve trovarsi nello stato INACTIVE prima di poterlo eliminare.

aws iot delete-authorizer \
    --authorizer-name CustomAuthorizer

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta DeleteAuthorizer nella Guida per gli sviluppatori di AWS IoT.

Come eliminare un gruppo di fatturazione

L’esempio delete-billing-group seguente elimina il gruppo di fatturazione specificato. È possibile eliminare un gruppo di fatturazione anche se contiene uno o più oggetti.

aws iot delete-billing-group \
    --billing-group-name BillingGroupTwo

Il comando non produce output.

Per ulteriori informazioni, consulta Gruppi di fatturazione nella Guida per gli sviluppatori di AWS IoT.

Come eliminare un certificato CA

L’esempio delete-ca-certificate seguente elimina il certificato CA con l’ID specificato.

aws iot delete-ca-certificate \
    --certificate-id f4efed62c0142f16af278166f61962501165c4f0536295207426460058cd1467

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta DeleteCACertificate nella Documentazione di riferimento delle API AWS IoT.

Come eliminare un certificato di dispositivo

L’esempio delete-certificate seguente elimina il certificato di dispositivo con l’ID specificato.

aws iot delete-certificate \
    --certificate-id c0c57bbc8baaf4631a9a0345c957657f5e710473e3ddbee1428d216d54d53ac9

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta DeleteCertificate nella Documentazione di riferimento delle API AWS IoT.

Come eliminare una metrica personalizzata

L’esempio delete-custom-metric seguente elimina una metrica personalizzata.

aws iot delete-custom-metric \
    --metric-name batteryPercentage \
    --region us-east-1

Output:

HTTP 200

Per ulteriori informazioni, consulta Parametri personalizzati nella Guida per gli sviluppatori di AWS IoT Core.

Come eliminare una dimensione

L’esempio delete-dimension seguente elimina una dimensione denominata TopicFilterForAuthMessages.

aws iot delete-dimension \
    --name TopicFilterForAuthMessages

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Comandi di rilevamento nella Guida per gli sviluppatori di AWS IoT.

Come eliminare una configurazione di dominio

L’esempio delete-domain-configuration seguente elimina una configurazione di dominio denominata additionalDataDomain dall’account AWS.

aws iot delete-domain-configuration \
    --domain-configuration-name "additionalDataDomain" \
    --domain-configuration-status "OK"

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Endpoint configurabili nella Guida per gli sviluppatori di AWS IoT.

Come eliminare un gruppo di oggetti dinamico

L’esempio delete-dynamic-thing-group seguente elimina il gruppo di oggetti dinamici specificato.

aws iot delete-dynamic-thing-group \
    --thing-group-name "RoomTooWarm"

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Gruppi di oggetti dinamici nella Guida per gli sviluppatori di AWS IoT.

Come eliminare l’esecuzione di un processo

L’esempio delete-job-execution seguente elimina l’esecuzione del processo specificato su un dispositivo. Utilizza describe-job-execution per ottenere il numero di esecuzione.

aws iot delete-job-execution
    --job-id "example-job-02"
    --thing-name "MyRaspberryPi"
    --execution-number 1

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Creazione e gestione di processi (CLI) nella Guida per gli sviluppatori di AWS IoT.

Come eliminare un processo

L’esempio delete-job seguente elimina il processo specificato. Specificando l’opzione --force, il processo viene eliminato anche se lo stato è IN_PROGRESS.

aws iot delete-job \
    --job-id "example-job-04" \
    --force

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Creazione e gestione di processi (CLI) nella Guida per gli sviluppatori di AWS IoT.

Come eliminare un’azione di mitigazione

L’esempio delete-mitigation-action seguente elimina l’azione di mitigazione specificata.

aws iot delete-mitigation-action \
    --action-name AddThingsToQuarantineGroup1Action

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta DeleteMitigationAction (Comandi delle operazioni di mitigazione) nella Guida per gli sviluppatori di AWS IoT.

Come eliminare un aggiornamento OTA

L’esempio delete-ota-update seguente elimina l’aggiornamento OTA specificato.

aws iot delete-ota-update \
    --ota-update-id ota12345 \
    --delete-stream \
    --force-delete-aws-job

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta DeleteOTAUpdate nella Documentazione di riferimento delle API AWS IoT.

Come eliminare una versione di policy

L’esempio delete-policy-version seguente elimina la versione 2 della policy specificata dal tuo account AWS.

aws iot delete-policy-version \
    --policy-name UpdateDeviceCertPolicy \
    --policy-version-id 2

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Policy IoT AWS nella Guida per gli sviluppatori di AWS IoT.

Come eliminare una policy

L’esempio delete-policy seguente elimina la policy specificata dal tuo account AWS.

aws iot delete-policy --policy-name UpdateDeviceCertPolicy

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Policy AWS IoT nella Guida per gli sviluppatori di AWS IoT.

Come eliminare una versione del modello di provisioning

L’esempio delete-provisioning-template-version seguente elimina la versione 2 del modello di provisioning specificato.

aws iot delete-provisioning-template-version \
    --version-id 2 \
    --template-name "widget-template"

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Tunnel sicuro di AWS IoT nella Guida per gli sviluppatori di AWS IoT Core.

Come eliminare un modello di provisioning

L’esempio delete-provisioning-template seguente elimina il modello di provisioning specificato.

aws iot delete-provisioning-template \
    --template-name widget-template

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Tunnel sicuro di AWS IoT nella Guida per gli sviluppatori di AWS IoT Core.

Come eliminare il codice di registrazione

L’esempio delete-registration-code seguente elimina un codice di registrazione specifico dell’account AWS IoT.

aws iot delete-registration-code

Questo comando non produce alcun output.

Per ulteriori informazioni consulta Uso di un certificato personale nella Guida per gli sviluppatori di AWS IoT.

Come eliminare un alias di ruolo AWS IoT

L’esempio delete-role-alias seguente elimina un alias di ruolo AWS IoT denominato LightBulbRole.

aws iot delete-role-alias \
    --role-alias LightBulbRole

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Autorizzazione di chiamate dirette a servizi AWS nella Guida per gli sviluppatori di AWS IoT.

Come eliminare un audit pianificato

L’esempio delete-scheduled-audit seguente elimina l’audit pianificato di AWS IoT Device Defender denominato AWSIoTDeviceDefenderDailyAudit.

aws iot delete-scheduled-audit \
    --scheduled-audit-name AWSIoTDeviceDefenderDailyAudit

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Comandi di auditing nella Guida per gli sviluppatori di AWS IoT.

Come eliminare un profilo di sicurezza

L’esempio delete-security-profile seguente elimina un profilo di sicurezza denominato PossibleIssue.

aws iot delete-security-profile \
    --security-profile-name PossibleIssue

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Comandi di rilevamento nella Guida per gli sviluppatori di AWS IoT.

Come eliminare un flusso

L’esempio delete-stream seguente elimina il flusso specificato.

aws iot delete-stream \
    --stream-id stream12345

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta DeleteStream nella Documentazione di riferimento delle API AWS IoT.

Come eliminare un gruppo di oggetti

L’esempio delete-thing-group seguente elimina il gruppo di oggetti specificato. Non è possibile eliminare un gruppo di oggetti se contiene gruppi di oggetti secondari.

aws iot delete-thing-group \
    --thing-group-name DefectiveBulbs

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Gruppi di oggetti nella Guida per gli sviluppatori di AWS IoT.

Esempio 1: per eliminare un tipo di oggetto

L’esempio delete-thing-type seguente elimina un tipo di oggetto obsoleto.

aws iot delete-thing-type \
    --thing-type-name "obsoleteThingType"

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Tipi di oggetti nella Guida per gli sviluppatori di AWS IoT.

Come visualizzare informazioni dettagliate su un oggetto

L’esempio delete-thing seguente elimina un oggetto dal registro AWS IoT per il tuo account AWS.

aws iot delete-thing --thing-name "FourthBulb"

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Come gestire gli oggetti con il registro nella Guida per gli sviluppatori di AWS IoT.

Come eliminare la destinazione di una regola di argomento

L’esempio delete-topic-rule-destination seguente elimina la destinazione di una regola di argomento specificata.

aws iot delete-topic-rule-destination \
    --arn "arn:aws:iot:us-west-2:123456789012:ruledestination/http/a1b2c3d4-5678-90ab-cdef-11111EXAMPLE"

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Eliminazione di una destinazione della regola dell’argomento nella Guida per gli sviluppatori di AWS IoT.

Come eliminare una regola

L’esempio delete-topic-rule seguente elimina la regola specificata.

aws iot delete-topic-rule \
    --rule-name "LowMoistureRule"

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Eliminazione di una regola nella Guida per gli sviluppatori di AWS IoT.

Come eliminare il livello di registrazione di log per un gruppo di oggetti

L’esempio delete-v2-logging-level seguente elimina il livello di registrazione di log per il gruppo di oggetti specificato.

aws iot delete-v2-logging-level \
    --target-type THING_GROUP \
    --target-name LightBulbs

Questo comando non produce alcun output.

Esempio 1: per rendere obsoleto un tipo di oggetto

L’esempio deprecate-thing-type seguente rende obsoleto un tipo di oggetto in modo che gli utenti non possano associarvi nuovi oggetti.

aws iot deprecate-thing-type \
    --thing-type-name "obsoleteThingType"

Questo comando non produce alcun output.

Esempio 2: per invertire l’obsolescenza di un tipo di oggetto

L’esempio deprecate-thing-type seguente inverte l’obsolescenza di un tipo di oggetto, in modo che gli utenti possano riassociarvi nuovi oggetti.

aws iot deprecate-thing-type \
    --thing-type-name "obsoleteThingType" \
    --undo-deprecate

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Tipi di oggetti nella Guida per gli sviluppatori di AWS IoT.

Come visualizzare le impostazioni per la configurazione di audit correnti

L’esempio describe-account-audit-configuration seguente elenca le impostazioni per la configurazione di audit correnti di AWS IoT Device Defender.

aws iot describe-account-audit-configuration

Output:

{
    "roleArn": "arn:aws:iam::123456789012:role/service-role/AWSIoTDeviceDefenderAudit_1551201085996",
    "auditNotificationTargetConfigurations": {
        "SNS": {
            "targetArn": "arn:aws:sns:us-west-2:123456789012:ddaudits",
            "roleArn": "arn:aws:iam::123456789012:role/service-role/AWSIoTDeviceDefenderAudit",
            "enabled": true
        }
    },
    "auditCheckConfigurations": {
        "AUTHENTICATED_COGNITO_ROLE_OVERLY_PERMISSIVE_CHECK": {
            "enabled": true
        },
        "CA_CERTIFICATE_EXPIRING_CHECK": {
            "enabled": true
        },
        "CONFLICTING_CLIENT_IDS_CHECK": {
            "enabled": true
        },
        "DEVICE_CERTIFICATE_EXPIRING_CHECK": {
            "enabled": true
        },
        "DEVICE_CERTIFICATE_SHARED_CHECK": {
            "enabled": true
        },
        "IOT_POLICY_OVERLY_PERMISSIVE_CHECK": {
            "enabled": true
        },
        "LOGGING_DISABLED_CHECK": {
            "enabled": true
        },
        "REVOKED_CA_CERTIFICATE_STILL_ACTIVE_CHECK": {
            "enabled": true
        },
        "REVOKED_DEVICE_CERTIFICATE_STILL_ACTIVE_CHECK": {
            "enabled": true
        },
        "UNAUTHENTICATED_COGNITO_ROLE_OVERLY_PERMISSIVE_CHECK": {
            "enabled": true
        }
    }
}

Per ulteriori informazioni, consulta Comandi di auditing nella Guida per gli sviluppatori di AWS IoT.

Come elencare i dettagli relativi agli esiti di un audit

L’esempio describe-audit-finding seguente elenca i dettagli relativi agli esiti di un audit di AWS IoT Device Defender specificato. Un audit può produrre vari esiti. Utilizza il comando list-audit-findings per ricavare un elenco degli esiti di un audit per ottenere findingId.

aws iot describe-audit-finding \
    --finding-id "ef4826b8-e55a-44b9-b460-5c485355371b"

Output:

{
    "finding": {
        "findingId": "ef4826b8-e55a-44b9-b460-5c485355371b",
        "taskId": "873ed69c74a9ec8fa9b8e88e9abc4661",
        "checkName": "IOT_POLICY_OVERLY_PERMISSIVE_CHECK",
        "taskStartTime": 1576012045.745,
        "findingTime": 1576012046.168,
        "severity": "CRITICAL",
        "nonCompliantResource": {
            "resourceType": "IOT_POLICY",
            "resourceIdentifier": {
                "policyVersionIdentifier": {
                    "policyName": "smp-ggrass-group_Core-policy",
                    "policyVersionId": "1"
                }
            }
         },
        "reasonForNonCompliance": "Policy allows broad access to IoT data plane actions: [iot:Subscribe, iot:Connect, iot:GetThingShadow, iot:DeleteThingShadow, iot:UpdateThingShadow, iot:Publish].",
        "reasonForNonComplianceCode": "ALLOWS_BROAD_ACCESS_TO_IOT_DATA_PLANE_ACTIONS"
    }
}

Per ulteriori informazioni, consulta Controllo dei risultati dell’audit (Comandi di auditing) nella Guida per gli sviluppatori di AWS IoT.

Come mostrare i dettagli di un’attività relativa alle azioni di mitigazione degli audit

L’esempio describe-audit-mitigation-actions-task seguente mostra i dettagli dell’attività specificata, in cui l’azione ResetPolicyVersionAction è stata applicata a un esito. I risultati includono l’ora di inizio e l’ora di fine dell’attività, il numero di esiti presi individuati (e il risultato) e la definizione dell’azione applicata nell’ambito di questa attività.

aws iot describe-audit-mitigation-actions-task \
    --task-id ResetPolicyTask01

Output:

{
    "taskStatus": "COMPLETED",
    "startTime": "2019-12-10T15:13:19.457000-08:00",
    "endTime": "2019-12-10T15:13:19.947000-08:00",
    "taskStatistics": {
        "IOT_POLICY_OVERLY_PERMISSIVE_CHECK": {
            "totalFindingsCount": 1,
            "failedFindingsCount": 0,
            "succeededFindingsCount": 1,
            "skippedFindingsCount": 0,
            "canceledFindingsCount": 0
        }
    },
    "target": {
        "findingIds": [
            "ef4826b8-e55a-44b9-b460-5c485355371b"
        ]
    },
    "auditCheckToActionsMapping": {
        "IOT_POLICY_OVERLY_PERMISSIVE_CHECK": [
            "ResetPolicyVersionAction"
        ]
    },
    "actionsDefinition": [
        {
            "name": "ResetPolicyVersionAction",
            "id": "1ea0b415-bef1-4a01-bd13-72fb63c59afb",
            "roleArn": "arn:aws:iam::123456789012:role/service-role/ReplacePolicyVersionRole",
            "actionParams": {
                "replaceDefaultPolicyVersionParams": {
                    "templateName": "BLANK_POLICY"
                }
            }
        }
    ]
}

Per ulteriori informazioni, consulta DescribeAuditMitigationActionsTask (Comandi delle operazioni di mitigazione) nella Guida per gli sviluppatori di AWS IoT.

Come ottenere i dettagli relativi alla soppressione degli esiti di un audit

L’esempio describe-audit-suppression seguente elenca i dettagli relativi alla soppressione degli esiti di un audit.

aws iot describe-audit-task \
    --task-id "787ed873b69cb4d6cdbae6ddd06996c5"

Output:

{
    "taskStatus": "COMPLETED",
    "taskType": "SCHEDULED_AUDIT_TASK",
    "taskStartTime": 1596168096.157,
    "taskStatistics": {
        "totalChecks": 1,
        "inProgressChecks": 0,
        "waitingForDataCollectionChecks": 0,
        "compliantChecks": 0,
        "nonCompliantChecks": 1,
        "failedChecks": 0,
        "canceledChecks": 0
    },
    "scheduledAuditName": "AWSIoTDeviceDefenderDailyAudit",
    "auditDetails": {
        "DEVICE_CERTIFICATE_EXPIRING_CHECK": {
            "checkRunStatus": "COMPLETED_NON_COMPLIANT",
            "checkCompliant": false,
            "totalResourcesCount": 195,
            "nonCompliantResourcesCount": 2
        }
    }
}

Per ulteriori informazioni, consulta Soppressioni della ricerca di audit nella Guida per gli sviluppatori di AWS IoT.

Come ottenere informazioni su un’istanza di audit

L’esempio describe-audit-task seguente ottiene informazioni su un’istanza di un audit di AWS IoT Device Defender. Se l’audit è completo, nei risultati vengono incluse le statistiche riassuntive relative all’esecuzione.

aws iot describe-audit-task \
    --task-id a3aea009955e501a31b764abe1bebd3d

Output:

 {
    "taskStatus": "COMPLETED",
    "taskType": "ON_DEMAND_AUDIT_TASK",
    "taskStartTime": 1560356923.434,
    "taskStatistics": {
        "totalChecks": 3,
        "inProgressChecks": 0,
        "waitingForDataCollectionChecks": 0,
        "compliantChecks": 3,
        "nonCompliantChecks": 0,
        "failedChecks": 0,
        "canceledChecks": 0
    },
    "auditDetails": {
        "CA_CERTIFICATE_EXPIRING_CHECK": {
            "checkRunStatus": "COMPLETED_COMPLIANT",
            "checkCompliant": true,
            "totalResourcesCount": 0,
            "nonCompliantResourcesCount": 0
        },
        "DEVICE_CERTIFICATE_EXPIRING_CHECK": {
            "checkRunStatus": "COMPLETED_COMPLIANT",
            "checkCompliant": true,
            "totalResourcesCount": 6,
            "nonCompliantResourcesCount": 0
        },
        "REVOKED_CA_CERTIFICATE_STILL_ACTIVE_CHECK": {
            "checkRunStatus": "COMPLETED_COMPLIANT",
            "checkCompliant": true,
            "totalResourcesCount": 0,
            "nonCompliantResourcesCount": 0
        }
    }
}

Per ulteriori informazioni, consulta Comandi di auditing nella Guida per gli sviluppatori di AWS IoT.

Come ottenere informazioni su un sistema di autorizzazione personalizzato

L’esempio describe-authorizer seguente visualizza i dettagli del sistema di autorizzazione personalizzato specificato.

aws iot describe-authorizer \
    --authorizer-name CustomAuthorizer

Output:

{
    "authorizerDescription": {
        "authorizerName": "CustomAuthorizer",
        "authorizerArn": "arn:aws:iot:us-west-2:123456789012:authorizer/CustomAuthorizer",
        "authorizerFunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:CustomAuthorizerFunction",
        "tokenKeyName": "MyAuthToken",
        "tokenSigningPublicKeys": {
            "FIRST_KEY": "-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA1uJOB4lQPgG/lM6ZfIwo\nZ+7ENxAio9q6QD4FFqjGZsvjtYwjoe1RKK0U8Eq9xb5O3kRSmyIwTzwzm/f4Gf0Y\nZUloJ+t3PUUwHrmbYTAgTrCUgRFygjfgVwGCPs5ZAX4Eyqt5cr+AIHIiUDbxSa7p\nzwOBKPeic0asNJpqT8PkBbRaKyleJh5oo81NDHHmVtbBm5A5YiJjqYXLaVAowKzZ\n+GqsNvAQ9Jy1wI2VrEa1OfL8flDB/BJLm7zjpfPOHDJQgID0XnZwAlNnZcOhCwIx\n50g2LW2Oy9R/dmqtDmJiVP97Z4GykxPvwlYHrUXY0iW1R3AR/Ac1NhCTGZMwVDB1\nlQIDAQAB\n-----END PUBLIC KEY-----"
        },
        "status": "ACTIVE",
        "creationDate": 1571245658.069,
        "lastModifiedDate": 1571245658.069
    }
}

Per ulteriori informazioni, consulta DescribeAuthorizer nella Documentazione di riferimento delle API AWS IoT.

Come ottenere informazioni su un gruppo di fatturazione

L’esempio describe-billing-group seguente ottiene informazioni per il gruppo di fatturazione specificato.

aws iot describe-billing-group --billing-group-name GroupOne

Output:

{
    "billingGroupName": "GroupOne",
    "billingGroupId": "103de383-114b-4f51-8266-18f209ef5562",
    "billingGroupArn": "arn:aws:iot:us-west-2:123456789012:billinggroup/GroupOne",
    "version": 1,
    "billingGroupProperties": {},
    "billingGroupMetadata": {
        "creationDate": 1560199355.378
    }
}

Per ulteriori informazioni, consulta Gruppi di fatturazione nella Guida per gli sviluppatori di AWS IoT.

Come ottenere dettagli su un certificato CA

L’esempio describe-ca-certificate seguente visualizza i dettagli del certificato CA specificato.

aws iot describe-ca-certificate \
    --certificate-id f4efed62c0142f16af278166f61962501165c4f0536295207426460058cd1467

Output:

{
    "certificateDescription": {
        "certificateArn": "arn:aws:iot:us-west-2:123456789012:cacert/f4efed62c0142f16af278166f61962501165c4f0536295207426460058cd1467",
        "certificateId": "f4efed62c0142f16af278166f61962501165c4f0536295207426460058cd1467",
        "status": "INACTIVE",
        "certificatePem": "-----BEGIN CERTIFICATE-----\nMIICzzCCAbegEXAMPLEJANVEPWXl8taPMA0GCSqGSIb3DQEBBQUAMB4xCzAJBgNV\nBAYTAlVTMQ8wDQYDVQQKDAZBbWF6b24wHhcNMTkwOTI0MjEzMTE1WhcNMjkwOTIx\nMjEzMTE1WjAeMQswCQYDVQQGEwJVUzEPMA0GA1UECgwGQW1hem9uMIIBIjANBgkq\nhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAzd3R3ioalCS0MhFWfBrVGR036EK07UAf\nVdz9EXAMPLE1VczICbADnATK522kEIB51/18VzlFtAhQL5V5eybXKnB7QebNer5m\n4Yibx7shR5oqNzFsrXWxuugN5+w5gEfqNMawOjhF4LsculKG49yuqjcDU19/13ua\n3B2gxs1Pe7TiWWvUskzxnbO1F2WCshbEJvqY8fIWtGYCjTeJAgQ9hvZx/69XhKen\nwV9LJwOQxrsUS0Ty8IHwbB8fRy72VM3u7fJoaU+nO4jD5cqaoEPtzoeFUEXAMPLE\nyVAJpqHwgbYbcUfn7V+AB6yh1+0Fa1rEQGuZDPGyJslxwr5vh8nRewIDAQABoxAw\nDjAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBBQUAA4IBAQA+3a5CV3IJgOnd0AgI\nBgVMtmYzTvqAngx26aG9/spvCjXckh2SBF+EcBlCFwH1yakwjJL1dR4yarnrfxgI\nEqP4AOYVimAVoQ5FBwnloHe16+3qtDiblU9DeXBUCtS55EcfrEXAMPLEYtXdqU5C\nU9ia4KAjV0dxW1+EFYMwX5eGeb0gDTNHBylV6B/fOSZiQAwDYp4x3B+gAP+a/bWB\nu1umOqtBdWe6L6/83L+JhaTByqV25iVJ4c/UZUnG8926wUlDM9zQvEXuEVvzZ7+m\n4PSNqst/nVOvnLpoG4e0WgcJgANuB33CSWtjWSuYsbhmqQRknGhREXAMPLEZT4fm\nfo0e\n-----END CERTIFICATE-----\n",
        "ownedBy": "123456789012",
        "creationDate": 1569365372.053,
        "autoRegistrationStatus": "DISABLE",
        "lastModifiedDate": 1569365372.053,
        "customerVersion": 1,
        "generationId": "c5c2eb95-140b-4f49-9393-6aaac85b2a90",
        "validity": {
            "notBefore": 1569360675.0,
            "notAfter": 1884720675.0
        }
    }
}

Per ulteriori informazioni, consulta DescribeCACertificate nella Documentazione di riferimento delle API AWS IoT.

Come ottenere informazioni su un certificato

L’esempio describe-certificate seguente visualizza i dettagli del certificato specificato.

aws iot describe-certificate \
    --certificate-id "4f0ba725787aa94d67d2fca420eca022242532e8b3c58e7465c7778b443fd65e"

Output:

{
    "certificateDescription": {
        "certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/4f0ba725787aa94d67d2fca420eca022242532e8b3c58e7465c7778b443fd65e",
        "certificateId": "4f0ba725787aa94d67d2fca420eca022242532e8b3c58e7465c7778b443fd65e",
        "status": "ACTIVE",
        "certificatePem": "-----BEGIN CERTIFICATE-----
MIICiTEXAMPLEQD6m7oRw0uXOjANBgkqhkiG9w0BAQUFADCBiDELMAkGA1UEBhMC
VVMxCzAJBgNVBEXAMPLEMRAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBbWF6
b24xFDASBgNVBAsTC0lBTSBDEXAMPLElMRIwEAYDVQQDEwlUZXN0Q2lsYWMxHzAd
BgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5EXAMPLEcNMTEwNDI1MjA0NTIxWhcN
MTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBhMCVVMxCzAJBgNEXAMPLEdBMRAwDgYD
VQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDASBgNVBAsTC0lBEXAMPLEz
b2xEXAMPLEYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEWEG5vb25lQGFt
YXpvbi5jb20wgZ8EXAMPLEZIhvcNAQEBBQADgY0AMIGJAoGBAMaK0dn+a4GmWIWJ
21uUSfwfEvySWtC2XADZ4nB+BLYEXAMPLEpiwsZ3G93vUEIO3IyNoH/f0wYK8m9T
rDHudUZg3qX4waLG5M43q7Wgc/MbQITxOUSQv7c7EXAMPLEGBzZswY6786m86gpE
Ibb3OhjZnzcvQAaRHhdlQWIMm2nrAgMBAAEwDQYJKoZIhvcNAQEFEXAMPLEAtCu4
nUhVVxYUnEXAMPLE8Mg9q6q+auNKyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0Fkb
FFBjvSfpJIlJ00zbhNYS5f6GEXAMPLEl0ZxBHjJnyp378OD8uTs7fLvjx79LjSTb
NYiytVbZPQUQ5Yaxu2jXnimvw3rrszlaEXAMPLE=
-----END CERTIFICATE-----",
        "ownedBy": "123456789012",
        "creationDate": 1541022751.983,
        "lastModifiedDate": 1541022751.983,
        "customerVersion": 1,
        "transferData": {},
        "generationId": "6974fbed-2e61-4114-bc5e-4204cc79b045",
        "validity": {
            "notBefore": 1541022631.0,
            "notAfter": 2524607999.0
        }
    }
}

Per ulteriori informazioni, consulta DescribeCertificate nella Documentazione di riferimento delle API AWS IoT.

Come ottenere informazioni su una metrica personalizzata di Device Defender

L’esempio describe-custom-metric seguente ottiene informazioni su una metrica personalizzata denominata myCustomMetric.

aws iot describe-custom-metric \
    --metric-name myCustomMetric

Output:

{
    "metricName": "myCustomMetric",
    "metricArn": "arn:aws:iot:us-east-1:1234564789012:custommetric/myCustomMetric",
    "metricType": "number",
    "displayName": "My custom metric",
    "creationDate": 2020-11-17T23:02:12.879000-09:00,
    "lastModifiedDate": 2020-11-17T23:02:12.879000-09:00
}

Per ulteriori informazioni, consulta Parametri personalizzati nella Guida per gli sviluppatori di AWS IoT Core.

Come ottenere informazioni sul sistema di autorizzazione personalizzato predefinito

L’esempio describe-default-authorizer seguente visualizza i dettagli del sistema di autorizzazione personalizzato predefinito.

aws iot describe-default-authorizer

Output:

{
    "authorizerName": "CustomAuthorizer",
    "authorizerArn": "arn:aws:iot:us-west-2:123456789012:authorizer/CustomAuthorizer"
}

Per ulteriori informazioni, consulta DescribeDefaultAuthorizer nella Documentazione di riferimento delle API AWS IoT.

Come ottenere informazioni su una dimensione

L’esempio describe-dimension seguente ottiene informazioni su una dimensione denominata TopicFilterForAuthMessages.

aws iot describe-dimension \
    --name TopicFilterForAuthMessages

Output:

{
    "name": "TopicFilterForAuthMessages",
    "arn": "arn:aws:iot:eu-west-2:123456789012:dimension/TopicFilterForAuthMessages",
    "type": "TOPIC_FILTER",
    "stringValues": [
        "device/+/auth"
    ],
    "creationDate": 1578620223.255,
    "lastModifiedDate": 1578620223.255
}

Per ulteriori informazioni, consulta Comandi di rilevamento nella Guida per gli sviluppatori di AWS IoT.

Come descrivere una configurazione di dominio

L’esempio describe-domain-configuration seguente visualizza i dettagli sulla configurazione di dominio specificata.

aws iot describe-domain-configuration \
    --domain-configuration-name "additionalDataDomain"

Output:

{
    "domainConfigurationName": "additionalDataDomain",
    "domainConfigurationArn": "arn:aws:iot:us-east-1:758EXAMPLE143:domainconfiguration/additionalDataDomain/norpw",
    "domainName": "d055exampleed74y71zfd-ats.beta.us-east-1.iot.amazonaws.com",
    "serverCertificates": [],
    "domainConfigurationStatus": "ENABLED",
    "serviceType": "DATA",
    "domainType": "AWS_MANAGED",
    "lastStatusChangeDate": 1601923783.774
}

Per ulteriori informazioni, consulta Endpoint configurabili nella Guida per gli sviluppatori di AWS IoT.

Esempio 1. Come ottenere l’endpoint AWS corrente

L’esempio describe-endpoint seguente recupera l’endpoint AWS predefinito a cui vengono applicati tutti i comandi.

aws iot describe-endpoint

Output:

{
    "endpointAddress": "abc123defghijk.iot.us-west-2.amazonaws.com"
}

Per ulteriori informazioni, consulta DescribeEndpoint nella Guida per gli sviluppatori di AWS IoT.

Esempio 2: per ottenere l’endpoint ATS

L’esempio describe-endpoint seguente recupera l’endpoint Amazon Trust Services (ATS).

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

Output:

{
    "endpointAddress": "abc123defghijk-ats.iot.us-west-2.amazonaws.com"
}

Per ulteriori informazioni, consulta Certificati X.509 e AWS IoT nella Guida per gli sviluppatori di AWS IoT.

Come mostrare quali tipi di eventi vengono pubblicati

L’esempio describe-event-configurations seguente elenca la configurazione che controlla quali eventi vengono generati quando qualcosa viene aggiunto, aggiornato o eliminato.

aws iot describe-event-configurations

Output:

{
    "eventConfigurations": {
        "CA_CERTIFICATE": {
            "Enabled": false
        },
        "CERTIFICATE": {
            "Enabled": false
        },
        "JOB": {
            "Enabled": false
        },
        "JOB_EXECUTION": {
            "Enabled": false
        },
        "POLICY": {
            "Enabled": false
        },
        "THING": {
            "Enabled": false
        },
        "THING_GROUP": {
            "Enabled": false
        },
        "THING_GROUP_HIERARCHY": {
            "Enabled": false
        },
        "THING_GROUP_MEMBERSHIP": {
            "Enabled": false
        },
        "THING_TYPE": {
            "Enabled": false
        },
        "THING_TYPE_ASSOCIATION": {
            "Enabled": false
        }
    }
}

Per ulteriori informazioni, consulta Messaggi di eventi nella Guida per gli sviluppatori di AWS IoT.

Come recuperare lo stato corrente dell’indice degli oggetti

L’esempio describe-index seguente recupera lo stato corrente dell’indice degli oggetti.

aws iot describe-index \
    --index-name "AWS_Things"

Output:

{
    "indexName": "AWS_Things",
    "indexStatus": "ACTIVE",
    "schema": "REGISTRY_AND_SHADOW_AND_CONNECTIVITY_STATUS"
}

Per ulteriori informazioni, consulta Gestione dell’indicizzazione degli oggetti nella Guida per gli sviluppatori di AWS IoT.

Come ottenere i dettagli di esecuzione di un processo su un dispositivo

L’esempio describe-job-execution seguente ottiene i dettagli di esecuzione del processo specificato.

aws iot describe-job-execution \
    --job-id "example-job-01" \
    --thing-name "MyRaspberryPi"

Output:

{
    "execution": {
        "jobId": "example-job-01",
        "status": "QUEUED",
        "statusDetails": {},
        "thingArn": "arn:aws:iot:us-west-2:123456789012:thing/MyRaspberryPi",
        "queuedAt": 1560787023.636,
        "lastUpdatedAt": 1560787023.636,
        "executionNumber": 1,
        "versionNumber": 1
    }
}

Per ulteriori informazioni, consulta Creazione e gestione di processi (CLI) nella Guida per gli sviluppatori di AWS IoT.

Come ottenere lo stato dettagliato di un processo

L’esempio describe-job seguente ottiene lo stato dettagliato del progetto con ID example-job-01.

aws iot describe-job \
    --job-id "example-job-01"

Output:

{
    "job": {
        "jobArn": "arn:aws:iot:us-west-2:123456789012:job/example-job-01",
        "jobId": "example-job-01",
        "targetSelection": "SNAPSHOT",
        "status": "IN_PROGRESS",
        "targets": [
            "arn:aws:iot:us-west-2:123456789012:thing/MyRaspberryPi"
        ],
        "description": "example job test",
        "presignedUrlConfig": {},
        "jobExecutionsRolloutConfig": {},
        "createdAt": 1560787022.733,
        "lastUpdatedAt": 1560787026.294,
        "jobProcessDetails": {
            "numberOfCanceledThings": 0,
            "numberOfSucceededThings": 0,
            "numberOfFailedThings": 0,
            "numberOfRejectedThings": 0,
            "numberOfQueuedThings": 1,
            "numberOfInProgressThings": 0,
            "numberOfRemovedThings": 0,
            "numberOfTimedOutThings": 0
        },
        "timeoutConfig": {}
    }
}

Per ulteriori informazioni, consulta Creazione e gestione di processi (CLI) nella Guida per gli sviluppatori di AWS IoT.

Come visualizzare i dettagli di un’azione di mitigazione definita

L’esempio describe-mitigation-action seguente visualizza i dettagli dell’azione di mitigazione specificata.

aws iot describe-mitigation-action \
    --action-name AddThingsToQuarantineGroupAction

Output:

{
    "actionName": "AddThingsToQuarantineGroupAction",
    "actionType": "ADD_THINGS_TO_THING_GROUP",
    "actionArn": "arn:aws:iot:us-west-2:123456789012:mitigationaction/AddThingsToQuarantineGroupAction",
    "actionId": "2fd2726d-98e1-4abf-b10f-09465ccd6bfa",
    "roleArn": "arn:aws:iam::123456789012:role/service-role/MoveThingsToQuarantineGroupRole",
    "actionParams": {
        "addThingsToThingGroupParams": {
            "thingGroupNames": [
                "QuarantineGroup1"
            ],
            "overrideDynamicGroups": true
        }
    },
    "creationDate": "2019-12-10T11:09:35.999000-08:00",
    "lastModifiedDate": "2019-12-10T11:09:35.999000-08:00"
}

Per ulteriori informazioni, consulta DescribeMitigationAction (Comandi delle operazioni di mitigazione) nella Guida per gli sviluppatori di AWS IoT.

Come descrivere una versione del modello di provisioning

L’esempio describe-provisioning-template-version seguente descrive una versione del modello di provisioning.

aws iot describe-provisioning-template-version \
    --template-name MyTestProvisioningTemplate \
    --version-id 1

Output:

{
    "versionId": 1,
    "creationDate": 1589308310.574,
    "templateBody": "{
        \"Parameters\":{
            \"SerialNumber\":{
                \"Type\":\"String\"
            },
            \"AWS::IoT::Certificate::Id\":{
                \"Type\":\"String\"
            }
        },
        \"Resources\":{
            \"certificate\":{
                \"Properties\":{
                    \"CertificateId\":{
                        \"Ref\":\"AWS::IoT::Certificate::Id\"
                    },
                    \"Status\":\"Active\"
                },
                \"Type\":\"AWS::IoT::Certificate\"
            },
            \"policy\":{
                \"Properties\":{
                    \"PolicyName\":\"MyIotPolicy\"
                },
                \"Type\":\"AWS::IoT::Policy\"
            },
            \"thing\":{
                \"OverrideSettings\":{
                    \"AttributePayload\":\"MERGE\",
                    \"ThingGroups\":\"DO_NOTHING\",
                    \"ThingTypeName\":\"REPLACE\"
                },
                \"Properties\":{
                    \"AttributePayload\":{},
                    \"ThingGroups\":[],
                    \"ThingName\":{
                        \"Fn::Join\":[
                            \"\",
                            [
                                \"DemoGroup_\",
                                {\"Ref\":\"SerialNumber\"}
                            ]
                        ]
                    },
                    \"ThingTypeName\":\"VirtualThings\"
                },
                \"Type\":\"AWS::IoT::Thing\"
            }
        }
    }",
    "isDefaultVersion": true
}

Per ulteriori informazioni, consulta Provisioning di dispositivi che non dispongono di certificati dispositivo mediante il provisioning del parco istanze dispositivi nella Guida per gli sviluppatori di AWS IoT Core.

Come descrivere un modello di provisioning

L’esempio describe-provisioning-template seguente descrive un modello di provisioning.

aws iot describe-provisioning-template \
    --template-name MyTestProvisioningTemplate

Output:

{
    "templateArn": "arn:aws:iot:us-west-2:57EXAMPLE833:provisioningtemplate/MyTestProvisioningTemplate",
    "templateName": "MyTestProvisioningTemplate",
    "creationDate": 1589308310.574,
    "lastModifiedDate": 1589308345.539,
    "defaultVersionId": 1,
    "templateBody": "{
        \"Parameters\":{
            \"SerialNumber\":{
                \"Type\":\"String\"
            },
            \"AWS::IoT::Certificate::Id\":{
                \"Type\":\"String\"
            }
        },
        \"Resources\":{
            \"certificate\":{
                \"Properties\":{
                    \"CertificateId\":{
                        \"Ref\":\"AWS::IoT::Certificate::Id\"
                    },
                    \"Status\":\"Active\"
                },
                \"Type\":\"AWS::IoT::Certificate\"
            },
            \"policy\":{
                \"Properties\":{
                    \"PolicyName\":\"MyIotPolicy\"
                },
                \"Type\":\"AWS::IoT::Policy\"
            },
            \"thing\":{
                \"OverrideSettings\":{
                    \"AttributePayload\":\"MERGE\",
                    \"ThingGroups\":\"DO_NOTHING\",
                    \"ThingTypeName\":\"REPLACE\"
                },
                \"Properties\":{
                    \"AttributePayload\":{},
                    \"ThingGroups\":[],
                    \"ThingName\":{
                        \"Fn::Join\":[
                            \"\",
                            [
                                \"DemoGroup_\",
                                {\"Ref\":\"SerialNumber\"}
                            ]
                        ]
                    },
                    \"ThingTypeName\":\"VirtualThings\"
                },
                \"Type\":\"AWS::IoT::Thing\"
            }
        }
    }",
    "enabled": true,
    "provisioningRoleArn": "arn:aws:iam::571032923833:role/service-role/IoT_access"
}

Per ulteriori informazioni, consulta Provisioning di dispositivi che non dispongono di certificati dispositivo mediante il provisioning del parco istanze dispositivi nella Guida per gli sviluppatori di AWS IoT Core.

Come ottenere informazioni su un alias di ruolo AWS IoT

L’esempio describe-role-alias seguente visualizza i dettagli dell’alias di ruolo specificato.

aws iot describe-role-alias \
    --role-alias LightBulbRole

Output:

{
    "roleAliasDescription": {
        "roleAlias": "LightBulbRole",
        "roleAliasArn": "arn:aws:iot:us-west-2:123456789012:rolealias/LightBulbRole",
        "roleArn": "arn:aws:iam::123456789012:role/light_bulb_role_001",
        "owner": "123456789012",
        "credentialDurationSeconds": 3600,
        "creationDate": 1570558643.221,
        "lastModifiedDate": 1570558643.221
    }
}

Per ulteriori informazioni, consulta DescribeRoleAlias nella Documentazione di riferimento delle API AWS IoT.

Come ottenere informazioni su un audit pianificato

L’esempio describe-scheduled-audit seguente ottiene informazioni dettagliate su un audit pianificato di AWS IoT Device Defender denominato AWSIoTDeviceDefenderDailyAudit.

aws iot describe-scheduled-audit \
    --scheduled-audit-name AWSIoTDeviceDefenderDailyAudit

Output:

{
    "frequency": "DAILY",
    "targetCheckNames": [
        "AUTHENTICATED_COGNITO_ROLE_OVERLY_PERMISSIVE_CHECK",
        "CONFLICTING_CLIENT_IDS_CHECK",
        "DEVICE_CERTIFICATE_SHARED_CHECK",
        "IOT_POLICY_OVERLY_PERMISSIVE_CHECK",
        "REVOKED_CA_CERTIFICATE_STILL_ACTIVE_CHECK",
        "UNAUTHENTICATED_COGNITO_ROLE_OVERLY_PERMISSIVE_CHECK"
    ],
    "scheduledAuditName": "AWSIoTDeviceDefenderDailyAudit",
    "scheduledAuditArn": "arn:aws:iot:us-west-2:123456789012:scheduledaudit/AWSIoTDeviceDefenderDailyAudit"
}

Per ulteriori informazioni, consulta Comandi di auditing nella Guida per gli sviluppatori di AWS IoT.

Come ottenere informazioni su un profilo di sicurezza

L’esempio describe-security-profile seguente ottiene informazioni sul profilo di sicurezza AWS IoT Device Defender denominato PossibleIssue.

aws iot describe-security-profile \
    --security-profile-name PossibleIssue

Output:

{
    "securityProfileName": "PossibleIssue",
    "securityProfileArn": "arn:aws:iot:us-west-2:123456789012:securityprofile/PossibleIssue",
    "securityProfileDescription": "check to see if authorization fails 10 times in 5 minutes or if cellular bandwidth exceeds 128",
    "behaviors": [
        {
            "name": "CellularBandwidth",
            "metric": "aws:message-byte-size",
            "criteria": {
                "comparisonOperator": "greater-than",
                "value": {
                    "count": 128
                },
                "consecutiveDatapointsToAlarm": 1,
                "consecutiveDatapointsToClear": 1
            }
        },
        {
            "name": "Authorization",
            "metric": "aws:num-authorization-failures",
            "criteria": {
                "comparisonOperator": "greater-than",
                "value": {
                    "count": 10
                },
                "durationSeconds": 300,
                "consecutiveDatapointsToAlarm": 1,
                "consecutiveDatapointsToClear": 1
            }
        }
    ],
    "version": 1,
    "creationDate": 1560278102.528,
    "lastModifiedDate": 1560278102.528
}

Per ulteriori informazioni, consulta Comandi di rilevamento nella Guida per gli sviluppatori di AWS IoT.

Come ottenere informazioni su un flusso

L’esempio describe-stream seguente mostra i dettagli sul flusso specificato.

aws iot describe-stream \
    --stream-id stream12345

Output:

{
    "streamInfo": {
        "streamId": "stream12345",
        "streamArn": "arn:aws:iot:us-west-2:123456789012:stream/stream12345",
        "streamVersion": 1,
        "description": "This stream is used for Amazon FreeRTOS OTA Update 12345.",
        "files": [
            {
                "fileId": "123",
                "s3Location": {
                    "bucket":"codesign-ota-bucket",
                    "key":"48c67f3c-63bb-4f92-a98a-4ee0fbc2bef6"
                }
            }
        ],
        "createdAt": 1557863215.995,
        "lastUpdatedAt": 1557863215.995,
        "roleArn": "arn:aws:iam:123456789012:role/service-role/my_ota_stream_role"
    }
}

Per ulteriori informazioni, consulta DescribeStream nella Documentazione di riferimento delle API AWS IoT.

Come ottenere informazioni su un gruppo di oggetti

L’esempio describe-thing-group seguente ottiene informazioni sul gruppo di oggetti denominato HalogenBulbs.

aws iot describe-thing-group \
    --thing-group-name HalogenBulbs

Output:

{
    "thingGroupName": "HalogenBulbs",
    "thingGroupId": "f4ec6b84-b42b-499d-9ce1-4dbd4d4f6f6e",
    "thingGroupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/HalogenBulbs",
    "version": 1,
    "thingGroupProperties": {},
    "thingGroupMetadata": {
        "parentGroupName": "LightBulbs",
        "rootToParentThingGroups": [
            {
                "groupName": "LightBulbs",
                "groupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/LightBulbs"
            }
        ],
        "creationDate": 1559927609.897
    }
}

Per ulteriori informazioni, consulta Gruppi di oggetti nella Guida per gli sviluppatori di AWS IoT.

Come ottenere informazioni su un tipo di oggetto

L’esempio describe-thing-type seguente visualizza informazioni sul tipo di oggetto specificato definito nel tuo account AWS.

aws iot describe-thing-type \
    --thing-type-name "LightBulb"

Output:

{
    "thingTypeName": "LightBulb",
    "thingTypeId": "ce3573b0-0a3c-45a7-ac93-4e0ce14cd190",
    "thingTypeArn": "arn:aws:iot:us-west-2:123456789012:thingtype/LightBulb",
    "thingTypeProperties": {
        "thingTypeDescription": "light bulb type",
        "searchableAttributes": [
            "model",
            "wattage"
        ]
    },
    "thingTypeMetadata": {
        "deprecated": false,
        "creationDate": 1559772562.498
    }
}

Per ulteriori informazioni, consulta Tipi di oggetti nella Guida per gli sviluppatori di AWS IoT.

Come visualizzare informazioni dettagliate su un oggetto

L’esempio describe-thing seguente mostra informazioni su un oggetto (dispositivo) definito nel registro AWS IoT per il tuo account AWS.

aws iot describe-thing --thing-name "MyLightBulb"

Output:

{
    "defaultClientId": "MyLightBulb",
    "thingName": "MyLightBulb",
    "thingId": "40da2e73-c6af-406e-b415-15acae538797",
    "thingArn": "arn:aws:iot:us-west-2:123456789012:thing/MyLightBulb",
    "thingTypeName": "LightBulb",
    "attributes": {
        "model": "123",
        "wattage": "75"
    },
    "version": 1
}

Per ulteriori informazioni, consulta Come gestire gli oggetti con il registro nella Guida per gli sviluppatori di AWS IoT.

Esempio 1: per scollegare una policy AWS IoT da un gruppo di oggetti

L’esempio detach-policy seguente scollega la policy specificata da un gruppo di oggetti e, per estensione, da tutti gli oggetti presenti nel gruppo e in eventuali gruppi secondari.

aws iot detach-policy \
    --target "arn:aws:iot:us-west-2:123456789012:thinggroup/LightBulbs" \
    --policy-name "MyFirstGroup_Core-policy"

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Gruppi di oggetti nella Guida per gli sviluppatori di AWS IoT.

Esempio 2: per scollegare una policy AWS IoT da un certificato di dispositivo

L’esempio detach-policy seguente scollega la policy TemperatureSensorPolicy da un certificato di dispositivo identificato mediante ARN.

aws iot detach-policy \
    --policy-name TemperatureSensorPolicy \
    --target arn:aws:iot:us-west-2:123456789012:cert/488b6a7f2acdeb00a77384e63c4e40b18b1b3caaae57b7272ba44c45e3448142

Questo comando non produce alcun output.

Come rimuovere l’associazione di un profilo di sicurezza da una destinazione

L’esempio detach-security-profile seguente rimuove l’associazione tra il profilo di sicurezza AWS IoT Device Defender denominato Testprofile e la destinazione di tutti gli oggetti registrati.

aws iot detach-security-profile \
    --security-profile-name Testprofile \
    --security-profile-target-arn "arn:aws:iot:us-west-2:123456789012:all/registered-things"

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Comandi di rilevamento nella Guida per gli sviluppatori di AWS IoT.

Come annullare il collegamento di un certificato/principale da un oggetto

L’esempio detach-thing-principal seguente rimuove un certificato che rappresenta un principale dall’oggetto specificato.

aws iot detach-thing-principal \
    --thing-name "MyLightBulb" \
    --principal "arn:aws:iot:us-west-2:123456789012:cert/604c48437a57b7d5fc5d137c5be75011c6ee67c9a6943683a1acb4b1626bac36"

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Come gestire gli oggetti con il registro nella Guida per gli sviluppatori di AWS IoT.

Come disabilitare una regola dell’argomento

L’esempio disable-topic-rule seguente disabilita la regola dell’argomento specificata.

aws iot disable-topic-rule \
    --rule-name "MyPlantPiMoistureAlertRule"

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Visualizzazione delle regole nella Guida per gli sviluppatori di AWS IoT.

Come abilitare una regola dell’argomento

L’esempio enable-topic-rule seguente abilita (o riabilita) la regola dell’argomento specificata.

aws iot enable-topic-rule \
    --rule-name "MyPlantPiMoistureAlertRule"

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Visualizzazione delle regole nella Guida per gli sviluppatori di AWS IoT.

Come elencare lo stato di addestramento dei modelli di un profilo Device Defender ML Detect

L’esempio get-behavior-model-training-summaries seguente elenca lo stato di addestramento dei modelli per i comportamenti configurati nel profilo di sicurezza scelto. Per ogni comportamento vengono elencati il nome, lo stato del modello e la percentuale di punti dati raccolti.

aws iot get-behavior-model-training-summaries \
    --security-profile-name MySecuirtyProfileName

Output:

{
    "summaries": [
        {
            "securityProfileName": "MySecuirtyProfileName",
            "behaviorName": "Messages_sent_ML_behavior",
            "modelStatus": "PENDING_BUILD",
            "datapointsCollectionPercentage": 0.0
        },
        {
            "securityProfileName": "MySecuirtyProfileName",
            "behaviorName": "Messages_received_ML_behavior",
            "modelStatus": "PENDING_BUILD",
            "datapointsCollectionPercentage": 0.0
        },
        {
            "securityProfileName": "MySecuirtyProfileName",
            "behaviorName": "Authorization_failures_ML_behavior",
            "modelStatus": "PENDING_BUILD",
            "datapointsCollectionPercentage": 0.0
        },
        {
            "securityProfileName": "MySecuirtyProfileName",
            "behaviorName": "Message_size_ML_behavior",
            "modelStatus": "PENDING_BUILD",
            "datapointsCollectionPercentage": 0.0
        },
        {
            "securityProfileName": "MySecuirtyProfileName",
            "behaviorName": "Connection_attempts_ML_behavior",
            "modelStatus": "PENDING_BUILD",
            "datapointsCollectionPercentage": 0.0
        },
        {
            "securityProfileName": "MySPNoALerts",
            "behaviorName": "Disconnects_ML_behavior",
            "modelStatus": "PENDING_BUILD",
            "datapointsCollectionPercentage": 0.0
        }
    ]
}

Per ulteriori informazioni, consulta GetBehaviorModelTrainingSummaries (Comandi di rilevamento) nella Guida per gli sviluppatori di AWS IoT.

Come restituire il conteggio approssimativo dei valori univoci che corrispondono alla query

È possibile utilizzare il seguente script di configurazione per creare 10 oggetti che rappresentano 10 sensori di temperatura. Ogni nuovo oggetto contiene 3 attributi.

# Bash script. If in other shells, type `bash` before running
Temperatures=(70 71 72 73 74 75 47 97 98 99)
Racks=(Rack1 Rack1 Rack2 Rack2 Rack3 Rack4 Rack5 Rack6 Rack6 Rack6)
IsNormal=(true true true true true true false false false false)
for ((i=0; i<10 ; i++))
do
  thing=$(aws iot create-thing --thing-name "TempSensor$i" --attribute-payload attributes="{temperature=${Temperatures[i]},rackId=${Racks[i]},stateNormal=${IsNormal[i]}}")
  aws iot describe-thing --thing-name "TempSensor$i"
done

Output di esempio dello script di configurazione:

{
    "version": 1,
    "thingName": "TempSensor0",
    "defaultClientId": "TempSensor0",
    "attributes": {
        "rackId": "Rack1",
        "stateNormal": "true",
        "temperature": "70"
    },
    "thingArn": "arn:aws:iot:us-east-1:123456789012:thing/TempSensor0",
    "thingId": "example1-90ab-cdef-fedc-ba987example"
}

L’esempio get-cardinality seguente esegue una query sui 10 sensori creati dallo script di configurazione e restituisce il numero di rack con sensori di temperatura che segnalano valori di temperatura anomali. Se il valore della temperatura è inferiore a 60 o superiore a 80, il sensore di temperatura si trova in uno stato anomalo.

aws iot get-cardinality \
    --aggregation-field "attributes.rackId" \
    --query-string "thingName:TempSensor* AND attributes.stateNormal:false"

Output:

{
    "cardinality": 2
}

Per ulteriori informazioni, consulta Interrogazione di dati aggregati<https://docs.aws.amazon.com/iot/latest/developerguide/index-aggregate.html> nella Guida per gli sviluppatori di AWS IoT.

Come elencare le policy che influiscono su un oggetto

L’esempio get-effective-policies seguente elenca le policy che influiscono sull’oggetto specificato, incluse le policy associate a tutti i gruppi a cui appartiene.

aws iot get-effective-policies \
    --thing-name TemperatureSensor-001 \
    --principal arn:aws:iot:us-west-2:123456789012:cert/488b6a7f2acdeb00a77384e63c4e40b18b1b3caaae57b7272ba44c45e3448142

Output:

{
    "effectivePolicies": [
        {
            "policyName": "TemperatureSensorPolicy",
            "policyArn": "arn:aws:iot:us-west-2:123456789012:policy/TemperatureSensorPolicy",
            "policyDocument": "{
                \"Version\": \"2012-10-17\",
                \"Statement\": [
                    {
                        \"Effect\": \"Allow\",
                        \"Action\": [
                            \"iot:Publish\",
                            \"iot:Receive\"
                        ],
                        \"Resource\": [
                            \"arn:aws:iot:us-west-2:123456789012:topic/topic_1\",
                            \"arn:aws:iot:us-west-2:123456789012:topic/topic_2\"
                        ]
                    },
                    {
                        \"Effect\": \"Allow\",
                        \"Action\": [
                            \"iot:Subscribe\"
                        ],
                        \"Resource\": [
                            \"arn:aws:iot:us-west-2:123456789012:topicfilter/topic_1\",
                            \"arn:aws:iot:us-west-2:123456789012:topicfilter/topic_2\"
                        ]
                    },
                    {
                        \"Effect\": \"Allow\",
                        \"Action\": [
                            \"iot:Connect\"
                        ],
                        \"Resource\": [
                            \"arn:aws:iot:us-west-2:123456789012:client/basicPubSub\"
                        ]
                    }
                ]
            }"
        }
    ]
}

Per ulteriori informazioni, consulta Recupero delle policy valide per un oggetto nella Guida per gli sviluppatori di AWS IoT.

Come ottenere la configurazione di indicizzazione degli oggetti

L’esempio get-indexing-configuration seguente ottiene i dati di configurazione correnti per l’indicizzazione del parco AWS IoT.

aws iot get-indexing-configuration

Output:

{
    "thingIndexingConfiguration": {
        "thingIndexingMode": "OFF",
        "thingConnectivityIndexingMode": "OFF"
    },
    "thingGroupIndexingConfiguration": {
        "thingGroupIndexingMode": "OFF"
    }
}

Per ulteriori informazioni, consulta Gestione dell’indicizzazione degli oggetti nella Guida per gli sviluppatori di AWS IoT.

Come recuperare il documento per un processo

L’esempio get-job-document seguente visualizza i dettagli sul documento relativo al processo con ID example-job-01.

aws iot get-job-document \
    --job-id "example-job-01"

Output:

{
    "document": "\n{\n    \"operation\":\"customJob\",\n    \"otherInfo\":\"someValue\"\n}\n"
}

Per ulteriori informazioni, consulta Creazione e gestione di processi (CLI) nella Guida per gli sviluppatori di AWS IoT.

Come ottenere le opzioni di registrazione di log

L’esempio get-logging-options seguente ottiene le opzioni di registrazione di log correnti per il tuo account AWS.

aws iot get-logging-options

Output:

{
    "roleArn": "arn:aws:iam::123456789012:role/service-role/iotLoggingRole",
    "logLevel": "ERROR"
}

Per ulteriori informazioni, consulta la Guida per gli sviluppatori di AWS IoT.

Come recuperare informazioni su un aggiornamento OTA

L’esempio get-ota-update seguente mostra i dettagli dell’aggiornamento OTA specificato.

aws iot get-ota-update \
    --ota-update-id ota12345

Output:

{
    "otaUpdateInfo": {
        "otaUpdateId": "ota12345",
        "otaUpdateArn": "arn:aws:iot:us-west-2:123456789012:otaupdate/itsaupdate",
        "creationDate": 1557863215.995,
        "lastModifiedDate": 1557863215.995,
        "description": "A critical update needed right away.",
        "targets": [
           "device1",
           "device2",
           "device3",
           "device4"
        ],
        "targetSelection": "SNAPSHOT",
        "protocols": ["HTTP"],
        "awsJobExecutionsRolloutConfig": {
           "maximumPerMinute": 10
        },
        "otaUpdateFiles": [
            {
                "fileName": "firmware.bin",
                "fileLocation": {
                    "stream": {
                        "streamId": "004",
                        "fileId":123
                    }
                },
                "codeSigning": {
                    "awsSignerJobId": "48c67f3c-63bb-4f92-a98a-4ee0fbc2bef6"
                }
            }
        ],
        "roleArn": "arn:aws:iam:123456789012:role/service-role/my_ota_role"
        "otaUpdateStatus": "CREATE_COMPLETE",
        "awsIotJobId": "job54321",
        "awsIotJobArn": "arn:aws:iot:us-west-2:123456789012:job/job54321",
        "errorInfo": {
        }
    }
}

Per ulteriori informazioni, consulta GetOTAUpdate nella Documentazione di riferimento delle API AWS IoT.

Come raggruppare i valori aggregati che corrispondono alla query in raggruppamenti percentili

È possibile utilizzare il seguente script di configurazione per creare 10 oggetti che rappresentano 10 sensori di temperatura. Ogni nuovo oggetto contiene 1 attributo.

# Bash script. If in other shells, type `bash` before running
Temperatures=(70 71 72 73 74 75 47 97 98 99)
for ((i=0; i<10 ; i++))
do
    thing=$(aws iot create-thing --thing-name "TempSensor$i" --attribute-payload attributes="{temperature=${Temperatures[i]}}")
    aws iot describe-thing --thing-name "TempSensor$i"
done

Output di esempio dello script di configurazione:

{
    "version": 1,
    "thingName": "TempSensor0",
    "defaultClientId": "TempSensor0",
    "attributes": {
        "temperature": "70"
    },
    "thingArn": "arn:aws:iot:us-east-1:123456789012:thing/TempSensor0",
    "thingId": "example1-90ab-cdef-fedc-ba987example"
}

L’esempio get-percentiles seguente esegue una query sui 10 sensori creati dallo script di configurazione e restituisce un valore per ogni gruppo percentile specificato. Il gruppo percentile “10” contiene il valore del campo aggregato che si verifica in circa il 10% dei valori corrispondenti alla query. Nell’output seguente, {"percent": 10.0, "value": 67.7} significa che circa il 10,0% dei valori di temperatura è inferiore a 67,7.

aws iot get-percentiles \
    --aggregation-field "attributes.temperature" \
    --query-string "thingName:TempSensor*" \
    --percents 10 25 50 75 90

Output:

{
    "percentiles": [
        {
            "percent": 10.0,
            "value": 67.7
        },
        {
            "percent": 25.0,
            "value": 71.25
        },
        {
            "percent": 50.0,
            "value": 73.5
        },
        {
            "percent": 75.0,
            "value": 91.5
        },
        {
            "percent": 90.0,
            "value": 98.1
        }
    ]
}

Per ulteriori informazioni, consulta Interrogazione di dati aggregati nella Guida per gli sviluppatori di AWS IoT.

Come ottenere informazioni su una versione specifica di una policy

L’esempio get-policy-version seguente ottiene informazioni sulla prima versione della policy specificata.

aws iot get-policy \
    --policy-name UpdateDeviceCertPolicy
    --policy-version-id "1"

Output:

{
    "policyArn": "arn:aws:iot:us-west-2:123456789012:policy/UpdateDeviceCertPolicy",
    "policyName": "UpdateDeviceCertPolicy",
    "policyDocument": "{ \"Version\": \"2012-10-17\", \"Statement\": [ { \"Effect\": \"Allow\", \"Action\":  \"iot:UpdateCertificate\", \"Resource\": \"*\" } ] }",
    "policyVersionId": "1",
    "isDefaultVersion": false,
    "creationDate": 1559925941.924,
    "lastModifiedDate": 1559926175.458,
    "generationId": "5066f1b6712ce9d2a1e56399771649a272d6a921762fead080e24fe52f24e042"
}

Per ulteriori informazioni, consulta Policy AWS IoT nella Guida per gli sviluppatori di AWS IoT.

Come ottenere informazioni sulla versione predefinita di una policy

L’esempio get-policy seguente recupera informazioni sulla versione predefinita della policy specificata.

aws iot get-policy \
    --policy-name UpdateDeviceCertPolicy

Output:

{
    "policyName": "UpdateDeviceCertPolicy",
    "policyArn": "arn:aws:iot:us-west-2:123456789012:policy/UpdateDeviceCertPolicy",
    "policyDocument": "{ \"Version\": \"2012-10-17\", \"Statement\": [ { \"Effect\": \"Allow\", \"Action\":  \"iot:UpdateCertificate\", \"Resource\": \"*\" } ] }",
    "defaultVersionId": "2",
    "creationDate": 1559925941.924,
    "lastModifiedDate": 1559925941.924,
    "generationId": "5066f1b6712ce9d2a1e56399771649a272d6a921762fead080e24fe52f24e042"
}

Per ulteriori informazioni, consulta Policy AWS IoT nella Guida per gli sviluppatori di AWS IoT.

Come ottenere il codice di registrazione specifico per l’account AWS

L’esempio get-registration-code seguente recupera il codice di registrazione specifico dell’account AWS.

aws iot get-registration-code

Output:

{
    "registrationCode": "15c51ae5e36ba59ba77042df1115862076bea4bd15841c838fcb68d5010a614c"
}

Per ulteriori informazioni consulta Uso di un certificato personale nella Guida per gli sviluppatori di AWS IoT.

Come cercare dati aggregati nell’indice del dispositivo

L’esempio get-statistics seguente restituisce il numero di elementi con una proprietà denominata connectivity.connected impostata su false (ovvero il numero di dispositivi non connessi) nel device shadow.

aws iot get-statistics \
    --index-name AWS_Things \
    --query-string "connectivity.connected:false"

Output:

{
    "statistics": {
        "count": 6
    }
}

Per ulteriori informazioni, consulta Ottenimento di statistiche sul parco istanze del dispositivo nella Guida per gli sviluppatori di AWS IoT.

Come ottenere la destinazione di una regola dell’argomento

L’esempio get-topic-rule-destination seguente ottiene informazioni sulla destinazione di una regola dell’argomento.

aws iot get-topic-rule-destination \
    --arn "arn:aws:iot:us-west-2:123456789012:ruledestination/http/a1b2c3d4-5678-90ab-cdef-11111EXAMPLE"

Output:

{
    "topicRuleDestination": {
        "arn": "arn:aws:iot:us-west-2:123456789012:ruledestination/http/a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
        "status": "DISABLED",
        "httpUrlProperties": {
            "confirmationUrl": "https://example.com"
        }
    }
}

Per ulteriori informazioni, consulta Utilizzo delle destinazioni delle regole degli argomenti nella Guida per gli sviluppatori di AWS IoT.

Come ottenere informazioni su una regola

L’esempio get-topic-rule seguente ottiene informazioni sulla regola specificata.

aws iot get-topic-rule \
    --rule-name MyRPiLowMoistureAlertRule

Output:

{
    "ruleArn": "arn:aws:iot:us-west-2:123456789012:rule/MyRPiLowMoistureAlertRule",
    "rule": {
        "ruleName": "MyRPiLowMoistureAlertRule",
        "sql": "SELECT * FROM '$aws/things/MyRPi/shadow/update/accepted' WHERE state.reported.moisture = 'low'\n                    ",
        "description": "Sends an alert whenever soil moisture level readings are too low.",
        "createdAt": 1558624363.0,
        "actions": [
            {
                "sns": {
                    "targetArn": "arn:aws:sns:us-west-2:123456789012:MyRPiLowMoistureTopic",
                    "roleArn": "arn:aws:iam::123456789012:role/service-role/MyRPiLowMoistureTopicRole",
                    "messageFormat": "RAW"
                }
            }
        ],
        "ruleDisabled": false,
        "awsIotSqlVersion": "2016-03-23"
    }
}

Per ulteriori informazioni, consulta Visualizzazione delle regole nella Guida per gli sviluppatori di AWS IoT.

Come elencare le opzioni di registrazione di log correnti

L’esempio get-v2-logging-options seguente elenca le opzioni di registrazione di log correnti per AWS IoT.

aws iot get-v2-logging-options

Output:

{
    "roleArn": "arn:aws:iam::094249569039:role/service-role/iotLoggingRole",
    "defaultLogLevel": "WARN",
    "disableAllLogs": false
}

Per ulteriori informazioni, consulta la Guida per gli sviluppatori di AWS IoT.

Come elencare le violazioni attive

L’esempio list-active-violations seguente elenca tutte le violazioni per il profilo di sicurezza specificato.

aws iot list-active-violations \
    --security-profile-name Testprofile

Output:

{
    "activeViolations": [
        {
            "violationId": "174db59167fa474c80a652ad1583fd44",
            "thingName": "iotconsole-1560269126751-1",
            "securityProfileName": "Testprofile",
            "behavior": {
                "name": "Authorization",
                "metric": "aws:num-authorization-failures",
                "criteria": {
                    "comparisonOperator": "greater-than",
                    "value": {
                        "count": 10
                    },
                    "durationSeconds": 300,
                    "consecutiveDatapointsToAlarm": 1,
                    "consecutiveDatapointsToClear": 1
                }
            },
            "lastViolationValue": {
                "count": 0
            },
            "lastViolationTime": 1560293700.0,
            "violationStartTime": 1560279000.0
        },
        {
            "violationId": "c8a9466a093d3b7b35cd44ca58bdbeab",
            "thingName": "TvnQoEoU",
            "securityProfileName": "Testprofile",
            "behavior": {
                "name": "CellularBandwidth",
                "metric": "aws:message-byte-size",
                "criteria": {
                    "comparisonOperator": "greater-than",
                    "value": {
                        "count": 128
                    },
                    "consecutiveDatapointsToAlarm": 1,
                    "consecutiveDatapointsToClear": 1
                }
            },
            "lastViolationValue": {
                "count": 110
            },
            "lastViolationTime": 1560369000.0,
            "violationStartTime": 1560276600.0
        },
        {
            "violationId": "74aa393adea02e6648f3ac362beed55e",
            "thingName": "iotconsole-1560269232412-2",
            "securityProfileName": "Testprofile",
            "behavior": {
                "name": "Authorization",
                "metric": "aws:num-authorization-failures",
                "criteria": {
                    "comparisonOperator": "greater-than",
                    "value": {
                        "count": 10
                    },
                    "durationSeconds": 300,
                    "consecutiveDatapointsToAlarm": 1,
                    "consecutiveDatapointsToClear": 1
                }
            },
            "lastViolationValue": {
                "count": 0
            },
            "lastViolationTime": 1560276600.0,
            "violationStartTime": 1560276600.0
        },
        {
            "violationId": "1e6ab5f7cf39a1466fcd154e1377e406",
            "thingName": "TvnQoEoU",
            "securityProfileName": "Testprofile",
            "behavior": {
                "name": "Authorization",
                "metric": "aws:num-authorization-failures",
                "criteria": {
                    "comparisonOperator": "greater-than",
                    "value": {
                        "count": 10
                    },
                    "durationSeconds": 300,
                    "consecutiveDatapointsToAlarm": 1,
                    "consecutiveDatapointsToClear": 1
                }
            },
            "lastViolationValue": {
                "count": 0
            },
            "lastViolationTime": 1560369000.0,
            "violationStartTime": 1560276600.0
        }
    ]
}

Esempio 1: per elencare le policy collegate a un gruppo

L’esempio list-attached-policies seguente elenca le policy collegate al gruppo specificato.

aws iot list-attached-policies \
    --target "arn:aws:iot:us-west-2:123456789012:thinggroup/LightBulbs"

Output:

{
    "policies": [
        {
            "policyName": "UpdateDeviceCertPolicy",
            "policyArn": "arn:aws:iot:us-west-2:123456789012:policy/UpdateDeviceCertPolicy"
        }
    ]
}

Per ulteriori informazioni, consulta Gruppi di oggetti nella Guida per gli sviluppatori di AWS IoT.

Esempio 2: per elencare le policy collegate a un certificato di dispositivo

L’esempio list-attached-policies seguente elenca le policy AWS IoT collegate al certificato di dispositivo. Il certificato viene identificato mediante il rispettivo ARN.

aws iot list-attached-policies \
    --target arn:aws:iot:us-west-2:123456789012:cert/488b6a7f2acdeb00a77384e63c4e40b18b1b3caaae57b7272ba44c45e3448142

Output:

{
    "policies": [
        {
            "policyName": "TemperatureSensorPolicy",
            "policyArn": "arn:aws:iot:us-west-2:123456789012:policy/TemperatureSensorPolicy"
        }
    ]
}

Per ulteriori informazioni, consulta Gruppi di oggetti nella Guida per gli sviluppatori di AWS IoT.

Esempio 1: per elencare tutti gli esiti di un audit

L’esempio list-audit-findings seguente elenca tutti gli esiti di un audit AWS IoT Device Defender con un ID attività specificato.

aws iot list-audit-findings \
    --task-id a3aea009955e501a31b764abe1bebd3d

Output:

{
    "findings": []
}

Esempio 2: per elencare gli esiti per un tipo di controllo di audit

L’esempio list-audit-findings seguente mostra gli esiti degli audit di AWS IoT Device Defender eseguiti tra il 5 giugno 2019 e il 19 giugno 2019, in cui i dispositivi condividono un certificato di dispositivo. Quando specifichi un nome per il controllo, devi fornire un’ora di inizio e un’ora di fine.

aws iot list-audit-findings \
    --check-name DEVICE_CERTIFICATE_SHARED_CHECK \
    --start-time 1559747125 \
    --end-time 1560962028

Output:

{
    "findings": [
        {
            "taskId": "eeef61068b0eb03c456d746c5a26ee04",
            "checkName": "DEVICE_CERTIFICATE_SHARED_CHECK",
            "taskStartTime": 1560161017.172,
            "findingTime": 1560161017.592,
            "severity": "CRITICAL",
            "nonCompliantResource": {
                "resourceType": "DEVICE_CERTIFICATE",
                "resourceIdentifier": {
                    "deviceCertificateId": "b193ab7162c0fadca83246d24fa090300a1236fe58137e121b011804d8ac1d6b"
                }
            },
            "relatedResources": [
                {
                    "resourceType": "CLIENT_ID",
                    "resourceIdentifier": {
                        "clientId": "ZipxgAIl"
                    },
                    "additionalInfo": {
                        "CONNECTION_TIME": "1560086374068"
                    }
                },
                {
                    "resourceType": "CLIENT_ID",
                    "resourceIdentifier": {
                        "clientId": "ZipxgAIl"
                    },
                    "additionalInfo": {
                        "CONNECTION_TIME": "1560081552187",
                        "DISCONNECTION_TIME": "1560086371552"
                    }
                },
                {
                    "resourceType": "CLIENT_ID",
                    "resourceIdentifier": {
                        "clientId": "ZipxgAIl"
                    },
                    "additionalInfo": {
                        "CONNECTION_TIME": "1559289863631",
                        "DISCONNECTION_TIME": "1560081532716"
                    }
                }
            ],
            "reasonForNonCompliance": "Certificate shared by one or more devices.",
            "reasonForNonComplianceCode": "CERTIFICATE_SHARED_BY_MULTIPLE_DEVICES"
        },
        {
            "taskId": "bade6b5efd2e1b1569822f6021b39cf5",
            "checkName": "DEVICE_CERTIFICATE_SHARED_CHECK",
            "taskStartTime": 1559988217.27,
            "findingTime": 1559988217.655,
            "severity": "CRITICAL",
            "nonCompliantResource": {
                "resourceType": "DEVICE_CERTIFICATE",
                "resourceIdentifier": {
                    "deviceCertificateId": "b193ab7162c0fadca83246d24fa090300a1236fe58137e121b011804d8ac1d6b"
                }
            },
            "relatedResources": [
                {
                    "resourceType": "CLIENT_ID",
                    "resourceIdentifier": {
                        "clientId": "xShGENLW"
                    },
                    "additionalInfo": {
                        "CONNECTION_TIME": "1559972350825"
                    }
                },
                {
                    "resourceType": "CLIENT_ID",
                    "resourceIdentifier": {
                        "clientId": "xShGENLW"
                    },
                    "additionalInfo": {
                        "CONNECTION_TIME": "1559255062002",
                        "DISCONNECTION_TIME": "1559972350616"
                    }
                }
            ],
            "reasonForNonCompliance": "Certificate shared by one or more devices.",
            "reasonForNonComplianceCode": "CERTIFICATE_SHARED_BY_MULTIPLE_DEVICES"
        },
        {
            "taskId": "c23f6233ba2d35879c4bb2810fb5ffd6",
            "checkName": "DEVICE_CERTIFICATE_SHARED_CHECK",
            "taskStartTime": 1559901817.31,
            "findingTime": 1559901817.767,
            "severity": "CRITICAL",
            "nonCompliantResource": {
                "resourceType": "DEVICE_CERTIFICATE",
                "resourceIdentifier": {
                    "deviceCertificateId": "b193ab7162c0fadca83246d24fa090300a1236fe58137e121b011804d8ac1d6b"
                }
            },
            "relatedResources": [
                {
                    "resourceType": "CLIENT_ID",
                    "resourceIdentifier": {
                        "clientId": "TvnQoEoU"
                    },
                    "additionalInfo": {
                        "CONNECTION_TIME": "1559826729768"
                    }
                },
                {
                    "resourceType": "CLIENT_ID",
                    "resourceIdentifier": {
                        "clientId": "TvnQoEoU"
                    },
                    "additionalInfo": {
                        "CONNECTION_TIME": "1559345920964",
                        "DISCONNECTION_TIME": "1559826728402"
                    }
                }
            ],
            "reasonForNonCompliance": "Certificate shared by one or more devices.",
            "reasonForNonComplianceCode": "CERTIFICATE_SHARED_BY_MULTIPLE_DEVICES"
        }
    ]
}

Per ulteriori informazioni, consulta Comandi di auditing nella Guida per gli sviluppatori di AWS IoT.

Come elencare i dettagli dell’esecuzione di un’azione di mitigazione degli audit

Un’attività di mitigazione degli audit applica un’azione di mitigazione a uno o più esiti di un audit di AWS IoT Device Defender. L’esempio list-audit-mitigation-actions-executions seguente elenca i dettagli dell’attività di mitigazione con l’azione taskId specificata e per gli esiti indicati.

aws iot list-audit-mitigation-actions-executions \
    --task-id myActionsTaskId \
    --finding-id 0edbaaec-2fe1-4cf5-abc9-d4c3e51f7464

Output:

{
    "actionsExecutions": [
        {
            "taskId": "myActionsTaskId",
            "findingId": "0edbaaec-2fe1-4cf5-abc9-d4c3e51f7464",
            "actionName": "ResetPolicyVersionAction",
            "actionId": "1ea0b415-bef1-4a01-bd13-72fb63c59afb",
            "status": "COMPLETED",
            "startTime": "2019-12-10T15:19:13.279000-08:00",
            "endTime": "2019-12-10T15:19:13.337000-08:00"
        }
    ]
}

Per ulteriori informazioni, consulta ListAuditMitigationActionsExecutions (Comandi delle operazioni di mitigazione) nella Guida per gli sviluppatori di AWS IoT.

Come elencare le attività relative alle azioni di mitigazione degli audit

L’esempio list-audit-mitigation-actions-tasks seguente elenca le azioni di mitigazione applicate agli esiti entro il periodo di tempo specificato.

aws iot list-audit-mitigation-actions-tasks \
    --start-time 1594157400 \
    --end-time 1594157430

Output:

{
    "tasks": [
        {
                "taskId": "0062f2d6-3999-488f-88c7-bef005414103",
                "startTime": "2020-07-07T14:30:15.172000-07:00",
            "taskStatus": "COMPLETED"
        }
    ]
}

Per ulteriori informazioni, consulta ListAuditMitigationActionsTasks (Comandi delle operazioni di mitigazione) nella Guida per gli sviluppatori di AWS IoT.

Come elencare tutte le soppressioni degli esiti di audit

L’esempio list-audit-suppressions seguente elenca tutte le soppressioni degli esiti di audit attive.

aws iot list-audit-suppressions

Output:

{
    "suppressions": [
        {
        "checkName": "DEVICE_CERTIFICATE_EXPIRING_CHECK",
            "resourceIdentifier": {
                "deviceCertificateId": "c7691e<shortened>"
            },
        "expirationDate": 1597881600.0,
        "suppressIndefinitely": false
        }
    ]
}

Per ulteriori informazioni, consulta Soppressioni della ricerca di audit nella Guida per gli sviluppatori di AWS IoT.

Come elencare tutti gli esiti di un audit

L’esempio list-audit-tasks seguente elenca le attività di audit eseguite tra il 5 giugno 2019 e il 12 giugno 2019.

aws iot list-audit-tasks \
    --start-time 1559747125 \
    --end-time 1560357228

Output:

{
    "tasks": [
        {
            "taskId": "a3aea009955e501a31b764abe1bebd3d",
            "taskStatus": "COMPLETED",
            "taskType": "ON_DEMAND_AUDIT_TASK"
        },
        {
            "taskId": "f76b4b5102b632cd9ae38a279c266da1",
            "taskStatus": "COMPLETED",
            "taskType": "SCHEDULED_AUDIT_TASK"
        },
        {
            "taskId": "51d9967d9f9ff4d26529505f6d2c444a",
            "taskStatus": "COMPLETED",
            "taskType": "SCHEDULED_AUDIT_TASK"
        },
        {
            "taskId": "eeef61068b0eb03c456d746c5a26ee04",
            "taskStatus": "COMPLETED",
            "taskType": "SCHEDULED_AUDIT_TASK"
        },
        {
            "taskId": "041c49557b7c7b04c079a49514b55589",
            "taskStatus": "COMPLETED",
            "taskType": "SCHEDULED_AUDIT_TASK"
        },
        {
            "taskId": "82c7f2afac1562d18a4560be73998acc",
            "taskStatus": "COMPLETED",
            "taskType": "SCHEDULED_AUDIT_TASK"
        },
        {
            "taskId": "bade6b5efd2e1b1569822f6021b39cf5",
            "taskStatus": "COMPLETED",
            "taskType": "SCHEDULED_AUDIT_TASK"
        },
        {
            "taskId": "c23f6233ba2d35879c4bb2810fb5ffd6",
            "taskStatus": "COMPLETED",
            "taskType": "SCHEDULED_AUDIT_TASK"
        },
        {
            "taskId": "ac9086b7222a2f5e2e17bb6fd30b3aeb",
            "taskStatus": "COMPLETED",
            "taskType": "SCHEDULED_AUDIT_TASK"
        }
    ]
}

Per ulteriori informazioni, consulta Comandi di auditing nella Guida per gli sviluppatori di AWS IoT.

Come elencare un sistema di autorizzazione personalizzato

L’esempio list-authorizers seguente elenca i sistemi di autorizzazione personalizzati nel tuo account AWS.

aws iot list-authorizers

Output:

{
    "authorizers": [
        {
            "authorizerName": "CustomAuthorizer",
            "authorizerArn": "arn:aws:iot:us-west-2:123456789012:authorizer/CustomAuthorizer"
        },
        {
            "authorizerName": "CustomAuthorizer2",
            "authorizerArn": "arn:aws:iot:us-west-2:123456789012:authorizer/CustomAuthorizer2"
        },
        {
            "authorizerName": "CustomAuthorizer3",
            "authorizerArn": "arn:aws:iot:us-west-2:123456789012:authorizer/CustomAuthorizer3"
        }
    ]
}

Per ulteriori informazioni, consulta ListAuthorizers nella Documentazione di riferimento delle API AWS IoT.

Come elencare i gruppi di fatturazione per un account e una Regione AWS

L’esempio list-billing-groups seguente elenca tutti i gruppi di fatturazione definiti per il tuo account AWS e la tua Regione AWS.

aws iot list-billing-groups

Output:

{
    "billingGroups": [
        {
            "groupName": "GroupOne",
            "groupArn": "arn:aws:iot:us-west-2:123456789012:billinggroup/GroupOne"
        }
    ]
}

Per ulteriori informazioni, consulta Gruppi di fatturazione nella Guida per gli sviluppatori di AWS IoT.

Come elencare i certificati CA registrati nell’account AWS

L’esempio list-ca-certificates seguente elenca i certificati CA registrati nel tuo account AWS.

aws iot list-ca-certificates

Output:

{
    "certificates": [
        {
            "certificateArn": "arn:aws:iot:us-west-2:123456789012:cacert/f4efed62c0142f16af278166f61962501165c4f0536295207426460058cd1467",
            "certificateId": "f4efed62c0142f16af278166f61962501165c4f0536295207426460058cd1467",
            "status": "INACTIVE",
            "creationDate": 1569365372.053
        }
    ]
}

Per ulteriori informazioni consulta Uso di un certificato personale nella Guida per gli sviluppatori di AWS IoT.

Come elencare tutti i certificati di dispositivo firmati con un certificato CA

L’esempio list-certificates-by-ca seguente elenca tutti i certificati di dispositivo presenti nel tuo account AWS che sono firmati con il certificato CA specificato.

aws iot list-certificates-by-ca \
    --ca-certificate-id f4efed62c0142f16af278166f61962501165c4f0536295207426460058cd1467

Output:

{
    "certificates": [
        {
            "certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/488b6a7f2acdeb00a77384e63c4e40b18b1b3caaae57b7272ba44c45e3448142",
            "certificateId": "488b6a7f2acdeb00a77384e63c4e40b18b1b3caaae57b7272ba44c45e3448142",
            "status": "ACTIVE",
            "creationDate": 1569363250.557
        }
    ]
}

Per ulteriori informazioni, consulta ListCertificatesByCA nella Documentazione di riferimento delle API AWS IoT.

Esempio 1: per elencare i certificati registrati nell’account AWS

L’esempio list-certificates seguente elenca tutti i certificati registrati nel tuo account. Se disponi di un limite di paging superiore rispetto al valore predefinito di 25, puoi utilizzare il valore di risposta nextMarker di questo comando e fornirlo al comando successivo per ottenere il successivo batch di risultati. Ripeti l’operazione finché nextMarker non restituisce alcun valore.

aws iot list-certificates

Output:

{
    "certificates": [
        {
            "certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/604c48437a57b7d5fc5d137c5be75011c6ee67c9a6943683a1acb4b1626bac36",
            "certificateId": "604c48437a57b7d5fc5d137c5be75011c6ee67c9a6943683a1acb4b1626bac36",
            "status": "ACTIVE",
            "creationDate": 1556810537.617
        },
        {
            "certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/262a1ac8a7d8aa72f6e96e365480f7313aa9db74b8339ec65d34dc3074e1c31e",
            "certificateId": "262a1ac8a7d8aa72f6e96e365480f7313aa9db74b8339ec65d34dc3074e1c31e",
            "status": "ACTIVE",
            "creationDate": 1546447050.885
        },
        {
            "certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/b193ab7162c0fadca83246d24fa090300a1236fe58137e121b011804d8ac1d6b",
            "certificateId": "b193ab7162c0fadca83246d24fa090300a1236fe58137e121b011804d8ac1d6b",
            "status": "ACTIVE",
            "creationDate": 1546292258.322
        },
        {
            "certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/7aebeea3845d14a44ec80b06b8b78a89f3f8a706974b8b34d18f5adf0741db42",
            "certificateId": "7aebeea3845d14a44ec80b06b8b78a89f3f8a706974b8b34d18f5adf0741db42",
            "status": "ACTIVE",
            "creationDate": 1541457693.453
        },
        {
            "certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/54458aa39ebb3eb39c91ffbbdcc3a6ca1c7c094d1644b889f735a6fc2cd9a7e3",
            "certificateId": "54458aa39ebb3eb39c91ffbbdcc3a6ca1c7c094d1644b889f735a6fc2cd9a7e3",
            "status": "ACTIVE",
            "creationDate": 1541113568.611
        },
        {
            "certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/4f0ba725787aa94d67d2fca420eca022242532e8b3c58e7465c7778b443fd65e",
            "certificateId": "4f0ba725787aa94d67d2fca420eca022242532e8b3c58e7465c7778b443fd65e",
            "status": "ACTIVE",
            "creationDate": 1541022751.983
        }
    ]
}

Come elencare le metriche personalizzate

L’esempio list-custom-metrics seguente elenca tutte le metriche personalizzate.

aws iot list-custom-metrics \
    --region us-east-1

Output:

{
    "metricNames": [
        "batteryPercentage"
    ]
}

Per ulteriori informazioni, consulta Parametri personalizzati nella Guida per gli sviluppatori di AWS IoT Core.

Come elencare le dimensioni dell’account AWS

L’esempio list-dimensions seguente elenca tutte le dimensioni AWS IoT Device Defender definite nell’account AWS.

aws iot list-dimensions

Output:

{
    "dimensionNames": [
        "TopicFilterForAuthMessages",
        "TopicFilterForActivityMessages"
    ]
}

Per ulteriori informazioni, consulta Comandi di rilevamento nella Guida per gli sviluppatori di AWS IoT.

Come elencare le configurazioni di dominio

L’esempio list-domain-configurations seguente elenca le configurazioni di dominio dell’account AWS con il tipo di servizio specificato.

aws iot list-domain-configurations \
    --service-type "DATA"

Output:

{
    "domainConfigurations":
    [
        {
            "domainConfigurationName": "additionalDataDomain",
            "domainConfigurationArn": "arn:aws:iot:us-west-2:123456789012:domainconfiguration/additionalDataDomain/dikMh",
            "serviceType": "DATA"
        },

        {
            "domainConfigurationName": "iot:Jobs",
            "domainConfigurationArn": "arn:aws:iot:us-west-2:123456789012:domainconfiguration/iot:Jobs",
            "serviceType": "JOBS"
        },
        {
            "domainConfigurationName": "iot:Data-ATS",
            "domainConfigurationArn": "arn:aws:iot:us-west-2:123456789012:domainconfiguration/iot:Data-ATS",
            "serviceType": "DATA"
        },
        {
            "domainConfigurationName": "iot:CredentialProvider",
            "domainConfigurationArn": "arn:aws:iot:us-west-2:123456789012:domainconfiguration/iot:CredentialProvider",
            "serviceType": "CREDENTIAL_PROVIDER"
        }
    ]
}

Per ulteriori informazioni, consulta Endpoint configurabili nella Guida per gli sviluppatori di AWS IoT.

Come elencare gli indici di ricerca configurati

L’esempio list-indices seguente elenca tutti gli indici di ricerca configurati nell’account AWS. Se non hai abilitato l’indicizzazione degli oggetti, potresti non avere alcun indice.

aws iot list-indices

Output:

{
    "indexNames": [
        "AWS_Things"
    ]
}

Per ulteriori informazioni, consulta Gestione dell’indicizzazione degli oggetti nella Guida per gli sviluppatori di AWS IoT.

Come elencare i processi nell’account AWS

L’esempio list-job-executions-for-job seguente elenca tutte le esecuzioni per un job nell’account AWS, specificato tramite jobId.

aws iot list-job-executions-for-job \
    --job-id my-ota-job

Output:

{
     "executionSummaries": [
         {
             "thingArn": "arn:aws:iot:us-east-1:123456789012:thing/my_thing",
             "jobExecutionSummary": {
                 "status": "QUEUED",
                 "queuedAt": "2022-03-07T15:58:42.195000-08:00",
                 "lastUpdatedAt": "2022-03-07T15:58:42.195000-08:00",
                 "executionNumber": 1,
                 "retryAttempt": 0
             }
         }
     ]
 }

Per ulteriori informazioni, consulta Creazione e gestione di processi (CLI) nella Guida per gli sviluppatori di AWS IoT.

Come elencare i processi eseguiti per un oggetto

L’esempio list-job-executions-for-thing seguente elenca tutti i processi eseguiti per l’oggetto denominato MyRaspberryPi.

aws iot list-job-executions-for-thing \
    --thing-name "MyRaspberryPi"

Output:

{
    "executionSummaries": [
        {
            "jobId": "example-job-01",
            "jobExecutionSummary": {
                "status": "QUEUED",
                "queuedAt": 1560787023.636,
                "lastUpdatedAt": 1560787023.636,
                "executionNumber": 1
            }
        }
    ]
}

Per ulteriori informazioni, consulta Creazione e gestione di processi (CLI) nella Guida per gli sviluppatori di AWS IoT.

Come elencare i processi nell’account AWS

L’esempio list-jobs seguente elenca tutti i processi nell’account AWS ordinati in base allo stato.

aws iot list-jobs

Output:

{
    "jobs": [
        {
            "jobArn": "arn:aws:iot:us-west-2:123456789012:job/example-job-01",
            "jobId": "example-job-01",
            "targetSelection": "SNAPSHOT",
            "status": "IN_PROGRESS",
            "createdAt": 1560787022.733,
            "lastUpdatedAt": 1560787026.294
        }
    ]
}

Per ulteriori informazioni, consulta Creazione e gestione di processi (CLI) nella Guida per gli sviluppatori di AWS IoT.

Come elencare tutte le azioni di mitigazione definite

L’esempio list-mitigation-actions seguente elenca tutte le azioni di mitigazione definite per il tuo account e la tua Regione AWS. Per ogni azione vengono elencati il nome, l’ARN e la data di creazione.

aws iot list-mitigation-actions

Output:

{
    "actionIdentifiers": [
        {
            "actionName": "DeactivateCACertAction",
            "actionArn": "arn:aws:iot:us-west-2:123456789012:mitigationaction/DeactivateCACertAction",
            "creationDate": "2019-12-10T11:12:47.574000-08:00"
        },
        {
            "actionName": "ResetPolicyVersionAction",
            "actionArn": "arn:aws:iot:us-west-2:123456789012:mitigationaction/ResetPolicyVersionAction",
            "creationDate": "2019-12-10T11:11:48.920000-08:00"
        },
        {
            "actionName": "PublishFindingToSNSAction",
            "actionArn": "arn:aws:iot:us-west-2:123456789012:mitigationaction/PublishFindingToSNSAction",
            "creationDate": "2019-12-10T11:10:49.546000-08:00"
        },
        {
            "actionName": "AddThingsToQuarantineGroupAction",
            "actionArn": "arn:aws:iot:us-west-2:123456789012:mitigationaction/AddThingsToQuarantineGroupAction",
            "creationDate": "2019-12-10T11:09:35.999000-08:00"
        },
        {
            "actionName": "UpdateDeviceCertAction",
            "actionArn": "arn:aws:iot:us-west-2:123456789012:mitigationaction/UpdateDeviceCertAction",
            "creationDate": "2019-12-10T11:08:44.263000-08:00"
        },
        {
            "actionName": "SampleMitigationAction",
            "actionArn": "arn:aws:iot:us-west-2:123456789012:mitigationaction/SampleMitigationAction",
            "creationDate": "2019-12-10T11:03:41.840000-08:00"
        }
    ]
}

Per ulteriori informazioni, consulta ListMitigationActions (Comandi delle operazioni di mitigazione) nella Guida per gli sviluppatori di AWS IoT.

Come elencare tutte le azioni di mitigazione definite

L’esempio list-mitigations-actions seguente elenca tutte le azioni di mitigazione definite per il tuo account e la tua Regione AWS. Per ogni azione vengono elencati il nome, l’ARN e la data di creazione.

aws iot list-mitigation-actions

Output:

{
    "actionIdentifiers": [
        {
            "actionName": "DeactivateCACertAction",
            "actionArn": "arn:aws:iot:us-west-2:123456789012:mitigationaction/DeactivateCACertAction",
            "creationDate": "2019-12-10T11:12:47.574000-08:00"
        },
        {
            "actionName": "ResetPolicyVersionAction",
            "actionArn": "arn:aws:iot:us-west-2:123456789012:mitigationaction/ResetPolicyVersionAction",
            "creationDate": "2019-12-10T11:11:48.920000-08:00"
        },
        {
            "actionName": "PublishFindingToSNSAction",
            "actionArn": "arn:aws:iot:us-west-2:123456789012:mitigationaction/PublishFindingToSNSAction",
            "creationDate": "2019-12-10T11:10:49.546000-08:00"
        },
        {
            "actionName": "AddThingsToQuarantineGroupAction",
            "actionArn": "arn:aws:iot:us-west-2:123456789012:mitigationaction/AddThingsToQuarantineGroupAction",
            "creationDate": "2019-12-10T11:09:35.999000-08:00"
        },
        {
            "actionName": "UpdateDeviceCertAction",
            "actionArn": "arn:aws:iot:us-west-2:123456789012:mitigationaction/UpdateDeviceCertAction",
            "creationDate": "2019-12-10T11:08:44.263000-08:00"
        },
        {
            "actionName": "SampleMitigationAction",
            "actionArn": "arn:aws:iot:us-west-2:123456789012:mitigationaction/SampleMitigationAction",
            "creationDate": "2019-12-10T11:03:41.840000-08:00"
        }
    ]
}

Per ulteriori informazioni, consulta ListMitigationActions (Comandi delle operazioni di mitigazione) nella Guida per gli sviluppatori di AWS IoT.

Come elencare gli aggiornamenti OTA per l’account

L’esempio list-ota-updates seguente elenca gli aggiornamenti OTA disponibili.

aws iot list-ota-updates

Output:

{
    "otaUpdates": [
        {
            "otaUpdateId": "itsaupdate",
            "otaUpdateArn": "arn:aws:iot:us-west-2:123456789012:otaupdate/itsaupdate",
            "creationDate": 1557863215.995
        }
    ]
}

Per ulteriori informazioni, consulta ListOTAUpdates nella Documentazione di riferimento delle API AWS IoT.

Come elencare i certificati trasferiti in un altro account AWS

L’esempio list-outgoing-certificates seguente elenca tutti i certificati di dispositivo in fase di trasferimento in un altro account AWS utilizzando il comando transfer-certificate.

aws iot list-outgoing-certificates

Output:

{
    "outgoingCertificates": [
        {
            "certificateArn": "arn:aws:iot:us-west-2:030714055129:cert/488b6a7f2acdeb00a77384e63c4e40b18b1b3caaae57b7272ba44c45e3448142",
            "certificateId": "488b6a7f2acdeb00a77384e63c4e40b18b1b3caaae57b7272ba44c45e3448142",
            "transferredTo": "030714055129",
            "transferDate": 1569427780.441,
            "creationDate": 1569363250.557
        }
    ]
}

Per ulteriori informazioni, consulta ListOutgoingCertificates nella Documentazione di riferimento delle API AWS IoT.

Come elencare le policy definite nell’account AWS

L’esempio list-policies seguente elenca tutte le politiche definite nell’account AWS.

aws iot list-policies

Output:

{
    "policies": [
        {
            "policyName": "UpdateDeviceCertPolicy",
            "policyArn": "arn:aws:iot:us-west-2:123456789012:policy/UpdateDeviceCertPolicy"
        },
        {
            "policyName": "PlantIoTPolicy",
            "policyArn": "arn:aws:iot:us-west-2:123456789012:policy/PlantIoTPolicy"
        },
        {
            "policyName": "MyPiGroup_Core-policy",
            "policyArn": "arn:aws:iot:us-west-2:123456789012:policy/MyPiGroup_Core-policy"
        }
    ]
}

Per ulteriori informazioni, consulta Policy AWS IoT nella Guida per gli sviluppatori di AWS IoT.

Esempio 1: per visualizzare tutte le versioni di una policy

L’esempio list-policy-versions seguente elenca tutte le versioni della policy specificata e le relative date di creazione.

aws iot list-policy-versions \
    --policy-name LightBulbPolicy

Output:

{
    "policyVersions": [
        {
            "versionId": "2",
            "isDefaultVersion": true,
            "createDate": 1559925941.924
        },
        {
            "versionId": "1",
            "isDefaultVersion": false,
            "createDate": 1559925941.924
        }
    ]
}

Per ulteriori informazioni, consulta Policy AWS IoT nella Guida per gli sviluppatori di AWS IoT.

Come elencare gli oggetti collegati a un principale

L’esempio list-principal-things seguente elenca gli oggetti collegati al principale specificato da un ARN.

aws iot list-principal-things \
    --principal arn:aws:iot:us-west-2:123456789012:cert/2e1eb273792174ec2b9bf4e9b37e6c6c692345499506002a35159767055278e8

Output:

{
    "things": [
        "DeskLamp",
        "TableLamp"
    ]
}

Per ulteriori informazioni, consulta ListPrincipalThings nella Documentazione di riferimento delle API AWS IoT.

Come elencare le versioni di un modello di provisioning

L’esempio list-provisioning-template-versions seguente elenca le versioni disponibili del modello di provisioning specificato.

aws iot list-provisioning-template-versions \
    --template-name "widget-template"

Output:

{
    "versions": [
        {
            "versionId": 1,
            "creationDate": 1574800471.339,
            "isDefaultVersion": true
        },
        {
            "versionId": 2,
            "creationDate": 1574801192.317,
            "isDefaultVersion": false
        }
    ]
}

Per ulteriori informazioni, consulta Tunnel sicuro di AWS IoT nella Guida per gli sviluppatori di AWS IoT Core.

Come elencare i modelli di provisioning

L’esempio list-provisioning-templates seguente elenca tutti i modelli di provisioning nell’account AWS.

aws iot list-provisioning-templates

Output:

{
    "templates": [
        {
            "templateArn": "arn:aws:iot:us-east-1:123456789012:provisioningtemplate/widget-template",
            "templateName": "widget-template",
            "description": "A provisioning template for widgets",
            "creationDate": 1574800471.367,
            "lastModifiedDate": 1574801192.324,
            "enabled": false
        }
    ]
}

Per ulteriori informazioni, consulta Tunnel sicuro di AWS IoT nella Guida per gli sviluppatori di AWS IoT Core.

Come elencare gli alias di ruolo AWS IoT nell’account AWS

L’esempio list-role-aliases seguente elenca gli alias di ruolo AWS IoT nell’account AWS.

aws iot list-role-aliases

Output:

{
    "roleAliases": [
        "ResidentAlias",
        "ElectricianAlias"
    ]
}

Per ulteriori informazioni, consulta ListRoleAliases nella Documentazione di riferimento delle API AWS IoT.

Come elencare gli audit pianificati per l’account AWS

L’esempio list-scheduled-audits seguente elenca tutti gli audit pianificati per l’account AWS.

aws iot list-scheduled-audits

Output:

{
    "scheduledAudits": [
        {
            "scheduledAuditName": "AWSIoTDeviceDefenderDailyAudit",
            "scheduledAuditArn": "arn:aws:iot:us-west-2:123456789012:scheduledaudit/AWSIoTDeviceDefenderDailyAudit",
            "frequency": "DAILY"
        },
        {
            "scheduledAuditName": "AWSDeviceDefenderWeeklyAudit",
            "scheduledAuditArn": "arn:aws:iot:us-west-2:123456789012:scheduledaudit/AWSDeviceDefenderWeeklyAudit",
            "frequency": "WEEKLY",
            "dayOfWeek": "SUN"
        }
    ]
}

Per ulteriori informazioni, consulta Comandi di auditing nella Guida per gli sviluppatori di AWS IoT.

Come elencare i profili di sicurezza collegati a una destinazione

L’esempio list-security-profiles-for-target seguente elenca i profili di sicurezza AWS IoT Device Defender collegati a dispositivi non registrati.

aws iot list-security-profiles-for-target  \
    --security-profile-target-arn "arn:aws:iot:us-west-2:123456789012:all/unregistered-things"

Output:

{
    "securityProfileTargetMappings": [
        {
            "securityProfileIdentifier": {
                "name": "Testprofile",
                "arn": "arn:aws:iot:us-west-2:123456789012:securityprofile/Testprofile"
            },
            "target": {
                "arn": "arn:aws:iot:us-west-2:123456789012:all/unregistered-things"
            }
        }
    ]
}

Per ulteriori informazioni, consulta Comandi di rilevamento nella Guida per gli sviluppatori di AWS IoT.

Come elencare i profili di sicurezza per l’account AWS

L’esempio list-security-profiles seguente elenca tutti i profili di sicurezza AWS IoT Device Defender definiti nell’account AWS.

aws iot list-security-profiles

Output:

{
    "securityProfileIdentifiers": [
        {
            "name": "Testprofile",
            "arn": "arn:aws:iot:us-west-2:123456789012:securityprofile/Testprofile"
        }
    ]
}

Per ulteriori informazioni, consulta Comandi di rilevamento nella Guida per gli sviluppatori di AWS IoT.

Come elencare i flussi nell’account

L’esempio list-streams seguente elenca tutti i flussi nell’account AWS.

aws iot list-streams

Output:

{
    "streams": [
        {
            "streamId": "stream12345",
            "streamArn": "arn:aws:iot:us-west-2:123456789012:stream/stream12345",
            "streamVersion": 1,
            "description": "This stream is used for Amazon FreeRTOS OTA Update 12345."
        },
        {
            "streamId": "stream54321",
            "streamArn": "arn:aws:iot:us-west-2:123456789012:stream/stream54321",
            "streamVersion": 1,
            "description": "This stream is used for Amazon FreeRTOS OTA Update 54321."
        }
    ]
}

Per ulteriori informazioni, consulta ListStreams nella Documentazione di riferimento delle API AWS IoT.

Come visualizzare i tag e i relativi valori associati a una risorsa

L’esempio list-tags-for-resource seguente visualizza i tag e i valori associati al gruppo di oggetti LightBulbs.

aws iot list-tags-for-resource \
    --resource-arn "arn:aws:iot:us-west-2:094249569039:thinggroup/LightBulbs"

Output:

{
    "tags": [
        {
            "Key": "Assembly",
            "Value": "Fact1NW"
        },
        {
            "Key": "MyTag",
            "Value": "777"
        }
    ]
}

Per ulteriori informazioni, consulta Tagging delle risorse AWS IoT nella Guida per gli sviluppatori di AWS IoT.

Come elencare i principali associati a una policy AWS IoT

L’esempio list-targets-for-policy seguente elenca i certificati di dispositivo a cui è collegata la policy specificata.

aws iot list-targets-for-policy \
    --policy-name UpdateDeviceCertPolicy

Output:

{
    "targets": [
        "arn:aws:iot:us-west-2:123456789012:cert/488b6a7f2acdeb00a77384e63c4e40b18b1b3caaae57b7272ba44c45e3448142",
        "arn:aws:iot:us-west-2:123456789012:cert/d1eb269fb55a628552143c8f96eb3c258fcd5331ea113e766ba0c82bf225f0be"
    ]
}

Per ulteriori informazioni, consulta Gruppi di oggetti nella Guida per gli sviluppatori di AWS IoT.

Come elencare le destinazioni a cui è applicato un profilo di sicurezza

L’esempio list-targets-for-security-profile seguente elenca le destinazioni a cui viene applicato il profilo di sicurezza AWS IoT Device Defender denominato PossibleIssue.

aws iot list-targets-for-security-profile \
    --security-profile-name Testprofile

Output:

{
    "securityProfileTargets": [
        {
            "arn": "arn:aws:iot:us-west-2:123456789012:all/unregistered-things"
        },
        {
            "arn": "arn:aws:iot:us-west-2:123456789012:all/registered-things"
        }
    ]
}

Per ulteriori informazioni, consulta Comandi di rilevamento nella Guida per gli sviluppatori di AWS IoT.

Come visualizzare i gruppi a cui appartiene un oggetto

L’esempio list-thing-groups-for-thing seguente elenca i gruppi a cui appartiene l’oggetto specificato.

aws iot list-thing-groups-for-thing \
    --thing-name MyLightBulb

Output:

{
    "thingGroups": [
        {
            "groupName": "DeadBulbs",
            "groupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/DeadBulbs"
        },
        {
            "groupName": "LightBulbs",
            "groupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/LightBulbs"
        }
    ]
}

Per ulteriori informazioni, consulta Gruppi di oggetti nella Guida per gli sviluppatori di AWS IoT.

Come elencare i gruppi di oggetti nell’account AWS

L’esempio describe-thing-group seguente elenca tutti i gruppi di oggetti definiti nell’account AWS.

aws iot list-thing-groups

Output:

{
    "thingGroups": [
        {
            "groupName": "HalogenBulbs",
            "groupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/HalogenBulbs"
        },
        {
            "groupName": "LightBulbs",
            "groupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/LightBulbs"
        }
    ]
}

Per ulteriori informazioni, consulta Gruppi di oggetti nella Guida per gli sviluppatori di AWS IoT.

Come elencare i principali associati a un oggetto

L’esempio list-thing-principals seguente elenca i principali (certificati X.509, utenti IAM, gruppi, ruoli, identità Amazon Cognito o identità federate) associati all’oggetto specificato.

aws iot list-thing-principals \
    --thing-name MyRaspberryPi

Output:

{
    "principals": [
        "arn:aws:iot:us-west-2:123456789012:cert/33475ac865079a5ffd5ecd44240640349293facc760642d7d8d5dbb6b4c86893"
    ]
}

Per ulteriori informazioni, consulta ListThingPrincipals nella Documentazione di riferimento delle API AWS IoT.

Come elencare i tipi di oggetti definiti

L’esempio list-thing-types seguente visualizza tutti i tipi di oggetti definiti nell’account AWS.

aws iot list-thing-types

Output:

{
    "thingTypes": [
        {
            "thingTypeName": "LightBulb",
            "thingTypeArn": "arn:aws:iot:us-west-2:123456789012:thingtype/LightBulb",
            "thingTypeProperties": {
                "thingTypeDescription": "light bulb type",
                "searchableAttributes": [
                    "model",
                    "wattage"
                ]
            },
            "thingTypeMetadata": {
            "deprecated": false,
            "creationDate": 1559772562.498
            }
        }
    ]
}

Per ulteriori informazioni, consulta Tipi di oggetti nella Guida per gli sviluppatori di AWS IoT.

Come elencare gli oggetti in un gruppo di fatturazione

L’esempio list-things-in-billing-group seguente elenca gli oggetti presenti nel gruppo di fatturazione specificato.

aws iot list-things-in-billing-group \
    --billing-group-name GroupOne

Output:

{
    "things": [
        "MyOtherLightBulb",
        "MyLightBulb"
    ]
}

Per ulteriori informazioni, consulta Gruppi di fatturazione nella Guida per gli sviluppatori di AWS IoT.

Come elencare gli oggetti che appartengono a un gruppo

L’esempio list-things-in-thing-group seguente elenca gli oggetti che appartengono al gruppo di oggetti specificato.

aws iot list-things-in-thing-group \
    --thing-group-name LightBulbs

Output:

{
    "things": [
        "MyLightBulb"
    ]
}

Per ulteriori informazioni, consulta Gruppi di oggetti nella Guida per gli sviluppatori di AWS IoT.

Esempio 1: per elencare tutti gli oggetti presenti nel registro

L’esempio list-things seguente elenca gli oggetti (dispositivi) definiti nel registro AWS IoT per l’account AWS.

aws iot list-things

Output:

{
    "things": [
        {
            "thingName": "ThirdBulb",
            "thingTypeName": "LightBulb",
            "thingArn": "arn:aws:iot:us-west-2:123456789012:thing/ThirdBulb",
            "attributes": {
                "model": "123",
                "wattage": "75"
            },
            "version": 2
        },
        {
            "thingName": "MyOtherLightBulb",
            "thingTypeName": "LightBulb",
            "thingArn": "arn:aws:iot:us-west-2:123456789012:thing/MyOtherLightBulb",
            "attributes": {
                "model": "123",
                "wattage": "75"
            },
            "version": 3
        },
        {
            "thingName": "MyLightBulb",
            "thingTypeName": "LightBulb",
            "thingArn": "arn:aws:iot:us-west-2:123456789012:thing/MyLightBulb",
            "attributes": {
                "model": "123",
                "wattage": "75"
            },
            "version": 1
        },
        {
        "thingName": "SampleIoTThing",
        "thingArn": "arn:aws:iot:us-west-2:123456789012:thing/SampleIoTThing",
        "attributes": {},
        "version": 1
        }
    ]
}

Esempio 2: per elencare gli oggetti definiti con un attributo specifico

L’esempio list-things seguente visualizza un elenco degli oggetti contenenti un attributo denominato wattage.

aws iot list-things \
    --attribute-name wattage

Output:

{
    "things": [
        {
            "thingName": "MyLightBulb",
            "thingTypeName": "LightBulb",
            "thingArn": "arn:aws:iot:us-west-2:123456789012:thing/MyLightBulb",
            "attributes": {
                "model": "123",
                "wattage": "75"
            },
            "version": 1
        },
        {
            "thingName": "MyOtherLightBulb",
            "thingTypeName": "LightBulb",
            "thingArn": "arn:aws:iot:us-west-2:123456789012:thing/MyOtherLightBulb",
            "attributes": {
                "model": "123",
                "wattage": "75"
            },
            "version": 3
        }
    ]
}

Per ulteriori informazioni, consulta Come gestire gli oggetti con il registro nella Guida per gli sviluppatori di AWS IoT.

Come elencare le destinazioni delle regole degli argomenti

L’esempio list-topic-rule-destinations seguente elenca tutte le destinazioni delle regole degli argomenti definite nella Regione AWS corrente.

aws iot list-topic-rule-destinations

Output:

{
    "destinationSummaries": [
        {
            "arn": "arn:aws:iot:us-west-2:123456789012:ruledestination/http/a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
            "status": "ENABLED",
            "httpUrlSummary": {
                "confirmationUrl": "https://example.com"
            }
        }
    ]
}

Per ulteriori informazioni, consulta Utilizzo delle destinazioni delle regole degli argomenti nella Guida per gli sviluppatori di AWS IoT.

Come elencare le regole

L’esempio list-topic-rules seguente elenca tutte le regole che hai definito.

aws iot list-topic-rules

Output:

{
    "rules": [
        {
            "ruleArn": "arn:aws:iot:us-west-2:123456789012:rule/MyRPiLowMoistureAlertRule",
            "ruleName": "MyRPiLowMoistureAlertRule",
            "topicPattern": "$aws/things/MyRPi/shadow/update/accepted",
            "createdAt": 1558624363.0,
            "ruleDisabled": false
        },
        {
            "ruleArn": "arn:aws:iot:us-west-2:123456789012:rule/MyPlantPiMoistureAlertRule",
            "ruleName": "MyPlantPiMoistureAlertRule",
            "topicPattern": "$aws/things/MyPlantPi/shadow/update/accepted",
            "createdAt": 1541458459.0,
            "ruleDisabled": false
        }
    ]
}

Per ulteriori informazioni, consulta Visualizzazione delle regole nella Guida per gli sviluppatori di AWS IoT.

Come elencare i livelli di registrazione di log

L’esempio list-v2-logging-levels seguente elenca i livelli di registrazione di log configurati. Se non sono stati impostati livelli di registrazione di log, si verifica un errore NotConfiguredException quando esegui questo comando.

aws iot list-v2-logging-levels

Output:

{
    "logTargetConfigurations": [
        {
            "logTarget": {
                "targetType": "DEFAULT"
            },
            "logLevel": "ERROR"
        }
    ]
}

Come elencare le violazioni del profilo di sicurezza durante un periodo di tempo

L’esempio list-violation-events seguente elenca le violazioni che si sono verificate tra il 5 giugno 2019 e il 12 giugno 2019 per tutti i profili di sicurezza AWS IoT Device Defender relativi all’account AWS e alla Regione AWS correnti.

aws iot list-violation-events \
    --start-time 1559747125 \
    --end-time 1560351925

Output:

{
    "violationEvents": [
        {
            "violationId": "174db59167fa474c80a652ad1583fd44",
            "thingName": "iotconsole-1560269126751-1",
            "securityProfileName": "Testprofile",
            "behavior": {
                "name": "Authorization",
                "metric": "aws:num-authorization-failures",
                "criteria": {
                    "comparisonOperator": "greater-than",
                    "value": {
                        "count": 10
                    },
                    "durationSeconds": 300,
                    "consecutiveDatapointsToAlarm": 1,
                    "consecutiveDatapointsToClear": 1
                }
            },
            "metricValue": {
                "count": 0
            },
            "violationEventType": "in-alarm",
            "violationEventTime": 1560279000.0
        },
        {
            "violationId": "c8a9466a093d3b7b35cd44ca58bdbeab",
            "thingName": "TvnQoEoU",
            "securityProfileName": "Testprofile",
            "behavior": {
                "name": "CellularBandwidth",
                "metric": "aws:message-byte-size",
                "criteria": {
                    "comparisonOperator": "greater-than",
                    "value": {
                        "count": 128
                    },
                    "consecutiveDatapointsToAlarm": 1,
                    "consecutiveDatapointsToClear": 1
                }
            },
            "metricValue": {
                "count": 110
            },
            "violationEventType": "in-alarm",
            "violationEventTime": 1560276600.0
        },
        {
            "violationId": "74aa393adea02e6648f3ac362beed55e",
            "thingName": "iotconsole-1560269232412-2",
            "securityProfileName": "Testprofile",
            "behavior": {
                "name": "Authorization",
                "metric": "aws:num-authorization-failures",
                "criteria": {
                    "comparisonOperator": "greater-than",
                    "value": {
                        "count": 10
                    },
                    "durationSeconds": 300,
                    "consecutiveDatapointsToAlarm": 1,
                    "consecutiveDatapointsToClear": 1
                }
            },
            "metricValue": {
                "count": 0
            },
            "violationEventType": "in-alarm",
            "violationEventTime": 1560276600.0
        },
        {
            "violationId": "1e6ab5f7cf39a1466fcd154e1377e406",
            "thingName": "TvnQoEoU",
            "securityProfileName": "Testprofile",
            "behavior": {
                "name": "Authorization",
                "metric": "aws:num-authorization-failures",
                "criteria": {
                    "comparisonOperator": "greater-than",
                    "value": {
                        "count": 10
                    },
                    "durationSeconds": 300,
                    "consecutiveDatapointsToAlarm": 1,
                    "consecutiveDatapointsToClear": 1
                }
            },
            "metricValue": {
                "count": 0
            },
            "violationEventType": "in-alarm",
            "violationEventTime": 1560276600.0
        }
    ]
}

Per ulteriori informazioni, consulta Comandi di rilevamento nella Guida per gli sviluppatori di AWS IoT.

Come registrare un certificato di autorità di certificazione (CA)

L’esempio register-ca-certificate seguente registra un certificato CA. Il comando fornisce il certificato CA e un certificato di verifica della chiave che dimostra che possiedi la chiave privata associata al certificato CA.

aws iot register-ca-certificate \
    --ca-certificate file://rootCA.pem \
    --verification-cert file://verificationCert.pem

Output:

{
    "certificateArn": "arn:aws:iot:us-west-2:123456789012:cacert/f4efed62c0142f16af278166f61962501165c4f0536295207426460058cd1467",
    "certificateId": "f4efed62c0142f16af278166f61962501165c4f0536295207426460058cd1467"
 }

Per ulteriori informazioni, consulta RegisterCACertificate nella Documentazione di riferimento delle API AWS IoT.

Come registrare un certificato di dispositivo autofirmato

L’esempio register-certificate seguente registra il certificato di dispositivo deviceCert.pem firmato dal certificato CA rootCA.pem. Il certificato CA deve essere registrato prima di poterlo utilizzare per registrare un certificato di dispositivo autofirmato. Il certificato autofirmato deve essere firmato con lo stesso certificato CA passato a questo comando.

aws iot register-certificate \
    --certificate-pem file://deviceCert.pem \
    --ca-certificate-pem file://rootCA.pem

Output:

{
    "certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/488b6a7f2acdeb00a77384e63c4e40b18b1b3caaae57b7272ba44c45e3448142",
    "certificateId": "488b6a7f2acdeb00a77384e63c4e40b18b1b3caaae57b7272ba44c45e3448142"
 }

Per ulteriori informazioni, consulta RegisterCertificate nella Documentazione di riferimento delle API AWS IoT.

Come registrare un oggetto

L’esempio register-thing seguente registra un oggetto utilizzando un modello di provisioning.

aws iot register-thing \
    --template-body '{"Parameters":{"ThingName":{"Type":"String"},"AWS::IoT::Certificate::Id":{"Type":"String"}},"Resources": {"certificate":{"Properties":{"CertificateId":{"Ref":"AWS::IoT::Certificate::Id"},"Status":"Active"},"Type":"AWS::IoT::Certificate"},"policy":{"Properties":{"PolicyName":"MyIotPolicy"},"Type":"AWS::IoT::Policy"},"thing":{"OverrideSettings":{"AttributePayload":"MERGE","ThingGroups":"DO_NOTHING","ThingTypeName":"REPLACE"},"Properties":{"AttributePayload":{},"ThingGroups":[],"ThingName":{"Ref":"ThingName"},"ThingTypeName":"VirtualThings"},"Type":"AWS::IoT::Thing"}}}' \
    --parameters '{"ThingName":"Register-thing-trial-1","AWS::IoT::Certificate::Id":"799a9ea048a1e6aea42b55EXAMPLEf8697b4bafcd77a318a3068e30404b9233c"}'

Output:

{
    "certificatePem": "-----BEGIN CERTIFICATE-----\nMIIDWTCCAkGgAwIBAgIUYLk81I35cIppobpw
HiOJ2jNjboIwDQYJKoZIhvcNAQEL\nBQAwTTFLMEkGA1UECwxCQW1hem9uIFdlYiBTZXJ2aWNlcyBPPUFtYXpvbi
5jb20g\nSW5jLiBMPVNlYXR0bGUgU1Q9V2FzaGluZ3RvbiBDPVVTMB4XDTIwMDcyMzE2NDUw\nOVoXDTQ5MTIzMT
IzNTk1OVowHjEcMBoGA1UEAwwTQVdTIElvVCBDZXJ0aWZpY2F0\nZTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCC
AQoCggEBAO71uADhdBajqTmgrMV5\nmCFfBZQRMo1MdtVoZr2X+M4MzL+RARrtUzH9a2SMAckeX8KeblIOTKzORI
RDXnyE\n6lVOwjgAsd0ku22rFxex4eG2ikha7pYYkvuToqA7L3TxItRvfKrxRI4ZfJoFPip4\nKqiuBJVNOGKTcQ
Hd1RNOrddwwu6kFJLeKDmEXAMPLEdUF0N+qfR9yKnZQkm+g6Q2\nGXu7u0W3hn6nlRN8qVoka0uW12p53xM7oHVz
Gf+cxKBxlbOhGkp6yCfTSkUBm3Sp\n9zLw35kiHXVm4EVpwgNlnk6XcIGIkw8a/iy4pzmvuGAANY1/uU/zgCjymw
ZT5S30\nBV0CAwEAAaNgMF4wHwYDVR0jBBgwFoAUGx0tCcU3q2n1WXAuUCv6hugXjKswHQYD\nVR0OBBYEFOVtvZ
9Aj2RYFnkX7Iu01XTRUdxgMAwGA1UdEwEB/wQCMAAwDgYDVR0P\nAQH/BAQDAgeAMA0GCSqGSIb3DQEBCwUAA4IB
AQCXCQcpOtubS5ftOsDMTcpP/jNX\nDHyArxmjpSc2aCdmm7WX59lTKWyAdxGAvqaDVWqTo0oXI7tZ8w7aINlGi5
pXnifx\n3SBebMUoBbTktrC97yUaeL025mCFv8emDnTR/fE7PTsBKjW0g/rrfpwBxZLXDFwN\nnqkQjy3EDfifj2
6j0xYIqqWMPogyn4srOCKynS5wMJuQZlHQOnabVwnwK4Y0Mflp\np9+4susFUR9aT3BT1AcIwqSpzhlKhh4Iz7ND
kRn4amsUT210jg/zOO1Ow+BTHcVQ\nJly8XDu0CWSu04q6SnaBzHmlySIajxuRTP/AdfRouP1OXe+qlbPOBcvVvF
8o\n-----END CERTIFICATE-----\n",
    "resourceArns": {
        "certificate": "arn:aws:iot:us-west-2:571032923833:cert/799a9ea048a1e6aea42b55EXAMPLEf8697b4bafcd77a318a3068e30404b9233c",
        "thing": "arn:aws:iot:us-west-2:571032923833:thing/Register-thing-trial-1"
    }
}

Per ulteriori informazioni, consulta Provisioning per utente attendibile nella Guida per gli sviluppatori di AWS IoT Core.

Come rifiutare un trasferimento di certificato

L’esempio reject-certificate-transfer seguente rifiuta il trasferimento del certificato di dispositivo specificato da un altro account AWS.

aws iot reject-certificate-transfer \
    --certificate-id f0f33678c7c9a046e5cc87b2b1a58dfa0beec26db78addd5e605d630e05c7fc8

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Trasferire un certificato a un altro account nella Guida per gli sviluppatori di AWS IoT Core.

Come rimuovere un oggetto da un gruppo di fatturazione

L’esempio remove-thing-from-billing-group seguente rimuove l’oggetto specificato da un gruppo di fatturazione.

aws iot remove-thing-from-billing-group \
    --billing-group-name GroupOne \
    --thing-name MyOtherLightBulb

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Gruppi di fatturazione nella Guida per gli sviluppatori di AWS IoT.

Come rimuovere un oggetto da un gruppo di oggetti

L’esempio remove-thing-from-thing-group seguente rimuove l’oggetto specificato da un gruppo di oggetti.

aws iot remove-thing-from-thing-group \
    --thing-name bulb7 \
    --thing-group-name DeadBulbs

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Gruppi di oggetti <https://docs.aws.amazon.com/iot/latest/developerguide/thing-groups.html > nella Guida per gli sviluppatori di AWS IoT.

Come aggiornare la definizione di una regola dell’argomento

L’esempio replace-topic-rule seguente aggiorna la regola specificata per inviare un avviso SNS quando i valori del livello di umidità del terreno sono troppo bassi.

aws iot replace-topic-rule \
    --rule-name MyRPiLowMoistureAlertRule \
    --topic-rule-payload "{\"sql\": \"SELECT * FROM '$aws/things/MyRPi/shadow/update/accepted' WHERE state.reported.moisture = 'low'\", \"description\": \"Sends an alert when soil moisture level readings are too low.\",\"actions\": [{\"sns\":{\"targetArn\":\"arn:aws:sns:us-west-2:123456789012:MyRPiLowMoistureTopic\",\"roleArn\":\"arn:aws:iam::123456789012:role/service-role/MyRPiLowMoistureTopicRole\",\"messageFormat\": \"RAW\"}}],\"ruleDisabled\": false,\"awsIotSqlVersion\":\"2016-03-23\"}"

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Creating an AWS IoT Rule nella Guida per gli sviluppatori di AWS IoT.

Come eseguire una query sull’indice di oggetti

L’esempio search-index seguente esegue una query sull’indice AWS_Things per cercare gli oggetti il cui tipo è LightBulb.

aws iot search-index \
    --index-name "AWS_Things" \
    --query-string "thingTypeName:LightBulb"

Output:

{
    "things": [
        {
            "thingName": "MyLightBulb",
            "thingId": "40da2e73-c6af-406e-b415-15acae538797",
            "thingTypeName": "LightBulb",
            "thingGroupNames": [
                "LightBulbs",
                "DeadBulbs"
            ],
            "attributes": {
                "model": "123",
                "wattage": "75"
            },
            "connectivity": {
                "connected": false
            }
        },
        {
            "thingName": "ThirdBulb",
            "thingId": "615c8455-33d5-40e8-95fd-3ee8b24490af",
            "thingTypeName": "LightBulb",
            "attributes": {
                "model": "123",
                "wattage": "75"
            },
            "connectivity": {
                "connected": false
            }
        },
        {
            "thingName": "MyOtherLightBulb",
            "thingId": "6dae0d3f-40c1-476a-80c4-1ed24ba6aa11",
            "thingTypeName": "LightBulb",
            "attributes": {
                "model": "123",
                "wattage": "75"
            },
            "connectivity": {
                "connected": false
            }
        }
    ]
}

Per ulteriori informazioni, consulta Gestione dell’indicizzazione degli oggetti nella Guida per gli sviluppatori di AWS IoT.

Come impostare un sistema di autorizzazione predefinito

L’esempio set-default-authorizer seguente imposta il sistema di autorizzazione personalizzato denominato CustomAuthorizer come sistema di autorizzazione predefinito.

aws iot set-default-authorizer \
    --authorizer-name CustomAuthorizer

Output:

{
    "authorizerName": "CustomAuthorizer",
    "authorizerArn": "arn:aws:iot:us-west-2:123456789012:authorizer/CustomAuthorizer"
}

Per ulteriori informazioni, consulta CreateDefaultAuthorizer nella Documentazione di riferimento delle API AWS IoT.

Come impostare la versione predefinita di una policy

L’esempio set-default-policy-version seguente imposta la versione predefinita su 2 per la policy denominata UpdateDeviceCertPolicy.

aws iot set-default-policy-version \
    --policy-name UpdateDeviceCertPolicy \
    --policy-version-id 2

Questo comando non produce alcun output.

Come impostare il livello di registrazione di log per un gruppo di oggetti

L’esempio set-v2-logging-level seguente imposta il livello di registrazione di log per registrare avvertenze per il gruppo di oggetti specificato.

aws iot set-v2-logging-level \
    --log-target "{\"targetType\":\"THING_GROUP\",\"targetName\":\"LightBulbs\"}" \
    --log-level WARN

Questo comando non produce alcun output.

Come impostare le opzioni di registrazione di log

L’esempio set-v2-logging-options seguente imposta il livello di dettaglio della registrazione di log predefinito su ERROR e specifica l’ARN da utilizzare per la registrazione.

aws iot set-v2-logging-options \
    --default-log-level ERROR \
    --role-arn "arn:aws:iam::094249569039:role/service-role/iotLoggingRole"

Questo comando non produce alcun output.

Come applicare un’azione di mitigazione agli esiti di un audit

L’esempio start-audit-mitigation-actions-task seguente applica l’azione ResetPolicyVersionAction (che cancella la policy) al singolo esito specificato.

aws iot start-audit-mitigation-actions-task \
    --task-id "myActionsTaskId" \
    --target "findingIds=[\"0edbaaec-2fe1-4cf5-abc9-d4c3e51f7464\"]" \
    --audit-check-to-actions-mapping "IOT_POLICY_OVERLY_PERMISSIVE_CHECK=[\"ResetPolicyVersionAction\"]" \
    --client-request-token "adhadhahda"

Output:

{
    "taskId": "myActionsTaskId"
}

Per ulteriori informazioni, consulta StartAuditMitigationActionsTask (Comandi delle operazioni di mitigazione) nella Guida per gli sviluppatori di AWS IoT.

Come avviare immediatamente un audit

L’esempio start-on-demand-audit-task seguente avvia un audit AWS IoT Device Defender ed esegue tre controlli dei certificati.

aws iot start-on-demand-audit-task \
    --target-check-names CA_CERTIFICATE_EXPIRING_CHECK DEVICE_CERTIFICATE_EXPIRING_CHECK REVOKED_CA_CERTIFICATE_STILL_ACTIVE_CHECK

Output:

{
    "taskId": "a3aea009955e501a31b764abe1bebd3d"
}

Per ulteriori informazioni, consulta Comandi di auditing nella Guida per gli sviluppatori di AWS IoT.

Come specificare una chiave e un valore di tag per una risorsa

L’esempio tag-resource seguente applica il tag con una chiave Assembly e il valore Fact1NW al gruppo di oggetti LightBulbs.

aws iot tag-resource \
    --tags Key=Assembly,Value="Fact1NW" \
    --resource-arn "arn:aws:iot:us-west-2:094249569039:thinggroup/LightBulbs"

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Tagging delle risorse AWS IoT nella Guida per gli sviluppatori di AWS IoT.

Come testare le policy AWS IoT

L’esempio test-authorization seguente testa le policy AWS IoT associate al principale specificato.

aws iot test-authorization \
    --auth-infos actionType=CONNECT,resources=arn:aws:iot:us-east-1:123456789012:client/client1 \
    --principal arn:aws:iot:us-west-2:123456789012:cert/aab1068f7f43ac3e3cae4b3a8aa3f308d2a750e6350507962e32c1eb465d9775

Output:

{
    "authResults": [
        {
            "authInfo": {
                "actionType": "CONNECT",
                "resources": [
                    "arn:aws:iot:us-east-1:123456789012:client/client1"
                ]
            },
            "allowed": {
                "policies": [
                    {
                        "policyName": "TestPolicyAllowed",
                        "policyArn": "arn:aws:iot:us-west-2:123456789012:policy/TestPolicyAllowed"
                    }
                ]
            },
            "denied": {
                "implicitDeny": {
                    "policies": [
                        {
                            "policyName": "TestPolicyDenied",
                            "policyArn": "arn:aws:iot:us-west-2:123456789012:policy/TestPolicyDenied"
                        }
                    ]
                },
                "explicitDeny": {
                    "policies": [
                        {
                            "policyName": "TestPolicyExplicitDenied",
                            "policyArn": "arn:aws:iot:us-west-2:123456789012:policy/TestPolicyExplicitDenied"
                        }
                    ]
                }
            },
            "authDecision": "IMPLICIT_DENY",
            "missingContextValues": []
        }
    ]
}

Per ulteriori informazioni, consulta TestAuthorization nella Documentazione di riferimento delle API AWS IoT.

Come testare il sistema di autorizzazione personalizzato

L’esempio test-invoke-authorizer seguente testa il sistema di autorizzazione personalizzato.

aws iot test-invoke-authorizer \
    --authorizer-name IoTAuthorizer \
    --token allow \
    --token-signature "mE0GvaHqy9nER/FdgtJX5lXYEJ3b3vE7t1gEszc0TKGgLKWXTnPkb2AbKnOAZ8lGyoN5dVtWDWVmr25m7++zjbYIMk2TBvyGXhOmvKFBPkdgyA43KL6SiZy0cTqlPMcQDsP7VX2rXr7CTowCxSNKphGXdQe0/I5dQ+JO6KUaHwCmupt0/MejKtaNwiia064j6wprOAUwG5S1IYFuRd0X+wfo8pb0DubAIX1Ua705kuhRUcTx4SxUShEYKmN4IDEvLB6FsIr0B2wvB7y4iPmcajxzGl02ExvyCUNctCV9dYlRRGJj0nsGzBIXOI4sGytPfqlA7obdgmN22pkDzYvwjQ=="

Output:

{
    "isAuthenticated": true,
    "principalId": "principalId",
    "policyDocuments": [
        "{"Version":"2012-10-17",		 	 	 "Statement":[{"Action":"iot:Publish","Effect":"Allow","Resource":"arn:aws:iot:us-west-2:123456789012:topic/customauthtesting"}]}"
    ],
    "refreshAfterInSeconds": 600,
    "disconnectAfterInSeconds": 3600
}

Per ulteriori informazioni, consulta TestInvokeAuthorizer nella Documentazione di riferimento delle API AWS IoT.

Come trasferire un certificato di dispositivo in un account AWS diverso

L’esempio transfer-certificate seguente trasferisce un certificato di dispositivo in un altro account AWS. Il certificato e l’account AWS sono identificati tramite ID.

aws iot transfer-certificate \
    --certificate-id 488b6a7f2acdeb00a77384e63c4e40b18b1b3caaae57b7272ba44c45e3448142 \
    --target-aws-account 030714055129

Output:

{
    "transferredCertificateArn": "arn:aws:iot:us-west-2:030714055129:cert/488b6a7f2acdeb00a77384e63c4e40b18b1b3caaae57b7272ba44c45e3448142"
}

Per ulteriori informazioni, consulta Trasferire un certificato a un altro account nella Guida per gli sviluppatori di AWS IoT Core.

Come rimuovere una chiave di tag da una risorsa

L’esempio untag-resource seguente rimuove il tag MyTag e il relativo valore dal gruppo di oggetti LightBulbs.

command

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Tagging delle risorse AWS IoT nella Guida per gli sviluppatori di AWS IoT.

Esempio 1: per abilitare le notifiche di Amazon SNS per le notifiche di audit

L’esempio update-account-audit-configuration seguente abilita le notifiche di Amazon SNS per le notifiche di audit di AWS IoT Device Defender, specificando una destinazione e il ruolo utilizzato per scrivere su tale destinazione.

aws iot update-account-audit-configuration \
    --audit-notification-target-configurations "SNS={targetArn=\"arn:aws:sns:us-west-2:123456789012:ddaudits\",roleArn=\"arn:aws:iam::123456789012:role/service-role/AWSIoTDeviceDefenderAudit\",enabled=true}"

Questo comando non produce alcun output.

Esempio 2: per abilitare un controllo di audit

L’esempio update-account-audit-configuration seguente abilita il controllo di audit AWS IoT Device Defender denominato AUTHENTICATED_COGNITO_ROLE_OVERLY_PERMISSIVE_CHECK. Non è possibile disabilitare un controllo di audit se fa parte dell’oggetto targetCheckNames di uno o più audit pianificati per l’account AWS.

aws iot update-account-audit-configuration \
    --audit-check-configurations "{\"AUTHENTICATED_COGNITO_ROLE_OVERLY_PERMISSIVE_CHECK\":{\"enabled\":true}}"

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Comandi di auditing nella Guida per gli sviluppatori di AWS IoT.

Come aggiornare una soppressione degli esiti di un audit

L’esempio update-audit-suppression seguente aggiorna la data di scadenza della soppressione degli esiti di un audit al 21/09/2020.

aws iot update-audit-suppression \
    --check-name DEVICE_CERTIFICATE_EXPIRING_CHECK \
    --resource-identifier deviceCertificateId=c7691e<shortened> \
    --no-suppress-indefinitely \
    --expiration-date 2020-09-21

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Soppressioni della ricerca di audit nella Guida per gli sviluppatori di AWS IoT.

Come aggiornare un sistema di autorizzazione personalizzato

L’esempio update-authorizer seguente imposta lo stato di CustomAuthorizer2 su INACTIVE.

aws iot update-authorizer \
    --authorizer-name CustomAuthorizer2 \
    --status INACTIVE

Output:

{
    "authorizerName": "CustomAuthorizer2",
    "authorizerArn": "arn:aws:iot:us-west-2:123456789012:authorizer/CustomAuthorizer2"
}

Per ulteriori informazioni, consulta UpdateAuthorizer nella Documentazione di riferimento delle API AWS IoT.

Come aggiornare le informazioni su un gruppo di fatturazione

L’esempio update-billing-group seguente aggiorna la descrizione del gruppo di fatturazione specificato.

aws iot update-billing-group \
    --billing-group-name GroupOne \
    --billing-group-properties "billingGroupDescription=\"Primary bulb billing group\""

Output:

{
    "version": 2
}

Per ulteriori informazioni, consulta Gruppi di fatturazione nella Guida per gli sviluppatori di AWS IoT.

Come aggiornare un certificato di autorità di certificazione (CA)

L’esempio update-ca-certificate seguente imposta lo stato del certificato CA specificato su ACTIVE.

aws iot update-ca-certificate \
    --certificate-id f4efed62c0142f16af278166f61962501165c4f0536295207426460058cd1467 \
    --new-status ACTIVE

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta UpdateCACertificate nella Documentazione di riferimento delle API AWS IoT.

Come aggiornare un certificato di dispositivo

L’esempio update-certificate seguente imposta lo stato del certificato di dispositivo specificato su INACTIVE.

aws iot update-certificate \
    --certificate-id d1eb269fb55a628552143c8f96eb3c258fcd5331ea113e766ba0c82bf225f0be \
    --new-status INACTIVE

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta UpdateCertificate nella Documentazione di riferimento delle API AWS IoT.

Come aggiornare una metrica personalizzata

L’esempio update-custom-metric seguente aggiorna una metrica personalizzata per avere un nuovo oggetto display-name.

aws iot update-custom-metric \
    --metric-name batteryPercentage \
    --display-name 'remaining battery percentage on device' \
    --region us-east-1

Output:

{
    "metricName": "batteryPercentage",
    "metricArn": "arn:aws:iot:us-east-1:1234564789012:custommetric/batteryPercentage",
    "metricType": "number",
    "displayName": "remaining battery percentage on device",
    "creationDate": "2020-11-17T23:01:35.110000-08:00",
    "lastModifiedDate": "2020-11-17T23:02:12.879000-08:00"
}

Per ulteriori informazioni, consulta Parametri personalizzati nella Guida per gli sviluppatori di AWS IoT Core.

Come aggiornare una dimensione

L’esempio update-dimension seguente aggiorna una dimensione.

aws iot update-dimension \
    --name TopicFilterForAuthMessages \
    --string-values device/${iot:ClientId}/auth

Output:

{
    "name": "TopicFilterForAuthMessages",
    "lastModifiedDate": 1585866222.317,
    "stringValues": [
        "device/${iot:ClientId}/auth"
    ],
    "creationDate": 1585854500.474,
    "type": "TOPIC_FILTER",
    "arn": "arn:aws:iot:us-west-2:1234564789012:dimension/TopicFilterForAuthMessages"
}

Per ulteriori informazioni, consulta Parametri di ambito nei profili di sicurezza utilizzando le dimensioni nella Guida per gli sviluppatori di AWS IoT Core.

Come aggiornare una configurazione di dominio

L’esempio update-domain-configuration seguente disabilita la configurazione di dominio specificata.

aws iot update-domain-configuration \
    --domain-configuration-name "additionalDataDomain" \
    --domain-configuration-status "DISABLED"

Output:

{
    "domainConfigurationName": "additionalDataDomain",
    "domainConfigurationArn": "arn:aws:iot:us-west-2:123456789012:domainconfiguration/additionalDataDomain/dikMh"
}

Per ulteriori informazioni, consulta Endpoint configurabili nella Guida per gli sviluppatori di AWS IoT.

Come aggiornare un gruppo di oggetti dinamico

L’esempio update-dynamic-thing-group seguente aggiorna il gruppo di oggetti dinamici specificato. Fornisce una descrizione e aggiorna la stringa di query per modificare i criteri di appartenenza al gruppo.

aws iot update-dynamic-thing-group \
    --thing-group-name "RoomTooWarm"
    --thing-group-properties "thingGroupDescription=\"This thing group contains rooms warmer than 65F.\"" \
    --query-string "attributes.temperature>65"

Output:

{
    "version": 2
}

Per ulteriori informazioni, consulta Gruppi di oggetti dinamici nella Guida per gli sviluppatori di AWS IoT.

Come mostrare quali tipi di eventi vengono pubblicati

L’esempio update-event-configurations seguente aggiorna la configurazione per abilitare messaggi quando il certificato CA viene aggiunto, aggiornato o eliminato.

aws iot update-event-configurations \
    --event-configurations "{\"CA_CERTIFICATE\":{\"Enabled\":true}}"

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Messaggi di eventi nella Guida per gli sviluppatori di AWS IoT.

Come abilitare l’indicizzazione degli oggetti

L’esempio update-indexing-configuration seguente abilita l’indicizzazione degli oggetti per supportare la ricerca dei dati del registro, i dati shadow e lo stato di connettività degli oggetti utilizzando l’indice AWS_Things.

aws iot update-indexing-configuration
    --thing-indexing-configuration thingIndexingMode=REGISTRY_AND_SHADOW,thingConnectivityIndexingMode=STATUS

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Gestione dell’indicizzazione degli oggetti nella Guida per gli sviluppatori di AWS IoT.

Come ottenere lo stato dettagliato di un processo

L’esempio update-job seguente ottiene lo stato dettagliato del progetto con ID example-job-01.

aws iot describe-job \
    --job-id "example-job-01"

Output:

{
    "job": {
        "jobArn": "arn:aws:iot:us-west-2:123456789012:job/example-job-01",
        "jobId": "example-job-01",
        "targetSelection": "SNAPSHOT",
        "status": "IN_PROGRESS",
        "targets": [
            "arn:aws:iot:us-west-2:123456789012:thing/MyRaspberryPi"
        ],
        "description": "example job test",
        "presignedUrlConfig": {},
        "jobExecutionsRolloutConfig": {},
        "createdAt": 1560787022.733,
        "lastUpdatedAt": 1560787026.294,
        "jobProcessDetails": {
            "numberOfCanceledThings": 0,
            "numberOfSucceededThings": 0,
            "numberOfFailedThings": 0,
            "numberOfRejectedThings": 0,
            "numberOfQueuedThings": 1,
            "numberOfInProgressThings": 0,
            "numberOfRemovedThings": 0,
            "numberOfTimedOutThings": 0
        },
        "timeoutConfig": {}
    }
}

Per ulteriori informazioni, consulta Creazione e gestione di processi (CLI) nella Guida per gli sviluppatori di AWS IoT.

Come aggiornare un’azione di mitigazione

L’esempio update-mitigation-action seguente aggiorna l’azione di mitigazione specificata denominata AddThingsToQuarantineGroupAction, modifica il nome del gruppo di oggetti e imposta overrideDynamicGroups su false. È possibile verificare le modifiche utilizzando il comando describe-mitigation-action.

aws iot update-mitigation-action \
    --cli-input-json "{ \"actionName\": \"AddThingsToQuarantineGroupAction\", \"actionParams\": { \"addThingsToThingGroupParams\": {\"thingGroupNames\":[\"QuarantineGroup2\"],\"overrideDynamicGroups\": false}}}"

Output:

{
    "actionArn": "arn:aws:iot:us-west-2:123456789012:mitigationaction/AddThingsToQuarantineGroupAction",
    "actionId": "2fd2726d-98e1-4abf-b10f-09465ccd6bfa"
}

Per ulteriori informazioni, consulta UpdateMitigationAction (Comandi delle operazioni di mitigazione) nella Guida per gli sviluppatori di AWS IoT.

Come aggiornare un modello di provisioning

L’esempio update-provisioning-template seguente modifica la descrizione e l’ARN del ruolo per il modello di provisioning specificato e abilita il modello.

aws iot update-provisioning-template \
    --template-name widget-template \
    --enabled \
    --description "An updated provisioning template for widgets" \
    --provisioning-role-arn arn:aws:iam::504350838278:role/Provision_role

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Tunnel sicuro di AWS IoT nella Guida per gli sviluppatori di AWS IoT Core.

Come aggiornare un alias di ruolo

L’esempio update-role-alias seguente aggiorna l’alias di ruolo LightBulbRole.

aws iot update-role-alias \
    --role-alias LightBulbRole \
    --role-arn arn:aws:iam::123456789012:role/lightbulbrole-001

Output:

{
    "roleAlias": "LightBulbRole",
    "roleAliasArn": "arn:aws:iot:us-west-2:123456789012:rolealias/LightBulbRole"
}

Per ulteriori informazioni, consulta UpdateRoleAlias nella Documentazione di riferimento delle API AWS IoT.

Come aggiornare una definizione di audit pianificato

L’esempio update-scheduled-audit seguente modifica i nomi dei controlli di destinazione per un audit pianificato di AWS IoT Device Defender.

aws iot update-scheduled-audit \
    --scheduled-audit-name WednesdayCertCheck \
    --target-check-names CA_CERTIFICATE_EXPIRING_CHECK DEVICE_CERTIFICATE_EXPIRING_CHECK REVOKED_CA_CERTIFICATE_STILL_ACTIVE_CHECK

Output:

{
    "scheduledAuditArn": "arn:aws:iot:us-west-2:123456789012:scheduledaudit/WednesdayCertCheck"
}

Per ulteriori informazioni, consulta Comandi di auditing nella Guida per gli sviluppatori di AWS IoT.

Come modificare un profilo di sicurezza

L’esempio update-security-profile seguente aggiorna sia la descrizione che i comportamenti per un profilo di sicurezza AWS IoT Device Defender.

aws iot update-security-profile \
    --security-profile-name PossibleIssue \
    --security-profile-description "Check to see if authorization fails 12 times in 5 minutes or if cellular bandwidth exceeds 128"  \
    --behaviors "[{\"name\":\"CellularBandwidth\",\"metric\":\"aws:message-byte-size\",\"criteria\":{\"comparisonOperator\":\"greater-than\",\"value\":{\"count\":128},\"consecutiveDatapointsToAlarm\":1,\"consecutiveDatapointsToClear\":1}},{\"name\":\"Authorization\",\"metric\":\"aws:num-authorization-failures\",\"criteria\":{\"comparisonOperator\":\"less-than\",\"value\":{\"count\":12},\"durationSeconds\":300,\"consecutiveDatapointsToAlarm\":1,\"consecutiveDatapointsToClear\":1}}]"

Output:

{
    "securityProfileName": "PossibleIssue",
    "securityProfileArn": "arn:aws:iot:us-west-2:123456789012:securityprofile/PossibleIssue",
    "securityProfileDescription": "check to see if authorization fails 12 times in 5 minutes or if cellular bandwidth exceeds 128",
    "behaviors": [
        {
            "name": "CellularBandwidth",
            "metric": "aws:message-byte-size",
            "criteria": {
                "comparisonOperator": "greater-than",
                "value": {
                    "count": 128
                },
                "consecutiveDatapointsToAlarm": 1,
                "consecutiveDatapointsToClear": 1
            }
        },
        {
            "name": "Authorization",
            "metric": "aws:num-authorization-failures",
            "criteria": {
                "comparisonOperator": "less-than",
                "value": {
                    "count": 12
                },
                "durationSeconds": 300,
                "consecutiveDatapointsToAlarm": 1,
                "consecutiveDatapointsToClear": 1
            }
        }
    ],
    "version": 2,
    "creationDate": 1560278102.528,
    "lastModifiedDate": 1560352711.207
}

Per ulteriori informazioni, consulta Comandi di rilevamento nella Guida per gli sviluppatori di AWS IoT.

Come aggiornare un flusso

L’esempio update-stream seguente aggiorna un flusso esistente. La versione del flusso viene incrementata di 1.

aws iot update-stream \
    --cli-input-json file://update-stream.json

Contenuto di update-stream.json.

{
    "streamId": "stream12345",
    "description": "This stream is used for Amazon FreeRTOS OTA Update 12345.",
    "files": [
        {
            "fileId": 123,
            "s3Location": {
                "bucket":"codesign-ota-bucket",
                "key":"48c67f3c-63bb-4f92-a98a-4ee0fbc2bef6"
            }
        }
    ]
    "roleArn": "arn:aws:iam:us-west-2:123456789012:role/service-role/my_ota_stream_role"
}

Output:

{
    "streamId": "stream12345",
    "streamArn": "arn:aws:iot:us-west-2:123456789012:stream/stream12345",
    "description": "This stream is used for Amazon FreeRTOS OTA Update 12345.",
    "streamVersion": 2
}

Per ulteriori informazioni, consulta UpdateStream nella Documentazione di riferimento delle API AWS IoT.

Come aggiornare la definizione di un gruppo di oggetti

L’esempio update-thing-group seguente aggiorna la definizione per il gruppo di oggetti specificato, modificando la descrizione e due attributi.

aws iot update-thing-group \
    --thing-group-name HalogenBulbs \
    --thing-group-properties "thingGroupDescription=\"Halogen bulb group\", attributePayload={attributes={Manufacturer=AnyCompany,wattage=60}}"

Output:

{
    "version": 2
}

Per ulteriori informazioni, consulta Gruppi di oggetti nella Guida per gli sviluppatori di AWS IoT.

Come modificare i gruppi a cui appartiene un oggetto

L’esempio update-thing-groups-for-thing seguente rimuove l’oggetto denominato MyLightBulb dal gruppo denominato DeadBulbs e contemporaneamente lo aggiunge al gruppo denominato replaceableItems.

aws iot update-thing-groups-for-thing \
    --thing-name MyLightBulb \
    --thing-groups-to-add "replaceableItems" \
    --thing-groups-to-remove "DeadBulbs"

Questo comando non produce alcun output.

Per ulteriori informazioni, consulta Gruppi di oggetti nella Guida per gli sviluppatori di AWS IoT.

Come associare un oggetto a un tipo di oggetto

L’esempio update-thing seguente associa un oggetto nel registro AWS IoT a un tipo di oggetto. Quando crei l’associazione, fornisci valori per gli attributi definiti dal tipo di oggetto.