Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Gestione dei dispositivi con AWS IoT
AWS IoT fornisce un registro che ti aiuta a gestire *le cose*. Una cosa è una rappresentazione di un dispositivo o di un'entità logica specifici. Può trattarsi di un dispositivo fisico o un sensore, ad esempio una lampadina o un interruttore su un muro. Può anche essere un'entità logica come un'istanza di un'applicazione o un'entità fisica che non si connette AWS IoT ma è collegata ad altri dispositivi che lo fanno (ad esempio, un'auto dotata di sensori del motore o un pannello di controllo).
Le informazioni su un oggetto vengono archiviate nel registro come dati JSON. Di seguito è illustrato un esempio di oggetto:
```
{
"version": 3,
"thingName": "MyLightBulb",
"defaultClientId": "MyLightBulb",
"thingTypeName": "LightBulb",
"attributes": {
"model": "123",
"wattage": "75"
}
}
```
Gli oggetti sono identificati da un nome. Gli oggetti possono anche avere attributi, che sono coppie nome–valore che è possibile usare per archiviare le informazioni sull'oggetto, ad esempio il numero di serie o il produttore.
Un tipico caso d'uso di un dispositivo prevede l'uso del nome dell'oggetto come ID client MQTT predefinito. Sebbene non imponiamo una mappatura tra il nome del registro di un oggetto e l'utilizzo del client MQTT IDs, dei certificati o dello stato ombra, consigliamo di scegliere un nome di oggetto e utilizzarlo come ID client MQTT sia per il registro che per il servizio Device Shadow. In questo modo, puoi ottenere organizzazione e comodità per il parco istanze IoT senza rinunciare alla flessibilità del modello di certificati dei dispositivi sottostante o delle copie shadow.
Non è necessario creare un oggetto nel registro per connettere un dispositivo ad AWS IoT. L'aggiunta di oggetti al registro permette di semplificare le attività di gestione e ricerca di dispositivi.
I dati del registro degli oggetti (inclusi gli attributi, i tipi di oggetti e le appartenenze ai gruppi) possono anche essere recuperati dinamicamente nel motore delle regole per utilizzarli nell'elaborazione e nel routing dei messaggi. Per ulteriori informazioni, consulta [https://docs.aws.amazon.com//iot/latest/developerguide/iot-sql-functions.html#iot-sql-function-get-registry_data](https://docs.aws.amazon.com//iot/latest/developerguide/iot-sql-functions.html#iot-sql-function-get-registry_data).
# Gestire gli elementi con il registro
Si utilizza la AWS IoT console, AWS IoT l'API o il AWS CLI per interagire con il registro. Nelle seguenti sezioni viene illustrato come usare l'interfaccia a riga di comando per lavorare con il registro.
**Quando nomini gli oggetti:**
+ Non utilizzare informazioni di identificazione personale nel nome dell'oggetto. Il nome dell'oggetto può essere visualizzato nelle comunicazioni e nei report non crittografati.
**Topics**
+ [Crea un oggetto](create-thing.md)
+ [Visualizzazione dell'elenco di oggetti](list-things.md)
+ [Descrizione di oggetti](search-things.md)
+ [Aggiornamento di un oggetto](update-thing.md)
+ [Eliminazione di un oggetto](delete-thing.md)
+ [Collegamento di un'entità principale a un oggetto](attach-thing-principal.md)
+ [Elenca le cose associate a un preside](list-principal-things.md)
+ [Elenca i principi associati a una cosa](list-thing-principals.md)
+ [Elenca le cose associate a una V2 principale](list-principal-things-v2.md)
+ [Elenca i principi associati a una cosa V2](list-thing-principals-v2.md)
+ [Scollegamento di un'entità principale da un oggetto](detach-thing-principal.md)
# Crea un oggetto
Il comando seguente mostra come utilizzare il AWS IoT **CreateThing** comando dalla CLI per creare un oggetto. Non puoi cambiare il nome di un oggetto dopo averlo creato. Per cambiare il nome di un oggetto, creane uno nuovo, assegnagli il nuovo nome e poi elimina quello vecchio.
```
$ aws iot create-thing \
--thing-type-name "MyLightBulb" \
--attribute-payload "{\"attributes\": {\"wattage\":\"75\", \"model\":\"123\"}}"
```
Il comando **CreateThing** visualizza il nome e il nome della risorsa Amazon (ARN) del nuovo oggetto.
```
{
"thingArn": "arn:aws:iot:us-east-1:123456789012:thing/MyLightBulb",
"thingName": "MyLightBulb",
"thingId": "12345678abcdefgh12345678ijklmnop12345678"
}
```
**Nota**
Non è consigliabile utilizzare informazioni di identificazione personale nei nomi degli oggetti.
Per ulteriori informazioni, consulta [create-thing](https://docs.aws.amazon.com//cli/latest/reference/iot/create-thing.html) nella Guida di riferimento ai comandi dell' AWS CLI .
# Visualizzazione dell'elenco di oggetti
Usa il comando **ListThings** per elencare tutti gli oggetti nell'account:
```
$ aws iot list-things
```
```
{
"things": [
{
"attributes": {
"model": "123",
"wattage": "75"
},
"version": 1,
"thingName": "MyLightBulb"
},
{
"attributes": {
"numOfStates":"3"
},
"version": 11,
"thingName": "MyWallSwitch"
}
]
}
```
Usa il comando **ListThings** per cercare tutti gli oggetti di un tipo di oggetto specifico:
```
$ aws iot list-things --thing-type-name "LightBulb"
```
```
{
"things": [
{
"thingTypeName": "LightBulb",
"attributes": {
"model": "123",
"wattage": "75"
},
"version": 1,
"thingName": "MyRGBLight"
},
{
"thingTypeName": "LightBulb",
"attributes": {
"model": "123",
"wattage": "75"
},
"version": 1,
"thingName": "MySecondLightBulb"
}
]
}
```
Usa il comando **ListThings** per cercare tutti gli oggetti che hanno un attributo con un valore specifico. Questo comando ricerca fino a tre attributi.
```
$ aws iot list-things --attribute-name "wattage" --attribute-value "75"
```
```
{
"things": [
{
"thingTypeName": "StopLight",
"attributes": {
"model": "123",
"wattage": "75"
},
"version": 3,
"thingName": "MyLightBulb"
},
{
"thingTypeName": "LightBulb",
"attributes": {
"model": "123",
"wattage": "75"
},
"version": 1,
"thingName": "MyRGBLight"
},
{
"thingTypeName": "LightBulb",
"attributes": {
"model": "123",
"wattage": "75"
},
"version": 1,
"thingName": "MySecondLightBulb"
}
]
}
```
Per ulteriori informazioni, consulta [list-things](https://docs.aws.amazon.com//cli/latest/reference/iot/list-things.html) nella Guida di riferimento ai comandi dell' AWS CLI .
# Descrizione di oggetti
Utilizza il comando **DescribeThing** per visualizzare maggiori informazioni su un oggetto:
```
$ aws iot describe-thing --thing-name "MyLightBulb"
{
"version": 3,
"thingName": "MyLightBulb",
"thingArn": "arn:aws:iot:us-east-1:123456789012:thing/MyLightBulb",
"thingId": "12345678abcdefgh12345678ijklmnop12345678",
"defaultClientId": "MyLightBulb",
"thingTypeName": "StopLight",
"attributes": {
"model": "123",
"wattage": "75"
}
}
```
Puoi anche accedere a questa API all'interno del motore delle regole utilizzando la funzione `get_registry_data()` inline. È possibile utilizzare questa funzione per accedere e utilizzare dinamicamente le informazioni del registro degli oggetti (inclusi attributi, tipi di oggetti e appartenenze ai gruppi) chiamando e `ListThingGroupsForThing` APIs direttamente all'interno delle AWS IoT regole, abilitando l'elaborazione `DescribeThing` e il routing dei messaggi in tempo reale in base ai dati del registro del dispositivo. Per ulteriori informazioni, consulta [https://docs.aws.amazon.com//iot/latest/developerguide/iot-sql-functions.html#iot-sql-function-get-registry_data](https://docs.aws.amazon.com//iot/latest/developerguide/iot-sql-functions.html#iot-sql-function-get-registry_data).
Per ulteriori informazioni, vedere [describe-thing](https://docs.aws.amazon.com//cli/latest/reference/iot/describe-thing.html) dal Command Reference. AWS CLI
# Aggiornamento di un oggetto
Usa il comando **UpdateThing** per aggiornare un oggetto. Questo comando aggiorna solo gli attributi dell'oggetto. Non puoi cambiare il nome di un oggetto. Per cambiare il nome di un oggetto, creane uno nuovo, assegnagli un nuovo nome e quindi elimina quello vecchio.
```
$ aws iot update-thing --thing-name "MyLightBulb" --attribute-payload "{\"attributes\": {\"wattage\":\"150\", \"model\":\"456\"}}"
```
Il comando **UpdateThing** non produce output. Usa il comando **DescribeThing** per visualizzare il risultato:
```
$ aws iot describe-thing --thing-name "MyLightBulb"
{
"attributes": {
"model": "456",
"wattage": "150"
},
"version": 2,
"thingName": "MyLightBulb"
}
```
Per ulteriori informazioni, consulta [update-thing](https://docs.aws.amazon.com//cli/latest/reference/iot/update-thing.html) nella Guida di riferimento ai comandi dell' AWS CLI .
# Eliminazione di un oggetto
Usa il comando **DeleteThing** per eliminare un oggetto:
```
$ aws iot delete-thing --thing-name "MyThing"
```
Questo comando ha esito positivo senza alcun errore se l'eliminazione va a buon fine oppure se specifichi un oggetto che non esiste.
Per ulteriori informazioni, consulta [delete-thing](https://docs.aws.amazon.com//cli/latest/reference/iot/delete-thing.html) nella Guida di riferimento ai comandi dell' AWS CLI .
# Collegamento di un'entità principale a un oggetto
Un dispositivo fisico può utilizzare un dispositivo principale con cui comunicare AWS IoT. Un principale può essere un certificato X.509 o un ID Amazon Cognito. Puoi associare un certificato o un ID Amazon Cognito all'elemento nel registro che rappresenta il tuo dispositivo, eseguendo il [attach-thing-principal](https://docs.aws.amazon.com//cli/latest/reference/iot/attach-thing-principal.html)comando.
Per allegare un certificato o un ID Amazon Cognito al tuo dispositivo, usa il [attach-thing-principal](https://docs.aws.amazon.com//cli/latest/reference/iot/attach-thing-principal.html)comando:
```
$ aws iot attach-thing-principal \
--thing-name "MyLightBulb1" \
--principal "arn:aws:iot:us-east-1:123456789012:cert/a0c01f5835079de0a7514643d68ef8414ab739a1e94ee4162977b02b12842847"
```
Per allegare un certificato a un oggetto con un tipo di allegato (allegato esclusivo o allegato non esclusivo), usa il [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot/attach-thing-principal.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot/attach-thing-principal.html)comando e specifica un tipo nel `--thing-principal-type` campo. Un allegato esclusivo significa che il tuo elemento IoT è l'unico elemento allegato al certificato e questo certificato non può essere associato a nessun altro elemento. Un allegato non esclusivo significa che il tuo oggetto IoT è allegato al certificato e questo certificato può essere associato ad altri elementi. Per ulteriori informazioni, consulta [Associazione di qualsiasi AWS IoT cosa a una connessione client MQTT](exclusive-thing.md).
**Nota**
Per [Associazione di qualsiasi AWS IoT cosa a una connessione client MQTT](exclusive-thing.md) questa funzionalità, è possibile utilizzare solo il certificato X.509 come principale.
```
$ aws iot attach-thing-principal \
--thing-name "MyLightBulb2" \
--principal "arn:aws:iot:us-east-1:123456789012:cert/a0c01f5835079de0a7514643d68ef8414ab739a1e94ee4162977b02b12842847" \
--thing-principal-type "EXCLUSIVE_THING"
```
Se l'allegato ha esito positivo, il **AttachThingPrincipal** comando non produce alcun output. Per descrivere l'allegato, utilizzare il list-thing-principals-v comando 2 CLI.
Per ulteriori informazioni, consulta [AttachThingPrincipal](https://docs.aws.amazon.com//iot/latest/apireference/API_AttachThingPrincipal.html)l'*AWS IoT Core API Reference.*
# Elenca le cose associate a un preside
Per elencare gli elementi associati al principale specificato, esegui il [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot/list-principal-things.htmls](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot/list-principal-things.htmls)comando. Nota che questo comando non elenca il tipo di allegato tra l'oggetto e il certificato. Per elencare il tipo di allegato, utilizzare il [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot/list-principal-thingsv2.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot/list-principal-thingsv2.html)comando. Per ulteriori informazioni, consulta [Elenca le cose associate a una V2 principale](list-principal-things-v2.md).
```
$ aws iot list-principal-things \
--principal "arn:aws:iot:us-east-1:123456789012:cert/2e1eb273792174ec2b9bf4e9b37e6c6c692345499506002a35159767055278e8"
```
L'output può essere simile al seguente.
```
{
"things": [
"MyLightBulb1",
"MyLightBulb2"
]
}
```
Per ulteriori informazioni, consulta [ListPrincipalThings](https://docs.aws.amazon.com//iot/latest/apireference/API_ListPrincipalThings.html)l'*AWS IoT Core API Reference*.
# Elenca i principi associati a una cosa
Per elencare i principali associati all'oggetto specificato, esegui il [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot/list-thing-principals.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot/list-thing-principals.html)comando. Nota che questo comando non elenca il tipo di allegato tra l'oggetto e il certificato. Per elencare il tipo di allegato, utilizzare il [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot/list-thing-principalsv2.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot/list-thing-principalsv2.html)comando. Per ulteriori informazioni, consulta [Elenca i principi associati a una cosa V2](list-thing-principals-v2.md).
```
$ aws iot list-thing-principals \
--thing-name "MyLightBulb1"
```
L'output può essere simile al seguente.
```
{
"principals": [
"arn:aws:iot:us-east-1:123456789012:cert/2e1eb273792174ec2b9bf4e9b37e6c6c692345499506002a35159767055278e8",
"arn:aws:iot:us-east-1:123456789012:cert/1a234b39b4b68278f2e9d84bf97eac2cbf4a1c28b23ea29a44559b9bcf8d395b"
]
}
```
Per ulteriori informazioni, consulta [ListThingPrincipals](https://docs.aws.amazon.com//iot/latest/apireference/API_ListThingPrincipals.html)l'*AWS IoT Core API Reference*.
# Elenca le cose associate a una V2 principale
Per elencare gli elementi associati al certificato specificato, insieme al tipo di allegato, esegui il [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot/list-principal-thingsv2.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot/list-principal-thingsv2.html)comando. Il tipo di allegato si riferisce al modo in cui il certificato è allegato all'oggetto.
```
$ aws iot list-principal-things-v2 \
--principal "arn:aws:iot:us-east-1:123456789012:cert/2e1eb273792174ec2b9bf4e9b37e6c6c692345499506002a35159767055278e8"
```
L'output può essere simile al seguente.
```
{
"PrincipalThingObjects": [
{
"thingPrincipalType": "NON_EXCLUSIVE_THING",
"thing": "arn:aws:iot:us-east-1:123456789012:thing/thing_1"
},
{
"thingPrincipalType": "NON_EXCLUSIVE_THING",
"thing": "arn:aws:iot:us-east-1:123456789012:thing/thing_2"
}
]
}
```
Per ulteriori informazioni, consulta [ListPrincipalThingsV2](https://docs.aws.amazon.com//iot/latest/apireference/API_ListPrincipalThingsV2.html) dall'*AWS IoT Core API Reference.*
# Elenca i principi associati a una cosa V2
Per elencare i certificati associati all'oggetto specificato, insieme al tipo di allegato, esegui il [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot/list-thing-principalsv2.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot/list-thing-principalsv2.html)comando. Il tipo di allegato si riferisce al modo in cui il certificato è allegato all'oggetto.
```
$ aws iot list-thing-principals-v2 \
--thing-name "thing_1"
```
L'output può essere simile al seguente.
```
{
"ThingPrincipalObjects": [
{
"thingPrincipalType": "NON_EXCLUSIVE_THING",
"principal": "arn:aws:iot:us-east-1:123456789012:cert/2e1eb273792174ec2b9bf4e9b37e6c6c692345499506002a35159767055278e8"
},
{
"thingPrincipalType": "NON_EXCLUSIVE_THING",
"principal": "arn:aws:iot:us-east-1:123456789012:cert/1a234b39b4b68278f2e9d84bf97eac2cbf4a1c28b23ea29a44559b9bcf8d395b"
}
]
}
```
Per ulteriori informazioni, consulta [ListThingsPrincipalV2](https://docs.aws.amazon.com//iot/latest/apireference/API_ListThingPrincipalsV2.html) dall'*AWS IoT Core API Reference.*
# Scollegamento di un'entità principale da un oggetto
Usa il comando `DetachThingPrincipal` per scollegare un certificato da un oggetto:
```
$ aws iot detach-thing-principal \
--thing-name "MyLightBulb" \
--principal "arn:aws:iot:us-east-1:123456789012:cert/2e1eb273792174ec2b9bf4e9b37e6c6c692345499506002a35159767055278e8"
```
Il comando **DetachThingPrincipal** non produce output.
Per ulteriori informazioni, consulta [detach-thing-principal](https://docs.aws.amazon.com//iot/latest/apireference/API_DetachThingPrincipal.html)l'*AWS IoT Core API Reference.*
# Tipi di oggetti
I tipi di oggetti permettono di archiviare la descrizione e le informazioni di configurazione comuni a tutti gli oggetti associati allo stesso tipo. Ciò semplifica la gestione degli oggetti nel registro. Ad esempio, puoi definire un tipo di LightBulb cosa. Tutti gli elementi associati al tipo di LightBulb oggetto condividono una serie di attributi: numero di serie, produttore e potenza. Quando si crea un oggetto di tipo LightBulb (o si modifica il tipo di un oggetto esistente LightBulb), è possibile specificare i valori per ciascuno degli attributi definiti nel tipo di LightBulb oggetto.
Anche se i tipi di oggetti sono opzionali, il loro utilizzo è un modo semplice per individuare le cose.
+ Gli oggetti con un tipo possono avere fino a 50 attributi.
+ Gli oggetti senza un tipo possono avere fino a tre attributi.
+ Un oggetto può essere associato a un solo tipo.
+ Non vi è alcun limite al numero di tipi di oggetti che è possibile creare nell'account.
Non è possibile modificare il nome di un tipo di oggetto dopo averlo creato. È possibile dichiarare obsoleto un tipo di oggetto in qualsiasi momento per impedire che vi vengano associati nuovi oggetti. È inoltre possibile eliminare i tipi di oggetti a cui non sono associati oggetti.
**Topics**
+ [Creazione di un tipo di oggetto](create-thing-type.md)
+ [Visualizzazione dell'elenco di tipi di oggetti](list-thing-types.md)
+ [Descrizione di un tipo di oggetto](describe-thing-type.md)
+ [Associazione di un tipo di oggetto a un oggetto](associate-thing-type.md)
+ [Aggiornare un tipo di oggetto](update-thing-type.md)
+ [Dichiarazione di un tipo di oggetto come obsoleto](deprecate-thing-type.md)
+ [Eliminazione di un tipo di oggetto](delete-thing-types.md)
# Creazione di un tipo di oggetto
Usa il comando **CreateThingType** per creare un tipo di oggetto:
```
$ aws iot create-thing-type
--thing-type-name "LightBulb" --thing-type-properties "thingTypeDescription=light bulb type, searchableAttributes=wattage,model"
```
Il comando **CreateThingType** restituisce una risposta che contiene il tipo di oggetto e il relativo ARN:
```
{
"thingTypeName": "LightBulb",
"thingTypeId": "df9c2d8c-894d-46a9-8192-9068d01b2886",
"thingTypeArn": "arn:aws:iot:us-west-2:123456789012:thingtype/LightBulb"
}
```
# Visualizzazione dell'elenco di tipi di oggetti
Usa il comando **ListThingTypes** per elencare i tipi di oggetti:
```
$ aws iot list-thing-types
```
Il **ListThingTypes** comando restituisce un elenco dei tipi di oggetti definiti nel tuo Account AWS:
```
{
"thingTypes": [
{
"thingTypeName": "LightBulb",
"thingTypeProperties": {
"searchableAttributes": [
"wattage",
"model"
],
"thingTypeDescription": "light bulb type"
},
"thingTypeMetadata": {
"deprecated": false,
"creationDate": 1468423800950
}
}
]
}
```
# Descrizione di un tipo di oggetto
Usa il comando **DescribeThingType** per ottenere informazioni su un tipo di oggetto:
```
$ aws iot describe-thing-type --thing-type-name "LightBulb"
```
Il comando **DescribeThingType** restituisce le informazioni relative al tipo specificato:
```
{
"thingTypeProperties": {
"searchableAttributes": [
"model",
"wattage"
],
"thingTypeDescription": "light bulb type"
},
"thingTypeId": "df9c2d8c-894d-46a9-8192-9068d01b2886",
"thingTypeArn": "arn:aws:iot:us-west-2:123456789012:thingtype/LightBulb",
"thingTypeName": "LightBulb",
"thingTypeMetadata": {
"deprecated": false,
"creationDate": 1544466338.399
}
}
```
# Associazione di un tipo di oggetto a un oggetto
Usa il comando **CreateThing** per specificare un tipo di oggetto durate la creazione di un oggetto:
```
$ aws iot create-thing --thing-name "MyLightBulb" --thing-type-name "LightBulb" --attribute-payload "{\"attributes\": {\"wattage\":\"75\", \"model\":\"123\"}}"
```
Usa il comando **UpdateThing** in qualsiasi momento per modificare il tipo di oggetto associato a un oggetto:
```
$ aws iot update-thing --thing-name "MyLightBulb"
--thing-type-name "LightBulb" --attribute-payload "{\"attributes\": {\"wattage\":\"75\", \"model\":\"123\"}}"
```
Puoi anche usare il comando **UpdateThing** per eliminare l'associazione di un oggetto a un tipo.
# Aggiornare un tipo di oggetto
È possibile utilizzare il **UpdateThingType** comando per aggiornare un tipo di oggetto quando si crea un oggetto:
```
$ aws iot create-thing --thing-name "MyLightBulb" --thing-type-name "LightBulb" --attribute-payload "{\"attributes\": {\"wattage\":\"75\", \"model\":\"123\"}}"
```
Usa il comando **UpdateThing** in qualsiasi momento per modificare il tipo di oggetto associato a un oggetto:
```
$ aws iot update-thing --thing-name "MyLightBulb"
--thing-type-name "LightBulb" --attribute-payload "{\"attributes\": {\"wattage\":\"75\", \"model\":\"123\"}}"
```
Puoi anche usare il comando **UpdateThing** per eliminare l'associazione di un oggetto a un tipo.
# Dichiarazione di un tipo di oggetto come obsoleto
I tipi di oggetti non sono modificabili. Dopo essere stati definiti, non possono essere modificati. È possibile tuttavia dichiarare obsoleto un tipo di oggetto per impedire agli utenti di associarvi nuovi oggetti. Tutti gli oggetti esistenti associati al tipo di oggetto non vengono modificati.
Per dichiarare obsoleto un tipo di oggetto, usa il comando **DeprecateThingType**:
```
$ aws iot deprecate-thing-type --thing-type-name "myThingType"
```
Usa il comando **DescribeThingType** per visualizzare il risultato:
```
$ aws iot describe-thing-type --thing-type-name "StopLight":
```
```
{
"thingTypeName": "StopLight",
"thingTypeProperties": {
"searchableAttributes": [
"wattage",
"numOfLights",
"model"
],
"thingTypeDescription": "traffic light type",
},
"thingTypeMetadata": {
"deprecated": true,
"creationDate": 1468425854308,
"deprecationDate": 1468446026349
}
}
```
La dichiarazione di un tipo di oggetto come obsoleto è un'operazione reversibile. È possibile annullare la dichiarazione di un tipo come obsoleto usando il flag `--undo-deprecate` con il comando **DeprecateThingType** dell'interfaccia a riga di comando:
```
$ aws iot deprecate-thing-type --thing-type-name "myThingType" --undo-deprecate
```
Usa il comando **DescribeThingType** dell'interfaccia a riga di comando per visualizzare il risultato:
```
$ aws iot describe-thing-type --thing-type-name "StopLight":
```
```
{
"thingTypeName": "StopLight",
"thingTypeArn": "arn:aws:iot:us-east-1:123456789012:thingtype/StopLight",
"thingTypeId": "12345678abcdefgh12345678ijklmnop12345678"
"thingTypeProperties": {
"searchableAttributes": [
"wattage",
"numOfLights",
"model"
],
"thingTypeDescription": "traffic light type"
},
"thingTypeMetadata": {
"deprecated": false,
"creationDate": 1468425854308,
}
}
```
# Eliminazione di un tipo di oggetto
È possibile eliminare i tipi di oggetti solo dopo averli dichiarati obsoleti. Per eliminare un tipo di oggetto, usa il comando **DeleteThingType**:
```
$ aws iot delete-thing-type --thing-type-name "StopLight"
```
**Nota**
Prima di poter eliminare un tipo di oggetto, attendi cinque minuti dopo averlo reso obsoleto.
# Gruppi di oggetti statici
La classificazione degli oggetti in gruppi statici consente di gestire diversi oggetti contemporaneamente. I gruppi di oggetti statici contengono un gruppo di oggetti gestiti utilizzando la console, l'interfaccia a riga di comando o l'API. [I gruppi di oggetti dinamici](dynamic-thing-groups.md), d'altra parte, contengono oggetti che corrispondono a una query specificata. I gruppi di oggetti statici possono anche contenere altri gruppi di oggetti statici. È possibile creare una gerarchia di gruppi. È possibile collegare una policy a un gruppo padre affinché venga ereditata dai gruppi figlio, oltre che da tutti gli oggetti nel gruppo e nei relativi gruppi figlio. In questo modo, si semplifica il controllo delle autorizzazioni per un numero elevato di oggetti.
**Nota**
Le policy dei gruppi di oggetti non consentono l'accesso alle operazioni del piano AWS IoT Greengrass dati. Per consentire a un oggetto l'accesso a un'operazione del piano AWS IoT Greengrass dati, aggiungi l'autorizzazione a una AWS IoT policy che alleghi al certificato dell'oggetto. Per ulteriori informazioni, consultare [Autenticazione e autorizzazione del dispositivo](https://docs.aws.amazon.com/greengrass/v2/developerguide/device-auth#iot-policies.html) nella *Guida per gli sviluppatori di AWS IoT Greengrass *.
Di seguito sono elencate le operazioni che è possibile eseguire con i gruppi di oggetti statici:
+ Creare, descrivere o eliminare un gruppo.
+ Aggiungere un oggetto a un gruppo o a più gruppi.
+ Rimuovere un oggetto da un gruppo.
+ Elencare i gruppi creati.
+ Elencare tutti i gruppi figlio di un gruppo (i relativi discendenti diretti e indiretti).
+ Elencare gli oggetti in un gruppo, inclusi tutti gli oggetti nei relativi gruppi figlio.
+ Elencare tutti i gruppi predecessore di un gruppo (i relativi oggetti padre diretti e indiretti).
+ Aggiungere, eliminare o aggiornare gli attributi di un gruppo. Gli attributi sono coppie nome–valore che è possibile usare per archiviare le informazioni su un gruppo.
+ Collegare o scollegare una policy a o da un gruppo.
+ Elencare le policy collegate a un gruppo.
+ Elencare le policy ereditate da un oggetto (in forza delle policy collegate al relativo gruppo o a uno dei gruppi padre).
+ Configurare le opzioni di logging per gli oggetti in un gruppo. Per informazioni, consulta [Configurare la registrazione AWS IoT](configure-logging.md).
+ Creare processi che vengono inviati ed eseguiti su ogni oggetto in un gruppo e nei relativi gruppi figlio. Per informazioni, consulta [AWS IoT Lavori](iot-jobs.md).
**Nota**
Quando un oggetto è collegato a un gruppo di oggetti statico a cui è associata una AWS IoT Core policy, il nome dell'oggetto deve corrispondere all'ID client.
Di seguito sono elencate alcune limitazioni dei gruppi di oggetti statici:
+ Un gruppo può avere un solo elemento padre diretto.
+ Se un gruppo è figlio di un altro gruppo, specificalo al momento della creazione.
+ Non è possibile modificare il padre di un gruppo in un secondo momento, quindi assicurati di pianificare la gerarchia del gruppo e crea un gruppo padre prima di creare i gruppi figlio in esso contenuti.
+
Il numero di gruppi a cui un oggetto può appartenere è [limitato](https://docs.aws.amazon.com//general/latest/gr/iot_device_management.html#thing-limits).
+ Non è possibile aggiungere un oggetto a più di un gruppo nella stessa gerarchia. (In altre parole, non è possibile aggiungere un oggetto a due gruppi che condividono uno stesso padre.)
+ Non è possibile rinominare un gruppo.
+ I nomi dei gruppo di oggetti non possono contenere caratteri internazionali, ad esempio, û, é e ñ.
+ Non utilizzare informazioni che consentano l'identificazione personale nel nome del gruppo di oggetti. Il nome del gruppo di oggetti può essere visualizzato nelle comunicazioni e nei report non crittografati.
Le operazioni di collegamento e scollegamento di policy ai e dai gruppi possono migliorare notevolmente la sicurezza delle operazioni di AWS IoT in diversi modi. Il metodo per dispositivo di collegamento di una policy a un certificato, che viene quindi collegato a un oggetto, richiede molto tempo e rende difficile aggiornare rapidamente le policy o modificarle in un parco istanze di dispositivi. Se si collega una policy al gruppo di oggetti, sono necessarie meno operazioni quando è il momento di ruotare i certificati di un oggetto. Le policy vengono inoltre applicate dinamicamente agli oggetti quando cambia l'appartenenza ai gruppi, quindi non è necessario ricreare un set di autorizzazioni complesso ogni volta che per un dispositivo cambia l'appartenenza a un gruppo.
## Creazione di un gruppo di oggetti statico
Utilizza il comando **CreateThingGroup** per creare un gruppo di oggetti statico.
```
$ aws iot create-thing-group --thing-group-name LightBulbs
```
Il comando **CreateThingGroup** restituisce una risposta che contiene il nome, l'ID e l'ARN del gruppo di oggetti statico:
```
{
"thingGroupName": "LightBulbs",
"thingGroupId": "abcdefgh12345678ijklmnop12345678qrstuvwx",
"thingGroupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/LightBulbs"
}
```
**Nota**
Non è consigliabile utilizzare informazioni di identificazione personale nei nomi dei gruppi di oggetti.
Di seguito è illustrato un esempio in cui viene specificato un elemento padre del gruppo di oggetti statico al momento della creazione:
```
$ aws iot create-thing-group --thing-group-name RedLights --parent-group-name LightBulbs
```
Come in precedenza, il comando **CreateThingGroup** restituisce una risposta che contiene il nome del gruppo di oggetti statico e i relativi ID e ARN:
```
{
"thingGroupName": "RedLights",
"thingGroupId": "abcdefgh12345678ijklmnop12345678qrstuvwx",
"thingGroupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/RedLights",
}
```
**Importante**
Quando crei gerarchie di gruppi, tieni presenti i limiti seguenti:
Un gruppo di oggetti può avere un solo elemento padre diretto.
Il numero di gruppi figlio diretti che un gruppo di oggetti può avere è [limitato](https://docs.aws.amazon.com//general/latest/gr/iot_device_management.html#thing-group-limits).
La profondità massima di una gerarchia di gruppi è [limitata](https://docs.aws.amazon.com//general/latest/gr/iot_device_management.html#thing-group-limits).
Il numero di attributi che un gruppo di oggetti può avere è [limitato](https://docs.aws.amazon.com//general/latest/gr/iot_device_management.html#thing-group-limits). Gli attributi sono coppie nome–valore che è possibile usare per archiviare le informazioni su un gruppo. Anche le lunghezze di ciascun nome di attributo e di ogni valore sono [limitate](https://docs.aws.amazon.com//general/latest/gr/iot_device_management.html#thing-group-limits).
## Descrizione di un gruppo di oggetti
Usa il comando **DescribeThingGroup** per ottenere informazioni su un gruppo di oggetti:
```
$ aws iot describe-thing-group --thing-group-name RedLights
```
Il comando **DescribeThingGroup** restituisce le informazioni relative al gruppo specificato:
```
{
"thingGroupName": "RedLights",
"thingGroupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/RedLights",
"thingGroupId": "12345678abcdefgh12345678ijklmnop12345678",
"version": 1,
"thingGroupMetadata": {
"creationDate": 1478299948.882
"parentGroupName": "Lights",
"rootToParentThingGroups": [
{
"groupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/ShinyObjects",
"groupName": "ShinyObjects"
},
{
"groupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/LightBulbs",
"groupName": "LightBulbs"
}
]
},
"thingGroupProperties": {
"attributePayload": {
"attributes": {
"brightness": "3400_lumens"
},
},
"thingGroupDescription": "string"
},
}
```
## Aggiunta di un oggetto a un gruppo di oggetti statico
È possibile usare il comando **AddThingToThingGroup** per aggiungere un oggetto a un gruppo di oggetti statico:
```
$ aws iot add-thing-to-thing-group --thing-name MyLightBulb --thing-group-name RedLights
```
Il comando **AddThingToThingGroup** non produce output.
**Importante**
È possibile aggiungere un oggetto a un massimo di 10 gruppi. Non è tuttavia possibile aggiungere un oggetto a più di un gruppo nella stessa gerarchia. (In altre parole, non è possibile aggiungere un oggetto a due gruppi che condividono uno stesso padre.)
Se un oggetto appartiene al massimo numero possibile di gruppi di oggetti e almeno uno di questi gruppi è un gruppo di oggetti dinamico, è possibile utilizzare il flag [https://docs.aws.amazon.com/iot/latest/apireference/API_AddThingToThingGroup.html#iot-AddThingToThingGroup-request-overrideDynamicGroups](https://docs.aws.amazon.com/iot/latest/apireference/API_AddThingToThingGroup.html#iot-AddThingToThingGroup-request-overrideDynamicGroups) per far sì che i gruppi statici abbiano la priorità sui gruppi dinamici.
## Rimozione di un oggetto da un gruppo di oggetti statico
Usa il comando **RemoveThingFromThingGroup** per rimuovere un oggetto da un gruppo:
```
$ aws iot remove-thing-from-thing-group --thing-name MyLightBulb --thing-group-name RedLights
```
Il comando **RemoveThingFromThingGroup** non produce output.
## Elenco di oggetti in un gruppo di oggetti
Utilizza il comando **ListThingsInThingGroup** per elencare gli oggetti che appartengono a un gruppo:
```
$ aws iot list-things-in-thing-group --thing-group-name LightBulbs
```
Il comando **ListThingsInThingGroup** restituisce un elenco degli oggetti nel gruppo specificato:
```
{
"things":[
"TestThingA"
]
}
```
Il parametro `--recursive` permette di elencare gli oggetti appartenenti a un gruppo e quelli nei relativi gruppi figlio:
```
$ aws iot list-things-in-thing-group --thing-group-name LightBulbs --recursive
```
```
{
"things":[
"TestThingA",
"MyLightBulb"
]
}
```
**Nota**
Questa operazione è [consistente finale](https://web.stanford.edu/class/cs345d-01/rl/eventually-consistent.pdf). In altre parole, le modifiche al gruppo di cose potrebbero non essere riflesse contemporaneamente.
## Visualizzazione dell'elenco di gruppi di oggetti
Puoi usare il comando **ListThingGroups** per elencare i gruppi di oggetti del tuo account:
```
$ aws iot list-thing-groups
```
Il **ListThingGroups** comando restituisce un elenco dei gruppi di cose presenti in Account AWS:
```
{
"thingGroups": [
{
"groupName": "LightBulbs",
"groupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/LightBulbs"
},
{
"groupName": "RedLights",
"groupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/RedLights"
},
{
"groupName": "RedLEDLights",
"groupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/RedLEDLights"
},
{
"groupName": "RedIncandescentLights",
"groupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/RedIncandescentLights"
}
{
"groupName": "ReplaceableObjects",
"groupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/ReplaceableObjects"
}
]
}
```
Usa i filtri facoltativi per elencare i gruppi con un determinato gruppo padre (`--parent-group`) o i gruppi il cui nome inizia con un determinato prefisso (`--name-prefix-filter`). Il parametro `--recursive` permette di elencare anche tutti i gruppi figlio e non solo i gruppi figlio diretti di un gruppo di oggetti:
```
$ aws iot list-thing-groups --parent-group LightBulbs
```
In questo caso, il **ListThingGroups** comando restituisce un elenco dei gruppi figli diretti del gruppo di cose definito in Account AWS:
```
{
"childGroups":[
{
"groupName": "RedLights",
"groupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/RedLights"
}
]
}
```
Utilizza il parametro `--recursive` con il comando **ListThingGroups** per elencare tutti i gruppi figlio di un gruppo di oggetti, non solo i figli diretti:
```
$ aws iot list-thing-groups --parent-group LightBulbs --recursive
```
Il comando **ListThingGroups** restituisce un elenco di tutti i gruppi figlio del gruppo di oggetti:
```
{
"childGroups":[
{
"groupName": "RedLights",
"groupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/RedLights"
},
{
"groupName": "RedLEDLights",
"groupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/RedLEDLights"
},
{
"groupName": "RedIncandescentLights",
"groupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/RedIncandescentLights"
}
]
}
```
**Nota**
Questa operazione è [consistente finale](https://web.stanford.edu/class/cs345d-01/rl/eventually-consistent.pdf). In altre parole, le modifiche al gruppo di cose potrebbero non essere riflesse contemporaneamente.
## Elenco dei gruppi per un oggetto
Puoi utilizzare il comando **ListThingGroupsForThing** per elencare i gruppi diretti a cui appartiene l'oggetto:
```
$ aws iot list-thing-groups-for-thing --thing-name MyLightBulb
```
Il comando **ListThingGroupsForThing** restituisce un elenco dei gruppi di oggetti diretti a cui l'oggetto appartiene:
```
{
"thingGroups":[
{
"groupName": "LightBulbs",
"groupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/LightBulbs"
},
{
"groupName": "RedLights",
"groupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/RedLights"
},
{
"groupName": "ReplaceableObjects",
"groupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/ReplaceableObjects"
}
]
}
```
Puoi anche accedere a questa API all'interno del motore delle regole utilizzando la funzione `get_registry_data()` inline. È possibile utilizzare questa funzione per accedere e utilizzare dinamicamente le informazioni del registro degli oggetti (inclusi attributi, tipi di oggetti e appartenenze ai gruppi) chiamando e `ListThingGroupsForThing` APIs direttamente all'interno delle AWS IoT regole, abilitando l'elaborazione `DescribeThing` e il routing dei messaggi in tempo reale in base ai dati del registro del dispositivo. Per ulteriori informazioni, consulta [https://docs.aws.amazon.com//iot/latest/developerguide/iot-sql-functions.html#iot-sql-function-get-registry_data](https://docs.aws.amazon.com//iot/latest/developerguide/iot-sql-functions.html#iot-sql-function-get-registry_data).
## Aggiornamento di un gruppo di oggetti statico
Usa il comando **UpdateThingGroup** per aggiornare gli attributi di un gruppo di oggetti statico:
```
$ aws iot update-thing-group --thing-group-name "LightBulbs" --thing-group-properties "thingGroupDescription=\"this is a test group\", attributePayload=\"{\"attributes\"={\"Owner\"=\"150\",\"modelNames\"=\"456\"}}"
```
Il comando **UpdateThingGroup** restituisce una risposta che contiene il numero di versione del gruppo dopo l'aggiornamento:
```
{
"version": 4
}
```
**Nota**
Il numero di attributi che un oggetto può avere è [limitato](https://docs.aws.amazon.com//general/latest/gr/iot_device_management.html#thing-limits).
## Eliminazione di un gruppo di oggetti
Per eliminare un gruppo di oggetti, usa il comando **DeleteThingGroup**:
```
$ aws iot delete-thing-group --thing-group-name "RedLights"
```
Il comando **DeleteThingGroup** non produce output.
**Importante**
Se tenti di eliminare un gruppo di oggetti con gruppi di oggetti figlio, viene generato un errore:
```
A client error (InvalidRequestException) occurred when calling the DeleteThingGroup
operation: Cannot delete thing group : RedLights when there are still child groups attached to it.
```
Prima di eliminare il gruppo, elimina prima tutti i gruppi di bambini.
È possibile eliminare un gruppo con oggetti figlio, ma le autorizzazioni concesse agli oggetti in virtù dell'appartenenza al gruppo non sono più valide. Prima di eliminare un gruppo a cui è collegata una policy, controlla attentamente che la rimozione delle autorizzazioni non comprometta il corretto funzionamento degli oggetti nel gruppo. Inoltre, i comandi che mostrano a quali gruppi appartiene un oggetto (ad esempio,**ListGroupsForThing**) potrebbero continuare a mostrare il gruppo mentre i record nel cloud vengono aggiornati.
## Collegamento di una policy a un gruppo di oggetti statico
Usa il comando **AttachPolicy** per collegare una policy a un gruppo di oggetti statico e, di conseguenza, a tutti gli oggetti presenti nel gruppo e agli oggetti nei relativi gruppi figlio:
```
$ aws iot attach-policy \
--target "arn:aws:iot:us-west-2:123456789012:thinggroup/LightBulbs" \
--policy-name "myLightBulbPolicy"
```
Il comando **AttachPolicy** non produce output
**Importante**
È possibile collegare un numero massimo di due policy per un gruppo.
**Nota**
Non è consigliabile utilizzare informazioni di identificazione personale nei nomi delle policy.
Il parametro `--target` può essere l'ARN di un gruppo di oggetti (come indicato sopra), l'ARN di un certificato o un'identità Amazon Cognito. Per ulteriori informazioni su policy, certificati e autenticazione, consulta [Autenticazione](authentication.md).
Per ulteriori informazioni, consulta [policy AWS IoT Core](https://docs.aws.amazon.com/iot/latest/developerguide/iot-policies.html).
## Scollegamento di una policy da un gruppo di oggetti statico
Usa il comando **DetachPolicy** per scollegare una policy da un gruppo di oggetti e, di conseguenza, da tutti gli oggetti presenti nel gruppo e gli oggetti nei relativi gruppi figlio:
```
$ aws iot detach-policy --target "arn:aws:iot:us-west-2:123456789012:thinggroup/LightBulbs" --policy-name "myLightBulbPolicy"
```
Il comando **DetachPolicy** non produce output.
## Elenco di policy collegate a un gruppo di oggetti statico
Usa il comando **ListAttachedPolicies** per elencare le policy collegate a un gruppo di oggetti statico:
```
$ aws iot list-attached-policies --target "arn:aws:iot:us-west-2:123456789012:thinggroup/RedLights"
```
Il parametro `--target` può essere l'ARN di un gruppo di oggetti (come indicato sopra), l'ARN di un certificato o un'identità Amazon Cognito.
Aggiungi il parametro opzionale `--recursive` per includere tutte le policy collegate ai gruppi padre del gruppo.
Il comando **ListAttachedPolicies** restituisce un elenco di policy:
```
{
"policies": [
"MyLightBulbPolicy"
...
]
}
```
## Visualizzazione dell'elenco di gruppi per una policy
Usa il comando **ListTargetsForPolicy** per elencare i target, inclusi i gruppi, a cui una policy è collegata:
```
$ aws iot list-targets-for-policy --policy-name "MyLightBulbPolicy"
```
Aggiungi il parametro opzionale `--page-size number` per specificare il numero massimo di risultati da restituire per ogni query e il parametro `--marker string` nelle chiamate successive per recuperare il set di risultati successivo, se presente.
Il comando **ListTargetsForPolicy** restituisce un elenco di target e il token da usare per recuperare ulteriori risultati:
```
{
"nextMarker": "string",
"targets": [ "string" ... ]
}
```
## Recupero delle policy valide per un oggetto
Usa il comando **GetEffectivePolicies** per elencare le policy valide per un oggetto, incluse le policy collegate ai gruppi a cui l'oggetto appartiene, indipendentemente dal fatto che il gruppo sia un padre diretto o un predecessore indiretto:
```
$ aws iot get-effective-policies \
--thing-name "MyLightBulb" \
--principal "arn:aws:iot:us-east-1:123456789012:cert/a0c01f5835079de0a7514643d68ef8414ab739a1e94ee4162977b02b12842847"
```
Usa il parametro `--principal` per specificare l'ARN del certificato collegato all'oggetto. Se usi l'autenticazione dell'identità di Amazon Cognito, utilizza il parametro `--cognito-identity-pool-id` e, facoltativamente, aggiungi il parametro `--principal` per specificare un'identità di Amazon Cognito. Se specifichi solo `--cognito-identity-pool-id`, vengono restituite le policy associate al ruolo del pool di identità per gli utenti non autenticati. Se usi entrambi i parametri, vengono restituite le policy associate al ruolo del pool di identità per gli utenti autenticati.
Il parametro `--thing-name` è opzionale e può essere usato al posto del parametro `--principal`. Quando viene usato, vengono restituite le policy collegate a qualsiasi gruppo a cui l'oggetto appartiene e le policy collegate a qualsiasi gruppo padre di questi gruppi (fino al gruppo root della gerarchia).
Il comando **GetEffectivePolicies** restituisce un elenco di policy:
```
{
"effectivePolicies": [
{
"policyArn": "string",
"policyDocument": "string",
"policyName": "string"
}
...
]
}
```
## Test dell'autorizzazione per le operazioni MQTT
Usa il comando **TestAuthorization** per verificare se un'operazione [MQTT](https://docs.aws.amazon.com/iot/latest/developerguide/mqtt.html) (`Publish`, `Subscribe`) è permessa per un oggetto:
```
aws iot test-authorization \
--principal "arn:aws:iot:us-east-1:123456789012:cert/a0c01f5835079de0a7514643d68ef8414ab739a1e94ee4162977b02b12842847" \
--auth-infos "{\"actionType\": \"PUBLISH\", \"resources\": [ \"arn:aws:iot:us-east-1:123456789012:topic/my/topic\"]}"
```
Usa il parametro `--principal` per specificare l'ARN del certificato collegato all'oggetto. Se utilizzi l'autenticazione dell'identità di Amazon Cognito, specifica un'identità di Cognito come `--principal` oppure utilizza il parametro `--cognito-identity-pool-id` o entrambe le cose. Se specifichi solo `--cognito-identity-pool-id`, vengono considerate le policy associate al ruolo del pool di identità per gli utenti non autenticati. Se usi entrambi i parametri, vengono considerate le policy associate al ruolo del pool di identità per gli utenti autenticati.
Specifica una o più operazioni MQTT da testare elencando i set di risorse e i tipi di operazioni dopo il parametro `--auth-infos`. Il campo `actionType` deve contenere "PUBLISH", "SUBSCRIBE", "RECEIVE" o "CONNECT". Il `resources` campo deve contenere un elenco di risorse ARNs. Per ulteriori informazioni, consulta [AWS IoT Core politiche](iot-policies.md).
È possibile testare gli effetti dell'aggiunta di policy specificandole con il parametro `--policy-names-to-add`. In alternativa, è possibile testare gli effetti della rimozione di policy con il parametro `--policy-names-to-skip`.
Puoi usare il parametro opzionale `--client-id` per affinare ulteriormente i risultati.
Il comando **TestAuthorization** restituisce i dettagli delle operazioni permesse o non permesse per ogni set di query `--auth-infos` specificato:
```
{
"authResults": [
{
"allowed": {
"policies": [
{
"policyArn": "string",
"policyName": "string"
}
]
},
"authDecision": "string",
"authInfo": {
"actionType": "string",
"resources": [ "string" ]
},
"denied": {
"explicitDeny": {
"policies": [
{
"policyArn": "string",
"policyName": "string"
}
]
},
"implicitDeny": {
"policies": [
{
"policyArn": "string",
"policyName": "string"
}
]
}
},
"missingContextValues": [ "string" ]
}
]
}
```
# Gruppo di oggetti dinamici
I gruppi di oggetti dinamici vengono creati da specifiche query di ricerca nel registro. I parametri delle query di ricerca come la connettività del dispositivo, la creazione di ombre del dispositivo e i dati AWS IoT Device Defender sulle violazioni supportano questa funzionalità. I gruppi di oggetti dinamici richiedono l'indicizzazione del parco veicoli abilitata per indicizzare, cercare e aggregare i dati dei dispositivi. Puoi visualizzare in anteprima gli elementi in un gruppo di oggetti dinamico utilizzando una query di ricerca di indicizzazione della flotta prima di crearlo. Per ulteriori informazioni, consultare [Indicizzazione del parco istanze](iot-indexing.md) e [Sintassi delle query](query-syntax.md).
**Nota**
Le operazioni dinamiche dei gruppi di oggetti vengono misurate nelle operazioni di registro. Per ulteriori informazioni, vedere [AWS IoT Core ulteriori dettagli sulla misurazione.](https://aws.amazon.com/iot-core/pricing/additional-details/)
I gruppi di oggetti dinamici differiscono dai gruppi di oggetti statici per le seguenti caratteristiche:
+ L'appartenenza degli oggetti non è esplicitamente definita. Per creare un gruppo di oggetti dinamico, definite [una stringa di query di ricerca](example-queries.md) per determinare l'appartenenza al gruppo.
+ I gruppi di oggetti dinamici non possono far parte di una gerarchia.
+ I gruppi di oggetti dinamici non possono avere delle policy a loro applicate.
+ È possibile utilizzare un altro set di comandi per creare, aggiornare ed eliminare i gruppi di oggetti dinamici. Per tutte le altre operazioni, si utilizzano gli stessi comandi per entrambi i tipi di gruppi di oggetti.
+ Il numero di gruppi dinamici per Account AWS è [limitato](https://docs.aws.amazon.com//general/latest/gr/iot_device_management.html#thing-group-limits).
+ Non utilizzare informazioni che consentano l'identificazione personale nel nome del gruppo di oggetti. Il nome del gruppo di oggetti può essere visualizzato nelle comunicazioni e nei report non crittografati.
Per ulteriori informazioni sui gruppi di oggetti statici, consulta [Gruppi di oggetti statici](thing-groups.md).
## Casi d'uso di gruppi di oggetti dinamici
È possibile utilizzare gruppi di oggetti dinamici per i seguenti casi d'uso:
### Specificate un gruppo di oggetti dinamico come destinazione per un job
La creazione di un lavoro continuo con un gruppo di oggetti dinamico come destinazione consente di indirizzare automaticamente i dispositivi quando soddisfano i criteri desiderati. I criteri possono essere lo stato della connettività o qualsiasi criterio memorizzato nel registro o nello shadow, ad esempio la versione o il modello del software. Se un oggetto non appare nel gruppo di oggetti dinamico, non riceverà il documento di lavoro dal lavoro.
Ad esempio, se il tuo parco dispositivi richiede un aggiornamento del firmware per ridurre al minimo il rischio di interruzioni durante il processo di aggiornamento e desideri aggiornare il firmware solo su dispositivi con una durata della batteria superiore all'80%. È possibile creare un gruppo di oggetti dinamico denominato 80 PercentBatteryLife che include solo dispositivi con una durata della batteria superiore all'80% e utilizzarlo come destinazione per il proprio lavoro. Solo i dispositivi che soddisfano i criteri di durata della batteria riceveranno l'aggiornamento del firmware. Quando i dispositivi raggiungono il criterio di durata della batteria dell'80%, vengono automaticamente aggiunti al gruppo di oggetti dinamico e riceveranno l'aggiornamento del firmware.
È inoltre possibile disporre di più modelli di dispositivi con firmware o sistema operativo diversi, il che richiede versioni diverse dei nuovi aggiornamenti software. Questo è il caso d'uso più comune per i gruppi dinamici con processi continui, in cui è possibile creare un gruppo dinamico per ogni modello di dispositivo, firmware e combinazione di sistema operativo. È quindi possibile impostare lavori continui per ciascuno di questi gruppi dinamici per inviare aggiornamenti software man mano che i dispositivi diventano automaticamente membri di questi gruppi in base ai criteri definiti.
Per ulteriori informazioni sulla specifica dei gruppi di elementi come destinazioni di processo, consulta [CreateJob](https://docs.aws.amazon.com//iot/latest/apireference/API_CreateJob.html).
### Utilizza le modifiche dinamiche all'appartenenza ai gruppi per eseguire le azioni desiderate
Ogni volta che un dispositivo viene aggiunto o rimosso da un gruppo di oggetti dinamico, viene inviata una notifica a un argomento MQTT come parte degli aggiornamenti degli [eventi del registro](https://docs.aws.amazon.com//iot/latest/developerguide/registry-events.html). È possibile configurare [AWS IoT Core le regole](https://docs.aws.amazon.com//iot/latest/developerguide/iot-rules.html) per interagire con AWS i servizi in base agli aggiornamenti dinamici delle appartenenze ai gruppi e intraprendere le azioni desiderate. Le azioni di esempio includono scrivere su Amazon DynamoDB, richiamare una funzione Lambda o inviare una notifica ad Amazon SNS.
### Aggiungi dispositivi a un gruppo di oggetti dinamico per il rilevamento automatico delle violazioni
AWS IoT Device Defender I clienti di Detect possono definire un [profilo di sicurezza](https://docs.aws.amazon.com//iot/latest/developerguide/device-defender-detect.html) su un gruppo di oggetti dinamico. I dispositivi del gruppo di oggetti dinamico vengono rilevati automaticamente per rilevare eventuali violazioni dal profilo di sicurezza definito nel gruppo.
### Imposta i livelli di log sui gruppi di oggetti dinamici per osservare i dispositivi con una registrazione dettagliata
È possibile specificare un livello di log su un gruppo di oggetti dinamico. Ciò è utile se si desidera personalizzare solo il livello e i dettagli di registrazione per i dispositivi che soddisfano determinati criteri. Ad esempio, se sospetti che dispositivi con una determinata versione del firmware stiano causando errori nell'argomento pubblicato di una regola specifica, potresti voler impostare una registrazione dettagliata per eseguire il debug di questi problemi. In questo caso, puoi creare un gruppo dinamico per tutti i dispositivi che dispongono di questa versione del firmware, che supponiamo sia memorizzata come attributo di registro o nell'ombra di un dispositivo. È quindi possibile impostare un livello di debug, con l'obiettivo di registrazione definito come questo gruppo di oggetti dinamico. [Per ulteriori informazioni sulla registrazione dettagliata, consultate Monitoraggio tramite log. AWS IoT CloudWatch ](https://docs.aws.amazon.com//iot/latest/developerguide/cloud-watch-logs.html#fine-grained-logging) [Per ulteriori informazioni su come specificare un livello di registrazione per un gruppo di oggetti specifico, consulta Configurare la registrazione specifica per una risorsa. AWS IoT](https://docs.aws.amazon.com//iot/latest/developerguide/configure-logging.html#fine-logging-cli)
## Creazione di un gruppo di oggetti dinamico
Utilizza il comando **CreateDynamicThingGroup** per creare un gruppo di oggetti dinamico. Per creare un gruppo di oggetti dinamico per lo PercentBatteryLife scenario 80, utilizzate il comando **create-dynamic-thing-group** CLI:
```
$ aws iot create-dynamic-thing-group --thing-group-name "80PercentBatteryLife" --query-string "attributes.batterylife80"
```
**Nota**
Non utilizzate informazioni di identificazione personale nei nomi dei gruppi di cose dinamici.
Il **CreateDynamicThingGroup** comando restituisce una risposta. La risposta contiene il nome dell'indice, la stringa di query, la versione della query, il nome del gruppo di oggetti, l'ID del gruppo di oggetti e l'Amazon Resource Name (ARN) del gruppo di cose:
```
{
"indexName": "AWS_Things",
"queryVersion": "2017-09-30",
"thingGroupName": "80PercentBatteryLife",
"thingGroupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/80PercentBatteryLife",
"queryString": "attributes.batterylife80\n",
"thingGroupId": "abcdefgh12345678ijklmnop12345678qrstuvwx"
}
```
La creazione di gruppi di oggetti dinamici non avviene contemporaneamente. Il backfill del gruppo di oggetti dinamici richiede tempo per il completamento. Quando si crea un gruppo di oggetti dinamico, lo stato del gruppo è impostato su`BUILDING`. Quando il backfill è completo, lo stato diventa `ACTIVE`. Per verificare lo stato del gruppo di oggetti dinamico, utilizzate il [DescribeThingGroup](https://docs.aws.amazon.com/iot/latest/apireference/API_DescribeThingGroup.html)comando.
## Descrizione di un gruppo di oggetti dinamico
Utilizza il comando **DescribeThingGroup** per ottenere informazioni su un gruppo di oggetti dinamico:
```
$ aws iot describe-thing-group --thing-group-name "80PercentBatteryLife"
```
Il comando **DescribeThingGroup** restituisce le informazioni relative al gruppo specificato:
```
{
"status": "ACTIVE",
"indexName": "AWS_Things",
"thingGroupName": "80PercentBatteryLife",
"thingGroupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/80PercentBatteryLife",
"queryString": "attributes.batterylife80\n",
"version": 1,
"thingGroupMetadata": {
"creationDate": 1548716921.289
},
"thingGroupProperties": {},
"queryVersion": "2017-09-30",
"thingGroupId": "84dd9b5b-2b98-4c65-84e4-be0e1ecf4fd8"
}
```
L'esecuzione **DescribeThingGroup** su un gruppo di cose dinamico restituisce attributi specifici dei gruppi di cose dinamici. Gli attributi restituiti di esempio sono QueryString e lo status.
Lo stato di un gruppo di oggetti dinamici può utilizzare i seguenti valori:
`ACTIVE`
Il gruppo di oggetti dinamico è pronto per l'uso.
`BUILDING`
Il gruppo di oggetti dinamico viene creato e l'appartenenza agli oggetti è in fase di elaborazione.
`REBUILDING`
L'appartenenza del gruppo di oggetti dinamico viene aggiornata in seguito all'adeguamento della query di ricerca del gruppo.
**Nota**
Dopo aver creato un gruppo di oggetti dinamico, utilizzatelo indipendentemente dal suo stato. Solo i gruppi di oggetti dinamici con uno stato `ACTIVE` includono tutti gli oggetti che corrispondono alle query di ricerca per quel gruppo di oggetti dinamico. I gruppi di oggetti dinamici con gli stati `REBUILDING` e `BUILDING` potrebbero non includere tutti gli oggetti che corrispondono alla query di ricerca.
## Aggiornamento di un gruppo di oggetti dinamico
Utilizzare il comando **UpdateDynamicThingGroup** per aggiornare gli attributi di un gruppo di oggetti dinamico, tra cui la query di ricerca del gruppo. Il comando seguente aggiorna due attributi. Uno è la descrizione del gruppo di oggetti e l'altro è la stringa di query che modifica i criteri di appartenenza impostandoli sulla durata della batteria > 85:
```
$ aws iot update-dynamic-thing-group --thing-group-name "80PercentBatteryLife" --thing-group-properties "thingGroupDescription=\"This thing group contains devices with a battery life greater than 85 percent.\"" --query-string "attributes.batterylife85"
```
Il comando **UpdateDynamicThingGroup** restituisce una risposta che contiene il numero di versione del gruppo dopo l'aggiornamento:
```
{
"version": 2
}
```
L'aggiornamento di un gruppo di oggetti dinamico non avviene contemporaneamente. Il backfill del gruppo di oggetti dinamici richiede tempo per il completamento. Quando si aggiorna un gruppo di oggetti dinamico, lo stato del gruppo cambia `REBUILDING` mentre il gruppo aggiorna la propria appartenenza. Quando il backfill è completo, lo stato diventa `ACTIVE`. Per verificare lo stato del gruppo di oggetti dinamico, utilizzate il [DescribeThingGroup](https://docs.aws.amazon.com/iot/latest/apireference/API_DescribeThingGroup.html)comando.
## Eliminazione di un gruppo di oggetti dinamico
Utilizzare il comando **DeleteDynamicThingGroup** per eliminare un gruppo di oggetti dinamico:
```
$ aws iot delete-dynamic-thing-group --thing-group-name "80PercentBatteryLife"
```
Il comando **DeleteDynamicThingGroup** non produce output.
I comandi che mostrano i gruppi a cui un oggetto appartiene (ad esempio, **ListGroupsForThing**) potrebbero continuare a segnalare il gruppo mentre i record nel cloud vengono aggiornati.
## Limitazioni dei gruppi di oggetti dinamici e statici
I thing group dinamici e i thing group statici condividono le seguenti limitazioni:
+ Il numero di attributi che un gruppo di oggetti può avere è [limitato](https://docs.aws.amazon.com//general/latest/gr/iot_device_management.html#thing-group-limits).
+ Il numero di gruppi a cui un oggetto può appartenere è [limitato](https://docs.aws.amazon.com//general/latest/gr/iot_device_management.html#thing-group-limits).
+ Non è possibile rinominare i gruppi di oggetti.
+ I nomi dei gruppi di oggetti non possono contenere caratteri internazionali, ad esempio, û, é e ñ.
## Limitazioni di Dynamic Thing Group
I gruppi di oggetti dinamici presentano le seguenti limitazioni:
### Indicizzazione della flotta
Con il servizio di indicizzazione della flotta abilitato, puoi eseguire query di ricerca sulla tua flotta di dispositivi. È possibile creare e gestire gruppi di oggetti dinamici dopo il completamento del riempimento dell'indicizzazione della flotta. Il tempo di completamento del processo di riempimento è direttamente influenzato dalle dimensioni del parco dispositivi registrato presso il. Cloud AWS Una volta attivato il servizio di indicizzazione del parco istanze per i gruppi di oggetti dinamici, non è possibile eliminare tutti i gruppi di oggetti dinamici.
**Nota**
Se si dispone di autorizzazioni per eseguire query all'indice del parco istanze, è possibile accedere ai dati degli oggetti sull'intero parco istanze.
### Il numero di gruppi di oggetti dinamici è limitato
[Il numero di gruppi di oggetti dinamici è limitato.](https://docs.aws.amazon.com//general/latest/gr/iot_device_management.html#thing-group-limits)
### I comandi eseguiti in modo corretto possono registrare errori
Quando si crea o si aggiorna un gruppo di cose dinamico, è possibile che alcuni elementi siano idonei per l'inclusione in un gruppo di cose dinamico, ma non vi vengano aggiunti. [Questo scenario causerà l'esecuzione corretta del comando di creazione o aggiornamento durante la registrazione di un errore e la generazione di una metrica. `AddThingToDynamicThingGroupsFailed`](metrics_dimensions.md#iot-metrics) Una singola metrica può rappresentare più voci di registro.
Una [voce del CloudWatch registro degli errori](https://docs.aws.amazon.com/iot/latest/apireference/cwl-format.html#dynamic-group-logs) viene creata quando si verifica quanto segue:
+ Un oggetto idoneo non può essere aggiunto a un gruppo di oggetti dinamico.
+ Un oggetto viene rimosso da un gruppo di oggetti dinamico per aggiungerlo a un altro gruppo.
Quando un oggetto diventa idoneo per essere aggiunto a un gruppo di oggetti dinamico, considerate quanto segue:
+ L'oggetto è già nel numero massimo di gruppi in cui può essere? (Consulta [limiti](https://docs.aws.amazon.com//general/latest/gr/iot_device_management.html#thing-limits))
+ **NO: ** l'oggetto viene aggiunto al gruppo di oggetti dinamico.
+ **SÌ:** l'oggetto è già membro di altri gruppi di oggetti dinamici?
+ **NO:** l'oggetto non può essere aggiunto al gruppo di oggetti dinamico, viene registrato un errore e viene generato un [parametro `AddThingToDynamicThingGroupsFailed`](metrics_dimensions.md#iot-metrics).
+ **SÌ:** il gruppo di oggetti dinamico al quale deve unirsi è più vecchio di qualsiasi gruppo di oggetti dinamico al quale l'oggetto già apparteneva?
+ **NO:** l'oggetto non può essere aggiunto al gruppo di oggetti dinamico, viene registrato un errore e viene generato un [parametro `AddThingToDynamicThingGroupsFailed`](metrics_dimensions.md#iot-metrics).
+ **SÌ:** rimuove l'oggetto dal gruppo di oggetti dinamico più recente, registra un errore e aggiunge l'oggetto al gruppo di oggetti dinamico. Questo genera un errore e un [parametro `AddThingToDynamicThingGroupsFailed`](metrics_dimensions.md#iot-metrics) per il gruppo di oggetti dinamico dal quale l'oggetto è stato rimosso.
Quando un oggetto in un gruppo di oggetti dinamico non soddisfa più la query di ricerca, l'oggetto viene rimosso dal gruppo di oggetti dinamico. Allo stesso modo, quando un oggetto viene aggiornato per soddisfare la query di ricerca di un gruppo di oggetti dinamico, l'oggetto viene quindi aggiunto al gruppo come descritto in precedenza. Queste aggiunte e rimozioni sono normali e non producono voci di registro di errore.
### Con `overrideDynamicGroups` abilitato, i gruppi statici hanno la priorità sui gruppi dinamici
Il numero di gruppi a cui un oggetto può appartenere è [limitato](https://docs.aws.amazon.com//general/latest/gr/iot_device_management.html#thing-limits). Quando si utilizzano i [UpdateThingGroupsForThing](https://docs.aws.amazon.com/iot/latest/apireference/API_UpdateThingGroupsForThing.html)comandi [AddThingToThingGroup](https://docs.aws.amazon.com/iot/latest/apireference/API_AddThingToThingGroup.html)o per aggiornare l'appartenenza ai thing, l'aggiunta del `--overrideDynamicGroups` parametro dà la priorità ai thing group statici rispetto ai thing group dinamici.
Quando aggiungete un oggetto a un gruppo di oggetti statico, considerate quanto segue:
+ L'oggetto appartiene già al numero massimo di gruppi?
+ **NO:** l'oggetto viene aggiunto al gruppo di oggetti statico.
+ **SÌ:** l'oggetto è in qualche gruppo dinamico?
+ **NO:** l'oggetto non può essere aggiunto al gruppo di oggetti. Il comando solleva un'eccezione.
+ **SÌ:** è stato abilitato **--overrideDynamicGroups**?
+ **NO:** l'oggetto non può essere aggiunto al gruppo di oggetti. Il comando solleva un'eccezione.
+ **SÌ:** l'oggetto viene rimosso dal gruppo di oggetti dinamico creato più di recente, viene registrato un errore e viene generato un [parametro `AddThingToDynamicThingGroupsFailed`](metrics_dimensions.md#iot-metrics) per il gruppo di oggetti dinamico da cui è stato rimosso l'oggetto. Quindi, l'oggetto viene aggiunto al gruppo di oggetti statico.
### I gruppi di oggetti dinamici precedenti hanno la priorità sui gruppi più recenti
Il numero di gruppi a cui un oggetto può appartenere è [limitato](https://docs.aws.amazon.com//general/latest/gr/iot_device_management.html#thing-limits). Quando un'operazione di creazione o aggiornamento crea un'ulteriore idoneità di gruppo per un oggetto e l'oggetto ha raggiunto il limite di gruppo, può verificarsi la rimozione da un altro gruppo di oggetti dinamico per abilitare questa aggiunta. Per ulteriori informazioni su come ciò si verifica, vedere [I comandi eseguiti in modo corretto possono registrare errori](#log-errors) e [Con `overrideDynamicGroups` abilitato, i gruppi statici hanno la priorità sui gruppi dinamici](#membership-limit) per esempi.
Quando un oggetto viene rimosso da un gruppo di oggetti dinamico, viene registrato un errore e viene generato un evento.
### Non è possibile applicare policy ai gruppi di oggetti dinamici
Il tentativo di applicazione di una policy a un gruppo di oggetti dinamico genera un'eccezione.
### L'appartenenza a un gruppo di oggetti dinamico è consistente finale
Solo lo stato finale di un oggetto è valutato per il registro. Gli stati intermedi possono essere ignorati se vengono aggiornati rapidamente. Evita di associare una regola o un lavoro a un gruppo di oggetti dinamico la cui appartenenza dipende da uno stato intermedio.
# Associazione di qualsiasi AWS IoT cosa a una connessione client MQTT
Un'associazione di oggetti esclusiva si verifica quando si allega un certificato X.509 a una singola AWS IoT cosa. In questo caso, il certificato non può essere utilizzato con altre cose. Garantendo che un certificato venga utilizzato solo da un singolo dispositivo IoT, aiuta a prevenire le vulnerabilità di sicurezza.
In AWS IoT, l'ID client è un identificatore univoco per un oggetto o un dispositivo quando si connette al broker AWS IoT Core MQTT. Se si utilizza un'associazione non esclusiva, è possibile allegare più elementi allo stesso certificato. Quando è attiva un'associazione di oggetti non esclusiva, per mantenere un'associazione chiara ed evitare potenziali conflitti, è necessario abbinare l'ID client al nome dell'oggetto.
**Topics**
+ [Casi d’uso](#exclusive-thing-benefits)
+ [Come associare un oggetto a una connessione](#exclusive-thing-how-to)
## Casi d’uso
L'associazione di un oggetto a una connessione offre le seguenti funzionalità.
**Nota**
Tieni presente che se il tuo oggetto IoT e la connessione client hanno un'associazione non esclusiva, puoi utilizzare tutte le seguenti funzionalità tranne la funzionalità degli eventi del ciclo di vita. Per includere il nome dell'oggetto nei messaggi relativi agli eventi del ciclo di vita, l'oggetto IoT e la connessione client devono avere un'associazione esclusiva.
**Variabili Thing Policy**: è possibile utilizzare le variabili Thing Policy per autorizzare l'accesso del dispositivo alle AWS IoT operazioni API. Queste variabili consentono di scrivere AWS IoT Core politiche che concedono o negano le autorizzazioni in base a proprietà degli oggetti come nomi, tipi e valori degli attributi. Utilizzando le variabili Thing Policy, è possibile applicare la stessa policy per controllare più AWS IoT Core dispositivi. Ciò consente di semplificare la gestione delle policy e ridurre la duplicazione delle risorse. Per ulteriori informazioni, vedere [Variabili della politica di Thing](https://docs.aws.amazon.com//iot/latest/developerguide/thing-policy-variables.html).
**Eventi del ciclo** di vita: è possibile ricevere il nome dell'oggetto negli eventi del ciclo di vita (ad esempio, connessione, disconnessione, sottoscrizione e annullamento dell'iscrizione). Ciò consente l'elaborazione del nome dell'oggetto incluso nei messaggi, ad esempio nelle regole. Per ulteriori informazioni, consulta Eventi del [ciclo](https://docs.aws.amazon.com//iot/latest/developerguide/life-cycle-events.html) di vita.
Registrazione **specifica della risorsa: è possibile configurare la registrazione specifica** della risorsa per i gruppi di oggetti e applicare facilmente la configurazione di registrazione desiderata per tutti gli elementi all'interno del gruppo di oggetti definito. Per ulteriori informazioni, consulta [Configura le sostituzioni specifiche per le risorse in (CLI) AWS IoT](configure-logging.md#fine-logging-cli).
Allocazione **dei costi: è possibile creare gruppi di fatturazione con tag personalizzati per l'allocazione** dei costi e aggiungere gli elementi a questi gruppi. [Per ulteriori informazioni, consulta Gruppi di fatturazione.](https://docs.aws.amazon.com//iot/latest/developerguide/tagging-iot-billing-groups.html)
## Come associare un oggetto a una connessione
Se il tuo ID client corrisponde al nome dell'oggetto nel registro, dopo aver allegato un certificato X.509 a quell'oggetto IoT, AWS IoT Core assocerà la connessione client all'oggetto. Se il tuo ID client non corrisponde al nome dell'oggetto nel registro, puoi allegare esclusivamente un certificato X.509 all'oggetto per stabilire questa associazione. La cosa che ha questo allegato esclusivo è chiamata cosa esclusiva. Altrimenti, si chiama cosa non esclusiva. Quando un certificato è associato a un oggetto esclusivo, questo certificato può essere associato ad altri elementi solo se lo si scollega dall'oggetto esclusivo. In questa sezione, scegliete una delle due opzioni Console di gestione AWS o AWS CLI se associare un oggetto a una connessione.
### Console di gestione AWS
**Per allegare un certificato a un oggetto utilizzando esclusivamente il Console di gestione AWS.**
1. Aprire la [AWS IoT home page](https://console.aws.amazon.com//iot/home#/home) nella AWS IoT console. Nella barra di navigazione a sinistra, da **Sicurezza**, scegli **Certificati**.
1. Nella pagina **Certificati**, scegli un certificato a cui desideri allegare un elemento. Quindi scegli **Allega a elementi** da **Azioni** nell'angolo in alto a destra della pagina.
In alternativa, scegli un certificato e vai alla pagina dei dettagli del certificato. Scegli la scheda **Oggetti**, quindi scegli **Allega agli oggetti**.
1. Nella pagina **Allega certificato a una o più cose**, seleziona la casella di controllo **Associa l'oggetto alla connessione**. Quindi scegli un elemento a cui allegare questo certificato dall'elenco a discesa **Oggetti**.
1. Scegli **Allega oggetti.** Se l'azione ha esito positivo, vedrai un banner con la scritta «Allegato correttamente un elemento al certificato» e l'elemento verrà aggiunto alla scheda **Oggetti**.
**Per scollegare un certificato da un oggetto esclusivo utilizzando il Console di gestione AWS**
1. Aprire la [AWS IoT home page](https://console.aws.amazon.com//iot/home#/home) nella AWS IoT console. Nella barra di navigazione a sinistra, da **Sicurezza**, scegli **Certificati**.
1. Nella pagina **Certificati**, scegli un certificato e vai alla pagina dei dettagli del certificato.
1. Nella pagina dei dettagli del certificato, scegli la scheda **Cose**. Quindi scegli un elemento a cui vuoi scollegare il certificato. Scegli **Scollega cose.**
1. Nella finestra **Scollega le cose**, conferma l'azione. Seleziona **Scollega**. **Se l'azione ha esito positivo, vedrai un banner con la scritta «Hai rimosso con successo un elemento dal tuo certificato» e l'elemento non verrà più visualizzato nella scheda Oggetti.**
### AWS CLI
1. Per allegare un certificato a un oggetto utilizzando AWS CLI, esegui il [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot/attach-thing-principal.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot/attach-thing-principal.html)comando. Per specificare l' certificate-to-thingallegato esclusivo, è necessario specificare `EXCLUSIVE_THING` nel `--thing-principal-type` campo. Un comando di esempio può essere il seguente.
```
aws iot attach-thing-principal \
--thing-name "thing_1" \
--principal "arn:aws:iot:us-east-1:123456789012:cert/2e1eb273792174ec2b9bf4e9b37e6c6c692345499506002a35159767055278e8" \
--thing-principal-type "EXCLUSIVE_THING"
```
Il comando non produce output. Per ulteriori informazioni, consulta [Collegamento di un'entità principale a un oggetto](attach-thing-principal.md).
1. Per elencare gli elementi associati al certificato specificato insieme al tipo di allegato, esegui il `list-principal-things-v2` comando. Il tipo di allegato si riferisce al modo in cui il certificato è allegato all'oggetto. Un comando di esempio può essere il seguente.
```
$ aws iot list-principal-things-v2 \
--principal "arn:aws:iot:us-east-1:123456789012:cert/2e1eb273792174ec2b9bf4e9b37e6c6c692345499506002a35159767055278e8"
```
L'output può essere simile al seguente.
```
{
"PrincipalThingObjects": [
{
"thingPrincipalType": "EXCLUSIVE_THING",
"thing": "arn:aws:iot:us-east-1:123456789012:thing/thing_1"
}
]
}
```
Per ulteriori informazioni, consulta [Elenca le cose associate a una V2 principale](list-principal-things-v2.md).
1. Per elencare i principi associati all'oggetto specificato insieme al tipo di allegato, esegui il `list-thing-principals-v2` comando. Il tipo di allegato si riferisce al modo in cui il certificato è allegato all'oggetto. Un comando di esempio può essere il seguente.
```
$ aws iot list-thing-principals-v2 \
--thing-name "thing_1"
```
L'output può essere simile al seguente.
```
{
"ThingPrincipalObjects": [
{
"thingPrincipalType": "EXCLUSIVE_THING",
"principal": "arn:aws:iot:us-east-1:123456789012:cert/2e1eb273792174ec2b9bf4e9b37e6c6c692345499506002a35159767055278e8"
}
]
}
```
Per ulteriori informazioni, consulta [Elenca i principi associati a una cosa V2](list-thing-principals-v2.md).
1. Per scollegare un certificato da un oggetto, esegui il [detach-thing-principal](https://docs.aws.amazon.com/cli/latest/reference/iot/detach-thing-principal.html)comando.
```
aws iot detach-thing-principal \
--principal "arn:aws:iot:us-east-1:123456789012:cert/2e1eb273792174ec2b9bf4e9b37e6c6c692345499506002a35159767055278e8" \
--thing-name "thing_1"
```
Il comando non produce output. Per ulteriori informazioni, consulta [Scollegamento di un'entità principale da un oggetto](detach-thing-principal.md).
# Aggiungere attributi di propagazione per l’arricchimento dei messaggi
In AWS IoT Core, è possibile arricchire i messaggi MQTT dai dispositivi aggiungendo attributi di propagazione, che sono metadati contestuali provenienti da attributi degli oggetti o dettagli di connessione. Questo processo, noto come arricchimento dei messaggi, può essere utile in vari scenari. Ad esempio, puoi arricchire i messaggi per ogni operazione di pubblicazione in entrata senza apportare modifiche sul dispositivo o dover utilizzare regole. Sfruttando gli attributi di propagazione, puoi trarre vantaggio da un modo più efficiente ed economico per arricchire i tuoi dati IoT senza la complessità della configurazione delle regole o della gestione delle configurazioni di ripubblicazione.
[https://docs.aws.amazon.com//iot/latest/developerguide/iot-basic-ingest.html](https://docs.aws.amazon.com//iot/latest/developerguide/iot-basic-ingest.html) È importante notare che, sebbene i dispositivi di pubblicazione possano utilizzare qualsiasi versione MQTT, gli abbonati (applicazioni o servizi che utilizzano messaggi) devono supportare [MQTT 5](https://docs.oasis-open.org/mqtt/mqtt/v5.0/mqtt-v5.0.html) per ricevere i messaggi arricchiti con attributi di propagazione. I messaggi arricchiti verranno aggiunti come proprietà utente MQTT 5 a ogni messaggio pubblicato dai dispositivi. Se si utilizzano [le regole](https://docs.aws.amazon.com//iot/latest/developerguide/iot-rules.html), è possibile sfruttare la funzione [get\$1user\$1properties](https://docs.aws.amazon.com//iot/latest/developerguide/iot-sql-functions.html#iot-sql-function-get-user-properties) per recuperare i dati arricchiti per il routing o l'elaborazione dei messaggi in base ai dati.
In AWS IoT Core, puoi aggiungere attributi di propagazione quando crei o aggiorni un tipo di oggetto, utilizzando o il. Console di gestione AWS AWS CLI
**Importante**
Quando si aggiungono attributi di propagazione, è necessario assicurarsi che il client che pubblica il messaggio sia stato autenticato con un certificato. Per ulteriori informazioni, consulta [Autenticazione client](client-authentication.md).
**Nota**
Se si tenta di testare questa funzionalità utilizzando il client di test MQTT all'interno della console, potrebbe non funzionare poiché richiede l'autenticazione dei client MQTT con un certificato associato.
## Console di gestione AWS
**Per aggiungere attributi di propagazione per l'arricchimento dei messaggi utilizzando il Console di gestione AWS**
1. Aprire la [AWS IoT home page](https://console.aws.amazon.com//iot/home#/home) nella AWS IoT console. Nella barra di navigazione a sinistra, da **Gestisci**, scegli **Tutti i dispositivi**. Quindi scegli **Tipi di oggetti**.
1. Nella pagina **Tipi di oggetto**, scegli **Crea tipo di oggetto**.
Per configurare l'arricchimento dei messaggi aggiornando un tipo di oggetto, scegli un tipo di oggetto. Quindi, nella pagina dei dettagli del tipo di oggetto, scegli **Aggiorna**.
1. Nella pagina **Crea tipo di oggetto**, scegli o inserisci le informazioni sul tipo di oggetto nelle **proprietà del tipo di oggetto**.
Se si sceglie di aggiornare un tipo di oggetto, verranno visualizzate **le proprietà del tipo di oggetto** dopo aver scelto **Aggiorna** nel passaggio precedente.
1. In **Configurazione aggiuntiva**, espandi **Attributi di propagazione**. Quindi scegliete l'**attributo** dell'oggetto e immettete l'attributo dell'oggetto che desiderate inserire nei messaggi pubblicati MQTT5 . Utilizzando la console, è possibile aggiungere fino a tre attributi dell'oggetto.
Nella sezione **Attributi di propagazione**, scegliete **Attributo di connessione** e immettete il tipo di attributo e, facoltativamente, il nome dell'attributo.
1. Facoltativamente, aggiungi tag. Quindi scegli **Crea tipo di oggetto**.
Se scegli di aggiornare un tipo di oggetto, scegli **Aggiorna tipo di oggetto**.
## AWS CLI
1. Per aggiungere attributi di propagazione per l'arricchimento dei messaggi creando un nuovo tipo di oggetto utilizzando il AWS CLI, esegui il comando. [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot/create-thing-type.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot/create-thing-type.html) Un comando di esempio può essere il seguente.
```
aws iot create-thing-type \
--thing-type-name "LightBulb" \
--thing-type-properties "{\"mqtt5Configuration\":{\"propagatingAttributes\":[{\"userPropertyKey\":\"iot:ClientId\", \"connectionAttribute\":\"iot:ClientId\"}, {\"userPropertyKey\":\"test\", \"thingAttribute\":\"A\"}]}}" \
```
L'output del comando può essere simile al seguente.
```
{
"thingTypeName": "LightBulb",
"thingTypeArn": "arn:aws:iot:us-west-2:123456789012:thingtype/LightBulb",
"thingTypeId": "ce3573b0-0a3c-45a7-ac93-4e0ce14cd190"
}
```
1. Per configurare l'arricchimento dei messaggi aggiornando un oggetto type using AWS CLI, esegui il [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot/update-thing-type.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot/update-thing-type.html)comando. Tieni presente che puoi eseguire l'aggiornamento solo `mqtt5Configuration` quando esegui questo comando. Un comando di esempio può essere il seguente.
```
aws iot update-thing-type \
--thing-type-name "MyThingType" \
--thing-type-properties "{\"mqtt5Configuration\":{\"propagatingAttributes\":[{\"userPropertyKey\":\"iot:ClientId\", \"connectionAttribute\":\"iot:ClientId\"}, {\"userPropertyKey\":\"test\", \"thingAttribute\":\"A\"}]}}" \
```
Il comando non produce output.
1. Per descrivere un tipo di oggetto, esegui il `describe-thing-type` comando. Questo comando produrrà un output con le informazioni di configurazione per l'arricchimento dei messaggi sul `thing-type-properties` campo. Un comando di esempio può essere il seguente.
```
aws iot describe-thing-type \
--thing-type-name "LightBulb"
```
L'output può essere simile al seguente.
```
{
"thingTypeName": "LightBulb",
"thingTypeId": "bdf72512-0116-4392-8d79-bf39b17ef73d",
"thingTypeArn": "arn:aws:iot:us-east-1:123456789012:thingtype/LightBulb",
"thingTypeProperties": {
"mqtt5Configuration": {
"propagatingAttributes": [
{
"userPropertyKey": "iot:ClientId",
"connectionAttribute": "iot:ClientId"
},
{
"userPropertyKey": "test",
"thingAttribute": "attribute"
}
]
}
},
"thingTypeMetadata": {
"deprecated": false,
"creationDate": "2024-10-18T17:37:46.656000+00:00"
}
}
```
Per ulteriori informazioni, consulta [Tipi di oggetti](thing-types.md).