Sono disponibili altri esempi AWS SDK nel repository [AWS Doc SDK](https://github.com/awsdocs/aws-doc-sdk-examples) Examples. GitHub
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à.
# AWS IoT Greengrass esempi che utilizzano AWS CLI
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando AWS Command Line Interface with AWS IoT Greengrass.
Le *azioni* sono estratti di codice da programmi più grandi e devono essere eseguite nel contesto. Sebbene le azioni mostrino come richiamare le singole funzioni del servizio, è possibile visualizzarle contestualizzate negli scenari correlati.
Ogni esempio include un link al codice sorgente completo, in cui vengono fornite le istruzioni su come configurare ed eseguire il codice nel contesto.
**Topics**
+ [Azioni](#actions)
## Azioni
### `associate-role-to-group`
Il seguente esempio di codice mostra come utilizzare`associate-role-to-group`.
**AWS CLI**
**Come associare un ruolo a un gruppo Greengrass**
L’esempio `associate-role-to-group` seguente associa il ruolo IAM specificato a un gruppo Greengrass. Il ruolo di gruppo viene utilizzato dalle funzioni e dai connettori Lambda locali per accedere ai servizi AWS . Ad esempio, il ruolo del gruppo potrebbe concedere le autorizzazioni necessarie per l'integrazione dei CloudWatch log.
```
aws greengrass associate-role-to-group \
--group-id 2494ee3f-7f8a-4e92-a78b-d205f808b84b \
--role-arn arn:aws:iam::123456789012:role/GG-Group-Role
```
Output:
```
{
"AssociatedAt": "2019-09-10T20:03:30Z"
}
```
Per ulteriori informazioni, consulta [Configurare il ruolo del gruppo](https://docs.aws.amazon.com/greengrass/latest/developerguide/config-iam-roles.html) nella *Guida per gli sviluppatori di AWS IoT Greengrass*.
+ Per i dettagli sull'API, consulta *AWS CLI Command [AssociateRoleToGroup](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/associate-role-to-group.html)Reference*.
### `associate-service-role-to-account`
Il seguente esempio di codice mostra come utilizzare`associate-service-role-to-account`.
**AWS CLI**
**Per associare un ruolo di servizio al tuo AWS account**
L'`associate-service-role-to-account`esempio seguente associa un ruolo di servizio IAM, specificato dal relativo ARN, a AWS IoT Greengrass nel tuo account. AWS È necessario aver precedentemente creato il ruolo di servizio in IAM e associare ad esso un documento di policy che consenta a AWS IoT Greengrass di assumere questo ruolo.
```
aws greengrass associate-service-role-to-account \
--role-arn "arn:aws:iam::123456789012:role/service-role/Greengrass_ServiceRole"
```
Output:
```
{
"AssociatedAt": "2019-06-25T18:12:45Z"
}
```
Per ulteriori informazioni, consulta [Ruolo del servizio Greengrass](https://docs.aws.amazon.com/greengrass/latest/developerguide/service-role.html) nella *Guida per gli sviluppatori di AWS IoT Greengrass*.
+ Per i dettagli sull'API, consulta [AssociateServiceRoleToAccount AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/associate-service-role-to-account.html)*Command Reference.*
### `create-connector-definition-version`
Il seguente esempio di codice mostra come utilizzare`create-connector-definition-version`.
**AWS CLI**
**Come creare una versione della definizione del connettore**
L’esempio `create-connector-definition-version` seguente crea una versione della definizione del connettore e la associa alla definizione del connettore specificata. Tutti i connettori in una versione definiscono i valori per i relativi parametri.
```
aws greengrass create-connector-definition-version \
--connector-definition-id "55d0052b-0d7d-44d6-b56f-21867215e118" \
--connectors "[{\"Id\": \"MyTwilioNotificationsConnector\", \"ConnectorArn\": \"arn:aws:greengrass:us-west-2::/connectors/TwilioNotifications/versions/2\", \"Parameters\": {\"TWILIO_ACCOUNT_SID\": \"AC1a8d4204890840d7fc482aab38090d57\", \"TwilioAuthTokenSecretArn\": \"arn:aws:secretsmanager:us-west-2:123456789012:secret:greengrass-TwilioAuthToken-ntSlp6\", \"TwilioAuthTokenSecretArn-ResourceId\": \"TwilioAuthToken\", \"DefaultFromPhoneNumber\": \"4254492999\"}}]"
```
Output:
```
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/connectors/55d0052b-0d7d-44d6-b56f-21867215e118/versions/33f709a0-c825-49cb-9eea-dc8964fbd635",
"CreationTimestamp": "2019-06-24T20:46:30.134Z",
"Id": "55d0052b-0d7d-44d6-b56f-21867215e118",
"Version": "33f709a0-c825-49cb-9eea-dc8964fbd635"
}
```
+ Per i dettagli sull'API, consulta [CreateConnectorDefinitionVersion AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-connector-definition-version.html)*Command Reference*.
### `create-connector-definition`
Il seguente esempio di codice mostra come utilizzare`create-connector-definition`.
**AWS CLI**
**Come creare una definizione di connettore**
L’esempio `create-connector-definition` seguente crea una definizione di connettore e una versione iniziale della definizione di connettore. La versione iniziale contiene un connettore. Tutti i connettori in una versione definiscono i valori per i relativi parametri.
```
aws greengrass create-connector-definition \
--name MySNSConnector \
--initial-version "{\"Connectors\": [{\"Id\":\"MySNSConnector\",\"ConnectorArn\":\"arn:aws:greengrass:us-west-2::/connectors/SNS/versions/1\",\"Parameters\": {\"DefaultSNSArn\":\"arn:aws:sns:us-west-2:123456789012:GGConnectorTopic\"}}]}"
```
Output:
```
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/connectors/b5c4ebfd-f672-49a3-83cd-31c7216a7bb8",
"CreationTimestamp": "2019-06-19T19:30:01.300Z",
"Id": "b5c4ebfd-f672-49a3-83cd-31c7216a7bb8",
"LastUpdatedTimestamp": "2019-06-19T19:30:01.300Z",
"LatestVersion": "63c57963-c7c2-4a26-a7e2-7bf478ea2623",
"LatestVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/connectors/b5c4ebfd-f672-49a3-83cd-31c7216a7bb8/versions/63c57963-c7c2-4a26-a7e2-7bf478ea2623",
"Name": "MySNSConnector"
}
```
Per ulteriori informazioni, consulta [Nozioni di base sui connettori Greengrass (CLI)](https://docs.aws.amazon.com/greengrass/latest/developerguide/connectors-cli.html) nella **Guida per gli sviluppatori di AWS IoT Greengrass**.
+ Per i dettagli sull'API, consulta [CreateConnectorDefinition AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-connector-definition.html)*Command Reference*.
### `create-core-definition-version`
Il seguente esempio di codice mostra come utilizzare`create-core-definition-version`.
**AWS CLI**
**Come creare una versione della definizione di core**
L’esempio `create-core-definition-version` seguente crea una versione della definizione di core e la associa alla definizione di core specificata. La versione può contenere un solo core. Prima di poter creare un core, è necessario creare e fornire l'oggetto AWS IoT corrispondente. Questo processo include i seguenti comandi `iot`, che restituiscono `ThingArn` e `CertificateArn` necessari per il comando `create-core-definition-version`.
Crea l'oggetto AWS IoT che corrisponde al dispositivo principale:
```
aws iot create-thing \
--thing-name "MyCoreDevice"
```
Output:
```
{
"thingArn": "arn:aws:iot:us-west-2:123456789012:thing/MyCoreDevice",
"thingName": "MyCoreDevice",
"thingId": "cb419a19-9099-4515-9cec-e9b0e760608a"
}
```
Crea chiavi pubbliche e private e il certificato del dispositivo core per l’oggetto. Questo esempio utilizza il comando `create-keys-and-certificate` e richiede le autorizzazioni di scrittura nella directory corrente. In alternativa, puoi utilizzare il comando `create-certificate-from-csr`.
```
aws iot create-keys-and-certificate \
--set-as-active \
--certificate-pem-outfile "myCore.cert.pem" \
--public-key-outfile "myCore.public.key" \
--private-key-outfile "myCore.private.key"
```
Output:
```
{
"certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/123a15ec415668c2349a76170b64ac0878231c1e21ec83c10e92a1EXAMPLExyz",
"certificatePem": "-----BEGIN CERTIFICATE-----\nMIIDWTCAkGgAwIBATgIUCgq6EGqou6zFqWgIZRndgQEFW+gwDQYJKoZIhvc...KdGewQS\n-----END CERTIFICATE-----\n",
"keyPair": {
"PublicKey": "-----BEGIN PUBLIC KEY-----\nMIIBIjANBzrqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAqKpRgnn6yq26U3y...wIDAQAB\n-----END PUBLIC KEY-----\n",
"PrivateKey": "-----BEGIN RSA PRIVATE KEY-----\nMIIEowIABAKCAQEAqKpRgnn6yq26U3yt5YFZquyukfRjbMXDcNOK4rMCxDR...fvY4+te\n-----END RSA PRIVATE KEY-----\n"
},
"certificateId": "123a15ec415668c2349a76170b64ac0878231c1e21ec83c10e92a1EXAMPLExyz"
}
```
Crea una policy AWS IoT che consenta `iot` e `greengrass` agisca. Per semplificare, la seguente policy consente azioni su tutte le risorse, ma la policy dovrebbe essere più restrittiva.
```
aws iot create-policy \
--policy-name "Core_Devices" \
--policy-document "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Action\":[\"iot:Publish\",\"iot:Subscribe\",\"iot:Connect\",\"iot:Receive\"],\"Resource\":[\"*\"]},{\"Effect\":\"Allow\",\"Action\":[\"iot:GetThingShadow\",\"iot:UpdateThingShadow\",\"iot:DeleteThingShadow\"],\"Resource\":[\"*\"]},{\"Effect\":\"Allow\",\"Action\":[\"greengrass:*\"],\"Resource\":[\"*\"]}]}"
```
Output:
```
{
"policyName": "Core_Devices",
"policyArn": "arn:aws:iot:us-west-2:123456789012:policy/Core_Devices",
"policyDocument": "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Action\":[\"iot:Publish\",\"iot:Subscribe\",\"iot:Connect\",\"iot:Receive\"],\"Resource\":[\"*\"]},{\"Effect\":\"Allow\",\"Action\":[\"iot:GetThingShadow\",\"iot:UpdateThingShadow\",\"iot:DeleteThingShadow\"],\"Resource\":[\"*\"]},{\"Effect\":\"Allow\",\"Action\":[\"greengrass:*\"],\"Resource\":[\"*\"]}]}",
"policyVersionId": "1"
}
```
Collega la policy al certificato:
```
aws iot attach-policy \
--policy-name "Core_Devices" \
--target "arn:aws:iot:us-west-2:123456789012:cert/123a15ec415668c2349a76170b64ac0878231c1e21ec83c10e92a1EXAMPLExyz"
```
Questo comando non produce alcun output.
Collega l’oggetto al certificato:
```
aws iot attach-thing-principal \
--thing-name "MyCoreDevice" \
--principal "arn:aws:iot:us-west-2:123456789012:cert/123a15ec415668c2349a76170b64ac0878231c1e21ec83c10e92a1EXAMPLExyz"
```
Questo comando non produce alcun output.
Crea una versione della definizione core:
```
aws greengrass create-core-definition-version \
--core-definition-id "582efe12-b05a-409e-9a24-a2ba1bcc4a12" \
--cores "[{\"Id\":\"MyCoreDevice\",\"ThingArn\":\"arn:aws:iot:us-west-2:123456789012:thing/MyCoreDevice\",\"CertificateArn\":\"arn:aws:iot:us-west-2:123456789012:cert/123a15ec415668c2349a76170b64ac0878231c1e21ec83c10e92a1EXAMPLExyz\",\"SyncShadow\":true}]"
```
Output:
```
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/cores/582efe12-b05a-409e-9a24-a2ba1bcc4a12/versions/3fdc1190-2ce5-44de-b98b-eec8f9571014",
"Version": "3fdc1190-2ce5-44de-b98b-eec8f9571014",
"CreationTimestamp": "2019-09-18T00:15:09.838Z",
"Id": "582efe12-b05a-409e-9a24-a2ba1bcc4a12"
}
```
Per ulteriori informazioni, consulta [Configurare AWS IoT Greengrass Core nella IoT *AWS Greengrass*](https://docs.aws.amazon.com/greengrass/latest/developerguide/gg-core.html) Developer Guide.
+ Per i dettagli sull'API, consulta *AWS CLI Command [CreateCoreDefinitionVersion](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-core-definition-version.html)Reference*.
### `create-core-definition`
Il seguente esempio di codice mostra come utilizzare`create-core-definition`.
**AWS CLI**
**Esempio 1: come creare una definizione di core vuota**
L’esempio `create-core-definition` seguente crea una definizione di core Greengrass vuota (nessuna versione iniziale). Prima che il core sia utilizzabile, è necessario utilizzare il comando `create-core-definition-version` per fornire gli altri parametri per il core.
```
aws greengrass create-core-definition \
--name cliGroup_Core
```
Output:
```
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/cores/b5c08008-54cb-44bd-9eec-c121b04283b5",
"CreationTimestamp": "2019-06-25T18:23:22.106Z",
"Id": "b5c08008-54cb-44bd-9eec-c121b04283b5",
"LastUpdatedTimestamp": "2019-06-25T18:23:22.106Z",
"Name": "cliGroup_Core"
}
```
**Esempio 2: come creare una definizione di core con una versione iniziale**
L’esempio `create-core-definition` seguente crea una definizione di core che contiene una versione iniziale della definizione di core. La versione può contenere un solo core. Prima di poter creare un core, è necessario creare e fornire l'oggetto AWS IoT corrispondente. Questo processo include i seguenti comandi `iot`, che restituiscono `ThingArn` e `CertificateArn` necessari per il comando `create-core-definition`.
Crea l'oggetto AWS IoT che corrisponde al dispositivo principale:
```
aws iot create-thing \
--thing-name "MyCoreDevice"
```
Output:
```
{
"thingArn": "arn:aws:iot:us-west-2:123456789012:thing/MyCoreDevice",
"thingName": "MyCoreDevice",
"thingId": "cb419a19-9099-4515-9cec-e9b0e760608a"
}
```
Crea chiavi pubbliche e private e il certificato del dispositivo core per l’oggetto. Questo esempio utilizza il comando `create-keys-and-certificate` e richiede le autorizzazioni di scrittura nella directory corrente. In alternativa, puoi utilizzare il comando `create-certificate-from-csr`.
```
aws iot create-keys-and-certificate \
--set-as-active \
--certificate-pem-outfile "myCore.cert.pem" \
--public-key-outfile "myCore.public.key" \
--private-key-outfile "myCore.private.key"
```
Output:
```
{
"certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/123a15ec415668c2349a76170b64ac0878231c1e21ec83c10e92a1EXAMPLExyz",
"certificatePem": "-----BEGIN CERTIFICATE-----\nMIIDWTCAkGgAwIBATgIUCgq6EGqou6zFqWgIZRndgQEFW+gwDQYJKoZIhvc...KdGewQS\n-----END CERTIFICATE-----\n",
"keyPair": {
"PublicKey": "-----BEGIN PUBLIC KEY-----\nMIIBIjANBzrqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAqKpRgnn6yq26U3y...wIDAQAB\n-----END PUBLIC KEY-----\n",
"PrivateKey": "-----BEGIN RSA PRIVATE KEY-----\nMIIEowIABAKCAQEAqKpRgnn6yq26U3yt5YFZquyukfRjbMXDcNOK4rMCxDR...fvY4+te\n-----END RSA PRIVATE KEY-----\n"
},
"certificateId": "123a15ec415668c2349a76170b64ac0878231c1e21ec83c10e92a1EXAMPLExyz"
}
```
Crea una policy AWS IoT che consenta `iot` e `greengrass` agisca. Per semplificare, la seguente policy consente azioni su tutte le risorse, ma la policy dovrebbe essere più restrittiva.
```
aws iot create-policy \
--policy-name "Core_Devices" \
--policy-document "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Action\":[\"iot:Publish\",\"iot:Subscribe\",\"iot:Connect\",\"iot:Receive\"],\"Resource\":[\"*\"]},{\"Effect\":\"Allow\",\"Action\":[\"iot:GetThingShadow\",\"iot:UpdateThingShadow\",\"iot:DeleteThingShadow\"],\"Resource\":[\"*\"]},{\"Effect\":\"Allow\",\"Action\":[\"greengrass:*\"],\"Resource\":[\"*\"]}]}"
```
Output:
```
{
"policyName": "Core_Devices",
"policyArn": "arn:aws:iot:us-west-2:123456789012:policy/Core_Devices",
"policyDocument": "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Action\":[\"iot:Publish\",\"iot:Subscribe\",\"iot:Connect\",\"iot:Receive\"],\"Resource\":[\"*\"]},{\"Effect\":\"Allow\",\"Action\":[\"iot:GetThingShadow\",\"iot:UpdateThingShadow\",\"iot:DeleteThingShadow\"],\"Resource\":[\"*\"]},{\"Effect\":\"Allow\",\"Action\":[\"greengrass:*\"],\"Resource\":[\"*\"]}]}",
"policyVersionId": "1"
}
```
Collega la policy al certificato:
```
aws iot attach-policy \
--policy-name "Core_Devices" \
--target "arn:aws:iot:us-west-2:123456789012:cert/123a15ec415668c2349a76170b64ac0878231c1e21ec83c10e92a1EXAMPLExyz"
```
Questo comando non produce alcun output.
Collega l’oggetto al certificato:
```
aws iot attach-thing-principal \
--thing-name "MyCoreDevice" \
--principal "arn:aws:iot:us-west-2:123456789012:cert/123a15ec415668c2349a76170b64ac0878231c1e21ec83c10e92a1EXAMPLExyz"
```
Questo comando non produce alcun output.
Crea una definizione core:
```
aws greengrass create-core-definition \
--name "MyCores" \
--initial-version "{\"Cores\":[{\"Id\":\"MyCoreDevice\",\"ThingArn\":\"arn:aws:iot:us-west-2:123456789012:thing/MyCoreDevice\",\"CertificateArn\":\"arn:aws:iot:us-west-2:123456789012:cert/123a15ec415668c2349a76170b64ac0878231c1e21ec83c10e92a1EXAMPLExyz\",\"SyncShadow\":true}]}"
```
Output:
```
{
"LatestVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/cores/582efe12-b05a-409e-9a24-a2ba1bcc4a12/versions/cc87b5b3-8f4b-465d-944c-1d6de5dbfcdb",
"Name": "MyCores",
"LastUpdatedTimestamp": "2019-09-18T00:11:06.197Z",
"LatestVersion": "cc87b5b3-8f4b-465d-944c-1d6de5dbfcdb",
"CreationTimestamp": "2019-09-18T00:11:06.197Z",
"Id": "582efe12-b05a-409e-9a24-a2ba1bcc4a12",
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/cores/582efe12-b05a-409e-9a24-a2ba1bcc4a12"
}
```
Per ulteriori informazioni, consulta [Configurare AWS IoT Greengrass Core nella IoT *AWS Greengrass*](https://docs.aws.amazon.com/greengrass/latest/developerguide/gg-core.html) Developer Guide.
+ Per i dettagli sull'API, consulta *AWS CLI Command [CreateCoreDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-core-definition.html)Reference*.
### `create-deployment`
Il seguente esempio di codice mostra come utilizzare`create-deployment`.
**AWS CLI**
**Come creare un’implementazione per una versione di un gruppo Greengrass**
L’esempio `create-deployment` seguente distribuisce la versione specificata di un gruppo Greengrass.
```
aws greengrass create-deployment \
--deployment-type NewDeployment \
--group-id "ce2e7d01-3240-4c24-b8e6-f6f6e7a9eeca" \
--group-version-id "dc40c1e9-e8c8-4d28-a84d-a9cad5f599c9"
```
Output:
```
{
"DeploymentArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/groups/ce2e7d01-3240-4c24-b8e6-f6f6e7a9eeca/deployments/bfceb608-4e97-45bc-af5c-460144270308",
"DeploymentId": "bfceb608-4e97-45bc-af5c-460144270308"
}
```
Per ulteriori informazioni, consulta [Nozioni di base sui connettori (CLI)](https://docs.aws.amazon.com/greengrass/latest/developerguide/connectors-cli.html) nella *Guida per gli sviluppatori di AWS IoT Greengrass*.
+ Per i dettagli sull'API, consulta [CreateDeployment AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-deployment.html)*Command Reference*.
### `create-device-definition-version`
Il seguente esempio di codice mostra come utilizzare`create-device-definition-version`.
**AWS CLI**
**Come creare una versione di definizione del dispositivo**
L’esempio `create-device-definition-version` seguente crea una versione della definizione del dispositivo e la associa alla definizione del dispositivo specificata. La versione definisce due dispositivi. Prima di poter creare un dispositivo Greengrass, è necessario creare e fornire il dispositivo AWS IoT corrispondente. Questo processo include i seguenti comandi `iot` che è necessario eseguire per ottenere le informazioni richieste per il comando Greengrass:
Crea l'oggetto AWS IoT che corrisponde al dispositivo:
```
aws iot create-thing \
--thing-name "InteriorTherm"
```
Output:
```
{
"thingArn": "arn:aws:iot:us-west-2:123456789012:thing/InteriorTherm",
"thingName": "InteriorTherm",
"thingId": "01d4763c-78a6-46c6-92be-7add080394bf"
}
```
Crea chiavi pubbliche e private e il certificato del dispositivo per l’oggetto. Questo esempio utilizza il comando `create-keys-and-certificate` e richiede le autorizzazioni di scrittura nella directory corrente. In alternativa, puoi utilizzare il comando `create-certificate-from-csr`.
```
aws iot create-keys-and-certificate \
--set-as-active \
--certificate-pem-outfile "myDevice.cert.pem" \
--public-key-outfile "myDevice.public.key" \
--private-key-outfile "myDevice.private.key"
```
Output:
```
{
"certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/66a415ec415668c2349a76170b64ac0878231c1e21ec83c10e92a18bd568eb92",
"certificatePem": "-----BEGIN CERTIFICATE-----\nMIIDWTCAkGgAwIBATgIUCgq6EGqou6zFqWgIZRndgQEFW+gwDQYJKoZIhvc...KdGewQS\n-----END CERTIFICATE-----\n",
"keyPair": {
"PublicKey": "-----BEGIN PUBLIC KEY-----\nMIIBIjANBzrqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAqKpRgnn6yq26U3y...wIDAQAB\n-----END PUBLIC KEY-----\n",
"PrivateKey": "-----BEGIN RSA PRIVATE KEY-----\nMIIEowIABAKCAQEAqKpRgnn6yq26U3yt5YFZquyukfRjbMXDcNOK4rMCxDR...fvY4+te\n-----END RSA PRIVATE KEY-----\n"
},
"certificateId": "66a415ec415668c2349a76170b64ac0878231c1e21ec83c10e92a18bd568eb92"
}
```
Crea una policy AWS IoT che consenta `iot` e `greengrass` agisca. Per semplicità, la seguente policy consente azioni su tutte le risorse, ma la tua policy può essere più restrittiva:
```
aws iot create-policy \
--policy-name "GG_Devices" \
--policy-document "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Action\":[\"iot:Publish\",\"iot:Subscribe\",\"iot:Connect\",\"iot:Receive\"],\"Resource\":[\"*\"]},{\"Effect\":\"Allow\",\"Action\":[\"iot:GetThingShadow\",\"iot:UpdateThingShadow\",\"iot:DeleteThingShadow\"],\"Resource\":[\"*\"]},{\"Effect\":\"Allow\",\"Action\":[\"greengrass:*\"],\"Resource\":[\"*\"]}]}"
```
Output:
```
{
"policyName": "GG_Devices",
"policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GG_Devices",
"policyDocument": "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Action\":[\"iot:Publish\",\"iot:Subscribe\",\"iot:Connect\",\"iot:Receive\"],\"Resource\":[\"*\"]},{\"Effect\":\"Allow\",\"Action\":[\"iot:GetThingShadow\",\"iot:UpdateThingShadow\",\"iot:DeleteThingShadow\"],\"Resource\":[\"*\"]},{\"Effect\":\"Allow\",\"Action\":[\"greengrass:*\"],\"Resource\":[\"*\"]}]}",
"policyVersionId": "1"
}
```
Collega la policy al certificato:
```
aws iot attach-policy \
--policy-name "GG_Devices" \
--target "arn:aws:iot:us-west-2:123456789012:cert/66a415ec415668c2349a76170b64ac0878231c1e21ec83c10e92a18bd568eb92"
```
Collega l’oggetto al certificato
```
aws iot attach-thing-principal \
--thing-name "InteriorTherm" \
--principal "arn:aws:iot:us-west-2:123456789012:cert/66a415ec415668c2349a76170b64ac0878231c1e21ec83c10e92a18bd568eb92"
```
Dopo aver creato e configurato l’oggetto IoT come mostrato sopra, utilizza i comandi `ThingArn` e `CertificateArn` dei primi due comandi nell’esempio seguente.
```
aws greengrass create-device-definition-version \
--device-definition-id "f9ba083d-5ad4-4534-9f86-026a45df1ccd" \
--devices "[{\"Id\":\"InteriorTherm\",\"ThingArn\":\"arn:aws:iot:us-west-2:123456789012:thing/InteriorTherm\",\"CertificateArn\":\"arn:aws:iot:us-west-2:123456789012:cert/66a415ec415668c2349a76170b64ac0878231c1e21ec83c10e92a18bd568eb92\",\"SyncShadow\":true},{\"Id\":\"ExteriorTherm\",\"ThingArn\":\"arn:aws:iot:us-west-2:123456789012:thing/ExteriorTherm\",\"CertificateArn\":\"arn:aws:iot:us-west-2:123456789012:cert/6c52ce1b47bde88a637e9ccdd45fe4e4c2c0a75a6866f8f63d980ee22fa51e02\",\"SyncShadow\":true}]"
```
Output:
```
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/devices/f9ba083d-5ad4-4534-9f86-026a45df1ccd/versions/83c13984-6fed-447e-84d5-5b8aa45d5f71",
"Version": "83c13984-6fed-447e-84d5-5b8aa45d5f71",
"CreationTimestamp": "2019-09-11T00:15:09.838Z",
"Id": "f9ba083d-5ad4-4534-9f86-026a45df1ccd"
}
```
+ Per i dettagli sull'API, consulta [CreateDeviceDefinitionVersion AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-device-definition-version.html)*Command Reference*.
### `create-device-definition`
Il seguente esempio di codice mostra come utilizzare`create-device-definition`.
**AWS CLI**
**Come creare una definizione di dispositivo**
L’esempio `create-device-definition` seguente crea una definizione di dispositivo che contiene una versione iniziale della definizione di dispositivo. La versione iniziale definisce due dispositivi. Prima di poter creare un dispositivo Greengrass, è necessario creare e fornire il dispositivo AWS IoT corrispondente. Questo processo include i seguenti comandi `iot` che è necessario eseguire per ottenere le informazioni richieste per il comando Greengrass:
Crea l'oggetto AWS IoT che corrisponde al dispositivo:
```
aws iot create-thing \
--thing-name "InteriorTherm"
```
Output:
```
{
"thingArn": "arn:aws:iot:us-west-2:123456789012:thing/InteriorTherm",
"thingName": "InteriorTherm",
"thingId": "01d4763c-78a6-46c6-92be-7add080394bf"
}
```
Crea chiavi pubbliche e private e il certificato del dispositivo per l’oggetto. Questo esempio utilizza il comando `create-keys-and-certificate` e richiede le autorizzazioni di scrittura nella directory corrente. In alternativa, puoi utilizzare il comando `create-certificate-from-csr`.
```
aws iot create-keys-and-certificate \
--set-as-active \
--certificate-pem-outfile "myDevice.cert.pem" \
--public-key-outfile "myDevice.public.key" \
--private-key-outfile "myDevice.private.key"
```
Output:
```
{
"certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/66a415ec415668c2349a76170b64ac0878231c1e21ec83c10e92a18bd568eb92",
"certificatePem": "-----BEGIN CERTIFICATE-----\nMIIDWTCAkGgAwIBATgIUCgq6EGqou6zFqWgIZRndgQEFW+gwDQYJKoZIhvc...KdGewQS\n-----END CERTIFICATE-----\n",
"keyPair": {
"PublicKey": "-----BEGIN PUBLIC KEY-----\nMIIBIjANBzrqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAqKpRgnn6yq26U3y...wIDAQAB\n-----END PUBLIC KEY-----\n",
"PrivateKey": "-----BEGIN RSA PRIVATE KEY-----\nMIIEowIABAKCAQEAqKpRgnn6yq26U3yt5YFZquyukfRjbMXDcNOK4rMCxDR...fvY4+te\n-----END RSA PRIVATE KEY-----\n"
},
"certificateId": "66a415ec415668c2349a76170b64ac0878231c1e21ec83c10e92a18bd568eb92"
}
```
Crea una policy AWS IoT che consenta `iot` e `greengrass` agisca. Per semplicità, la seguente policy consente azioni su tutte le risorse, ma la tua policy può essere più restrittiva:
```
aws iot create-policy \
--policy-name "GG_Devices" \
--policy-document "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Action\":[\"iot:Publish\",\"iot:Subscribe\",\"iot:Connect\",\"iot:Receive\"],\"Resource\":[\"*\"]},{\"Effect\":\"Allow\",\"Action\":[\"iot:GetThingShadow\",\"iot:UpdateThingShadow\",\"iot:DeleteThingShadow\"],\"Resource\":[\"*\"]},{\"Effect\":\"Allow\",\"Action\":[\"greengrass:*\"],\"Resource\":[\"*\"]}]}"
```
Output:
```
{
"policyName": "GG_Devices",
"policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GG_Devices",
"policyDocument": "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Action\":[\"iot:Publish\",\"iot:Subscribe\",\"iot:Connect\",\"iot:Receive\"],\"Resource\":[\"*\"]},{\"Effect\":\"Allow\",\"Action\":[\"iot:GetThingShadow\",\"iot:UpdateThingShadow\",\"iot:DeleteThingShadow\"],\"Resource\":[\"*\"]},{\"Effect\":\"Allow\",\"Action\":[\"greengrass:*\"],\"Resource\":[\"*\"]}]}",
"policyVersionId": "1"
}
```
Collega la policy al certificato:
```
aws iot attach-policy \
--policy-name "GG_Devices" \
--target "arn:aws:iot:us-west-2:123456789012:cert/66a415ec415668c2349a76170b64ac0878231c1e21ec83c10e92a18bd568eb92"
```
Collega l’oggetto al certificato
```
aws iot attach-thing-principal \
--thing-name "InteriorTherm" \
--principal "arn:aws:iot:us-west-2:123456789012:cert/66a415ec415668c2349a76170b64ac0878231c1e21ec83c10e92a18bd568eb92"
```
Dopo aver creato e configurato l’oggetto IoT come mostrato sopra, utilizza i comandi `ThingArn` e `CertificateArn` dei primi due comandi nell’esempio seguente.
```
aws greengrass create-device-definition \
--name "Sensors" \
--initial-version "{\"Devices\":[{\"Id\":\"InteriorTherm\",\"ThingArn\":\"arn:aws:iot:us-west-2:123456789012:thing/InteriorTherm\",\"CertificateArn\":\"arn:aws:iot:us-west-2:123456789012:cert/66a415ec415668c2349a76170b64ac0878231c1e21ec83c10e92a18bd568eb92\",\"SyncShadow\":true},{\"Id\":\"ExteriorTherm\",\"ThingArn\":\"arn:aws:iot:us-west-2:123456789012:thing/ExteriorTherm\",\"CertificateArn\":\"arn:aws:iot:us-west-2:123456789012:cert/6c52ce1b47bde88a637e9ccdd45fe4e4c2c0a75a6866f8f63d980ee22fa51e02\",\"SyncShadow\":true}]}"
```
Output:
```
{
"LatestVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/devices/f9ba083d-5ad4-4534-9f86-026a45df1ccd/versions/3b5cc510-58c1-44b5-9d98-4ad858ffa795",
"Name": "Sensors",
"LastUpdatedTimestamp": "2019-09-11T00:11:06.197Z",
"LatestVersion": "3b5cc510-58c1-44b5-9d98-4ad858ffa795",
"CreationTimestamp": "2019-09-11T00:11:06.197Z",
"Id": "f9ba083d-5ad4-4534-9f86-026a45df1ccd",
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/devices/f9ba083d-5ad4-4534-9f86-026a45df1ccd"
}
```
+ Per i dettagli sull'API, consulta [CreateDeviceDefinition AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-device-definition.html)*Command Reference*.
### `create-function-definition-version`
Il seguente esempio di codice mostra come utilizzare`create-function-definition-version`.
**AWS CLI**
**Come creare la versione della definizione di funzione**
L’esempio `create-function-definition-version` seguente crea una nuova versione della definizione di funzione specificata. Questa versione specifica una singola funzione il cui ID è `Hello-World-function`, consente l’accesso al file system e specifica una dimensione massima della memoria e un periodo di timeout.
```
aws greengrass create-function-definition-version \
--cli-input-json "{\"FunctionDefinitionId\": \"e626e8c9-3b8f-4bf3-9cdc-d26ecdeb9fa3\",\"Functions\": [{\"Id\": \"Hello-World-function\", \"FunctionArn\": \""arn:aws:lambda:us-west-2:123456789012:function:Greengrass_HelloWorld_Counter:gghw-alias"\",\"FunctionConfiguration\": {\"Environment\": {\"AccessSysfs\": true},\"Executable\": \"greengrassHelloWorldCounter.function_handler\",\"MemorySize\": 16000,\"Pinned\": false,\"Timeout\": 25}}]}"
```
Output:
```
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/e626e8c9-3b8f-4bf3-9cdc-d26ecdeb9fa3/versions/74abd1cc-637e-4abe-8684-9a67890f4043",
"CreationTimestamp": "2019-06-25T22:03:43.376Z",
"Id": "e626e8c9-3b8f-4bf3-9cdc-d26ecdeb9fa3",
"Version": "74abd1cc-637e-4abe-8684-9a67890f4043"
}
```
+ Per i dettagli sull'API, consulta [CreateFunctionDefinitionVersion AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-function-definition-version.html)*Command Reference*.
### `create-function-definition`
Il seguente esempio di codice mostra come utilizzare`create-function-definition`.
**AWS CLI**
**Come creare una definizione di funzione Lambda**
L’esempio `create-function-definition` seguente crea una definizione di funzione Lambda e una versione iniziale fornendo un elenco di funzioni Lambda (in questo caso, un elenco di una sola funzione denominata `TempMonitorFunction`) e le relative configurazioni. Prima di poter creare la definizione della funzione, è necessario l’ARN della funzione Lambda. Per creare la funzione e il relativo alias, utilizza i comandi `create-function` e `publish-version` di Lambda. Il `create-function` comando di Lambda richiede l'ARN del ruolo di esecuzione, anche se AWS IoT Greengrass non utilizza quel ruolo perché le autorizzazioni sono specificate nel ruolo del gruppo Greengrass. Puoi usare il comando `create-role` IAM per creare un ruolo vuoto per ottenere un ARN da utilizzare con `create-function` di Lambda oppure puoi utilizzare un ruolo di esecuzione esistente.
```
aws greengrass create-function-definition \
--name MyGreengrassFunctions \
--initial-version "{\"Functions\": [{\"Id\": \"TempMonitorFunction\", \"FunctionArn\": \"arn:aws:lambda:us-west-2:123456789012:function:TempMonitor:GG_TempMonitor\", \"FunctionConfiguration\": {\"Executable\": \"temp_monitor.function_handler\", \"MemorySize\": 16000,\"Timeout\": 5}}]}"
```
Output:
```
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/3b0d0080-87e7-48c6-b182-503ec743a08b",
"CreationTimestamp": "2019-06-19T22:24:44.585Z",
"Id": "3b0d0080-87e7-48c6-b182-503ec743a08b",
"LastUpdatedTimestamp": "2019-06-19T22:24:44.585Z",
"LatestVersion": "67f918b9-efb4-40b0-b87c-de8c9faf085b",
"LatestVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/3b0d0080-87e7-48c6-b182-503ec743a08b/versions/67f918b9-efb4-40b0-b87c-de8c9faf085b",
"Name": "MyGreengrassFunctions"
}
```
Per ulteriori informazioni, consulta [Come configurare l'accesso alle risorse locali utilizzando l'interfaccia a riga di AWS comando](https://docs.aws.amazon.com/greengrass/latest/developerguide/lra-cli.html) nella *AWS IoT Greengrass Developer Guide*.
+ Per i dettagli sull'API, consulta [CreateFunctionDefinition AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-function-definition.html)*Command Reference.*
### `create-group-certificate-authority`
Il seguente esempio di codice mostra come utilizzare`create-group-certificate-authority`.
**AWS CLI**
**Come creare un’autorità di certificazione (CA) per un gruppo**
L’esempio `create-group-certificate-authority` seguente crea o ruota una CA per il gruppo specificato.
```
aws greengrass create-group-certificate-authority \
--group-id "8eaadd72-ce4b-4f15-892a-0cc4f3a343f1"
```
Output:
```
{
"GroupCertificateAuthorityArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/groups/8eaadd72-ce4b-4f15-892a-0cc4f3a343f1/certificateauthorities/d31630d674c4437f6c5dbc0dca56312a902171ce2d086c38e509c8EXAMPLEcc5"
}
```
Per ulteriori informazioni, consulta [Sicurezza di AWS IoT Greengrass](https://docs.aws.amazon.com/greengrass/latest/developerguide/gg-sec.html) nella *Guida per gli sviluppatori di AWS IoT Greengrass*.
+ Per i dettagli sull'API, consulta [CreateGroupCertificateAuthority AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-group-certificate-authority.html)*Command Reference*.
### `create-group-version`
Il seguente esempio di codice mostra come utilizzare`create-group-version`.
**AWS CLI**
**Come creare una versione di un gruppo Greengrass**
L’esempio `create-group-version` seguente crea una versione di gruppo e la associa al gruppo specificato. La versione fa riferimento alle versioni core, di risorsa, di connettore, di funzione e di abbonamento che contengono le entità da includere in questa versione di gruppo. È necessario creare queste entità prima della versione del gruppo.
Per creare una definizione di risorsa con una versione iniziale, utilizza il comando `create-resource-definition`. Per creare una definizione di connettore con una versione iniziale, utilizza il comando `create-connector-definition`. Per creare una definizione di funzione con una versione iniziale, utilizza il comando `create-function-definition`. Per creare una definizione di abbonamento con una versione iniziale, utilizza il comando `create-subscription-definition`. Per recuperare l’ARN dell’ultima versione di definizione core, utilizza il comando `get-group-version` e specifica l’ID dell’ultima versione di gruppo.
```
aws greengrass create-group-version \
--group-id "ce2e7d01-3240-4c24-b8e6-f6f6e7a9eeca" \
--core-definition-version-arn "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/cores/6a630442-8708-4838-ad36-eb98849d975e/versions/6c87151b-1fb4-4cb2-8b31-6ee715d8f8ba" \
--resource-definition-version-arn "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/resources/c8bb9ebc-c3fd-40a4-9c6a-568d75569d38/versions/a5f94d0b-f6bc-40f4-bb78-7a1c5fe13ba1" \
--connector-definition-version-arn "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/connectors/55d0052b-0d7d-44d6-b56f-21867215e118/versions/78a3331b-895d-489b-8823-17b4f9f418a0" \
--function-definition-version-arn "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/3b0d0080-87e7-48c6-b182-503ec743a08b/versions/67f918b9-efb4-40b0-b87c-de8c9faf085b" \
--subscription-definition-version-arn "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/subscriptions/9d611d57-5d5d-44bd-a3b4-feccbdd69112/versions/aa645c47-ac90-420d-9091-8c7ffa4f103f"
```
Output:
```
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/groups/ce2e7d01-3240-4c24-b8e6-f6f6e7a9eeca/versions/e10b0459-4345-4a09-88a4-1af1f5d34638",
"CreationTimestamp": "2019-06-20T18:42:47.020Z",
"Id": "ce2e7d01-3240-4c24-b8e6-f6f6e7a9eeca",
"Version": "e10b0459-4345-4a09-88a4-1af1f5d34638"
}
```
Per ulteriori informazioni, vedere [Panoramica del modello a AWS oggetti del gruppo IoT Greengrass](https://docs.aws.amazon.com/greengrass/latest/developerguide/deployments.html#api-overview) nella IoT *AWS Greengrass* Developer Guide.
+ Per i dettagli sull'API, consulta *AWS CLI Command [CreateGroupVersion](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-group-version.html)Reference*.
### `create-group`
Il seguente esempio di codice mostra come utilizzare`create-group`.
**AWS CLI**
**Come creare un gruppo Greengrass**
L’esempio `create-group` seguente elimina un gruppo denominato `cli-created-group`.
```
aws greengrass create-group \
--name cli-created-group
```
Output:
```
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/groups/4e22bd92-898c-436b-ade5-434d883ff749",
"CreationTimestamp": "2019-06-25T18:07:17.688Z",
"Id": "4e22bd92-898c-436b-ade5-434d883ff749",
"LastUpdatedTimestamp": "2019-06-25T18:07:17.688Z",
"Name": "cli-created-group"
}
```
Per ulteriori informazioni, vedere [Panoramica del modello a AWS oggetti del gruppo IoT Greengrass](https://docs.aws.amazon.com/greengrass/latest/developerguide/deployments.html#api-overview) nella IoT *AWS Greengrass* Developer Guide.
+ Per i dettagli sull'API, consulta *AWS CLI Command [CreateGroup](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-group.html)Reference*.
### `create-logger-definition-version`
Il seguente esempio di codice mostra come utilizzare`create-logger-definition-version`.
**AWS CLI**
**Come creare una versione della definizione di logger**
L’esempio `create-logger-definition-version` seguente crea una versione della definizione di logger e la associa a una definizione di logger. La versione definisce quattro configurazioni di registrazione: 1) registri dei componenti di sistema sul file system del dispositivo principale, 2) registri delle funzioni Lambda definiti dall'utente sul file system del dispositivo principale, 3) registri dei componenti di sistema in Amazon Logs e 4) registri delle funzioni Lambda definiti dall'utente in Amazon Logs CloudWatch . CloudWatch Nota: per l'integrazione con Logs, il ruolo del gruppo deve concedere le autorizzazioni appropriate. CloudWatch
```
aws greengrass create-logger-definition-version \
--logger-definition-id "a454b62a-5d56-4ca9-bdc4-8254e1662cb0" \
--loggers "[{\"Id\":\"1\",\"Component\":\"GreengrassSystem\",\"Level\":\"ERROR\",\"Space\":10240,\"Type\":\"FileSystem\"},{\"Id\":\"2\",\"Component\":\"Lambda\",\"Level\":\"INFO\",\"Space\":10240,\"Type\":\"FileSystem\"},{\"Id\":\"3\",\"Component\":\"GreengrassSystem\",\"Level\":\"WARN\",\"Type\":\"AWSCloudWatch\"},{\"Id\":\"4\",\"Component\":\"Lambda\",\"Level\":\"INFO\",\"Type\":\"AWSCloudWatch\"}]"
```
Output:
```
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/loggers/a454b62a-5d56-4ca9-bdc4-8254e1662cb0/versions/49aedb1e-01a3-4d39-9871-3a052573f1ea",
"Version": "49aedb1e-01a3-4d39-9871-3a052573f1ea",
"CreationTimestamp": "2019-07-24T00:04:48.523Z",
"Id": "a454b62a-5d56-4ca9-bdc4-8254e1662cb0"
}
```
Per ulteriori informazioni, consulta [Monitoring with AWS IoT Greengrass Logs](https://docs.aws.amazon.com/greengrass/latest/developerguide/greengrass-logs-overview.html) nella IoT *AWS Greengrass* Developer Guide.
+ *Per i dettagli sull'API, consulta Command [CreateLoggerDefinitionVersion](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-logger-definition-version.html)Reference AWS CLI .*
### `create-logger-definition`
Il seguente esempio di codice mostra come utilizzare`create-logger-definition`.
**AWS CLI**
**Come creare una definizione del logger**
L’esempio `create-logger-definition` seguente crea una definizione di logger che contiene una versione iniziale della definizione di logger. La versione iniziale definisce tre configurazioni di registrazione: 1) registri dei componenti di sistema sul file system del dispositivo principale, 2) registri delle funzioni Lambda definiti dall'utente sul file system del dispositivo principale e 3) registri delle funzioni Lambda definiti dall'utente in Amazon Logs. CloudWatch Nota: per l'integrazione dei CloudWatch log, il ruolo del gruppo deve concedere le autorizzazioni appropriate.
```
aws greengrass create-logger-definition \
--name "LoggingConfigs" \
--initial-version "{\"Loggers\":[{\"Id\":\"1\",\"Component\":\"GreengrassSystem\",\"Level\":\"ERROR\",\"Space\":10240,\"Type\":\"FileSystem\"},{\"Id\":\"2\",\"Component\":\"Lambda\",\"Level\":\"INFO\",\"Space\":10240,\"Type\":\"FileSystem\"},{\"Id\":\"3\",\"Component\":\"Lambda\",\"Level\":\"INFO\",\"Type\":\"AWSCloudWatch\"}]}"
```
Output:
```
{
"LatestVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/loggers/a454b62a-5d56-4ca9-bdc4-8254e1662cb0/versions/de1d9854-1588-4525-b25e-b378f60f2322",
"Name": "LoggingConfigs",
"LastUpdatedTimestamp": "2019-07-23T23:52:17.165Z",
"LatestVersion": "de1d9854-1588-4525-b25e-b378f60f2322",
"CreationTimestamp": "2019-07-23T23:52:17.165Z",
"Id": "a454b62a-5d56-4ca9-bdc4-8254e1662cb0",
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/loggers/a454b62a-5d56-4ca9-bdc4-8254e1662cb0"
}
```
Per ulteriori informazioni, consulta [Monitoring with AWS IoT Greengrass Logs](https://docs.aws.amazon.com/greengrass/latest/developerguide/greengrass-logs-overview.html) nella IoT *AWS Greengrass* Developer Guide.
+ *Per i dettagli sull'API, consulta Command [CreateLoggerDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-logger-definition.html)Reference AWS CLI .*
### `create-resource-definition-version`
Il seguente esempio di codice mostra come utilizzare`create-resource-definition-version`.
**AWS CLI**
**Come creare una versione di una definizione di risorsa**
L'`create-resource-definition-version`esempio seguente crea una nuova versione di a TwilioAuthToken.
```
aws greengrass create-resource-definition-version \
--resource-definition-id "c8bb9ebc-c3fd-40a4-9c6a-568d75569d38" \
--resources "[{\"Id\": \"TwilioAuthToken\",\"Name\": \"MyTwilioAuthToken\",\"ResourceDataContainer\": {\"SecretsManagerSecretResourceData\": {\"ARN\": \"arn:aws:secretsmanager:us-west-2:123456789012:secret:greengrass-TwilioAuthToken-ntSlp6\"}}}]"
```
Output:
```
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/resources/c8bb9ebc-c3fd-40a4-9c6a-568d75569d38/versions/b3bcada0-5fb6-42df-bf0b-1ee4f15e769e",
"CreationTimestamp": "2019-06-24T21:17:25.623Z",
"Id": "c8bb9ebc-c3fd-40a4-9c6a-568d75569d38",
"Version": "b3bcada0-5fb6-42df-bf0b-1ee4f15e769e"
}
```
+ Per i dettagli sull'API, vedere [CreateResourceDefinitionVersion](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-resource-definition-version.html)in *AWS CLI Command Reference*.
### `create-resource-definition`
Il seguente esempio di codice mostra come utilizzare`create-resource-definition`.
**AWS CLI**
**Come creare una definizione di risorsa**
L’esempio `create-resource-definition` seguente crea una definizione di risorsa che contiene un elenco di risorse da utilizzare in un gruppo Greengrass. In questo esempio, viene inclusa una versione iniziale della definizione di risorsa fornendo un elenco di risorse. L'elenco include una risorsa per un token di autorizzazione Twilio e l'ARN per un segreto archiviato in Secrets AWS Manager. Prima di poter creare la definizione di risorsa, è necessario creare un segreto.
```
aws greengrass create-resource-definition \
--name MyGreengrassResources \
--initial-version "{\"Resources\": [{\"Id\": \"TwilioAuthToken\",\"Name\": \"MyTwilioAuthToken\",\"ResourceDataContainer\": {\"SecretsManagerSecretResourceData\": {\"ARN\": \"arn:aws:secretsmanager:us-west-2:123456789012:secret:greengrass-TwilioAuthToken-ntSlp6\"}}}]}"
```
Output:
```
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/resources/c8bb9ebc-c3fd-40a4-9c6a-568d75569d38",
"CreationTimestamp": "2019-06-19T21:51:28.212Z",
"Id": "c8bb9ebc-c3fd-40a4-9c6a-568d75569d38",
"LastUpdatedTimestamp": "2019-06-19T21:51:28.212Z",
"LatestVersion": "a5f94d0b-f6bc-40f4-bb78-7a1c5fe13ba1",
"LatestVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/resources/c8bb9ebc-c3fd-40a4-9c6a-568d75569d38/versions/a5f94d0b-f6bc-40f4-bb78-7a1c5fe13ba1",
"Name": "MyGreengrassResources"
}
```
Per ulteriori informazioni, consulta [Come configurare l'accesso alle risorse locali utilizzando l'interfaccia a riga di AWS comando](https://docs.aws.amazon.com/greengrass/latest/developerguide/lra-cli.html) nella *AWS IoT Greengrass Developer Guide*.
+ Per i dettagli sull'API, consulta [CreateResourceDefinition AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-resource-definition.html)*Command Reference.*
### `create-software-update-job`
Il seguente esempio di codice mostra come utilizzare`create-software-update-job`.
**AWS CLI**
**Come creare un processo di aggiornamento del software per il core**
L'`create-software-update-job`esempio seguente crea un processo di aggiornamento over-the-air (OTA) per aggiornare il software AWS IoT Greengrass Core sul core il cui nome è. `MyFirstGroup_Core` Questo comando richiede un ruolo IAM che consenta l’accesso ai pacchetti di aggiornamento software in Amazon S3 e includa `iot.amazonaws.com` come entità attendibile.
```
aws greengrass create-software-update-job \
--update-targets-architecture armv7l \
--update-targets [\"arn:aws:iot:us-west-2:123456789012:thing/MyFirstGroup_Core\"] \
--update-targets-operating-system raspbian \
--software-to-update core \
--s3-url-signer-role arn:aws:iam::123456789012:role/OTA_signer_role \
--update-agent-log-level WARN
```
Output:
```
{
"IotJobId": "GreengrassUpdateJob_30b353e3-3af7-4786-be25-4c446663c09e",
"IotJobArn": "arn:aws:iot:us-west-2:123456789012:job/GreengrassUpdateJob_30b353e3-3af7-4786-be25-4c446663c09e",
"PlatformSoftwareVersion": "1.9.3"
}
```
Per ulteriori informazioni, consulta [Aggiornamenti OTA del software AWS IoT Greengrass Core](https://docs.aws.amazon.com/greengrass/latest/developerguide/core-ota-update.html) nella IoT *AWS Greengrass* Developer Guide.
+ Per i dettagli sull'API, consulta *AWS CLI Command [CreateSoftwareUpdateJob](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-software-update-job.html)Reference*.
### `create-subscription-definition-version`
Il seguente esempio di codice mostra come utilizzare`create-subscription-definition-version`.
**AWS CLI**
**Come creare una nuova versione della definizione di abbonamento**
L’esempio `create-subscription-definition-version` seguente crea una nuova versione di una definizione di abbonamento che contiene tre abbonamenti: una notifica di attivazione, un input di temperatura e uno stato di output.
```
aws greengrass create-subscription-definition-version \
--subscription-definition-id "9d611d57-5d5d-44bd-a3b4-feccbdd69112" \
--subscriptions "[{\"Id\": \"TriggerNotification\", \"Source\": \"arn:aws:lambda:us-west-2:123456789012:function:TempMonitor:GG_TempMonitor\", \"Subject\": \"twilio/txt\", \"Target\": \"arn:aws:greengrass:us-west-2::/connectors/TwilioNotifications/versions/1\"},{\"Id\": \"TemperatureInput\", \"Source\": \"cloud\", \"Subject\": \"temperature/input\", \"Target\": \"arn:aws:lambda:us-west-2:123456789012:function:TempMonitor:GG_TempMonitor\"},{\"Id\": \"OutputStatus\", \"Source\": \"arn:aws:greengrass:us-west-2::/connectors/TwilioNotifications/versions/1\", \"Subject\": \"twilio/message/status\", \"Target\": \"cloud\"}]"
```
Output:
```
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/subscriptions/9d611d57-5d5d-44bd-a3b4-feccbdd69112/versions/7b65dfae-50b6-4d0f-b3e0-27728bfb0620",
"CreationTimestamp": "2019-06-24T21:21:33.837Z",
"Id": "9d611d57-5d5d-44bd-a3b4-feccbdd69112",
"Version": "7b65dfae-50b6-4d0f-b3e0-27728bfb0620"
}
```
+ Per i dettagli sull'API, consulta [CreateSubscriptionDefinitionVersion AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-subscription-definition-version.html)*Command Reference*.
### `create-subscription-definition`
Il seguente esempio di codice mostra come utilizzare`create-subscription-definition`.
**AWS CLI**
**Come creare una definizione di abbonamento**
L’esempio `create-subscription-definition` seguente crea una definizione di abbonamento e ne specifica la versione iniziale. La versione iniziale contiene tre abbonamenti: uno per l'argomento MQTT a cui è abbonato il connettore, uno per consentire a una funzione di ricevere letture di temperatura dall' AWS IoT e uno per consentire all' AWS IoT di ricevere informazioni sullo stato dal connettore. L’esempio fornisce l’ARN per l’alias della funzione Lambda creato in precedenza utilizzando il comando `create-alias` di Lambda.
```
aws greengrass create-subscription-definition \
--initial-version "{\"Subscriptions\": [{\"Id\": \"TriggerNotification\", \"Source\": \"arn:aws:lambda:us-west-2:123456789012:function:TempMonitor:GG_TempMonitor\", \"Subject\": \"twilio/txt\", \"Target\": \"arn:aws:greengrass:us-west-2::/connectors/TwilioNotifications/versions/1\"},{\"Id\": \"TemperatureInput\", \"Source\": \"cloud\", \"Subject\": \"temperature/input\", \"Target\": \"arn:aws:lambda:us-west-2:123456789012:function:TempMonitor:GG_TempMonitor\"},{\"Id\": \"OutputStatus\", \"Source\": \"arn:aws:greengrass:us-west-2::/connectors/TwilioNotifications/versions/1\", \"Subject\": \"twilio/message/status\", \"Target\": \"cloud\"}]}"
```
Output:
```
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/subscriptions/9d611d57-5d5d-44bd-a3b4-feccbdd69112",
"CreationTimestamp": "2019-06-19T22:34:26.677Z",
"Id": "9d611d57-5d5d-44bd-a3b4-feccbdd69112",
"LastUpdatedTimestamp": "2019-06-19T22:34:26.677Z",
"LatestVersion": "aa645c47-ac90-420d-9091-8c7ffa4f103f",
"LatestVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/subscriptions/9d611d57-5d5d-44bd-a3b4-feccbdd69112/versions/aa645c47-ac90-420d-9091-8c7ffa4f103f"
}
```
Per ulteriori informazioni, consulta [Nozioni di base sui connettori (CLI)](https://docs.aws.amazon.com/greengrass/latest/developerguide/connectors-cli.html) nella *Guida per gli sviluppatori di AWS IoT Greengrass*.
+ *Per i dettagli sull'API, vedere [CreateSubscriptionDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-subscription-definition.html)in Command Reference.AWS CLI *
### `delete-connector-definition`
Il seguente esempio di codice mostra come utilizzare`delete-connector-definition`.
**AWS CLI**
**Come eliminare una definizione di connettore**
L’esempio `delete-connector-definition` seguente elimina la definizione di connettore Greengrass specificata. Se si elimina una definizione di connettore utilizzata da un gruppo, tale gruppo non può essere distribuito correttamente.
```
aws greengrass delete-connector-definition \
--connector-definition-id "b5c4ebfd-f672-49a3-83cd-31c7216a7bb8"
```
Questo comando non produce alcun output.
+ Per i dettagli sull'API, consulta [DeleteConnectorDefinition AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/delete-connector-definition.html)*Command Reference*.
### `delete-core-definition`
Il seguente esempio di codice mostra come utilizzare`delete-core-definition`.
**AWS CLI**
**Come eliminare una definizione core**
L’esempio `delete-core-definition` seguente elimina la definizione core di Greengrass specificata, incluse tutte le versioni. Se elimini una definizione core associata a un gruppo Greengrass, quel gruppo non può essere distribuito correttamente.
```
aws greengrass delete-core-definition \
--core-definition-id "ff36cc5f-9f98-4994-b468-9d9b6dc52abd"
```
Questo comando non produce alcun output.
+ Per i dettagli sull'API, consulta [DeleteCoreDefinition AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/delete-core-definition.html)*Command Reference*.
### `delete-device-definition`
Il seguente esempio di codice mostra come utilizzare`delete-device-definition`.
**AWS CLI**
**Come eliminare una definizione di dispositivo**
L’esempio `delete-device-definition` seguente elimina la definizione di dispositivo specificata, incluse tutte le relative versioni. Se si elimina una versione di definizione di dispositivo utilizzata da una versione di gruppo, la versione di gruppo non può essere distribuita correttamente.
```
aws greengrass delete-device-definition \
--device-definition-id "f9ba083d-5ad4-4534-9f86-026a45df1ccd"
```
Questo comando non produce alcun output.
+ Per i dettagli sull'API, consulta [DeleteDeviceDefinition AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/delete-device-definition.html)*Command Reference*.
### `delete-function-definition`
Il seguente esempio di codice mostra come utilizzare`delete-function-definition`.
**AWS CLI**
**Come eliminare una definizione di funzione**
L’esempio `delete-function-definition` seguente elimina la definizione di funzione Greengrass specificata. Se si elimina una definizione di funzione utilizzata da un gruppo, tale gruppo non può essere distribuito correttamente.
```
aws greengrass delete-function-definition \
--function-definition-id "fd4b906a-dff3-4c1b-96eb-52ebfcfac06a"
```
Questo comando non produce alcun output.
+ Per i dettagli sull'API, consulta [DeleteFunctionDefinition AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/delete-function-definition.html)*Command Reference*.
### `delete-group`
Il seguente esempio di codice mostra come utilizzare`delete-group`.
**AWS CLI**
**Come eliminare un gruppo**
L’esempio `delete-group` seguente elimina il gruppo Greengrass specificato.
```
aws greengrass delete-group \
--group-id "4e22bd92-898c-436b-ade5-434d883ff749"
```
Questo comando non produce alcun output.
+ Per i dettagli sull'API, consulta [DeleteGroup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/delete-group.html)*Command Reference*.
### `delete-logger-definition`
Il seguente esempio di codice mostra come utilizzare`delete-logger-definition`.
**AWS CLI**
**Come eliminare una definizione di logger**
L’esempio `delete-logger-definition` seguente elimina la definizione di logger specificata, incluse tutte le versioni della definizione di logger. Se si elimina una versione di definizione di logger utilizzata da una versione di gruppo, la versione di gruppo non può essere distribuita correttamente.
```
aws greengrass delete-logger-definition \
--logger-definition-id "a454b62a-5d56-4ca9-bdc4-8254e1662cb0"
```
Questo comando non produce alcun output.
Per ulteriori informazioni, consulta [Monitoring with AWS IoT Greengrass Logs](https://docs.aws.amazon.com/greengrass/latest/developerguide/greengrass-logs-overview.html) nella IoT *AWS Greengrass* Developer Guide.
+ *Per i dettagli sull'API, consulta Command [DeleteLoggerDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/delete-logger-definition.html)Reference AWS CLI .*
### `delete-resource-definition`
Il seguente esempio di codice mostra come utilizzare`delete-resource-definition`.
**AWS CLI**
**Come eliminare una definizione di risorsa**
L’esempio `delete-resource-definition` seguente elimina la definizione di risorsa specificata, incluse tutte le versioni della risorsa. Se si elimina una definizione di risorsa utilizzata da un gruppo, tale gruppo non può essere distribuito correttamente.
```
aws greengrass delete-resource-definition \
--resource-definition-id "ad8c101d-8109-4b0e-b97d-9cc5802ab658"
```
Questo comando non produce alcun output.
+ Per i dettagli sull'API, consulta [DeleteResourceDefinition AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/delete-resource-definition.html)*Command Reference*.
### `delete-subscription-definition`
Il seguente esempio di codice mostra come utilizzare`delete-subscription-definition`.
**AWS CLI**
**Come eliminare una definizione di abbonamento**
L’esempio `delete-subscription-definition` seguente elimina la definizione di abbonamento Greengrass specificata. Se si elimina un abbonamento utilizzato da un gruppo, tale gruppo non può essere distribuito correttamente.
```
aws greengrass delete-subscription-definition \
--subscription-definition-id "cd6f1c37-d9a4-4e90-be94-01a7404f5967"
```
Questo comando non produce alcun output.
+ Per i dettagli sull'API, consulta [DeleteSubscriptionDefinition AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/delete-subscription-definition.html)*Command Reference*.
### `disassociate-role-from-group`
Il seguente esempio di codice mostra come utilizzare`disassociate-role-from-group`.
**AWS CLI**
**Come dissociare il ruolo da un gruppo Greengrass**
L’esempio `disassociate-role-from-group` seguente dissocia il ruolo IAM dal gruppo Greengrass specificato.
```
aws greengrass disassociate-role-from-group \
--group-id 2494ee3f-7f8a-4e92-a78b-d205f808b84b
```
Output:
```
{
"DisassociatedAt": "2019-09-10T20:05:49Z"
}
```
Per ulteriori informazioni, consulta [Configurare il ruolo del gruppo](https://docs.aws.amazon.com/greengrass/latest/developerguide/config-iam-roles.html) nella *Guida per gli sviluppatori di AWS IoT Greengrass*.
+ Per i dettagli sull'API, consulta [DisassociateRoleFromGroup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/disassociate-role-from-group.html)*Command Reference*.
### `disassociate-service-role-from-account`
Il seguente esempio di codice mostra come utilizzare`disassociate-service-role-from-account`.
**AWS CLI**
**Per dissociare un ruolo di servizio dal proprio account AWS **
L'`disassociate-service-role-from-account`esempio seguente rimuove il ruolo di servizio associato all' AWS account. Se non si utilizza il ruolo di servizio in nessuna AWS regione, utilizzare il `delete-role-policy` comando per scollegare la politica `AWSGreengrassResourceAccessRolePolicy` gestita dal ruolo, quindi utilizzare il `delete-role` comando per eliminare il ruolo.
```
aws greengrass disassociate-service-role-from-account
```
Output:
```
{
"DisassociatedAt": "2019-06-25T22:12:55Z"
}
```
Per ulteriori informazioni, consulta [Ruolo del servizio Greengrass](https://docs.aws.amazon.com/greengrass/latest/developerguide/service-role.html) nella **Guida per gli sviluppatori di AWS IoT Greengrass**.
+ Per i dettagli sull'API, consulta [DisassociateServiceRoleFromAccount AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/disassociate-service-role-from-account.html)*Command Reference.*
### `get-associated-role`
Il seguente esempio di codice mostra come utilizzare`get-associated-role`.
**AWS CLI**
**Come associare il ruolo a un gruppo Greengrass**
L’esempio `get-associated-role` seguente ottiene il ruolo IAM associato al gruppo Greengrass specificato. Il ruolo di gruppo viene utilizzato dalle funzioni e dai connettori Lambda locali per accedere ai servizi AWS .
```
aws greengrass get-associated-role \
--group-id 2494ee3f-7f8a-4e92-a78b-d205f808b84b
```
Output:
```
{
"RoleArn": "arn:aws:iam::123456789012:role/GG-Group-Role",
"AssociatedAt": "2019-09-10T20:03:30Z"
}
```
Per ulteriori informazioni, consulta [Configurare il ruolo del gruppo](https://docs.aws.amazon.com/greengrass/latest/developerguide/config-iam-roles.html) nella *Guida per gli sviluppatori di AWS IoT Greengrass*.
+ Per i dettagli sull'API, consulta [GetAssociatedRole AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-associated-role.html)*Command Reference.*
### `get-bulk-deployment-status`
Il seguente esempio di codice mostra come utilizzare`get-bulk-deployment-status`.
**AWS CLI**
**Come controllare lo stato dell’implementazione in blocco**
L’esempio `get-bulk-deployment-status` seguente recupera le informazioni sullo stato per l’operazione di implementazione in blocco specificata. In questo esempio, il file che ha specificato i gruppi da distribuire ha un record di input non valido.
```
aws greengrass get-bulk-deployment-status \
--bulk-deployment-id "870fb41b-6288-4e0c-bc76-a7ba4b4d3267"
```
Output:
```
{
"BulkDeploymentMetrics": {
"InvalidInputRecords": 1,
"RecordsProcessed": 1,
"RetryAttempts": 0
},
"BulkDeploymentStatus": "Completed",
"CreatedAt": "2019-06-25T16:11:33.265Z",
"tags": {}
}
```
Per ulteriori informazioni, consulta [Creare implementazioni in blocco per i gruppi](https://docs.aws.amazon.com/greengrass/latest/developerguide/bulk-deploy-cli.html) nella *Guida per gli sviluppatori di AWS IoT Greengrass*.
+ Per i dettagli sull'API, consulta [GetBulkDeploymentStatus AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-bulk-deployment-status.html)*Command Reference*.
### `get-connectivity-info`
Il seguente esempio di codice mostra come utilizzare`get-connectivity-info`.
**AWS CLI**
**Come ottenere le informazioni di connettività per un core Greengrass**
L’esempio `get-connectivity-info` seguente visualizza gli endpoint che i dispositivi possono utilizzare per connettersi al core Greengrass specificato. Le informazioni sulla connettività sono un elenco di indirizzi IP o nomi di dominio, con i numeri di porta corrispondenti e i metadati opzionali definiti dal cliente.
```
aws greengrass get-connectivity-info \
--thing-name "MyGroup_Core"
```
Output:
```
{
"ConnectivityInfo": [
{
"Metadata": "",
"PortNumber": 8883,
"HostAddress": "127.0.0.1",
"Id": "AUTOIP_127.0.0.1_0"
},
{
"Metadata": "",
"PortNumber": 8883,
"HostAddress": "192.168.1.3",
"Id": "AUTOIP_192.168.1.3_1"
},
{
"Metadata": "",
"PortNumber": 8883,
"HostAddress": "::1",
"Id": "AUTOIP_::1_2"
},
{
"Metadata": "",
"PortNumber": 8883,
"HostAddress": "fe80::1e69:ed93:f5b:f6d",
"Id": "AUTOIP_fe80::1e69:ed93:f5b:f6d_3"
}
]
}
```
+ Per i dettagli sull'API, consulta [GetConnectivityInfo AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-connectivity-info.html)*Command Reference*.
### `get-connector-definition-version`
Il seguente esempio di codice mostra come utilizzare`get-connector-definition-version`.
**AWS CLI**
**Per recuperare informazioni su una versione specifica della definizione di un connettore**
L’esempio `get-connector-definition-version` seguente recupera informazioni sulla versione specificata della definizione di connettore specificata. Per recuperare tutte le versioni IDs della definizione del connettore, utilizzate il `list-connector-definition-versions` comando. Per recuperare l’ID dell’ultima versione aggiunta alla definizione di connettore, utilizza il comando `get-connector-definition` e controlla la proprietà `LatestVersion`.
```
aws greengrass get-connector-definition-version \
--connector-definition-id "b5c4ebfd-f672-49a3-83cd-31c7216a7bb8" \
--connector-definition-version-id "63c57963-c7c2-4a26-a7e2-7bf478ea2623"
```
Output:
```
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/connectors/b5c4ebfd-f672-49a3-83cd-31c7216a7bb8/versions/63c57963-c7c2-4a26-a7e2-7bf478ea2623",
"CreationTimestamp": "2019-06-19T19:30:01.300Z",
"Definition": {
"Connectors": [
{
"ConnectorArn": "arn:aws:greengrass:us-west-2::/connectors/SNS/versions/1",
"Id": "MySNSConnector",
"Parameters": {
"DefaultSNSArn": "arn:aws:sns:us-west-2:123456789012:GGConnectorTopic"
}
}
]
},
"Id": "b5c4ebfd-f672-49a3-83cd-31c7216a7bb8",
"Version": "63c57963-c7c2-4a26-a7e2-7bf478ea2623"
}
```
Per ulteriori informazioni, consulta [Integrazione con servizi e protocolli tramite i connettori Greengrass](https://docs.aws.amazon.com/greengrass/latest/developerguide/connectors.html) nella **Guida per gli sviluppatori di AWS IoT Greengrass**.
+ Per i dettagli sull'API, vedere [GetConnectorDefinitionVersion](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-connector-definition-version.html)in *AWS CLI Command Reference.*
### `get-connector-definition`
Il seguente esempio di codice mostra come utilizzare`get-connector-definition`.
**AWS CLI**
**Come recuperare le informazioni su una definizione di connettore**
L’esempio `get-connector-definition` seguente recupera le informazioni sulla definizione del connettore specificata. Per recuperare le definizioni IDs dei connettori, utilizzate il `list-connector-definitions` comando.
```
aws greengrass get-connector-definition \
--connector-definition-id "b5c4ebfd-f672-49a3-83cd-31c7216a7bb8"
```
Output:
```
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/connectors/b5c4ebfd-f672-49a3-83cd-31c7216a7bb8",
"CreationTimestamp": "2019-06-19T19:30:01.300Z",
"Id": "b5c4ebfd-f672-49a3-83cd-31c7216a7bb8",
"LastUpdatedTimestamp": "2019-06-19T19:30:01.300Z",
"LatestVersion": "63c57963-c7c2-4a26-a7e2-7bf478ea2623",
"LatestVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/connectors/b5c4ebfd-f672-49a3-83cd-31c7216a7bb8/versions/63c57963-c7c2-4a26-a7e2-7bf478ea2623",
"Name": "MySNSConnector",
"tags": {}
}
```
Per ulteriori informazioni, consulta [Integrazione con servizi e protocolli tramite i connettori Greengrass](https://docs.aws.amazon.com/greengrass/latest/developerguide/connectors.html) nella **Guida per gli sviluppatori di AWS IoT Greengrass**.
+ Per i dettagli sull'API, consulta [GetConnectorDefinition AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-connector-definition.html)*Command Reference.*
### `get-core-definition-version`
Il seguente esempio di codice mostra come utilizzare`get-core-definition-version`.
**AWS CLI**
**Come recuperare dettagli su una versione specifica della definizione di core Greengrass**
L’esempio `get-core-definition-version` seguente recupera le informazioni sulla versione specificata della definizione di core specificata. Per recuperare tutte le versioni della definizione principale, utilizzate il `list-core-definition-versions` comando. IDs Per recuperare l’ID dell’ultima versione aggiunta alla definizione core, utilizza il comando `get-core-definition` e controlla la proprietà `LatestVersion`.
```
aws greengrass get-core-definition-version \
--core-definition-id "c906ed39-a1e3-4822-a981-7b9bd57b4b46" \
--core-definition-version-id "42aeeac3-fd9d-4312-a8fd-ffa9404a20e0"
```
Output:
```
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/cores/c906ed39-a1e3-4822-a981-7b9bd57b4b46/versions/42aeeac3-fd9d-4312-a8fd-ffa9404a20e0",
"CreationTimestamp": "2019-06-18T16:21:21.351Z",
"Definition": {
"Cores": [
{
"CertificateArn": "arn:aws:iot:us-west-2:123456789012:cert/928dea7b82331b47c3ff77b0e763fc5e64e2f7c884e6ef391baed9b6b8e21b45",
"Id": "1a39aac7-0885-4417-91f6-23e4cea6c511",
"SyncShadow": false,
"ThingArn": "arn:aws:iot:us-west-2:123456789012:thing/GGGroup4Pi3_Core"
}
]
},
"Id": "c906ed39-a1e3-4822-a981-7b9bd57b4b46",
"Version": "42aeeac3-fd9d-4312-a8fd-ffa9404a20e0"
}
```
+ Per i dettagli sull'API, consulta [GetCoreDefinitionVersion AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-core-definition-version.html)*Command Reference.*
### `get-core-definition`
Il seguente esempio di codice mostra come utilizzare`get-core-definition`.
**AWS CLI**
**Come recuperare i dettagli per una definizione di core Greengrass**
L’esempio `get-core-definition` seguente recupera le informazioni sulla definizione di core specificata. Per recuperare le IDs definizioni principali, utilizzate il `list-core-definitions` comando.
```
aws greengrass get-core-definition \
--core-definition-id "c906ed39-a1e3-4822-a981-7b9bd57b4b46"
```
Output:
```
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/cores/237d6916-27cf-457f-ba0c-e86cfb5d25cd",
"CreationTimestamp": "2018-10-18T04:47:06.721Z",
"Id": "237d6916-27cf-457f-ba0c-e86cfb5d25cd",
"LastUpdatedTimestamp": "2018-10-18T04:47:06.721Z",
"LatestVersion": "bd2cd6d4-2bc5-468a-8962-39e071e34b68",
"LatestVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/cores/237d6916-27cf-457f-ba0c-e86cfb5d25cd/versions/bd2cd6d4-2bc5-468a-8962-39e071e34b68",
"tags": {}
}
```
+ Per i dettagli sull'API, consulta [GetCoreDefinition AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-core-definition.html)*Command Reference.*
### `get-deployment-status`
Il seguente esempio di codice mostra come utilizzare`get-deployment-status`.
**AWS CLI**
**Come recuperare lo stato di un’implementazione**
L’esempio `get-deployment-status` seguente recupera lo stato per l’implementazione specificata del gruppo Greengrass specificato. Per ottenere l’ID di implementazione, utilizza il comando `list-deployments` e specifica l’ID del gruppo.
```
aws greengrass get-deployment-status \
--group-id "1013db12-8b58-45ff-acc7-704248f66731" \
--deployment-id "1065b8a0-812b-4f21-9d5d-e89b232a530f"
```
Output:
```
{
"DeploymentStatus": "Success",
"DeploymentType": "NewDeployment",
"UpdatedAt": "2019-06-18T17:04:44.761Z"
}
```
+ Per i dettagli sull'API, consulta [GetDeploymentStatus AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-deployment-status.html)*Command Reference*.
### `get-device-definition-version`
Il seguente esempio di codice mostra come utilizzare`get-device-definition-version`.
**AWS CLI**
**Come ottenere una versione della definizione di dispositivo**
L’esempio `get-device-definition-version` seguente recupera le informazioni sulla versione specificata della definizione di dispositivo specificata. Per recuperare tutte le versioni IDs della definizione del dispositivo, utilizzare il `list-device-definition-versions` comando. Per recuperare l’ID dell’ultima versione aggiunta alla definizione di dispositivo, utilizza il comando `get-device-definition` e controlla la proprietà `LatestVersion`.
```
aws greengrass get-device-definition-version \
--device-definition-id "f9ba083d-5ad4-4534-9f86-026a45df1ccd" \
--device-definition-version-id "83c13984-6fed-447e-84d5-5b8aa45d5f71"
```
Output:
```
{
"Definition": {
"Devices": [
{
"CertificateArn": "arn:aws:iot:us-west-2:123456789012:cert/6c52ce1b47bde88a637e9ccdd45fe4e4c2c0a75a6866f8f63d980ee22fa51e02",
"ThingArn": "arn:aws:iot:us-west-2:123456789012:thing/ExteriorTherm",
"SyncShadow": true,
"Id": "ExteriorTherm"
},
{
"CertificateArn": "arn:aws:iot:us-west-2:123456789012:cert/66a415ec415668c2349a76170b64ac0878231c1e21ec83c10e92a18bd568eb92",
"ThingArn": "arn:aws:iot:us-west-2:123456789012:thing/InteriorTherm",
"SyncShadow": true,
"Id": "InteriorTherm"
}
]
},
"Version": "83c13984-6fed-447e-84d5-5b8aa45d5f71",
"CreationTimestamp": "2019-09-11T00:15:09.838Z",
"Id": "f9ba083d-5ad4-4534-9f86-026a45df1ccd",
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/devices/f9ba083d-5ad4-4534-9f86-026a45df1ccd/versions/83c13984-6fed-447e-84d5-5b8aa45d5f71"
}
```
+ Per i dettagli sull'API, vedere [GetDeviceDefinitionVersion](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-device-definition-version.html)in *AWS CLI Command Reference.*
### `get-device-definition`
Il seguente esempio di codice mostra come utilizzare`get-device-definition`.
**AWS CLI**
**Come ottenere una definizione di dispositivo**
L’esempio `get-device-definition` seguente recupera le informazioni sulla definizione di dispositivo specificata. Per recuperare le definizioni IDs del dispositivo, utilizzare il `list-device-definitions` comando.
```
aws greengrass get-device-definition \
--device-definition-id "f9ba083d-5ad4-4534-9f86-026a45df1ccd"
```
Output:
```
{
"LatestVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/devices/f9ba083d-5ad4-4534-9f86-026a45df1ccd/versions/83c13984-6fed-447e-84d5-5b8aa45d5f71",
"Name": "TemperatureSensors",
"tags": {},
"LastUpdatedTimestamp": "2019-09-11T00:19:03.698Z",
"LatestVersion": "83c13984-6fed-447e-84d5-5b8aa45d5f71",
"CreationTimestamp": "2019-09-11T00:11:06.197Z",
"Id": "f9ba083d-5ad4-4534-9f86-026a45df1ccd",
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/devices/f9ba083d-5ad4-4534-9f86-026a45df1ccd"
}
```
+ Per i dettagli sull'API, consulta [GetDeviceDefinition AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-device-definition.html)*Command Reference.*
### `get-function-definition-version`
Il seguente esempio di codice mostra come utilizzare`get-function-definition-version`.
**AWS CLI**
**Come recuperare dettagli su una versione specifica di una funzione Lambda**
L’esempio `get-function-definition-version` seguente recupera le informazioni sulla versione specificata della definizione di funzione specificata. Per recuperare tutte le versioni IDs della definizione della funzione, utilizzate il `list-function-definition-versions` comando. Per recuperare l’ID dell’ultima versione aggiunta alla definizione di funzione, utilizza il comando `get-function-definition` e controlla la proprietà `LatestVersion`.
```
aws greengrass get-function-definition-version \
--function-definition-id "063f5d1a-1dd1-40b4-9b51-56f8993d0f85" \
--function-definition-version-id "9748fda7-1589-4fcc-ac94-f5559e88678b"
```
Output:
```
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/063f5d1a-1dd1-40b4-9b51-56f8993d0f85/versions/9748fda7-1589-4fcc-ac94-f5559e88678b",
"CreationTimestamp": "2019-06-18T17:04:30.776Z",
"Definition": {
"Functions": [
{
"FunctionArn": "arn:aws:lambda:::function:GGIPDetector:1",
"FunctionConfiguration": {
"Environment": {},
"MemorySize": 32768,
"Pinned": true,
"Timeout": 3
},
"Id": "26b69bdb-e547-46bc-9812-84ec04b6cc8c"
},
{
"FunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:Greengrass_HelloWorld:GG_HelloWorld",
"FunctionConfiguration": {
"EncodingType": "json",
"Environment": {
"Variables": {}
},
"MemorySize": 16384,
"Pinned": true,
"Timeout": 25
},
"Id": "384465a8-eedf-48c6-b793-4c35f7bfae9b"
}
]
},
"Id": "063f5d1a-1dd1-40b4-9b51-56f8993d0f85",
"Version": "9748fda7-1589-4fcc-ac94-f5559e88678b"
}
```
+ Per i dettagli sull'API, vedere [GetFunctionDefinitionVersion](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-function-definition-version.html)in *AWS CLI Command Reference.*
### `get-function-definition`
Il seguente esempio di codice mostra come utilizzare`get-function-definition`.
**AWS CLI**
**Come recuperare la definizione di funzione**
L’esempio `get-function-definition` seguente visualizza i dettagli della definizione di istanza specificata. Per recuperare le definizioni IDs delle funzioni, utilizzate il `list-function-definitions` comando.
```
aws greengrass get-function-definition \
--function-definition-id "063f5d1a-1dd1-40b4-9b51-56f8993d0f85"
```
Output:
```
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/063f5d1a-1dd1-40b4-9b51-56f8993d0f85",
"CreationTimestamp": "2019-06-18T16:21:21.431Z",
"Id": "063f5d1a-1dd1-40b4-9b51-56f8993d0f85",
"LastUpdatedTimestamp": "2019-06-18T16:21:21.431Z",
"LatestVersion": "9748fda7-1589-4fcc-ac94-f5559e88678b",
"LatestVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/063f5d1a-1dd1-40b4-9b51-56f8993d0f85/versions/9748fda7-1589-4fcc-ac94-f5559e88678b",
"tags": {}
}
```
+ Per i dettagli sull'API, consulta [GetFunctionDefinition AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-function-definition.html)*Command Reference.*
### `get-group-certificate-authority`
Il seguente esempio di codice mostra come utilizzare`get-group-certificate-authority`.
**AWS CLI**
**Come recuperare la CA associata a un gruppo Greengrass**
L’esempio `get-group-certificate-authority` seguente recupera l’autorità di certificazione (CA) associata al gruppo Greengrass specificato. Per ottenere l’ID dell’autorità di certificazione, utilizza il comando `list-group-certificate-authorities` e specifica l’ID del gruppo.
```
aws greengrass get-group-certificate-authority \
--group-id "1013db12-8b58-45ff-acc7-704248f66731" \
--certificate-authority-id "f0430e1736ea8ed30cc5d5de9af67a7e3586bad9ae4d89c2a44163f65fdd8cf6"
```
Output:
```
{
"GroupCertificateAuthorityArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/groups/1013db12-8b58-45ff-acc7-704248f66731/certificateauthorities/f0430e1736ea8ed30cc5d5de9af67a7e3586bad9ae4d89c2a44163f65fdd8cf6",
"GroupCertificateAuthorityId": "f0430e1736ea8ed30cc5d5de9af67a7e3586bad9ae4d89c2a44163f65fdd8cf6",
"PemEncodedCertificate": "-----BEGIN CERTIFICATE-----
MIICiTCCAfICCQD6m7oRw0uXOjANBgkqhkiG9w0BAQUFADCBWEXAMPLEGA1UEBhMC
VVMxCzAJBgNVBAgTAldBMRAwDEXAMPLEEwdTZWF0dGxlMQ8wDQYDVQQKEwZBbWF6
b24xFDASBgNVBAEXAMPLESBDb25zb2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMxHzAd
BgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5jEXAMPLENMTEwNDI1MjA0NTIxWhcN
MTIwNDI0MjA0EXAMPLEBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAldBMRAwDgYD
VQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBbWEXAMPLEDASBgNVBAsTC0lBTSBDb25z
b2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWEXAMPLEgkqhkiG9w0BCQEWEG5vb25lQGFt
YXpvbi5EXAMPLE8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAMaK0dn+a4GmWIWJ
21uUSfwfEvySWtC2XADZ4nB+BLYgVIk60CEXAMPLE93vUEIO3IyNoH/f0wYK8m9T
rDHudUZg3qX4waLG5M43q7Wgc/MbQITxOUSQv7c7ugFFDzQGBzZswYEXAMPLEgpE
Ibb3OhjZnzcvQAaRHhdlQWIMm2nrAgMBAAEwDQYJKEXAMPLEAQEFBQADgYEAtCu4
nUhVVxYUntneD9+h8Mg9q6q+auNKyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0Fkb
FFBjvSfpJIlJ00zbhNYS5f6GuoEDmFJl0ZxBHjJnyp378OD8uTs7fLvjx79LjSTb
NYiytVbZPQUQ5Yaxu2jXnimvw3rrszlaEXAMPLE=
-----END CERTIFICATE-----\n"
}
```
+ Per i dettagli sull'API, consulta [GetGroupCertificateAuthority AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-group-certificate-authority.html)*Command Reference*.
### `get-group-certificate-configuration`
Il seguente esempio di codice mostra come utilizzare`get-group-certificate-configuration`.
**AWS CLI**
**Come recuperare la configurazione per l’autorità di certificazione utilizzata dal gruppo Greengrass**
L’esempio `get-group-certificate-configuration` seguente recupera l’autorità di certificazione (CA) utilizzata dal gruppo Greengrass specificato.
```
aws greengrass get-group-certificate-configuration \
--group-id "1013db12-8b58-45ff-acc7-704248f66731"
```
Output:
```
{
"CertificateAuthorityExpiryInMilliseconds": 2524607999000,
"CertificateExpiryInMilliseconds": 604800000,
"GroupId": "1013db12-8b58-45ff-acc7-704248f66731"
}
```
+ Per i dettagli sull'API, consulta [GetGroupCertificateConfiguration AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-group-certificate-configuration.html)*Command Reference*.
### `get-group-version`
Il seguente esempio di codice mostra come utilizzare`get-group-version`.
**AWS CLI**
**Come recuperare le informazioni su una versione di un gruppo Greengrass**
L’esempio `get-group-version` seguente recupera le informazioni sulla versione specificata del gruppo specificato. Per recuperare tutte le versioni del gruppo, utilizzate il `list-group-versions` comando. IDs Per recuperare l’ID dell’ultima versione aggiunta al gruppo, utilizza il comando `get-group` e controlla la proprietà `LatestVersion`.
```
aws greengrass get-group-version \
--group-id "1013db12-8b58-45ff-acc7-704248f66731" \
--group-version-id "115136b3-cfd7-4462-b77f-8741a4b00e5e"
```
Output:
```
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/groups/1013db12-8b58-45ff-acc7-704248f66731/versions/115136b3-cfd7-4462-b77f-8741a4b00e5e",
"CreationTimestamp": "2019-06-18T17:04:30.915Z",
"Definition": {
"CoreDefinitionVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/cores/c906ed39-a1e3-4822-a981-7b9bd57b4b46/versions/42aeeac3-fd9d-4312-a8fd-ffa9404a20e0",
"FunctionDefinitionVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/063f5d1a-1dd1-40b4-9b51-56f8993d0f85/versions/9748fda7-1589-4fcc-ac94-f5559e88678b",
"SubscriptionDefinitionVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/subscriptions/70e49321-83d5-45d2-bc09-81f4917ae152/versions/88ae8699-12ac-4663-ba3f-4d7f0519140b"
},
"Id": "1013db12-8b58-45ff-acc7-704248f66731",
"Version": "115136b3-cfd7-4462-b77f-8741a4b00e5e"
}
```
+ Per i dettagli sull'API, consulta [GetGroupVersion AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-group-version.html)*Command Reference.*
### `get-group`
Il seguente esempio di codice mostra come utilizzare`get-group`.
**AWS CLI**
**Come recuperare informazioni su un gruppo Greengrass**
L’esempio `get-group` seguente recupera le informazioni sul gruppo Greengrass specificato. Per recuperare i IDs tuoi gruppi, usa il `list-groups` comando.
```
aws greengrass get-group \
--group-id "1013db12-8b58-45ff-acc7-704248f66731"
```
Output:
```
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/groups/1013db12-8b58-45ff-acc7-704248f66731",
"CreationTimestamp": "2019-06-18T16:21:21.457Z",
"Id": "1013db12-8b58-45ff-acc7-704248f66731",
"LastUpdatedTimestamp": "2019-06-18T16:21:21.457Z",
"LatestVersion": "115136b3-cfd7-4462-b77f-8741a4b00e5e",
"LatestVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/groups/1013db12-8b58-45ff-acc7-704248f66731/versions/115136b3-cfd7-4462-b77f-8741a4b00e5e",
"Name": "GGGroup4Pi3",
"tags": {}
}
```
+ Per i dettagli sull'API, consulta [GetGroup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-group.html)*Command Reference.*
### `get-logger-definition-version`
Il seguente esempio di codice mostra come utilizzare`get-logger-definition-version`.
**AWS CLI**
**Come recuperare le informazioni su una versione di una definizione di logger**
L’esempio `get-logger-definition-version` seguente recupera le informazioni sulla versione specificata della definizione di logger specificata. Per recuperare tutte le versioni IDs della definizione del logger, usa il `list-logger-definition-versions` comando. Per recuperare l’ID dell’ultima versione aggiunta alla definizione di logger, utilizza il comando `get-logger-definition` e controlla la proprietà `LatestVersion`.
```
aws greengrass get-logger-definition-version \
--logger-definition-id "49eeeb66-f1d3-4e34-86e3-3617262abf23" \
--logger-definition-version-id "5e3f6f64-a565-491e-8de0-3c0d8e0f2073"
```
Output:
```
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/loggers/49eeeb66-f1d3-4e34-86e3-3617262abf23/versions/5e3f6f64-a565-491e-8de0-3c0d8e0f2073",
"CreationTimestamp": "2019-05-08T16:10:13.866Z",
"Definition": {
"Loggers": []
},
"Id": "49eeeb66-f1d3-4e34-86e3-3617262abf23",
"Version": "5e3f6f64-a565-491e-8de0-3c0d8e0f2073"
}
```
+ Per i dettagli sull'API, vedere [GetLoggerDefinitionVersion](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-logger-definition-version.html)in *AWS CLI Command Reference*.
### `get-logger-definition`
Il seguente esempio di codice mostra come utilizzare`get-logger-definition`.
**AWS CLI**
**Come recuperare le informazioni su una definizione di logger**
L’esempio `get-logger-definition` seguente recupera le informazioni sulla definizione di logger specificata. Per recuperare le definizioni IDs del tuo logger, usa il `list-logger-definitions` comando.
```
aws greengrass get-logger-definition \
--logger-definition-id "49eeeb66-f1d3-4e34-86e3-3617262abf23"
```
Output:
```
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/loggers/49eeeb66-f1d3-4e34-86e3-3617262abf23",
"CreationTimestamp": "2019-05-08T16:10:13.809Z",
"Id": "49eeeb66-f1d3-4e34-86e3-3617262abf23",
"LastUpdatedTimestamp": "2019-05-08T16:10:13.809Z",
"LatestVersion": "5e3f6f64-a565-491e-8de0-3c0d8e0f2073",
"LatestVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/loggers/49eeeb66-f1d3-4e34-86e3-3617262abf23/versions/5e3f6f64-a565-491e-8de0-3c0d8e0f2073",
"tags": {}
}
```
+ Per i dettagli sull'API, vedere [GetLoggerDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-logger-definition.html)in *AWS CLI Command Reference*.
### `get-resource-definition-version`
Il seguente esempio di codice mostra come utilizzare`get-resource-definition-version`.
**AWS CLI**
**Come recuperare le informazioni su una versione specifica di una definizione di risorsa**
L’esempio `get-resource-definition-version` seguente recupera le informazioni sulla versione specificata della definizione di risorsa specificata. Per recuperare tutte le versioni IDs della definizione della risorsa, utilizzate il `list-resource-definition-versions` comando. Per recuperare l’ID dell’ultima versione aggiunta alla definizione di risorsa, utilizza il comando `get-resource-definition` e controlla la proprietà `LatestVersion`.
```
aws greengrass get-resource-definition-version \
--resource-definition-id "ad8c101d-8109-4b0e-b97d-9cc5802ab658" \
--resource-definition-version-id "26e8829a-491a-464d-9c87-664bf6f6f2be"
```
Output:
```
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/resources/ad8c101d-8109-4b0e-b97d-9cc5802ab658/versions/26e8829a-491a-464d-9c87-664bf6f6f2be",
"CreationTimestamp": "2019-06-19T16:40:59.392Z",
"Definition": {
"Resources": [
{
"Id": "26ff3f7b-839a-4217-9fdc-a218308b3963",
"Name": "usb-port",
"ResourceDataContainer": {
"LocalDeviceResourceData": {
"GroupOwnerSetting": {
"AutoAddGroupOwner": false
},
"SourcePath": "/dev/bus/usb"
}
}
}
]
},
"Id": "ad8c101d-8109-4b0e-b97d-9cc5802ab658",
"Version": "26e8829a-491a-464d-9c87-664bf6f6f2be"
}
```
+ Per i dettagli sull'API, consulta [GetResourceDefinitionVersion AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-resource-definition-version.html)*Command Reference.*
### `get-resource-definition`
Il seguente esempio di codice mostra come utilizzare`get-resource-definition`.
**AWS CLI**
**Come recuperare le informazioni sulla definizione di risorsa**
L’esempio `get-resource-definition` seguente recupera informazioni sulla definizione di risorsa specificata. Per recuperare le definizioni IDs delle risorse, usa il `list-resource-definitions` comando.
```
aws greengrass get-resource-definition \
--resource-definition-id "ad8c101d-8109-4b0e-b97d-9cc5802ab658"
```
Output:
```
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/resources/ad8c101d-8109-4b0e-b97d-9cc5802ab658",
"CreationTimestamp": "2019-06-19T16:40:59.261Z",
"Id": "ad8c101d-8109-4b0e-b97d-9cc5802ab658",
"LastUpdatedTimestamp": "2019-06-19T16:40:59.261Z",
"LatestVersion": "26e8829a-491a-464d-9c87-664bf6f6f2be",
"LatestVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/resources/ad8c101d-8109-4b0e-b97d-9cc5802ab658/versions/26e8829a-491a-464d-9c87-664bf6f6f2be",
"tags": {}
}
```
+ Per i dettagli sull'API, consulta [GetResourceDefinition AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-resource-definition.html)*Command Reference.*
### `get-service-role-for-account`
Il seguente esempio di codice mostra come utilizzare`get-service-role-for-account`.
**AWS CLI**
**Come recuperare i dettagli relativi al ruolo di servizio collegato all’account**
L'`get-service-role-for-account`esempio seguente recupera le informazioni sul ruolo di servizio associato all' AWS account.
```
aws greengrass get-service-role-for-account
```
Output:
```
{
"AssociatedAt": "2018-10-18T15:59:20Z",
"RoleArn": "arn:aws:iam::123456789012:role/service-role/Greengrass_ServiceRole"
}
```
Per ulteriori informazioni, consulta [Ruolo del servizio Greengrass](https://docs.aws.amazon.com/greengrass/latest/developerguide/service-role.html) nella **Guida per gli sviluppatori di AWS IoT Greengrass**.
+ Per i dettagli sull'API, consulta [GetServiceRoleForAccount AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-service-role-for-account.html)*Command Reference.*
### `get-subscription-definition-version`
Il seguente esempio di codice mostra come utilizzare`get-subscription-definition-version`.
**AWS CLI**
**Come recuperare le informazioni su una versione specifica di una definizione di abbonamento**
L’esempio `get-subscription-definition-version` seguente recupera le informazioni sulla versione specificata della definizione di abbonamento specificata. Per recuperare tutte le versioni IDs della definizione dell'abbonamento, utilizzare il `list-subscription-definition-versions` comando. Per recuperare l’ID dell’ultima versione aggiunta alla definizione di abbonamento, utilizza il comando `get-subscription-definition` e controlla la proprietà `LatestVersion`.
```
aws greengrass get-subscription-definition-version \
--subscription-definition-id "70e49321-83d5-45d2-bc09-81f4917ae152" \
--subscription-definition-version-id "88ae8699-12ac-4663-ba3f-4d7f0519140b"
```
Output:
```
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/subscriptions/70e49321-83d5-45d2-bc09-81f4917ae152/versions/88ae8699-12ac-4663-ba3f-4d7f0519140b",
"CreationTimestamp": "2019-06-18T17:03:52.499Z",
"Definition": {
"Subscriptions": [
{
"Id": "692c4484-d89f-4f64-8edd-1a041a65e5b6",
"Source": "arn:aws:lambda:us-west-2:123456789012:function:Greengrass_HelloWorld:GG_HelloWorld",
"Subject": "hello/world",
"Target": "cloud"
}
]
},
"Id": "70e49321-83d5-45d2-bc09-81f4917ae152",
"Version": "88ae8699-12ac-4663-ba3f-4d7f0519140b"
}
```
+ Per i dettagli sull'API, consulta [GetSubscriptionDefinitionVersion AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-subscription-definition-version.html)*Command Reference.*
### `get-subscription-definition`
Il seguente esempio di codice mostra come utilizzare`get-subscription-definition`.
**AWS CLI**
**Come recuperare le informazioni su una definizione di abbonamento**
L’esempio `get-subscription-definition` seguente recupera le informazioni sulla definizione di abbonamento specificata. Per recuperare le definizioni IDs delle sottoscrizioni, utilizzare il `list-subscription-definitions` comando.
```
aws greengrass get-subscription-definition \
--subscription-definition-id "70e49321-83d5-45d2-bc09-81f4917ae152"
```
Output:
```
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/subscriptions/70e49321-83d5-45d2-bc09-81f4917ae152",
"CreationTimestamp": "2019-06-18T17:03:52.392Z",
"Id": "70e49321-83d5-45d2-bc09-81f4917ae152",
"LastUpdatedTimestamp": "2019-06-18T17:03:52.392Z",
"LatestVersion": "88ae8699-12ac-4663-ba3f-4d7f0519140b",
"LatestVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/subscriptions/70e49321-83d5-45d2-bc09-81f4917ae152/versions/88ae8699-12ac-4663-ba3f-4d7f0519140b",
"tags": {}
}
```
+ Per i dettagli sull'API, consulta [GetSubscriptionDefinition AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-subscription-definition.html)*Command Reference.*
### `get-thing-runtime-configuration`
Il seguente esempio di codice mostra come utilizzare`get-thing-runtime-configuration`.
**AWS CLI**
**Come recuperare la configurazione di runtime di un core Greengrass**
L’esempio `get-thing-runtime-configuration` seguente recupera la configurazione di runtime di un core Greengrass. Prima di poter recuperare la configurazione di runtime, è necessario utilizzare il comando `update-thing-runtime-configuration` per creare una configurazione di runtime per il core.
```
aws greengrass get-thing-runtime-configuration \
--thing-name SampleGreengrassCore
```
Output:
```
{
"RuntimeConfiguration": {
"TelemetryConfiguration": {
"ConfigurationSyncStatus": "OutOfSync",
"Telemetry": "On"
}
}
}
```
Per ulteriori informazioni, consulta [Configurazione delle impostazioni di telemetria](https://docs.aws.amazon.com/greengrass/latest/developerguide/telemetry.html#configure-telemetry-settings) nella *Guida per gli sviluppatori di AWS IoT Greengrass*.
+ Per i dettagli sull'API, consulta [GetThingRuntimeConfiguration AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-thing-runtime-configuration.html)*Command Reference*.
### `list-bulk-deployment-detailed-reports`
Il seguente esempio di codice mostra come utilizzare`list-bulk-deployment-detailed-reports`.
**AWS CLI**
**Come elencare le informazioni sulle singole implementazioni in un’implementazione in blocco**
L’esempio `list-bulk-deployment-detailed-reports` seguente visualizza le informazioni sulle singole implementazioni in un’operazione di implementazione in blocco, incluso lo stato.
```
aws greengrass list-bulk-deployment-detailed-reports \
--bulk-deployment-id 42ce9c42-489b-4ed4-b905-8996aa50ef9d
```
Output:
```
{
"Deployments": [
{
"DeploymentType": "NewDeployment",
"DeploymentStatus": "Success",
"DeploymentId": "123456789012:a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
"DeploymentArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/groups/a1b2c3d4-5678-90ab-cdef-EXAMPLE33333/deployments/123456789012:123456789012:a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
"GroupArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/groups/a1b2c3d4-5678-90ab-cdef-EXAMPLE33333/versions/123456789012:a1b2c3d4-5678-90ab-cdef-EXAMPLE44444",
"CreatedAt": "2020-01-21T21:34:16.501Z"
},
{
"DeploymentType": "NewDeployment",
"DeploymentStatus": "InProgress",
"DeploymentId": "123456789012:a1b2c3d4-5678-90ab-cdef-EXAMPLE22222",
"DeploymentArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/groups/a1b2c3d4-5678-90ab-cdef-EXAMPLE55555/deployments/123456789012:123456789012:a1b2c3d4-5678-90ab-cdef-EXAMPLE22222",
"GroupArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/groups/a1b2c3d4-5678-90ab-cdef-EXAMPLE55555/versions/a1b2c3d4-5678-90ab-cdef-EXAMPLE66666",
"CreatedAt": "2020-01-21T21:34:16.486Z"
},
...
]
}
```
Per ulteriori informazioni, consulta [Creare implementazioni in blocco per i gruppi](https://docs.aws.amazon.com/greengrass/latest/developerguide/bulk-deploy-cli.html) nella *Guida per gli sviluppatori di AWS IoT Greengrass*.
+ Per i dettagli sull'API, consulta [ListBulkDeploymentDetailedReports AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-bulk-deployment-detailed-reports.html)*Command Reference*.
### `list-bulk-deployments`
Il seguente esempio di codice mostra come utilizzare`list-bulk-deployments`.
**AWS CLI**
**Come elencare le implementazioni in blocco**
L’esempio `list-bulk-deployments` seguente elenca tutte le implementazioni in blocco.
```
aws greengrass list-bulk-deployments
```
Output:
```
{
"BulkDeployments": [
{
"BulkDeploymentArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/bulk/deployments/870fb41b-6288-4e0c-bc76-a7ba4b4d3267",
"BulkDeploymentId": "870fb41b-6288-4e0c-bc76-a7ba4b4d3267",
"CreatedAt": "2019-06-25T16:11:33.265Z"
}
]
}
```
Per ulteriori informazioni, consulta [Creare implementazioni in blocco per i gruppi](https://docs.aws.amazon.com/greengrass/latest/developerguide/bulk-deploy-cli.html) nella *Guida per gli sviluppatori di AWS IoT Greengrass*.
+ Per i dettagli sull'API, consulta [ListBulkDeployments AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-bulk-deployments.html)*Command Reference*.
### `list-connector-definition-versions`
Il seguente esempio di codice mostra come utilizzare`list-connector-definition-versions`.
**AWS CLI**
**Come elencare le versioni disponibili per una definizione di connettore**
L’esempio `list-connector-definition-versions` seguente elenca le versioni disponibili per la definizione di connettore specificata. Utilizza il comando `list-connector-definitions` per ottenere l’ID della definizione di connettore.
```
aws greengrass list-connector-definition-versions \
--connector-definition-id "b5c4ebfd-f672-49a3-83cd-31c7216a7bb8"
```
Output:
```
{
"Versions": [
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/connectors/b5c4ebfd-f672-49a3-83cd-31c7216a7bb8/versions/63c57963-c7c2-4a26-a7e2-7bf478ea2623",
"CreationTimestamp": "2019-06-19T19:30:01.300Z",
"Id": "b5c4ebfd-f672-49a3-83cd-31c7216a7bb8",
"Version": "63c57963-c7c2-4a26-a7e2-7bf478ea2623"
}
]
}
```
Per ulteriori informazioni, consulta [Integrazione con servizi e protocolli tramite i connettori Greengrass](https://docs.aws.amazon.com/greengrass/latest/developerguide/connectors.html) nella **Guida per gli sviluppatori di AWS IoT Greengrass**.
+ Per i dettagli sull'API, consulta [ListConnectorDefinitionVersions AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-connector-definition-versions.html)*Command Reference*.
### `list-connector-definitions`
Il seguente esempio di codice mostra come utilizzare`list-connector-definitions`.
**AWS CLI**
**Come elencare i connettori Greengrass definiti**
L'`list-connector-definitions`esempio seguente elenca tutti i connettori Greengrass definiti per il tuo AWS account.
```
aws greengrass list-connector-definitions
```
Output:
```
{
"Definitions": [
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/connectors/b5c4ebfd-f672-49a3-83cd-31c7216a7bb8",
"CreationTimestamp": "2019-06-19T19:30:01.300Z",
"Id": "b5c4ebfd-f672-49a3-83cd-31c7216a7bb8",
"LastUpdatedTimestamp": "2019-06-19T19:30:01.300Z",
"LatestVersion": "63c57963-c7c2-4a26-a7e2-7bf478ea2623",
"LatestVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/connectors/b5c4ebfd-f672-49a3-83cd-31c7216a7bb8/versions/63c57963-c7c2-4a26-a7e2-7bf478ea2623",
"Name": "MySNSConnector"
}
]
}
```
Per ulteriori informazioni, consulta [Integrazione con servizi e protocolli tramite i connettori Greengrass](https://docs.aws.amazon.com/greengrass/latest/developerguide/connectors.html) nella **Guida per gli sviluppatori di AWS IoT Greengrass**.
+ Per i dettagli sull'API, consulta [ListConnectorDefinitions AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-connector-definitions.html)*Command Reference.*
### `list-core-definition-versions`
Il seguente esempio di codice mostra come utilizzare`list-core-definition-versions`.
**AWS CLI**
**Come elencare le versioni di una definizione di core Greengrass**
L'`list-core-definitions`esempio seguente elenca tutte le versioni della definizione di base Greengrass specificata. Puoi utilizzare il comando `list-core-definitions` per ottenere l’ID della versione.
```
aws greengrass list-core-definition-versions \
--core-definition-id "eaf280cb-138c-4d15-af36-6f681a1348f7"
```
Output:
```
{
"Versions": [
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/cores/eaf280cb-138c-4d15-af36-6f681a1348f7/versions/467c36e4-c5da-440c-a97b-084e62593b4c",
"CreationTimestamp": "2019-06-18T16:14:17.709Z",
"Id": "eaf280cb-138c-4d15-af36-6f681a1348f7",
"Version": "467c36e4-c5da-440c-a97b-084e62593b4c"
}
]
}
```
+ Per i dettagli sull'API, vedere [ListCoreDefinitionVersions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-core-definition-versions.html)in *AWS CLI Command Reference.*
### `list-core-definitions`
Il seguente esempio di codice mostra come utilizzare`list-core-definitions`.
**AWS CLI**
**Come elencare le definizioni di core Greengrass**
L'`list-core-definitions`esempio seguente elenca tutte le definizioni principali di Greengrass per il tuo AWS account.
```
aws greengrass list-core-definitions
```
Output:
```
{
"Definitions": [
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/cores/0507843c-c1ef-4f06-b051-817030df7e7d",
"CreationTimestamp": "2018-10-17T04:30:32.786Z",
"Id": "0507843c-c1ef-4f06-b051-817030df7e7d",
"LastUpdatedTimestamp": "2018-10-17T04:30:32.786Z",
"LatestVersion": "bcdf9e86-3793-491e-93af-3cdfbf4e22b7",
"LatestVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/cores/0507843c-c1ef-4f06-b051-817030df7e7d/versions/bcdf9e86-3793-491e-93af-3cdfbf4e22b7"
},
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/cores/31c22500-3509-4271-bafd-cf0655cda438",
"CreationTimestamp": "2019-06-18T16:24:16.064Z",
"Id": "31c22500-3509-4271-bafd-cf0655cda438",
"LastUpdatedTimestamp": "2019-06-18T16:24:16.064Z",
"LatestVersion": "2f350395-6d09-4c8a-8336-9ae5b57ace84",
"LatestVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/cores/31c22500-3509-4271-bafd-cf0655cda438/versions/2f350395-6d09-4c8a-8336-9ae5b57ace84"
},
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/cores/c906ed39-a1e3-4822-a981-7b9bd57b4b46",
"CreationTimestamp": "2019-06-18T16:21:21.351Z",
"Id": "c906ed39-a1e3-4822-a981-7b9bd57b4b46",
"LastUpdatedTimestamp": "2019-06-18T16:21:21.351Z",
"LatestVersion": "42aeeac3-fd9d-4312-a8fd-ffa9404a20e0",
"LatestVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/cores/c906ed39-a1e3-4822-a981-7b9bd57b4b46/versions/42aeeac3-fd9d-4312-a8fd-ffa9404a20e0"
},
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/cores/eaf280cb-138c-4d15-af36-6f681a1348f7",
"CreationTimestamp": "2019-06-18T16:14:17.709Z",
"Id": "eaf280cb-138c-4d15-af36-6f681a1348f7",
"LastUpdatedTimestamp": "2019-06-18T16:14:17.709Z",
"LatestVersion": "467c36e4-c5da-440c-a97b-084e62593b4c",
"LatestVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/cores/eaf280cb-138c-4d15-af36-6f681a1348f7/versions/467c36e4-c5da-440c-a97b-084e62593b4c"
}
]
}
```
+ Per i dettagli sull'API, consulta [ListCoreDefinitions AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-core-definitions.html)*Command Reference.*
### `list-deployments`
Il seguente esempio di codice mostra come utilizzare`list-deployments`.
**AWS CLI**
**Come elencare le implementazioni per un gruppo Greengrass**
L’esempio `list-deployments` seguente elenca le implementazioni per il gruppo Greengrass specificato. Puoi utilizzare il comando `list-groups` sul dispositivo per cercare l’ID di gruppo.
```
aws greengrass list-deployments \
--group-id "1013db12-8b58-45ff-acc7-704248f66731"
```
Output:
```
{
"Deployments": [
{
"CreatedAt": "2019-06-18T17:04:32.702Z",
"DeploymentId": "1065b8a0-812b-4f21-9d5d-e89b232a530f",
"DeploymentType": "NewDeployment",
"GroupArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/groups/1013db12-8b58-45ff-acc7-704248f66731/versions/115136b3-cfd7-4462-b77f-8741a4b00e5e"
}
]
}
```
+ Per i dettagli sull'API, consulta [ListDeployments AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-deployments.html)*Command Reference*.
### `list-device-definition-versions`
Il seguente esempio di codice mostra come utilizzare`list-device-definition-versions`.
**AWS CLI**
**Come elencare le versioni di una definizione di dispositivo**
L’esempio `list-device-definition-versions` seguente visualizza le versioni della definizione di dispositivo associate alla definizione di dispositivo specificata.
```
aws greengrass list-device-definition-versions \
--device-definition-id "f9ba083d-5ad4-4534-9f86-026a45df1ccd"
```
Output:
```
{
"Versions": [
{
"Version": "83c13984-6fed-447e-84d5-5b8aa45d5f71",
"CreationTimestamp": "2019-09-11T00:15:09.838Z",
"Id": "f9ba083d-5ad4-4534-9f86-026a45df1ccd",
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/devices/f9ba083d-5ad4-4534-9f86-026a45df1ccd/versions/83c13984-6fed-447e-84d5-5b8aa45d5f71"
},
{
"Version": "3b5cc510-58c1-44b5-9d98-4ad858ffa795",
"CreationTimestamp": "2019-09-11T00:11:06.197Z",
"Id": "f9ba083d-5ad4-4534-9f86-026a45df1ccd",
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/devices/f9ba083d-5ad4-4534-9f86-026a45df1ccd/versions/3b5cc510-58c1-44b5-9d98-4ad858ffa795"
}
]
}
```
+ Per i dettagli sull'API, consulta [ListDeviceDefinitionVersions AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-device-definition-versions.html)*Command Reference*.
### `list-device-definitions`
Il seguente esempio di codice mostra come utilizzare`list-device-definitions`.
**AWS CLI**
**Come elencare le definizioni di dispositivo**
L'`list-device-definitions`esempio seguente mostra i dettagli sulle definizioni dei dispositivi nell' AWS account nella AWS regione specificata.
```
aws greengrass list-device-definitions \
--region us-west-2
```
Output:
```
{
"Definitions": [
{
"LatestVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/devices/50f3274c-3f0a-4f57-b114-6f46085281ab/versions/c777b0f5-1059-449b-beaa-f003ebc56c34",
"LastUpdatedTimestamp": "2019-06-14T15:42:09.059Z",
"LatestVersion": "c777b0f5-1059-449b-beaa-f003ebc56c34",
"CreationTimestamp": "2019-06-14T15:42:09.059Z",
"Id": "50f3274c-3f0a-4f57-b114-6f46085281ab",
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/devices/50f3274c-3f0a-4f57-b114-6f46085281ab"
},
{
"LatestVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/devices/e01951c9-6134-479a-969a-1a15cac11c40/versions/514d57aa-4ee6-401c-9fac-938a9f7a51e5",
"Name": "TestDeviceDefinition",
"LastUpdatedTimestamp": "2019-04-16T23:17:43.245Z",
"LatestVersion": "514d57aa-4ee6-401c-9fac-938a9f7a51e5",
"CreationTimestamp": "2019-04-16T23:17:43.245Z",
"Id": "e01951c9-6134-479a-969a-1a15cac11c40",
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/devices/e01951c9-6134-479a-969a-1a15cac11c40"
},
{
"LatestVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/devices/f9ba083d-5ad4-4534-9f86-026a45df1ccd/versions/83c13984-6fed-447e-84d5-5b8aa45d5f71",
"Name": "TemperatureSensors",
"LastUpdatedTimestamp": "2019-09-10T00:19:03.698Z",
"LatestVersion": "83c13984-6fed-447e-84d5-5b8aa45d5f71",
"CreationTimestamp": "2019-09-11T00:11:06.197Z",
"Id": "f9ba083d-5ad4-4534-9f86-026a45df1ccd",
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/devices/f9ba083d-5ad4-4534-9f86-026a45df1ccd"
}
]
}
```
+ Per i dettagli sull'API, consulta [ListDeviceDefinitions AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-device-definitions.html)*Command Reference*.
### `list-function-definition-versions`
Il seguente esempio di codice mostra come utilizzare`list-function-definition-versions`.
**AWS CLI**
**Come elencare le versioni di una funzione Lambda**
L’esempio `list-function-definition-versions` seguente visualizza l’elenco di versioni per la funzione Lambda specificata. Per ottenere l’ID, puoi utilizzare il comando `list-function-definitions`.
```
aws greengrass list-function-definition-versions \
--function-definition-id "063f5d1a-1dd1-40b4-9b51-56f8993d0f85"
```
Output:
```
{
"Versions": [
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/063f5d1a-1dd1-40b4-9b51-56f8993d0f85/versions/9748fda7-1589-4fcc-ac94-f5559e88678b",
"CreationTimestamp": "2019-06-18T17:04:30.776Z",
"Id": "063f5d1a-1dd1-40b4-9b51-56f8993d0f85",
"Version": "9748fda7-1589-4fcc-ac94-f5559e88678b"
},
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/063f5d1a-1dd1-40b4-9b51-56f8993d0f85/versions/9b08df77-26f2-4c29-93d2-769715edcfec",
"CreationTimestamp": "2019-06-18T17:02:44.087Z",
"Id": "063f5d1a-1dd1-40b4-9b51-56f8993d0f85",
"Version": "9b08df77-26f2-4c29-93d2-769715edcfec"
},
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/063f5d1a-1dd1-40b4-9b51-56f8993d0f85/versions/4236239f-94f7-4b90-a2f8-2a24c829d21e",
"CreationTimestamp": "2019-06-18T17:01:42.284Z",
"Id": "063f5d1a-1dd1-40b4-9b51-56f8993d0f85",
"Version": "4236239f-94f7-4b90-a2f8-2a24c829d21e"
},
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/063f5d1a-1dd1-40b4-9b51-56f8993d0f85/versions/343408bb-549a-4fbe-b043-853643179a39",
"CreationTimestamp": "2019-06-18T16:21:21.431Z",
"Id": "063f5d1a-1dd1-40b4-9b51-56f8993d0f85",
"Version": "343408bb-549a-4fbe-b043-853643179a39"
}
]
}
```
+ Per i dettagli sull'API, consulta [ListFunctionDefinitionVersions AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-function-definition-versions.html)*Command Reference*.
### `list-function-definitions`
Il seguente esempio di codice mostra come utilizzare`list-function-definitions`.
**AWS CLI**
**Come elencare le funzioni Lambda**
L'`list-function-definitions`esempio seguente elenca tutte le funzioni Lambda definite per il tuo AWS account.
```
aws greengrass list-function-definitions
```
Output:
```
{
"Definitions": [
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/017970a5-8952-46dd-b1c1-020b3ae8e960",
"CreationTimestamp": "2018-10-17T04:30:32.884Z",
"Id": "017970a5-8952-46dd-b1c1-020b3ae8e960",
"LastUpdatedTimestamp": "2018-10-17T04:30:32.884Z",
"LatestVersion": "4380b302-790d-4ed8-92bf-02e88afecb15",
"LatestVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/017970a5-8952-46dd-b1c1-020b3ae8e960/versions/4380b302-790d-4ed8-92bf-02e88afecb15"
},
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/063f5d1a-1dd1-40b4-9b51-56f8993d0f85",
"CreationTimestamp": "2019-06-18T16:21:21.431Z",
"Id": "063f5d1a-1dd1-40b4-9b51-56f8993d0f85",
"LastUpdatedTimestamp": "2019-06-18T16:21:21.431Z",
"LatestVersion": "9748fda7-1589-4fcc-ac94-f5559e88678b",
"LatestVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/063f5d1a-1dd1-40b4-9b51-56f8993d0f85/versions/9748fda7-1589-4fcc-ac94-f5559e88678b"
},
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/6598e653-a262-440c-9967-e2697f64da7b",
"CreationTimestamp": "2019-06-18T16:24:16.123Z",
"Id": "6598e653-a262-440c-9967-e2697f64da7b",
"LastUpdatedTimestamp": "2019-06-18T16:24:16.123Z",
"LatestVersion": "38bc6ccd-98a2-4ce7-997e-16c84748fae4",
"LatestVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/6598e653-a262-440c-9967-e2697f64da7b/versions/38bc6ccd-98a2-4ce7-997e-16c84748fae4"
},
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/c668df84-fad2-491b-95f4-655d2cad7885",
"CreationTimestamp": "2019-06-18T16:14:17.784Z",
"Id": "c668df84-fad2-491b-95f4-655d2cad7885",
"LastUpdatedTimestamp": "2019-06-18T16:14:17.784Z",
"LatestVersion": "37dd68c4-a64f-40ba-aa13-71fecc3ebded",
"LatestVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/c668df84-fad2-491b-95f4-655d2cad7885/versions/37dd68c4-a64f-40ba-aa13-71fecc3ebded"
}
]
}
```
+ Per i dettagli sull'API, consulta [ListFunctionDefinitions AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-function-definitions.html)*Command Reference.*
### `list-group-certificate-authorities`
Il seguente esempio di codice mostra come utilizzare`list-group-certificate-authorities`.
**AWS CLI**
**Per elencare la corrente CAs di un gruppo**
L'`list-group-certificate-authorities`esempio seguente elenca le autorità di certificazione correnti (CAs) per il gruppo Greengrass specificato.
```
aws greengrass list-group-certificate-authorities \
--group-id "1013db12-8b58-45ff-acc7-704248f66731"
```
Output:
```
{
"GroupCertificateAuthorities": [
{
"GroupCertificateAuthorityArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/groups/1013db12-8b58-45ff-acc7-704248f66731/certificateauthorities/f0430e1736ea8ed30cc5d5de9af67a7e3586bad9ae4d89c2a44163f65fdd8cf6",
"GroupCertificateAuthorityId": "f0430e1736ea8ed30cc5d5de9af67a7e3586bad9ae4d89c2a44163f65fdd8cf6"
}
]
}
```
+ Per i dettagli sull'API, vedere [ListGroupCertificateAuthorities](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-group-certificate-authorities.html)in *AWS CLI Command Reference.*
### `list-group-versions`
Il seguente esempio di codice mostra come utilizzare`list-group-versions`.
**AWS CLI**
**Come elencare le versioni di un gruppo Greengrass**
L’esempio `list-group-versions` seguente elenca tutte le versioni del gruppo Greengrass specificato.
```
aws greengrass list-group-versions \
--group-id "1013db12-8b58-45ff-acc7-704248f66731"
```
Output:
```
{
"Versions": [
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/groups/1013db12-8b58-45ff-acc7-704248f66731/versions/115136b3-cfd7-4462-b77f-8741a4b00e5e",
"CreationTimestamp": "2019-06-18T17:04:30.915Z",
"Id": "1013db12-8b58-45ff-acc7-704248f66731",
"Version": "115136b3-cfd7-4462-b77f-8741a4b00e5e"
},
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/groups/1013db12-8b58-45ff-acc7-704248f66731/versions/4340669d-d14d-44e3-920c-46c928750750",
"CreationTimestamp": "2019-06-18T17:03:52.663Z",
"Id": "1013db12-8b58-45ff-acc7-704248f66731",
"Version": "4340669d-d14d-44e3-920c-46c928750750"
},
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/groups/1013db12-8b58-45ff-acc7-704248f66731/versions/1b06e099-2d5b-4f10-91b9-78c4e060f5da",
"CreationTimestamp": "2019-06-18T17:02:44.189Z",
"Id": "1013db12-8b58-45ff-acc7-704248f66731",
"Version": "1b06e099-2d5b-4f10-91b9-78c4e060f5da"
},
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/groups/1013db12-8b58-45ff-acc7-704248f66731/versions/2d3f27f1-3b43-4554-ab7a-73ec30477efe",
"CreationTimestamp": "2019-06-18T17:01:42.401Z",
"Id": "1013db12-8b58-45ff-acc7-704248f66731",
"Version": "2d3f27f1-3b43-4554-ab7a-73ec30477efe"
},
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/groups/1013db12-8b58-45ff-acc7-704248f66731/versions/d20f7ae9-3444-4c1c-b025-e2ede23cdd31",
"CreationTimestamp": "2019-06-18T16:21:21.457Z",
"Id": "1013db12-8b58-45ff-acc7-704248f66731",
"Version": "d20f7ae9-3444-4c1c-b025-e2ede23cdd31"
}
]
}
```
+ Per i dettagli sull'API, consulta [ListGroupVersions AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-group-versions.html)*Command Reference*.
### `list-groups`
Il seguente esempio di codice mostra come utilizzare`list-groups`.
**AWS CLI**
**Come elencare i gruppi Greengrass**
L'`list-groups`esempio seguente elenca tutti i gruppi Greengrass definiti nel tuo AWS account.
```
aws greengrass list-groups
```
Output:
```
{
"Groups": [
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/groups/1013db12-8b58-45ff-acc7-704248f66731",
"CreationTimestamp": "2019-06-18T16:21:21.457Z",
"Id": "1013db12-8b58-45ff-acc7-704248f66731",
"LastUpdatedTimestamp": "2019-06-18T16:21:21.457Z",
"LatestVersion": "115136b3-cfd7-4462-b77f-8741a4b00e5e",
"LatestVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/groups/1013db12-8b58-45ff-acc7-704248f66731/versions/115136b3-cfd7-4462-b77f-8741a4b00e5e",
"Name": "GGGroup4Pi3"
},
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/groups/1402daf9-71cf-4cfe-8be0-d5e80526d0d8",
"CreationTimestamp": "2018-10-31T21:52:46.603Z",
"Id": "1402daf9-71cf-4cfe-8be0-d5e80526d0d8",
"LastUpdatedTimestamp": "2018-10-31T21:52:46.603Z",
"LatestVersion": "749af901-60ab-456f-a096-91b12d983c29",
"LatestVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/groups/1402daf9-71cf-4cfe-8be0-d5e80526d0d8/versions/749af901-60ab-456f-a096-91b12d983c29",
"Name": "MyTestGroup"
},
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/groups/504b5c8d-bbed-4635-aff1-48ec5b586db5",
"CreationTimestamp": "2018-12-31T21:39:36.771Z",
"Id": "504b5c8d-bbed-4635-aff1-48ec5b586db5",
"LastUpdatedTimestamp": "2018-12-31T21:39:36.771Z",
"LatestVersion": "46911e8e-f9bc-4898-8b63-59c7653636ec",
"LatestVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/groups/504b5c8d-bbed-4635-aff1-48ec5b586db5/versions/46911e8e-f9bc-4898-8b63-59c7653636ec",
"Name": "smp-ggrass-group"
}
]
}
```
+ Per i dettagli sull'API, consulta [ListGroups AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-groups.html)*Command Reference.*
### `list-logger-definition-versions`
Il seguente esempio di codice mostra come utilizzare`list-logger-definition-versions`.
**AWS CLI**
**Come ottenere un elenco di versioni di una definizione di logger**
L’esempio `list-logger-definition-versions` seguente ottiene un elenco di tutte le versioni della definizione di logger specificata.
```
aws greengrass list-logger-definition-versions \
--logger-definition-id "49eeeb66-f1d3-4e34-86e3-3617262abf23"
```
Output:
```
{
"Versions": [
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/loggers/49eeeb66-f1d3-4e34-86e3-3617262abf23/versions/5e3f6f64-a565-491e-8de0-3c0d8e0f2073",
"CreationTimestamp": "2019-05-08T16:10:13.866Z",
"Id": "49eeeb66-f1d3-4e34-86e3-3617262abf23",
"Version": "5e3f6f64-a565-491e-8de0-3c0d8e0f2073"
},
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/loggers/49eeeb66-f1d3-4e34-86e3-3617262abf23/versions/3ec6d3af-eb85-48f9-a16d-1c795fe696d7",
"CreationTimestamp": "2019-05-08T16:10:13.809Z",
"Id": "49eeeb66-f1d3-4e34-86e3-3617262abf23",
"Version": "3ec6d3af-eb85-48f9-a16d-1c795fe696d7"
}
]
}
```
+ Per i dettagli sull'API, consulta [ListLoggerDefinitionVersions AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-logger-definition-versions.html)*Command Reference*.
### `list-logger-definitions`
Il seguente esempio di codice mostra come utilizzare`list-logger-definitions`.
**AWS CLI**
**Come ottenere un elenco di definizioni di logger**
L'`list-logger-definitions`esempio seguente elenca tutte le definizioni dei logger per il tuo AWS account.
```
aws greengrass list-logger-definitions
```
Output:
```
{
"Definitions": [
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/loggers/49eeeb66-f1d3-4e34-86e3-3617262abf23",
"CreationTimestamp": "2019-05-08T16:10:13.809Z",
"Id": "49eeeb66-f1d3-4e34-86e3-3617262abf23",
"LastUpdatedTimestamp": "2019-05-08T16:10:13.809Z",
"LatestVersion": "5e3f6f64-a565-491e-8de0-3c0d8e0f2073",
"LatestVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/loggers/49eeeb66-f1d3-4e34-86e3-3617262abf23/versions/5e3f6f64-a565-491e-8de0-3c0d8e0f2073"
}
]
}
```
+ Per i dettagli sull'API, consulta [ListLoggerDefinitions AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-logger-definitions.html)*Command Reference.*
### `list-resource-definition-versions`
Il seguente esempio di codice mostra come utilizzare`list-resource-definition-versions`.
**AWS CLI**
**Come elencare le versioni di una definizione di risorsa**
L’esempio `list-resource-definition-versions` seguente elenca le versioni per la risorsa Greengrass specificata.
```
aws greengrass list-resource-definition-versions \
--resource-definition-id "ad8c101d-8109-4b0e-b97d-9cc5802ab658"
```
Output:
```
{
"Versions": [
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/resources/ad8c101d-8109-4b0e-b97d-9cc5802ab658/versions/26e8829a-491a-464d-9c87-664bf6f6f2be",
"CreationTimestamp": "2019-06-19T16:40:59.392Z",
"Id": "ad8c101d-8109-4b0e-b97d-9cc5802ab658",
"Version": "26e8829a-491a-464d-9c87-664bf6f6f2be"
},
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/resources/ad8c101d-8109-4b0e-b97d-9cc5802ab658/versions/432d92f6-12de-4ec9-a704-619a942a62aa",
"CreationTimestamp": "2019-06-19T16:40:59.261Z",
"Id": "ad8c101d-8109-4b0e-b97d-9cc5802ab658",
"Version": "432d92f6-12de-4ec9-a704-619a942a62aa"
}
]
}
```
+ Per i dettagli sull'API, consulta [ListResourceDefinitionVersions AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-resource-definition-versions.html)*Command Reference*.
### `list-resource-definitions`
Il seguente esempio di codice mostra come utilizzare`list-resource-definitions`.
**AWS CLI**
**Come elencare le risorse definite**
L'`list-resource-definitions`esempio seguente elenca le risorse definite per l'utilizzo di AWS IoT Greengrass.
```
aws greengrass list-resource-definitions
```
Output:
```
{
"Definitions": [
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/resources/ad8c101d-8109-4b0e-b97d-9cc5802ab658",
"CreationTimestamp": "2019-06-19T16:40:59.261Z",
"Id": "ad8c101d-8109-4b0e-b97d-9cc5802ab658",
"LastUpdatedTimestamp": "2019-06-19T16:40:59.261Z",
"LatestVersion": "26e8829a-491a-464d-9c87-664bf6f6f2be",
"LatestVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/resources/ad8c101d-8109-4b0e-b97d-9cc5802ab658/versions/26e8829a-491a-464d-9c87-664bf6f6f2be"
},
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/resources/c8bb9ebc-c3fd-40a4-9c6a-568d75569d38",
"CreationTimestamp": "2019-06-19T21:51:28.212Z",
"Id": "c8bb9ebc-c3fd-40a4-9c6a-568d75569d38",
"LastUpdatedTimestamp": "2019-06-19T21:51:28.212Z",
"LatestVersion": "a5f94d0b-f6bc-40f4-bb78-7a1c5fe13ba1",
"LatestVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/resources/c8bb9ebc-c3fd-40a4-9c6a-568d75569d38/versions/a5f94d0b-f6bc-40f4-bb78-7a1c5fe13ba1",
"Name": "MyGreengrassResources"
}
]
}
```
+ Per i dettagli sull'API, consulta [ListResourceDefinitions AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-resource-definitions.html)*Command Reference.*
### `list-subscription-definition-versions`
Il seguente esempio di codice mostra come utilizzare`list-subscription-definition-versions`.
**AWS CLI**
**Come elencare le versioni di una definizione di abbonamento**
L’esempio `list-subscription-definition-versions` seguente elenca tutte le versioni dell’abbonamento specificate. Puoi utilizzare il comando `list-subscription-definitions` per cercare l’ID dell’abbonamento.
```
aws greengrass list-subscription-definition-versions \
--subscription-definition-id "70e49321-83d5-45d2-bc09-81f4917ae152"
```
Output:
```
{
"Versions": [
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/subscriptions/70e49321-83d5-45d2-bc09-81f4917ae152/versions/88ae8699-12ac-4663-ba3f-4d7f0519140b",
"CreationTimestamp": "2019-06-18T17:03:52.499Z",
"Id": "70e49321-83d5-45d2-bc09-81f4917ae152",
"Version": "88ae8699-12ac-4663-ba3f-4d7f0519140b"
},
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/subscriptions/70e49321-83d5-45d2-bc09-81f4917ae152/versions/7e320ba3-c369-4069-a2f0-90acb7f219d6",
"CreationTimestamp": "2019-06-18T17:03:52.392Z",
"Id": "70e49321-83d5-45d2-bc09-81f4917ae152",
"Version": "7e320ba3-c369-4069-a2f0-90acb7f219d6"
}
]
}
```
+ Per i dettagli sull'API, consulta [ListSubscriptionDefinitionVersions AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-subscription-definition-versions.html)*Command Reference*.
### `list-subscription-definitions`
Il seguente esempio di codice mostra come utilizzare`list-subscription-definitions`.
**AWS CLI**
**Come ottenere un elenco delle definizioni di abbonamenti**
L'`list-subscription-definitions`esempio seguente elenca tutti gli abbonamenti AWS IoT Greengrass definiti nel tuo account. AWS
```
aws greengrass list-subscription-definitions
```
Output:
```
{
"Definitions": [
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/subscriptions/70e49321-83d5-45d2-bc09-81f4917ae152",
"CreationTimestamp": "2019-06-18T17:03:52.392Z",
"Id": "70e49321-83d5-45d2-bc09-81f4917ae152",
"LastUpdatedTimestamp": "2019-06-18T17:03:52.392Z",
"LatestVersion": "88ae8699-12ac-4663-ba3f-4d7f0519140b",
"LatestVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/subscriptions/70e49321-83d5-45d2-bc09-81f4917ae152/versions/88ae8699-12ac-4663-ba3f-4d7f0519140b"
},
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/subscriptions/cd6f1c37-d9a4-4e90-be94-01a7404f5967",
"CreationTimestamp": "2018-10-18T15:45:34.024Z",
"Id": "cd6f1c37-d9a4-4e90-be94-01a7404f5967",
"LastUpdatedTimestamp": "2018-10-18T15:45:34.024Z",
"LatestVersion": "d1cf8fac-284f-4f6a-98fe-a2d36d089373",
"LatestVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/subscriptions/cd6f1c37-d9a4-4e90-be94-01a7404f5967/versions/d1cf8fac-284f-4f6a-98fe-a2d36d089373"
},
{
"Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/subscriptions/fa81bc84-3f59-4377-a84b-5d0134da359b",
"CreationTimestamp": "2018-10-22T17:09:31.429Z",
"Id": "fa81bc84-3f59-4377-a84b-5d0134da359b",
"LastUpdatedTimestamp": "2018-10-22T17:09:31.429Z",
"LatestVersion": "086d1b08-b25a-477c-a16f-6f9b3a9c295a",
"LatestVersionArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/subscriptions/fa81bc84-3f59-4377-a84b-5d0134da359b/versions/086d1b08-b25a-477c-a16f-6f9b3a9c295a"
}
]
}
```
+ Per i dettagli sull'API, consulta *AWS CLI Command [ListSubscriptionDefinitions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-subscription-definitions.html)Reference*.
### `list-tags-for-resource`
Il seguente esempio di codice mostra come utilizzare`list-tags-for-resource`.
**AWS CLI**
**Come elencare i tag collegati a una risorsa**
L’esempio `list-tags-for-resource` seguente elenca i tag e i relativi valori associati alla risorsa specificata.
```
aws greengrass list-tags-for-resource \
--resource-arn "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/resources/ad8c101d-8109-4b0e-b97d-9cc5802ab658"
```
Output:
```
{
"tags": {
"ResourceSubType": "USB",
"ResourceType": "Device"
}
}
```
Per ulteriori informazioni, consulta [Tagging delle risorse Greengrass](https://docs.aws.amazon.com/greengrass/latest/developerguide/tagging.html) nella **Guida per gli sviluppatori di AWS IoT Greengrass**.
+ Per i dettagli sull'API, consulta [ListTagsForResource AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-tags-for-resource.html)*Command Reference*.
### `reset-deployments`
Il seguente esempio di codice mostra come utilizzare`reset-deployments`.
**AWS CLI**
**Come eliminare le informazioni sull’implementazione per un gruppo Greengrass**
L’esempio `reset-deployments` seguente ripulisce le informazioni di implementazione per il gruppo Greengrass specificato. Quando si aggiunge `--force option`, le informazioni sull’implementazione vengono reimpostate senza attendere la risposta del dispositivo core.
```
aws greengrass reset-deployments \
--group-id "1402daf9-71cf-4cfe-8be0-d5e80526d0d8" \
--force
```
Output:
```
{
"DeploymentArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/groups/1402daf9-71cf-4cfe-8be0-d5e80526d0d8/deployments/7dd4e356-9882-46a3-9e28-6d21900c011a",
"DeploymentId": "7dd4e356-9882-46a3-9e28-6d21900c011a"
}
```
Per ulteriori informazioni, consulta [Reimpostazione delle implementazioni](https://docs.aws.amazon.com/greengrass/latest/developerguide/reset-deployments-scenario.html) nella *Guida per gli sviluppatori di AWS IoT Greengrass*.
+ Per i dettagli sull'API, consulta [ResetDeployments AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/reset-deployments.html)*Command Reference*.
### `start-bulk-deployment`
Il seguente esempio di codice mostra come utilizzare`start-bulk-deployment`.
**AWS CLI**
**Come avviare un’operazione di implementazione in blocco**
L’esempio `start-bulk-deployment` seguente avvia un’operazione di implementazione in blocco, utilizzando un file archiviato in un bucket S3 per specificare i gruppi da implementare.
```
aws greengrass start-bulk-deployment \
--cli-input-json "{\"InputFileUri\":\"https://gg-group-deployment1.s3-us-west-2.amazonaws.com/MyBulkDeploymentInputFile.txt\", \"ExecutionRoleArn\":\"arn:aws:iam::123456789012:role/ggCreateDeploymentRole\",\"AmznClientToken\":\"yourAmazonClientToken\"}"
```
Output:
```
{
"BulkDeploymentArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/bulk/deployments/870fb41b-6288-4e0c-bc76-a7ba4b4d3267",
"BulkDeploymentId": "870fb41b-6288-4e0c-bc76-a7ba4b4d3267"
}
```
Per ulteriori informazioni, consulta [Creare implementazioni in blocco per i gruppi](https://docs.aws.amazon.com/greengrass/latest/developerguide/bulk-deploy-cli.html) nella *Guida per gli sviluppatori di AWS IoT Greengrass*.
+ Per i dettagli sull'API, consulta [StartBulkDeployment AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/start-bulk-deployment.html)*Command Reference*.
### `stop-bulk-deployment`
Il seguente esempio di codice mostra come utilizzare`stop-bulk-deployment`.
**AWS CLI**
**Come interrompere un’implementazione in blocco**
L’esempio `stop-bulk-deployment` seguente interrompe l’implementazione in blocco specificata. Se si tenta di interrompere un’implementazione in blocco che è completa, viene visualizzato un errore: `InvalidInputException: Cannot change state of finished execution.`
```
aws greengrass stop-bulk-deployment \
--bulk-deployment-id "870fb41b-6288-4e0c-bc76-a7ba4b4d3267"
```
Questo comando non produce alcun output.
Per ulteriori informazioni, consulta [Creare implementazioni in blocco per i gruppi](https://docs.aws.amazon.com/greengrass/latest/developerguide/bulk-deploy-cli.html) nella *Guida per gli sviluppatori di AWS IoT Greengrass*.
+ Per i dettagli sull'API, consulta [StopBulkDeployment AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/stop-bulk-deployment.html)*Command Reference*.
### `tag-resource`
Il seguente esempio di codice mostra come utilizzare`tag-resource`.
**AWS CLI**
**Come applicare tag a una risorsa**
L’esempio `tag-resource` seguente applica due tag `ResourceType` e `ResourceSubType` alla risorsa Greengrass specificata. Questa operazione può sia aggiungere nuovi tag e valori sia aggiornare il valore dei tag esistenti. Pr rimuovere un tag, utilizza il comando `untag-resource`.
```
aws greengrass tag-resource \
--resource-arn "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/resources/ad8c101d-8109-4b0e-b97d-9cc5802ab658" \
--tags "ResourceType=Device,ResourceSubType=USB"
```
Questo comando non produce alcun output.
Per ulteriori informazioni, consulta [Tagging delle risorse Greengrass](https://docs.aws.amazon.com/greengrass/latest/developerguide/tagging.html) nella **Guida per gli sviluppatori di AWS IoT Greengrass**.
+ Per i dettagli sull'API, consulta [TagResource AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/tag-resource.html)*Command Reference*.
### `untag-resource`
Il seguente esempio di codice mostra come utilizzare`untag-resource`.
**AWS CLI**
**Come rimuovere un tag e il relativo valore da una risorsa**
L’esempio `untag-resource` seguente rimuove il tag con chiave `Category` dal gruppo Greengrass specificato. Se la chiave `Category` non esiste per la risorsa specificata, non viene restituito alcun errore.
```
aws greengrass untag-resource \
--resource-arn "arn:aws:greengrass:us-west-2:123456789012:/greengrass/groups/1013db12-8b58-45ff-acc7-704248f66731" \
--tag-keys "Category"
```
Questo comando non produce alcun output.
Per ulteriori informazioni, consulta [Tagging delle risorse Greengrass](https://docs.aws.amazon.com/greengrass/latest/developerguide/tagging.html) nella **Guida per gli sviluppatori di AWS IoT Greengrass**.
+ Per i dettagli sull'API, consulta [UntagResource AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/untag-resource.html)*Command Reference*.
### `update-connectivity-info`
Il seguente esempio di codice mostra come utilizzare`update-connectivity-info`.
**AWS CLI**
**Come aggiornare le informazioni sulla connettività per il core Greengrass**
L’esempio `update-connectivity-info` seguente modifica gli endpoint che i dispositivi possono utilizzare per connettersi al core Greengrass specificato. Le informazioni sulla connettività sono un elenco di indirizzi IP o nomi di dominio, con i numeri di porta corrispondenti e i metadati opzionali definiti dal cliente. Se la rete locale viene modificata, potrebbe essere necessario aggiornare le informazioni sulla connettività.
```
aws greengrass update-connectivity-info \
--thing-name "MyGroup_Core" \
--connectivity-info "[{\"Metadata\":\"\",\"PortNumber\":8883,\"HostAddress\":\"127.0.0.1\",\"Id\":\"localhost_127.0.0.1_0\"},{\"Metadata\":\"\",\"PortNumber\":8883,\"HostAddress\":\"192.168.1.3\",\"Id\":\"localIP_192.168.1.3\"}]"
```
Output:
```
{
"Version": "312de337-59af-4cf9-a278-2a23bd39c300"
}
```
+ Per i dettagli sull'API, consulta [UpdateConnectivityInfo AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/update-connectivity-info.html)*Command Reference*.
### `update-connector-definition`
Il seguente esempio di codice mostra come utilizzare`update-connector-definition`.
**AWS CLI**
**Come aggiornare il nome della definizione di un connettore**
L’esempio `update-connector-definition` seguente aggiorna il nome della definizione di connettore specificata. Se desideri aggiornare i dettagli del connettore, utilizza il comando `create-connector-definition-version` per creare una nuova versione.
```
aws greengrass update-connector-definition \
--connector-definition-id "55d0052b-0d7d-44d6-b56f-21867215e118" \
--name "GreengrassConnectors2019"
```
Per ulteriori informazioni, consulta [Integrazione con servizi e protocolli tramite i connettori](https://docs.aws.amazon.com/greengrass/latest/developerguide/connectors.html) nella *Guida per gli sviluppatori di AWS IoT Greengrass*.
+ Per i dettagli sull'API, consulta [UpdateConnectorDefinition AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/update-connector-definition.html)*Command Reference*.
### `update-core-definition`
Il seguente esempio di codice mostra come utilizzare`update-core-definition`.
**AWS CLI**
**Come creare una definizione core**
L’esempio `update-core-definition` seguente modifica il nome della definizione di core specificata. Puoi aggiornare solo la proprietà `name` di una definizione core.
```
aws greengrass update-core-definition \
--core-definition-id "582efe12-b05a-409e-9a24-a2ba1bcc4a12" \
--name "MyCoreDevices"
```
Questo comando non produce alcun output.
Per ulteriori informazioni, consulta [Configurare AWS IoT Greengrass Core nella IoT *AWS Greengrass*](https://docs.aws.amazon.com/greengrass/latest/developerguide/gg-core.html) Developer Guide.
+ Per i dettagli sull'API, consulta *AWS CLI Command [UpdateCoreDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/update-core-definition.html)Reference*.
### `update-device-definition`
Il seguente esempio di codice mostra come utilizzare`update-device-definition`.
**AWS CLI**
**Come aggiornare una definizione di dispositivo**
L’esempio `update-device-definition` seguente modifica il nome della definizione di dispositivo specificata. Puoi aggiornare solo la proprietà `name` di una definizione di dispositivo.
```
aws greengrass update-device-definition \
--device-definition-id "f9ba083d-5ad4-4534-9f86-026a45df1ccd" \
--name "TemperatureSensors"
```
Questo comando non produce alcun output.
+ Per i dettagli sull'API, consulta [UpdateDeviceDefinition AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/update-device-definition.html)*Command Reference*.
### `update-function-definition`
Il seguente esempio di codice mostra come utilizzare`update-function-definition`.
**AWS CLI**
**Come aggiornare il nome di una definizione di funzione**
L’esempio `update-function-definition` seguente aggiorna il nome della definizione di funzione specificata. Se desideri aggiornare i dettagli per la funzione, utilizza il comando `create-function-definition-version` per creare una nuova versione.
```
aws greengrass update-function-definition \
--function-definition-id "e47952bd-dea9-4e2c-a7e1-37bbe8807f46" \
--name ObsoleteFunction
```
Questo comando non produce alcun output.
Per ulteriori informazioni, consulta [Eseguire funzioni Lambda locali](https://docs.aws.amazon.com/greengrass/latest/developerguide/lambda-functions.html) nella *Guida per gli sviluppatori di AWS IoT Greengrass*.
+ Per i dettagli sull'API, consulta [UpdateFunctionDefinition AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/update-function-definition.html)*Command Reference*.
### `update-group-certificate-configuration`
Il seguente esempio di codice mostra come utilizzare`update-group-certificate-configuration`.
**AWS CLI**
**Come aggiornare la scadenza dei certificati di un gruppo**
L’esempio `update-group-certificate-configuration` seguente imposta una scadenza di 10 giorni per i certificati generati per il gruppo specificato.
```
aws greengrass update-group-certificate-configuration \
--group-id "8eaadd72-ce4b-4f15-892a-0cc4f3a343f1" \
--certificate-expiry-in-milliseconds 864000000
```
Output:
```
{
"CertificateExpiryInMilliseconds": 864000000,
"CertificateAuthorityExpiryInMilliseconds": 2524607999000,
"GroupId": "8eaadd72-ce4b-4f15-892a-0cc4f3a343f1"
}
```
Per ulteriori informazioni, consulta [Sicurezza di AWS IoT Greengrass](https://docs.aws.amazon.com/greengrass/latest/developerguide/gg-sec.html) nella *Guida per gli sviluppatori di AWS IoT Greengrass*.
+ Per i dettagli sull'API, consulta [UpdateGroupCertificateConfiguration AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/update-group-certificate-configuration.html)*Command Reference*.
### `update-group`
Il seguente esempio di codice mostra come utilizzare`update-group`.
**AWS CLI**
**Come aggiornare il nome del gruppo**
L’esempio `update-group` seguente aggiorna il nome del gruppo Greengrass specificato. Se desideri aggiornare i dettagli del gruppo, utilizza il comando `create-group-version` per creare una nuova versione.
```
aws greengrass update-group \
--group-id "1402daf9-71cf-4cfe-8be0-d5e80526d0d8" \
--name TestGroup4of6
```
Per ulteriori informazioni, consulta [Configure AWS IoT Greengrass on IoT nella AWS IoT AWS](https://docs.aws.amazon.com/greengrass/latest/developerguide/gg-config.html) *Greengrass* Developer Guide.
+ Per i dettagli sull'API, consulta *AWS CLI Command [UpdateGroup](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/update-group.html)Reference*.
### `update-logger-definition`
Il seguente esempio di codice mostra come utilizzare`update-logger-definition`.
**AWS CLI**
**Come aggiornare una definizione di logger**
L’esempio `update-logger-definition` seguente modifica il nome della definizione del logger specificata. Puoi aggiornare solo la proprietà `name` di una definizione di logger.
```
aws greengrass update-logger-definition \
--logger-definition-id "a454b62a-5d56-4ca9-bdc4-8254e1662cb0" \
--name "LoggingConfigsForSensors"
```
Questo comando non produce alcun output.
Per ulteriori informazioni, consulta [Monitoring with AWS IoT Greengrass Logs](https://docs.aws.amazon.com/greengrass/latest/developerguide/greengrass-logs-overview.html) nella IoT *AWS Greengrass* Developer Guide.
+ *Per i dettagli sull'API, consulta Command [UpdateLoggerDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/update-logger-definition.html)Reference AWS CLI .*
### `update-resource-definition`
Il seguente esempio di codice mostra come utilizzare`update-resource-definition`.
**AWS CLI**
**Come aggiornare il nome di una definizione di risorsa**
L’esempio `update-resource-definition` seguente aggiorna il nome per la definizione di risorsa specificata. Se desideri modificare i dettagli della risorsa, utilizza il comando `create-resource-definition-version` per creare una nuova versione.
```
aws greengrass update-resource-definition \
--resource-definition-id "c8bb9ebc-c3fd-40a4-9c6a-568d75569d38" \
--name GreengrassConnectorResources
```
Questo comando non produce alcun output.
Per ulteriori informazioni, consulta [Accesso alle risorse locali con funzioni Lambda e connettori](https://docs.aws.amazon.com/greengrass/latest/developerguide/access-local-resources.html) nella *Guida per gli sviluppatori di AWS IoT Greengrass*.
+ Per i dettagli sull'API, consulta [UpdateResourceDefinition AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/update-resource-definition.html)*Command Reference*.
### `update-subscription-definition`
Il seguente esempio di codice mostra come utilizzare`update-subscription-definition`.
**AWS CLI**
**Come aggiornare il nome di una definizione di abbonamento**
L’esempio `update-subscription-definition` seguente aggiorna il nome per la definizione di abbonamento specificata. Se desideri modificare i dettagli dell’abbonamento, utilizza il comando `create-subscription-definition-version` per creare una nuova versione.
```
aws greengrass update-subscription-definition \
--subscription-definition-id "fa81bc84-3f59-4377-a84b-5d0134da359b" \
--name "ObsoleteSubscription"
```
Questo comando non produce alcun output.
Per ulteriori informazioni, consulta il titolo nella *guida*.
+ Per i dettagli sull'API, consulta [UpdateSubscriptionDefinition AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/update-subscription-definition.html)*Command Reference*.
### `update-thing-runtime-configuration`
Il seguente esempio di codice mostra come utilizzare`update-thing-runtime-configuration`.
**AWS CLI**
**Come attivare la telemetria nella configurazione di runtime di un core Greengrass**
L’esempio `update-thing-runtime-configuration` seguente aggiorna la configurazione di runtime di un core Greengrass per attivare la telemetria.
```
aws greengrass update-thing-runtime-configuration \
--thing-name SampleGreengrassCore \
--telemetry-configuration {\"Telemetry\":\"On\"}
```
Questo comando non produce alcun output.
Per ulteriori informazioni, consulta [Configurazione delle impostazioni di telemetria](https://docs.aws.amazon.com/greengrass/latest/developerguide/telemetry.html#configure-telemetry-settings) nella *Guida per gli sviluppatori di AWS IoT Greengrass*.
+ Per i dettagli sull'API, consulta [UpdateThingRuntimeConfiguration AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/update-thing-runtime-configuration.html)*Command Reference*.