Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# AWS IoT Greengrass Beispiele mit AWS CLI
Die folgenden Codebeispiele zeigen Ihnen, wie Sie mithilfe von AWS Command Line Interface with Aktionen ausführen und allgemeine Szenarien implementieren AWS IoT Greengrass.
*Aktionen* sind Codeauszüge aus größeren Programmen und müssen im Kontext ausgeführt werden. Während Aktionen Ihnen zeigen, wie Sie einzelne Service-Funktionen aufrufen, können Sie Aktionen im Kontext der zugehörigen Szenarien anzeigen.
Jedes Beispiel enthält einen Link zum vollständigen Quellcode, wo Sie Anweisungen zum Einrichten und Ausführen des Codes im Kodex finden.
**Topics**
+ [Aktionen](#actions)
## Aktionen
### `associate-role-to-group`
Das folgende Codebeispiel zeigt, wie Sie`associate-role-to-group`.
**AWS CLI**
**So verknüpfen Sie eine Rolle mit Ihrer Greengrass-Gruppe**
Im folgenden Beispiel für `associate-role-to-group` wird die angegebene IAM-Rolle mit einer Greengrass-Gruppe verknüpft. Die Gruppenrolle wird von lokalen Lambda-Funktionen und Konnektoren für den Zugriff auf AWS Dienste verwendet. Beispielsweise kann Ihre Gruppenrolle die für die CloudWatch Logs-Integration erforderlichen Berechtigungen gewähren.
```
aws greengrass associate-role-to-group \
--group-id 2494ee3f-7f8a-4e92-a78b-d205f808b84b \
--role-arn arn:aws:iam::123456789012:role/GG-Group-Role
```
Ausgabe:
```
{
"AssociatedAt": "2019-09-10T20:03:30Z"
}
```
Weitere Informationen finden Sie unter [Konfigurieren der Gruppenrolle](https://docs.aws.amazon.com/greengrass/latest/developerguide/config-iam-roles.html) im *Entwicklerhandbuch für AWS IoT Greengrass*.
+ Einzelheiten zur API finden Sie [AssociateRoleToGroup](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/associate-role-to-group.html)in der *AWS CLI Befehlsreferenz*.
### `associate-service-role-to-account`
Das folgende Codebeispiel zeigt die Verwendung`associate-service-role-to-account`.
**AWS CLI**
**Um Ihrem AWS Konto eine Servicerolle zuzuordnen**
Im folgenden `associate-service-role-to-account` Beispiel wird eine IAM-Dienstrolle, die durch ihren ARN angegeben wird, AWS IoT Greengrass in Ihrem AWS Konto zugeordnet. Sie müssen die Servicerolle zuvor in IAM erstellt haben und ihr ein Richtliniendokument zuordnen, das es AWS IoT Greengrass ermöglicht, diese Rolle zu übernehmen.
```
aws greengrass associate-service-role-to-account \
--role-arn "arn:aws:iam::123456789012:role/service-role/Greengrass_ServiceRole"
```
Ausgabe:
```
{
"AssociatedAt": "2019-06-25T18:12:45Z"
}
```
Weitere Informationen finden Sie unter [Greengrass-Servicerolle](https://docs.aws.amazon.com/greengrass/latest/developerguide/service-role.html) im *Entwicklerhandbuch für AWS IoT Greengrass*.
+ Einzelheiten zur API finden Sie [AssociateServiceRoleToAccount](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/associate-service-role-to-account.html)in der *AWS CLI Befehlsreferenz*.
### `create-connector-definition-version`
Das folgende Codebeispiel zeigt die Verwendung`create-connector-definition-version`.
**AWS CLI**
**So erstellen Sie eine Konnektordefinitionsversion**
Im folgenden Beispiel für `create-connector-definition-version` wird eine Konnektordefinitionsversion erstellt und mit der angegebenen Konnektordefinition verknüpft. Alle Konnektoren in einer Version definieren Werte für ihre Parameter.
```
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\"}}]"
```
Ausgabe:
```
{
"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"
}
```
+ Einzelheiten zur API finden Sie [CreateConnectorDefinitionVersion](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-connector-definition-version.html)in der *AWS CLI Befehlsreferenz*.
### `create-connector-definition`
Das folgende Codebeispiel zeigt die Verwendung`create-connector-definition`.
**AWS CLI**
**So erstellen Sie eine Konnektordefinition**
Im folgenden Beispiel für `create-connector-definition` wird eine Konnektordefinition und eine erste Konnektordefinitionsversion erstellt. Die erste Version enthält einen Konnektor. Alle Konnektoren in einer Version definieren Werte für ihre Parameter.
```
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\"}}]}"
```
Ausgabe:
```
{
"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"
}
```
Weitere Informationen finden Sie unter [Erste Schritte mit Greengrass-Konnektoren (CLI)](https://docs.aws.amazon.com/greengrass/latest/developerguide/connectors-cli.html) im **Entwicklerhandbuch für AWS IoT Greengrass**.
+ Einzelheiten zur API finden Sie [CreateConnectorDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-connector-definition.html)in der *AWS CLI Befehlsreferenz*.
### `create-core-definition-version`
Das folgende Codebeispiel zeigt die Verwendung`create-core-definition-version`.
**AWS CLI**
**So erstellen Sie eine Kern-Definitionsversion**
Im folgenden Beispiel für `create-core-definition-version` wird eine Kern-Definitionsversion erstellt und mit der angegebenen Kerndefinition verknüpft. Die Version kann nur einen Kern enthalten. Bevor Sie einen Core erstellen können, müssen Sie zunächst das entsprechende AWS IoT-Ding erstellen und bereitstellen. Dieser Prozess umfasst die folgenden `iot`-Befehle, die `ThingArn` und `CertificateArn` zurückgeben, die für den Befehl `create-core-definition-version` erforderlich sind.
Erstellen Sie das AWS IoT-Ding, das dem Kerngerät entspricht:
```
aws iot create-thing \
--thing-name "MyCoreDevice"
```
Ausgabe:
```
{
"thingArn": "arn:aws:iot:us-west-2:123456789012:thing/MyCoreDevice",
"thingName": "MyCoreDevice",
"thingId": "cb419a19-9099-4515-9cec-e9b0e760608a"
}
```
Erstellen Sie öffentliche sowie private Schlüssel und das Zertifikat des Kerngeräts für das Objekt. In diesem Beispiel wird der Befehl `create-keys-and-certificate` verwendet und es sind Schreibberechtigungen für das aktuelle Verzeichnis erforderlich. Sie können aber auch den Befehl `create-certificate-from-csr` verwenden.
```
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"
```
Ausgabe:
```
{
"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"
}
```
Erstellen Sie eine AWS IoT-Richtlinie, die erlaubt `iot` und `greengrass` Maßnahmen ergreift. Der Einfachheit halber erlaubt die folgende Richtlinie Aktionen für alle Ressourcen, Ihre Richtlinie sollte jedoch restriktiver sein.
```
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\":[\"*\"]}]}"
```
Ausgabe:
```
{
"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"
}
```
Fügen Sie die Richtlinie dem Zertifikat an:
```
aws iot attach-policy \
--policy-name "Core_Devices" \
--target "arn:aws:iot:us-west-2:123456789012:cert/123a15ec415668c2349a76170b64ac0878231c1e21ec83c10e92a1EXAMPLExyz"
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben.
Fügen Sie das Objekt dem Zertifikat an:
```
aws iot attach-thing-principal \
--thing-name "MyCoreDevice" \
--principal "arn:aws:iot:us-west-2:123456789012:cert/123a15ec415668c2349a76170b64ac0878231c1e21ec83c10e92a1EXAMPLExyz"
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben.
Erstellen Sie die Kern-Definitionsversion:
```
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}]"
```
Ausgabe:
```
{
"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"
}
```
Weitere Informationen finden [Sie unter Configure the AWS IoT Greengrass Core](https://docs.aws.amazon.com/greengrass/latest/developerguide/gg-core.html) im *AWS IoT Greengrass Developer Guide*.
+ Einzelheiten zur API finden Sie unter [CreateCoreDefinitionVersion AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-core-definition-version.html)*Befehlsreferenz*.
### `create-core-definition`
Das folgende Codebeispiel zeigt die Verwendung`create-core-definition`.
**AWS CLI**
**Beispiel 1: So erstellen Sie eine leere Kerndefinition**
Im folgenden Beispiel für `create-core-definition` wird eine leere Greengrass-Kerndefinition (keine erste Version) erstellt. Bevor der Kern verwendet werden kann, müssen Sie den Befehl `create-core-definition-version` verwenden, um die anderen Parameter für den Kern bereitzustellen.
```
aws greengrass create-core-definition \
--name cliGroup_Core
```
Ausgabe:
```
{
"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"
}
```
**Beispiel 2: So erstellen Sie eine Kerndefinition mit einer ersten Version**
Im folgenden Beispiel für `create-core-definition` wird eine Kerndefinition erstellt, die eine erste Kern-Definitionsversion enthält. Die Version kann nur einen Kern enthalten. Bevor Sie einen Core erstellen können, müssen Sie zunächst das entsprechende AWS IoT-Ding erstellen und bereitstellen. Dieser Prozess umfasst die folgenden `iot`-Befehle, die `ThingArn` und `CertificateArn` zurückgeben, die für den Befehl `create-core-definition` erforderlich sind.
Erstellen Sie das AWS IoT-Ding, das dem Kerngerät entspricht:
```
aws iot create-thing \
--thing-name "MyCoreDevice"
```
Ausgabe:
```
{
"thingArn": "arn:aws:iot:us-west-2:123456789012:thing/MyCoreDevice",
"thingName": "MyCoreDevice",
"thingId": "cb419a19-9099-4515-9cec-e9b0e760608a"
}
```
Erstellen Sie öffentliche sowie private Schlüssel und das Zertifikat des Kerngeräts für das Objekt. In diesem Beispiel wird der Befehl `create-keys-and-certificate` verwendet und es sind Schreibberechtigungen für das aktuelle Verzeichnis erforderlich. Sie können aber auch den Befehl `create-certificate-from-csr` verwenden.
```
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"
```
Ausgabe:
```
{
"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"
}
```
Erstellen Sie eine AWS IoT-Richtlinie, die erlaubt `iot` und `greengrass` Maßnahmen ergreift. Der Einfachheit halber erlaubt die folgende Richtlinie Aktionen für alle Ressourcen, Ihre Richtlinie sollte jedoch restriktiver sein.
```
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\":[\"*\"]}]}"
```
Ausgabe:
```
{
"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"
}
```
Fügen Sie die Richtlinie dem Zertifikat an:
```
aws iot attach-policy \
--policy-name "Core_Devices" \
--target "arn:aws:iot:us-west-2:123456789012:cert/123a15ec415668c2349a76170b64ac0878231c1e21ec83c10e92a1EXAMPLExyz"
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben.
Fügen Sie das Objekt dem Zertifikat an:
```
aws iot attach-thing-principal \
--thing-name "MyCoreDevice" \
--principal "arn:aws:iot:us-west-2:123456789012:cert/123a15ec415668c2349a76170b64ac0878231c1e21ec83c10e92a1EXAMPLExyz"
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben.
Erstellen Sie die Kerndefinition:
```
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}]}"
```
Ausgabe:
```
{
"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"
}
```
Weitere Informationen finden [Sie unter Configure the AWS IoT Greengrass Core](https://docs.aws.amazon.com/greengrass/latest/developerguide/gg-core.html) im *AWS IoT Greengrass Developer Guide*.
+ Einzelheiten zur API finden Sie unter [CreateCoreDefinition AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-core-definition.html)*Befehlsreferenz*.
### `create-deployment`
Das folgende Codebeispiel zeigt die Verwendung`create-deployment`.
**AWS CLI**
**So erstellen Sie eine Bereitstellung für eine Version einer Greengrass-Gruppe**
Im folgenden Beispiel für `create-deployment` wird die angegebene Version einer Greengrass-Gruppe bereitgestellt.
```
aws greengrass create-deployment \
--deployment-type NewDeployment \
--group-id "ce2e7d01-3240-4c24-b8e6-f6f6e7a9eeca" \
--group-version-id "dc40c1e9-e8c8-4d28-a84d-a9cad5f599c9"
```
Ausgabe:
```
{
"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"
}
```
Weitere Informationen finden Sie unter [Erste Schritte mit Konnektoren (CLI)](https://docs.aws.amazon.com/greengrass/latest/developerguide/connectors-cli.html) im *Entwicklerhandbuch für AWS IoT Greengrass*.
+ Einzelheiten zur API finden Sie [CreateDeployment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-deployment.html)in der *AWS CLI Befehlsreferenz*.
### `create-device-definition-version`
Das folgende Codebeispiel zeigt die Verwendung`create-device-definition-version`.
**AWS CLI**
**So erstellen Sie eine Geräte-Definitionsversion**
Im folgenden Beispiel für `create-device-definition-version` wird eine Geräte-Definitionsversion erstellt und mit der angegebenen Gerätedefinition verknüpft. Die Version definiert zwei Geräte. Bevor Sie ein Greengrass-Gerät erstellen können, müssen Sie zunächst das entsprechende AWS IoT-Ding erstellen und bereitstellen. Dieser Prozess umfasst die folgenden `iot`-Befehle, die Sie ausführen müssen, um die erforderlichen Informationen für den Greengrass-Befehl abzurufen:
Erstellen Sie das AWS IoT-Ding, das dem Gerät entspricht:
```
aws iot create-thing \
--thing-name "InteriorTherm"
```
Ausgabe:
```
{
"thingArn": "arn:aws:iot:us-west-2:123456789012:thing/InteriorTherm",
"thingName": "InteriorTherm",
"thingId": "01d4763c-78a6-46c6-92be-7add080394bf"
}
```
Erstellen Sie öffentliche sowie private Schlüssel und das Zertifikat des Geräts für das Objekt. In diesem Beispiel wird der Befehl `create-keys-and-certificate` verwendet und es sind Schreibberechtigungen für das aktuelle Verzeichnis erforderlich. Sie können aber auch den Befehl `create-certificate-from-csr` verwenden:
```
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"
```
Ausgabe:
```
{
"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"
}
```
Erstellen Sie eine AWS IoT-Richtlinie, die erlaubt `iot` und `greengrass` Maßnahmen ergreift. Der Einfachheit halber erlaubt die folgende Richtlinie Aktionen für alle Ressourcen, Ihre Richtlinie kann jedoch restriktiver sein:
```
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\":[\"*\"]}]}"
```
Ausgabe:
```
{
"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"
}
```
Fügen Sie die Richtlinie dem Zertifikat an:
```
aws iot attach-policy \
--policy-name "GG_Devices" \
--target "arn:aws:iot:us-west-2:123456789012:cert/66a415ec415668c2349a76170b64ac0878231c1e21ec83c10e92a18bd568eb92"
```
Fügen Sie das Objekt dem Zertifikat an:
```
aws iot attach-thing-principal \
--thing-name "InteriorTherm" \
--principal "arn:aws:iot:us-west-2:123456789012:cert/66a415ec415668c2349a76170b64ac0878231c1e21ec83c10e92a18bd568eb92"
```
Nachdem Sie das IoT-Objekt wie oben gezeigt erstellt und konfiguriert haben, verwenden Sie `ThingArn` und `CertificateArn` aus den ersten beiden Befehlen im folgenden Beispiel.
```
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}]"
```
Ausgabe:
```
{
"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"
}
```
+ Einzelheiten zur API finden Sie [CreateDeviceDefinitionVersion](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-device-definition-version.html)in der *AWS CLI Befehlsreferenz*.
### `create-device-definition`
Das folgende Codebeispiel zeigt die Verwendung`create-device-definition`.
**AWS CLI**
**So erstellen Sie eine Gerätedefinition**
Im folgenden Beispiel für `create-device-definition` wird eine Gerätedefinition erstellt, die eine erste Geräte-Definitionsversion enthält. Die erste Version definiert zwei Geräte. Bevor Sie ein Greengrass-Gerät erstellen können, müssen Sie zunächst das entsprechende AWS IoT-Ding erstellen und bereitstellen. Dieser Prozess umfasst die folgenden `iot`-Befehle, die Sie ausführen müssen, um die erforderlichen Informationen für den Greengrass-Befehl abzurufen:
Erstellen Sie das AWS IoT-Ding, das dem Gerät entspricht:
```
aws iot create-thing \
--thing-name "InteriorTherm"
```
Ausgabe:
```
{
"thingArn": "arn:aws:iot:us-west-2:123456789012:thing/InteriorTherm",
"thingName": "InteriorTherm",
"thingId": "01d4763c-78a6-46c6-92be-7add080394bf"
}
```
Erstellen Sie öffentliche sowie private Schlüssel und das Zertifikat des Geräts für das Objekt. In diesem Beispiel wird der Befehl `create-keys-and-certificate` verwendet und es sind Schreibberechtigungen für das aktuelle Verzeichnis erforderlich. Sie können aber auch den Befehl `create-certificate-from-csr` verwenden:
```
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"
```
Ausgabe:
```
{
"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"
}
```
Erstellen Sie eine AWS IoT-Richtlinie, die erlaubt `iot` und `greengrass` Maßnahmen ergreift. Der Einfachheit halber erlaubt die folgende Richtlinie Aktionen für alle Ressourcen, Ihre Richtlinie kann jedoch restriktiver sein:
```
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\":[\"*\"]}]}"
```
Ausgabe:
```
{
"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"
}
```
Fügen Sie die Richtlinie dem Zertifikat an:
```
aws iot attach-policy \
--policy-name "GG_Devices" \
--target "arn:aws:iot:us-west-2:123456789012:cert/66a415ec415668c2349a76170b64ac0878231c1e21ec83c10e92a18bd568eb92"
```
Fügen Sie das Objekt dem Zertifikat an:
```
aws iot attach-thing-principal \
--thing-name "InteriorTherm" \
--principal "arn:aws:iot:us-west-2:123456789012:cert/66a415ec415668c2349a76170b64ac0878231c1e21ec83c10e92a18bd568eb92"
```
Nachdem Sie das IoT-Objekt wie oben gezeigt erstellt und konfiguriert haben, verwenden Sie `ThingArn` und `CertificateArn` aus den ersten beiden Befehlen im folgenden Beispiel.
```
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}]}"
```
Ausgabe:
```
{
"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"
}
```
+ Einzelheiten zur API finden Sie [CreateDeviceDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-device-definition.html)in der *AWS CLI Befehlsreferenz*.
### `create-function-definition-version`
Das folgende Codebeispiel zeigt die Verwendung`create-function-definition-version`.
**AWS CLI**
**So erstellen Sie eine Version der Funktionsdefinition**
Im folgenden Beispiel für `create-function-definition-version` wird eine neue Version der angegebenen Funktionsdefinition erstellt. Diese Version gibt eine einzelne Funktion mit der ID `Hello-World-function` an, erlaubt den Zugriff auf das Dateisystem und definiert eine maximale Speichergröße sowie einen Timeout-Zeitraum.
```
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}}]}"
```
Ausgabe:
```
{
"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"
}
```
+ Einzelheiten zur API finden Sie [CreateFunctionDefinitionVersion](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-function-definition-version.html)in der *AWS CLI Befehlsreferenz*.
### `create-function-definition`
Das folgende Codebeispiel zeigt die Verwendung`create-function-definition`.
**AWS CLI**
**So erstellen Sie eine Lambda-Funktionsdefinition**
Im folgenden Beispiel für `create-function-definition` werden eine Lambda-Funktionsdefinition und eine erste Version erstellt, indem eine Liste von Lambda-Funktionen (in diesem Fall eine Liste mit nur einer Funktion namens `TempMonitorFunction`) und deren Konfigurationen bereitstellt werden. Bevor Sie die Funktionsdefinition erstellen können, benötigen Sie den ARN der Lambda-Funktion. Verwenden Sie die Lambda-Befehle `create-function` und `publish-version`, um die Funktion und ihren Alias zu erstellen. Der `create-function` Befehl von Lambda erfordert den ARN der Ausführungsrolle, obwohl AWS IoT Greengrass diese Rolle nicht verwendet, da die Berechtigungen in der Greengrass-Gruppenrolle angegeben sind. Mit dem IAM-Befehl `create-role` können Sie eine leere Rolle erstellen und so einen ARN erhalten, der mit dem Lambda-Befehl `create-function` verwendet werden kann. Alternativ können Sie eine vorhandene Ausführungsrolle verwenden.
```
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}}]}"
```
Ausgabe:
```
{
"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"
}
```
Weitere Informationen finden Sie unter [How to Configure Local Resource Access Using the AWS Command Line Interface](https://docs.aws.amazon.com/greengrass/latest/developerguide/lra-cli.html) im *AWS IoT Greengrass Developer Guide*.
+ Einzelheiten zur API finden Sie unter [CreateFunctionDefinition AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-function-definition.html)*Befehlsreferenz.*
### `create-group-certificate-authority`
Das folgende Codebeispiel zeigt die Verwendung`create-group-certificate-authority`.
**AWS CLI**
**So erstellen Sie eine Zertifizierungsstelle (CA) für eine Gruppe**
Im folgenden Beispiel für `create-group-certificate-authority` wird eine CA für die angegebene Gruppe erstellt oder rotiert.
```
aws greengrass create-group-certificate-authority \
--group-id "8eaadd72-ce4b-4f15-892a-0cc4f3a343f1"
```
Ausgabe:
```
{
"GroupCertificateAuthorityArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/groups/8eaadd72-ce4b-4f15-892a-0cc4f3a343f1/certificateauthorities/d31630d674c4437f6c5dbc0dca56312a902171ce2d086c38e509c8EXAMPLEcc5"
}
```
Weitere Informationen finden Sie unter [Sicherheit in AWS IoT Greengrass](https://docs.aws.amazon.com/greengrass/latest/developerguide/gg-sec.html) im *Entwicklerhandbuch für AWS IoT Greengrass*.
+ Einzelheiten zur API finden Sie [CreateGroupCertificateAuthority](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-group-certificate-authority.html)in der *AWS CLI Befehlsreferenz*.
### `create-group-version`
Das folgende Codebeispiel zeigt die Verwendung`create-group-version`.
**AWS CLI**
**So erstellen Sie eine Version einer Greengrass-Gruppe**
Im folgenden Beispiel für `create-group-version` wird eine Gruppenversion erstellt und mit der angegebenen Gruppe verknüpft. Die Version verweist auf die Kern-, Ressourcen-, Konnektor-, Funktions- und Abonnementversionen, die die in diese Gruppenversion aufzunehmenden Entitäten enthalten. Sie müssen diese Entitäten erstellen, bevor Sie die Gruppenversion erstellen können.
Verwenden Sie den Befehl `create-resource-definition`, um eine Ressourcendefinition mit einer ersten Version zu erstellen. Verwenden Sie den Befehl `create-connector-definition`, um eine Konnektordefinition mit einer ersten Version zu erstellen. Verwenden Sie den Befehl `create-function-definition`, um eine Funktionsdefinition mit einer ersten Version zu erstellen. Verwenden Sie den Befehl `create-subscription-definition`, um eine Abonnementdefinition mit einer ersten Version zu erstellen. Verwenden Sie den Befehl `get-group-version` und geben Sie die ID der neuesten Gruppenversion an, um den ARN der neuesten Kern-Definitionsversion abzurufen.
```
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"
```
Ausgabe:
```
{
"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"
}
```
Weitere Informationen finden Sie unter [Überblick über das AWS IoT Greengrass Group Object Model](https://docs.aws.amazon.com/greengrass/latest/developerguide/deployments.html#api-overview) im *AWS IoT Greengrass Developer Guide*.
+ Einzelheiten zur API finden Sie [CreateGroupVersion](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-group-version.html)in der *AWS CLI Befehlsreferenz*.
### `create-group`
Das folgende Codebeispiel zeigt die Verwendung`create-group`.
**AWS CLI**
**So erstellen Sie eine Greengrass-Gruppe**
Im folgenden Beispiel für `create-group` wird eine Gruppe namens `cli-created-group` erstellt.
```
aws greengrass create-group \
--name cli-created-group
```
Ausgabe:
```
{
"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"
}
```
Weitere Informationen finden Sie unter [Überblick über das AWS IoT Greengrass Group Object Model](https://docs.aws.amazon.com/greengrass/latest/developerguide/deployments.html#api-overview) im *AWS IoT Greengrass Developer Guide*.
+ Einzelheiten zur API finden Sie [CreateGroup](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-group.html)in der *AWS CLI Befehlsreferenz*.
### `create-logger-definition-version`
Das folgende Codebeispiel zeigt die Verwendung`create-logger-definition-version`.
**AWS CLI**
**So erstellen Sie eine Logger-Definitionsversion**
Im folgenden Beispiel für `create-logger-definition-version` wird eine Logger-Definitionsversion erstellt und mit einer Logger-Definition verknüpft. Die Version definiert vier Protokollierungskonfigurationen: 1) Systemkomponentenprotokolle im Dateisystem des Kerngeräts, 2) benutzerdefinierte Lambda-Funktionsprotokolle im Dateisystem des Kerngeräts, 3) Systemkomponentenprotokolle in Amazon CloudWatch Logs und 4) benutzerdefinierte Lambda-Funktionsprotokolle in Amazon Logs. CloudWatch Hinweis: Für die CloudWatch Logs-Integration muss Ihre Gruppenrolle die entsprechenden Berechtigungen gewähren.
```
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\"}]"
```
Ausgabe:
```
{
"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"
}
```
Weitere Informationen finden Sie unter [Monitoring with AWS IoT Greengrass Logs](https://docs.aws.amazon.com/greengrass/latest/developerguide/greengrass-logs-overview.html) im *AWS IoT Greengrass Developer Guide*.
+ Einzelheiten zur API finden Sie [CreateLoggerDefinitionVersion](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-logger-definition-version.html)in der *AWS CLI Befehlsreferenz*.
### `create-logger-definition`
Das folgende Codebeispiel zeigt die Verwendung`create-logger-definition`.
**AWS CLI**
**So erstellen Sie eine Logger-Definition**
Im folgenden Beispiel für `create-logger-definition` wird eine Logger-Definition erstellt, die eine erste Logger-Definitionsversion enthält. Die erste Version definiert drei Protokollierungskonfigurationen: 1) Systemkomponentenprotokolle im Dateisystem des Kerngeräts, 2) benutzerdefinierte Lambda-Funktionsprotokolle im Dateisystem des Kerngeräts und 3) benutzerdefinierte Lambda-Funktionsprotokolle in Amazon Logs. CloudWatch Hinweis: Für die CloudWatch Logs-Integration muss Ihre Gruppenrolle die entsprechenden Berechtigungen gewähren.
```
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\"}]}"
```
Ausgabe:
```
{
"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"
}
```
Weitere Informationen finden Sie unter [Monitoring with AWS IoT Greengrass Logs](https://docs.aws.amazon.com/greengrass/latest/developerguide/greengrass-logs-overview.html) im *AWS IoT Greengrass Developer Guide*.
+ Einzelheiten zur API finden Sie [CreateLoggerDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-logger-definition.html)in der *AWS CLI Befehlsreferenz*.
### `create-resource-definition-version`
Das folgende Codebeispiel zeigt die Verwendung`create-resource-definition-version`.
**AWS CLI**
**So erstellen Sie eine Version einer Ressourcendefinition**
Das folgende `create-resource-definition-version` Beispiel erstellt eine neue Version von TwilioAuthToken a.
```
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\"}}}]"
```
Ausgabe:
```
{
"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"
}
```
+ Einzelheiten zur API finden Sie [CreateResourceDefinitionVersion](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-resource-definition-version.html)in der *AWS CLI Befehlsreferenz*.
### `create-resource-definition`
Das folgende Codebeispiel zeigt die Verwendung`create-resource-definition`.
**AWS CLI**
**So erstellen Sie eine Ressourcendefinition**
Im folgenden Beispiel für `create-resource-definition` wird eine Ressourcendefinition erstellt, die eine Liste der in einer Greengrass-Gruppe zu verwendenden Ressourcen enthält. In diesem Beispiel wird eine erste Version der Ressourcendefinition bereitgestellt, indem eine Liste von Ressourcen angegeben wird. Die Liste enthält eine Ressource für ein Twilio-Autorisierungstoken und den ARN für ein in AWS Secrets Manager gespeichertes Geheimnis. Sie müssen das Secret erstellen, bevor Sie die Ressourcendefinition erstellen können.
```
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\"}}}]}"
```
Ausgabe:
```
{
"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"
}
```
Weitere Informationen finden Sie unter [How to Configure Local Resource Access Using the AWS Command Line Interface](https://docs.aws.amazon.com/greengrass/latest/developerguide/lra-cli.html) im *AWS IoT Greengrass Developer Guide*.
+ Einzelheiten zur API finden Sie unter [CreateResourceDefinition AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-resource-definition.html)*Befehlsreferenz.*
### `create-software-update-job`
Das folgende Codebeispiel zeigt die Verwendung`create-software-update-job`.
**AWS CLI**
**So erstellen Sie einen Software-Aktualisierungsauftrag für einen Kern**
Im folgenden `create-software-update-job` Beispiel wird ein over-the-air (OTA-) Aktualisierungsauftrag erstellt, um die AWS IoT Greengrass Core-Software auf dem Core zu aktualisieren, dessen Name lautet`MyFirstGroup_Core`. Dieser Befehl erfordert eine IAM-Rolle, die Zugriff auf Softwareupdatepakete in Amazon S3 gewährt und `iot.amazonaws.com` als vertrauenswürdige Entität einschließt.
```
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
```
Ausgabe:
```
{
"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"
}
```
Weitere Informationen finden Sie unter [OTA-Updates der AWS IoT Greengrass Core Software](https://docs.aws.amazon.com/greengrass/latest/developerguide/core-ota-update.html) im *AWS IoT Greengrass Developer Guide*.
+ Einzelheiten zur API finden Sie [CreateSoftwareUpdateJob](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-software-update-job.html)in der *AWS CLI Befehlsreferenz*.
### `create-subscription-definition-version`
Das folgende Codebeispiel zeigt die Verwendung`create-subscription-definition-version`.
**AWS CLI**
**So erstellen Sie eine neue Version einer Abonnementdefinition**
Im folgenden Beispiel für `create-subscription-definition-version` wird eine neue Version einer Abonnementdefinition erstellt, die drei Abonnements enthält: eine Trigger-Benachrichtigung, eine Temperatureingabe und einen Ausgabestatus.
```
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\"}]"
```
Ausgabe:
```
{
"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"
}
```
+ Einzelheiten zur API finden Sie [CreateSubscriptionDefinitionVersion](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-subscription-definition-version.html)in der *AWS CLI Befehlsreferenz*.
### `create-subscription-definition`
Das folgende Codebeispiel zeigt die Verwendung`create-subscription-definition`.
**AWS CLI**
**So erstellen Sie eine Abonnementdefinition**
Im folgenden Beispiel für `create-subscription-definition` wird eine Abonnementdefinition erstellt und ihre erste Version angegeben. Die erste Version enthält drei Abonnements: eines für das MQTT-Thema, das der Connector abonniert, eines, das es einer Funktion ermöglicht, Temperaturwerte vom AWS IoT zu empfangen, und eines, das es AWS IoT ermöglicht, Statusinformationen vom Connector zu empfangen. In dem Beispiel wird der ARN für den Lambda-Funktionsalias bereitgestellt, der zuvor mithilfe des Lambda-Befehls `create-alias` erstellt wurde.
```
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\"}]}"
```
Ausgabe:
```
{
"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"
}
```
Weitere Informationen finden Sie unter [Erste Schritte mit Konnektoren (CLI)](https://docs.aws.amazon.com/greengrass/latest/developerguide/connectors-cli.html) im *Entwicklerhandbuch für AWS IoT Greengrass*.
+ Einzelheiten zur API finden Sie [CreateSubscriptionDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/create-subscription-definition.html)in der *AWS CLI Befehlsreferenz*.
### `delete-connector-definition`
Das folgende Codebeispiel zeigt die Verwendung`delete-connector-definition`.
**AWS CLI**
**So löschen Sie eine Konnektordefinition**
Im folgenden Beispiel für `delete-connector-definition` wird die angegebene Greengrass-Konnektordefinition gelöscht. Wenn Sie eine Konnektordefinition löschen, die von einer Gruppe verwendet wird, kann diese Gruppe nicht erfolgreich bereitgestellt werden.
```
aws greengrass delete-connector-definition \
--connector-definition-id "b5c4ebfd-f672-49a3-83cd-31c7216a7bb8"
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben.
+ Einzelheiten zur API finden Sie [DeleteConnectorDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/delete-connector-definition.html)in der *AWS CLI Befehlsreferenz*.
### `delete-core-definition`
Das folgende Codebeispiel zeigt die Verwendung`delete-core-definition`.
**AWS CLI**
**So löschen Sie eine Kerndefinition**
Im folgenden Beispiel für `delete-core-definition` wird die angegebene Greengrass-Kerndefinition einschließlich aller Versionen gelöscht. Wenn Sie einen Kern löschen, der mit einer Greengrass-Gruppe verknüpft ist, kann diese Gruppe nicht erfolgreich bereitgestellt werden.
```
aws greengrass delete-core-definition \
--core-definition-id "ff36cc5f-9f98-4994-b468-9d9b6dc52abd"
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben.
+ Einzelheiten zur API finden Sie [DeleteCoreDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/delete-core-definition.html)in der *AWS CLI Befehlsreferenz*.
### `delete-device-definition`
Das folgende Codebeispiel zeigt die Verwendung`delete-device-definition`.
**AWS CLI**
**So löschen Sie eine Gerätedefinition**
Im folgenden Beispiel für `delete-device-definition` wird die angegebene Gerätedefinition einschließlich all ihrer Versionen gelöscht. Wenn Sie eine Gerätedefinitionsversion löschen, die von einer Gruppenversion verwendet wird, kann die Gruppenversion nicht erfolgreich bereitgestellt werden.
```
aws greengrass delete-device-definition \
--device-definition-id "f9ba083d-5ad4-4534-9f86-026a45df1ccd"
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben.
+ Einzelheiten zur API finden Sie [DeleteDeviceDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/delete-device-definition.html)in der *AWS CLI Befehlsreferenz*.
### `delete-function-definition`
Das folgende Codebeispiel zeigt die Verwendung`delete-function-definition`.
**AWS CLI**
**So löschen Sie eine Funktionsdefinition**
Im folgenden Beispiel für `delete-function-definition` wird die angegebene Greengrass-Funktionsdefinition gelöscht. Wenn Sie eine Funktionsdefinition löschen, die von einer Gruppe verwendet wird, kann diese Gruppe nicht erfolgreich bereitgestellt werden.
```
aws greengrass delete-function-definition \
--function-definition-id "fd4b906a-dff3-4c1b-96eb-52ebfcfac06a"
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben.
+ Einzelheiten zur API finden Sie [DeleteFunctionDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/delete-function-definition.html)in der *AWS CLI Befehlsreferenz*.
### `delete-group`
Das folgende Codebeispiel zeigt die Verwendung`delete-group`.
**AWS CLI**
**Um eine Gruppe zu löschen**
Im folgenden Beispiel für `delete-group` wird die angegebene Greengrass-Gruppe gelöscht.
```
aws greengrass delete-group \
--group-id "4e22bd92-898c-436b-ade5-434d883ff749"
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben.
+ Einzelheiten zur API finden Sie [DeleteGroup](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/delete-group.html)in der *AWS CLI Befehlsreferenz*.
### `delete-logger-definition`
Das folgende Codebeispiel zeigt die Verwendung`delete-logger-definition`.
**AWS CLI**
**So löschen Sie eine Logger-Definition**
Im folgenden Beispiel für `delete-logger-definition` wird die angegebene Logger-Definition einschließlich aller Logger-Definitionsversionen gelöscht. Wenn Sie eine Logger-Definitionsversion löschen, die von einer Gruppenversion verwendet wird, kann die Gruppenversion nicht erfolgreich bereitgestellt werden.
```
aws greengrass delete-logger-definition \
--logger-definition-id "a454b62a-5d56-4ca9-bdc4-8254e1662cb0"
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben.
Weitere Informationen finden Sie unter [Monitoring with AWS IoT Greengrass Logs](https://docs.aws.amazon.com/greengrass/latest/developerguide/greengrass-logs-overview.html) im *AWS IoT Greengrass Developer Guide*.
+ Einzelheiten zur API finden Sie [DeleteLoggerDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/delete-logger-definition.html)in der *AWS CLI Befehlsreferenz*.
### `delete-resource-definition`
Das folgende Codebeispiel zeigt die Verwendung`delete-resource-definition`.
**AWS CLI**
**So löschen Sie eine Ressourcendefinition**
Im folgenden Beispiel für `delete-resource-definition` wird die angegebene Ressourcendefinition einschließlich aller Ressourcenversionen gelöscht. Wenn Sie eine Ressourcendefinition löschen, die von einer Gruppe verwendet wird, kann diese Gruppe nicht erfolgreich bereitgestellt werden.
```
aws greengrass delete-resource-definition \
--resource-definition-id "ad8c101d-8109-4b0e-b97d-9cc5802ab658"
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben.
+ Einzelheiten zur API finden Sie [DeleteResourceDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/delete-resource-definition.html)in der *AWS CLI Befehlsreferenz*.
### `delete-subscription-definition`
Das folgende Codebeispiel zeigt die Verwendung`delete-subscription-definition`.
**AWS CLI**
**So löschen Sie eine Abonnementdefinition**
Im folgenden Beispiel für `delete-subscription-definition` wird die angegebene Greengrass-Abonnementdefinition gelöscht. Wenn Sie ein Abonnement löschen, das von einer Gruppe verwendet wird, kann diese Gruppe nicht erfolgreich bereitgestellt werden.
```
aws greengrass delete-subscription-definition \
--subscription-definition-id "cd6f1c37-d9a4-4e90-be94-01a7404f5967"
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben.
+ Einzelheiten zur API finden Sie [DeleteSubscriptionDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/delete-subscription-definition.html)in der *AWS CLI Befehlsreferenz*.
### `disassociate-role-from-group`
Das folgende Codebeispiel zeigt die Verwendung`disassociate-role-from-group`.
**AWS CLI**
**So heben Sie die Verknüpfung der Rolle mit einer Greengrass-Gruppe auf**
Im folgenden Beispiel für `disassociate-role-from-group` wird die Verknüpfung der IAM-Rolle mit einer angegebenen Greengrass-Gruppe aufgehoben.
```
aws greengrass disassociate-role-from-group \
--group-id 2494ee3f-7f8a-4e92-a78b-d205f808b84b
```
Ausgabe:
```
{
"DisassociatedAt": "2019-09-10T20:05:49Z"
}
```
Weitere Informationen finden Sie unter [Konfigurieren der Gruppenrolle](https://docs.aws.amazon.com/greengrass/latest/developerguide/config-iam-roles.html) im *Entwicklerhandbuch für AWS IoT Greengrass*.
+ Einzelheiten zur API finden Sie [DisassociateRoleFromGroup](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/disassociate-role-from-group.html)in der *AWS CLI Befehlsreferenz*.
### `disassociate-service-role-from-account`
Das folgende Codebeispiel zeigt die Verwendung`disassociate-service-role-from-account`.
**AWS CLI**
**Um eine Servicerolle von Ihrem AWS Konto zu trennen**
Im folgenden `disassociate-service-role-from-account` Beispiel wird die Ihrem AWS Konto zugeordnete Servicerolle entfernt. Wenn Sie die Servicerolle in keiner AWS Region verwenden, verwenden Sie den `delete-role-policy` Befehl, um die `AWSGreengrassResourceAccessRolePolicy` verwaltete Richtlinie von der Rolle zu trennen, und verwenden Sie dann den `delete-role` Befehl, um die Rolle zu löschen.
```
aws greengrass disassociate-service-role-from-account
```
Ausgabe:
```
{
"DisassociatedAt": "2019-06-25T22:12:55Z"
}
```
Weitere Informationen finden Sie unter [Greengrass-Servicerolle](https://docs.aws.amazon.com/greengrass/latest/developerguide/service-role.html) im **Entwicklerhandbuch für AWS IoT Greengrass**.
+ Einzelheiten zur API finden Sie [DisassociateServiceRoleFromAccount](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/disassociate-service-role-from-account.html)in der *AWS CLI Befehlsreferenz.*
### `get-associated-role`
Das folgende Codebeispiel zeigt die Verwendung`get-associated-role`.
**AWS CLI**
**So rufen Sie die mit einer Greengrass-Gruppe verknüpfte Rolle ab**
Im folgenden Beispiel für `get-associated-role` wird die IAM-Rolle abgerufen, die mit der angegebenen Greengrass-Gruppe verknüpft ist. Die Gruppenrolle wird von lokalen Lambda-Funktionen und Konnektoren für den Zugriff auf AWS Dienste verwendet.
```
aws greengrass get-associated-role \
--group-id 2494ee3f-7f8a-4e92-a78b-d205f808b84b
```
Ausgabe:
```
{
"RoleArn": "arn:aws:iam::123456789012:role/GG-Group-Role",
"AssociatedAt": "2019-09-10T20:03:30Z"
}
```
Weitere Informationen finden Sie unter [Konfigurieren der Gruppenrolle](https://docs.aws.amazon.com/greengrass/latest/developerguide/config-iam-roles.html) im *Entwicklerhandbuch für AWS IoT Greengrass*.
+ Einzelheiten zur API finden Sie [GetAssociatedRole](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-associated-role.html)in der *AWS CLI Befehlsreferenz.*
### `get-bulk-deployment-status`
Das folgende Codebeispiel zeigt die Verwendung`get-bulk-deployment-status`.
**AWS CLI**
**So überprüfen Sie den Status Ihrer Sammelbereitstellung**
Im folgenden Beispiel für `get-bulk-deployment-status` werden Statusinformationen für die angegebene Sammelbereitstellungsoperation abgerufen. In diesem Beispiel weist die Datei, in der die bereitzustellenden Gruppen angegeben wurden, einen ungültigen Eingabedatensatz auf.
```
aws greengrass get-bulk-deployment-status \
--bulk-deployment-id "870fb41b-6288-4e0c-bc76-a7ba4b4d3267"
```
Ausgabe:
```
{
"BulkDeploymentMetrics": {
"InvalidInputRecords": 1,
"RecordsProcessed": 1,
"RetryAttempts": 0
},
"BulkDeploymentStatus": "Completed",
"CreatedAt": "2019-06-25T16:11:33.265Z",
"tags": {}
}
```
Weitere Informationen finden Sie unter [Erstellen von Sammelbereitstellungen für Gruppen](https://docs.aws.amazon.com/greengrass/latest/developerguide/bulk-deploy-cli.html) im *Entwicklerhandbuch für AWS IoT Greengrass*.
+ Einzelheiten zur API finden Sie [GetBulkDeploymentStatus](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-bulk-deployment-status.html)in der *AWS CLI Befehlsreferenz*.
### `get-connectivity-info`
Das folgende Codebeispiel zeigt die Verwendung`get-connectivity-info`.
**AWS CLI**
**So rufen Sie die Verbindungsinformationen für einen Greengrass-Kern ab**
Im folgenden Beispiel für `get-connectivity-info` werden die Endpunkte angezeigt, über die Geräte eine Verbindung zum angegebenen Greengrass-Kern herstellen können. Bei den Verbindungsinformationen handelt es sich um eine Liste von IP-Adressen oder Domainnamen mit den entsprechenden Portnummern und optionalen, vom Kunden definierten Metadaten.
```
aws greengrass get-connectivity-info \
--thing-name "MyGroup_Core"
```
Ausgabe:
```
{
"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"
}
]
}
```
+ Einzelheiten zur API finden Sie [GetConnectivityInfo](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-connectivity-info.html)in der *AWS CLI Befehlsreferenz*.
### `get-connector-definition-version`
Das folgende Codebeispiel zeigt die Verwendung`get-connector-definition-version`.
**AWS CLI**
**Um Informationen über eine bestimmte Version einer Connectordefinition abzurufen**
Im folgenden Beispiel für `get-connector-definition-version` werden Informationen zur angegebenen Version der angegebenen Konnektordefinition abgerufen. Verwenden Sie den `list-connector-definition-versions` Befehl, um die IDs aller Versionen der Konnektordefinition abzurufen. Verwenden Sie den Befehl `get-connector-definition` und überprüfen Sie die Eigenschaft `LatestVersion`, um die ID der letzten Version abzurufen, die der Konnektordefinition hinzugefügt wurde.
```
aws greengrass get-connector-definition-version \
--connector-definition-id "b5c4ebfd-f672-49a3-83cd-31c7216a7bb8" \
--connector-definition-version-id "63c57963-c7c2-4a26-a7e2-7bf478ea2623"
```
Ausgabe:
```
{
"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"
}
```
Weitere Informationen finden Sie unter [Integration mit Services und Protokollen mithilfe von Greengrass-Konnektoren](https://docs.aws.amazon.com/greengrass/latest/developerguide/connectors.html) im **Entwicklerhandbuch für AWS IoT Greengrass**.
+ Einzelheiten zur API finden Sie [GetConnectorDefinitionVersion](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-connector-definition-version.html)unter *AWS CLI Befehlsreferenz*.
### `get-connector-definition`
Das folgende Codebeispiel zeigt die Verwendung`get-connector-definition`.
**AWS CLI**
**So rufen Sie Informationen zu einer Konnektordefinition ab**
Im folgenden Beispiel für `get-connector-definition` werden Informationen zur angegebenen Konnektordefinition abgerufen. Verwenden Sie den IDs `list-connector-definitions` Befehl, um Ihre Connector-Definitionen abzurufen.
```
aws greengrass get-connector-definition \
--connector-definition-id "b5c4ebfd-f672-49a3-83cd-31c7216a7bb8"
```
Ausgabe:
```
{
"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": {}
}
```
Weitere Informationen finden Sie unter [Integration mit Services und Protokollen mithilfe von Greengrass-Konnektoren](https://docs.aws.amazon.com/greengrass/latest/developerguide/connectors.html) im **Entwicklerhandbuch für AWS IoT Greengrass**.
+ Einzelheiten zur API finden Sie [GetConnectorDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-connector-definition.html)in der *AWS CLI Befehlsreferenz*.
### `get-core-definition-version`
Das folgende Codebeispiel zeigt die Verwendung`get-core-definition-version`.
**AWS CLI**
**So rufen Sie Details zu einer bestimmten Version der Greengrass-Kerndefinition ab**
Im folgenden Beispiel für `get-core-definition-version` werden Informationen zur angegebenen Version der angegebenen Kerndefinition abgerufen. Verwenden Sie den `list-core-definition-versions` Befehl, um die IDs aller Versionen der Kerndefinition abzurufen. Verwenden Sie den Befehl `get-core-definition` und überprüfen Sie die Eigenschaft `LatestVersion`, um die ID der letzten Version abzurufen, die der Kerndefinition hinzugefügt wurde.
```
aws greengrass get-core-definition-version \
--core-definition-id "c906ed39-a1e3-4822-a981-7b9bd57b4b46" \
--core-definition-version-id "42aeeac3-fd9d-4312-a8fd-ffa9404a20e0"
```
Ausgabe:
```
{
"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"
}
```
+ Einzelheiten zur API finden Sie [GetCoreDefinitionVersion](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-core-definition-version.html)in der *AWS CLI Befehlsreferenz*.
### `get-core-definition`
Das folgende Codebeispiel zeigt die Verwendung`get-core-definition`.
**AWS CLI**
**So rufen Sie Details für eine Greengrass-Kerndefinition ab**
Im folgenden Beispiel für `get-core-definition` werden Informationen zur angegebenen Kerndefinition abgerufen. Verwenden Sie den IDs `list-core-definitions` Befehl, um Ihre Kerndefinitionen abzurufen.
```
aws greengrass get-core-definition \
--core-definition-id "c906ed39-a1e3-4822-a981-7b9bd57b4b46"
```
Ausgabe:
```
{
"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": {}
}
```
+ Einzelheiten zur API finden Sie [GetCoreDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-core-definition.html)in der *AWS CLI Befehlsreferenz*.
### `get-deployment-status`
Das folgende Codebeispiel zeigt die Verwendung`get-deployment-status`.
**AWS CLI**
**So rufen Sie den Status einer Bereitstellung ab**
Im folgenden Beispiel für `get-deployment-status` wird der Status für die angegebene Bereitstellung der angegebenen Greengrass-Gruppe abgerufen. Verwenden Sie den Befehl `list-deployments` und geben Sie die Gruppen-ID an, um die Bereitstellungs-ID abzurufen.
```
aws greengrass get-deployment-status \
--group-id "1013db12-8b58-45ff-acc7-704248f66731" \
--deployment-id "1065b8a0-812b-4f21-9d5d-e89b232a530f"
```
Ausgabe:
```
{
"DeploymentStatus": "Success",
"DeploymentType": "NewDeployment",
"UpdatedAt": "2019-06-18T17:04:44.761Z"
}
```
+ Einzelheiten zur API finden Sie [GetDeploymentStatus](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-deployment-status.html)in der *AWS CLI Befehlsreferenz*.
### `get-device-definition-version`
Das folgende Codebeispiel zeigt die Verwendung`get-device-definition-version`.
**AWS CLI**
**So rufen Sie eine Geräte-Definitionsversion ab**
Im folgenden Beispiel für `get-device-definition-version` werden Informationen zur angegebenen Version der angegebenen Gerätedefinition abgerufen. Verwenden Sie den `list-device-definition-versions` Befehl, um die IDs aller Versionen der Gerätedefinition abzurufen. Verwenden Sie den Befehl `get-device-definition` und überprüfen Sie die Eigenschaft `LatestVersion`, um die ID der letzten Version abzurufen, die der Gerätedefinition hinzugefügt wurde.
```
aws greengrass get-device-definition-version \
--device-definition-id "f9ba083d-5ad4-4534-9f86-026a45df1ccd" \
--device-definition-version-id "83c13984-6fed-447e-84d5-5b8aa45d5f71"
```
Ausgabe:
```
{
"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"
}
```
+ Einzelheiten zur API finden Sie [GetDeviceDefinitionVersion](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-device-definition-version.html)in der *AWS CLI Befehlsreferenz*.
### `get-device-definition`
Das folgende Codebeispiel zeigt die Verwendung`get-device-definition`.
**AWS CLI**
**So rufen Sie eine Gerätedefinition ab**
Im folgenden Beispiel für `get-device-definition` werden Informationen zur angegebenen Gerätedefinition abgerufen. Verwenden Sie den IDs `list-device-definitions` Befehl, um Ihre Gerätedefinitionen abzurufen.
```
aws greengrass get-device-definition \
--device-definition-id "f9ba083d-5ad4-4534-9f86-026a45df1ccd"
```
Ausgabe:
```
{
"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"
}
```
+ Einzelheiten zur API finden Sie [GetDeviceDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-device-definition.html)in der *AWS CLI Befehlsreferenz*.
### `get-function-definition-version`
Das folgende Codebeispiel zeigt die Verwendung`get-function-definition-version`.
**AWS CLI**
**So rufen Sie Details zu einer bestimmten Version einer Lambda-Funktion ab**
Im folgenden Beispiel für `get-function-definition-version` werden Informationen zur angegebenen Version der angegebenen Funktionsdefinition abgerufen. Verwenden Sie den `list-function-definition-versions` Befehl, um die IDs aller Versionen der Funktionsdefinition abzurufen. Verwenden Sie den Befehl `get-function-definition` und überprüfen Sie die Eigenschaft `LatestVersion`, um die ID der letzten Version abzurufen, die der Funktionsdefinition hinzugefügt wurde.
```
aws greengrass get-function-definition-version \
--function-definition-id "063f5d1a-1dd1-40b4-9b51-56f8993d0f85" \
--function-definition-version-id "9748fda7-1589-4fcc-ac94-f5559e88678b"
```
Ausgabe:
```
{
"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"
}
```
+ Einzelheiten zur API finden Sie [GetFunctionDefinitionVersion](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-function-definition-version.html)in der *AWS CLI Befehlsreferenz*.
### `get-function-definition`
Das folgende Codebeispiel zeigt die Verwendung`get-function-definition`.
**AWS CLI**
**So rufen Sie eine Funktionsdefinition ab**
Im folgenden Beispiel für `get-function-definition` werden Details für die angegebene Funktionsdefinition angezeigt. Verwenden Sie den IDs `list-function-definitions` Befehl, um Ihre Funktionsdefinitionen abzurufen.
```
aws greengrass get-function-definition \
--function-definition-id "063f5d1a-1dd1-40b4-9b51-56f8993d0f85"
```
Ausgabe:
```
{
"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": {}
}
```
+ Einzelheiten zur API finden Sie [GetFunctionDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-function-definition.html)in der *AWS CLI Befehlsreferenz*.
### `get-group-certificate-authority`
Das folgende Codebeispiel zeigt die Verwendung`get-group-certificate-authority`.
**AWS CLI**
**So rufen Sie die mit einer Greengrass-Gruppe verknüpfte CA ab**
Im folgenden Beispiel für `get-group-certificate-authority` wird die Zertifizierungsstelle (CA) abgerufen, die mit der angegebenen Greengrass-Gruppe verknüpft ist. Verwenden Sie den Befehl `list-group-certificate-authorities` und geben Sie die Gruppen-ID an, um die Zertifizierungsstellen-ID abzurufen.
```
aws greengrass get-group-certificate-authority \
--group-id "1013db12-8b58-45ff-acc7-704248f66731" \
--certificate-authority-id "f0430e1736ea8ed30cc5d5de9af67a7e3586bad9ae4d89c2a44163f65fdd8cf6"
```
Ausgabe:
```
{
"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"
}
```
+ Einzelheiten zur API finden Sie [GetGroupCertificateAuthority](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-group-certificate-authority.html)in der *AWS CLI Befehlsreferenz*.
### `get-group-certificate-configuration`
Das folgende Codebeispiel zeigt die Verwendung`get-group-certificate-configuration`.
**AWS CLI**
**So rufen Sie die Konfiguration für die von der Greengrass-Gruppe verwendete Zertifizierungsstelle ab**
Im folgenden Beispiel für `get-group-certificate-configuration` wird die Konfiguration für die Zertifizierungsstelle (CA) abgerufen, die von der angegebenen Greengrass-Gruppe verwendet wird.
```
aws greengrass get-group-certificate-configuration \
--group-id "1013db12-8b58-45ff-acc7-704248f66731"
```
Ausgabe:
```
{
"CertificateAuthorityExpiryInMilliseconds": 2524607999000,
"CertificateExpiryInMilliseconds": 604800000,
"GroupId": "1013db12-8b58-45ff-acc7-704248f66731"
}
```
+ Einzelheiten zur API finden Sie [GetGroupCertificateConfiguration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-group-certificate-configuration.html)in der *AWS CLI Befehlsreferenz*.
### `get-group-version`
Das folgende Codebeispiel zeigt die Verwendung`get-group-version`.
**AWS CLI**
**So rufen Sie Informationen zur Version einer Greengrass-Gruppe ab**
Im folgenden Beispiel für `get-group-version` werden Informationen zur angegebenen Version der angegebenen Gruppe abgerufen. Verwenden Sie den `list-group-versions` Befehl, um die IDs aller Versionen der Gruppe abzurufen. Verwenden Sie den Befehl `get-group` und überprüfen Sie die Eigenschaft `LatestVersion`, um die ID der letzten Version abzurufen, die der Gruppe hinzugefügt wurde.
```
aws greengrass get-group-version \
--group-id "1013db12-8b58-45ff-acc7-704248f66731" \
--group-version-id "115136b3-cfd7-4462-b77f-8741a4b00e5e"
```
Ausgabe:
```
{
"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"
}
```
+ Einzelheiten zur API finden Sie [GetGroupVersion](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-group-version.html)in der *AWS CLI Befehlsreferenz*.
### `get-group`
Das folgende Codebeispiel zeigt die Verwendung`get-group`.
**AWS CLI**
**So rufen Sie Informationen zu einer Greengrass-Gruppe ab**
Das folgende Beispiel für `get-group` ruft Informationen zur angegebenen Greengrass-Gruppe ab. Verwenden Sie den IDs `list-groups` Befehl, um die Ihrer Gruppen abzurufen.
```
aws greengrass get-group \
--group-id "1013db12-8b58-45ff-acc7-704248f66731"
```
Ausgabe:
```
{
"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": {}
}
```
+ Einzelheiten zur API finden Sie [GetGroup](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-group.html)in der *AWS CLI Befehlsreferenz*.
### `get-logger-definition-version`
Das folgende Codebeispiel zeigt die Verwendung`get-logger-definition-version`.
**AWS CLI**
**So rufen Sie Informationen zu einer Version einer Logger-Definition ab**
Im folgenden Beispiel für `get-logger-definition-version` werden Informationen zur angegebenen Version der angegebenen Logger-Definition abgerufen. Verwenden Sie den `list-logger-definition-versions` Befehl, um die IDs aller Versionen der Logger-Definition abzurufen. Verwenden Sie den Befehl `get-logger-definition` und überprüfen Sie die Eigenschaft `LatestVersion`, um die ID der letzten Version abzurufen, die der Logger-Definition hinzugefügt wurde.
```
aws greengrass get-logger-definition-version \
--logger-definition-id "49eeeb66-f1d3-4e34-86e3-3617262abf23" \
--logger-definition-version-id "5e3f6f64-a565-491e-8de0-3c0d8e0f2073"
```
Ausgabe:
```
{
"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"
}
```
+ Einzelheiten zur API finden Sie [GetLoggerDefinitionVersion](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-logger-definition-version.html)in der *AWS CLI Befehlsreferenz*.
### `get-logger-definition`
Das folgende Codebeispiel zeigt die Verwendung`get-logger-definition`.
**AWS CLI**
**So rufen Sie Informationen zu einer Logger-Definition ab**
Im folgenden Beispiel für `get-logger-definition` werden Informationen zur angegebenen Logger-Definition abgerufen. Verwenden Sie den IDs `list-logger-definitions` Befehl, um Ihre Logger-Definitionen abzurufen.
```
aws greengrass get-logger-definition \
--logger-definition-id "49eeeb66-f1d3-4e34-86e3-3617262abf23"
```
Ausgabe:
```
{
"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": {}
}
```
+ Einzelheiten zur API finden Sie [GetLoggerDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-logger-definition.html)in der *AWS CLI Befehlsreferenz*.
### `get-resource-definition-version`
Das folgende Codebeispiel zeigt die Verwendung`get-resource-definition-version`.
**AWS CLI**
**So rufen Sie Informationen zu einer bestimmten Version einer Ressourcendefinition ab**
Im folgenden Beispiel für `get-resource-definition-version` werden Informationen zur angegebenen Version der angegebenen Ressourcendefinition abgerufen. Verwenden Sie den `list-resource-definition-versions` Befehl, um die IDs aller Versionen der Ressourcendefinition abzurufen. Verwenden Sie den Befehl `get-resource-definition` und überprüfen Sie die Eigenschaft `LatestVersion`, um die ID der letzten Version abzurufen, die der Ressourcendefinition hinzugefügt wurde.
```
aws greengrass get-resource-definition-version \
--resource-definition-id "ad8c101d-8109-4b0e-b97d-9cc5802ab658" \
--resource-definition-version-id "26e8829a-491a-464d-9c87-664bf6f6f2be"
```
Ausgabe:
```
{
"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"
}
```
+ Einzelheiten zur API finden Sie [GetResourceDefinitionVersion](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-resource-definition-version.html)unter *AWS CLI Befehlsreferenz*.
### `get-resource-definition`
Das folgende Codebeispiel zeigt die Verwendung`get-resource-definition`.
**AWS CLI**
**So rufen Sie Informationen zu einer Ressourcendefinition ab**
Im folgenden Beispiel für `get-resource-definition` werden Informationen zur angegebenen Ressourcendefinition abgerufen. Verwenden Sie den IDs `list-resource-definitions` Befehl, um Ihre Ressourcendefinitionen abzurufen.
```
aws greengrass get-resource-definition \
--resource-definition-id "ad8c101d-8109-4b0e-b97d-9cc5802ab658"
```
Ausgabe:
```
{
"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": {}
}
```
+ Einzelheiten zur API finden Sie [GetResourceDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-resource-definition.html)in der *AWS CLI Befehlsreferenz*.
### `get-service-role-for-account`
Das folgende Codebeispiel zeigt die Verwendung`get-service-role-for-account`.
**AWS CLI**
**So rufen Sie die Details für die Servicerolle ab, die mit Ihrem Konto verknüpft ist**
Im folgenden `get-service-role-for-account` Beispiel werden Informationen über die Servicerolle abgerufen, die Ihrem AWS Konto zugeordnet ist.
```
aws greengrass get-service-role-for-account
```
Ausgabe:
```
{
"AssociatedAt": "2018-10-18T15:59:20Z",
"RoleArn": "arn:aws:iam::123456789012:role/service-role/Greengrass_ServiceRole"
}
```
Weitere Informationen finden Sie unter [Greengrass-Servicerolle](https://docs.aws.amazon.com/greengrass/latest/developerguide/service-role.html) im **Entwicklerhandbuch für AWS IoT Greengrass**.
+ Einzelheiten zur API finden Sie unter [GetServiceRoleForAccount AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-service-role-for-account.html)*Befehlsreferenz.*
### `get-subscription-definition-version`
Das folgende Codebeispiel zeigt die Verwendung`get-subscription-definition-version`.
**AWS CLI**
**So rufen Sie Informationen zu einer bestimmten Version einer Abonnementdefinition ab**
Im folgenden Beispiel für `get-subscription-definition-version` werden Informationen zur angegebenen Version der angegebenen Abonnementdefinition abgerufen. Verwenden Sie den `list-subscription-definition-versions` Befehl, um die IDs aller Versionen der Abonnementdefinition abzurufen. Verwenden Sie den Befehl `get-subscription-definition` und überprüfen Sie die Eigenschaft `LatestVersion`, um die ID der letzten Version abzurufen, die der Abonnementdefinition hinzugefügt wurde.
```
aws greengrass get-subscription-definition-version \
--subscription-definition-id "70e49321-83d5-45d2-bc09-81f4917ae152" \
--subscription-definition-version-id "88ae8699-12ac-4663-ba3f-4d7f0519140b"
```
Ausgabe:
```
{
"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"
}
```
+ Einzelheiten zur API finden Sie [GetSubscriptionDefinitionVersion](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-subscription-definition-version.html)in der *AWS CLI Befehlsreferenz*.
### `get-subscription-definition`
Das folgende Codebeispiel zeigt die Verwendung`get-subscription-definition`.
**AWS CLI**
**So rufen Sie Informationen zu einer Abonnementdefinition ab**
Im folgenden Beispiel für `get-subscription-definition` werden Informationen zur angegebenen Abonnementdefinition abgerufen. Verwenden Sie den IDs `list-subscription-definitions` Befehl, um Ihre Abonnementdefinitionen abzurufen.
```
aws greengrass get-subscription-definition \
--subscription-definition-id "70e49321-83d5-45d2-bc09-81f4917ae152"
```
Ausgabe:
```
{
"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": {}
}
```
+ Einzelheiten zur API finden Sie [GetSubscriptionDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-subscription-definition.html)in der *AWS CLI Befehlsreferenz*.
### `get-thing-runtime-configuration`
Das folgende Codebeispiel zeigt die Verwendung`get-thing-runtime-configuration`.
**AWS CLI**
**So rufen Sie die Laufzeitkonfiguration eines Greengrass-Kerns ab**
Im folgenden Beispiel für `get-thing-runtime-configuration` wird die Laufzeitkonfiguration eines Greengrass-Kerns abgerufen. Bevor Sie die Laufzeitkonfiguration abrufen können, müssen Sie den Befehl `update-thing-runtime-configuration` verwenden, um eine Laufzeitkonfiguration für den Kern zu erstellen.
```
aws greengrass get-thing-runtime-configuration \
--thing-name SampleGreengrassCore
```
Ausgabe:
```
{
"RuntimeConfiguration": {
"TelemetryConfiguration": {
"ConfigurationSyncStatus": "OutOfSync",
"Telemetry": "On"
}
}
}
```
Weitere Informationen finden Sie unter [Konfigurieren der Telemetrieeinstellungen](https://docs.aws.amazon.com/greengrass/latest/developerguide/telemetry.html#configure-telemetry-settings) im *Entwicklerhandbuch für AWS IoT Greengrass*.
+ Einzelheiten zur API finden Sie [GetThingRuntimeConfiguration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/get-thing-runtime-configuration.html)in der *AWS CLI Befehlsreferenz*.
### `list-bulk-deployment-detailed-reports`
Das folgende Codebeispiel zeigt die Verwendung`list-bulk-deployment-detailed-reports`.
**AWS CLI**
**So listen Sie Informationen zu einzelnen Bereitstellungen in einer Sammelbereitstellung auf**
Im folgenden Beispiel für `list-bulk-deployment-detailed-reports` werden Informationen zu den einzelnen Bereitstellungen in einer Sammelbereitstellungsoperation angezeigt, einschließlich des Status.
```
aws greengrass list-bulk-deployment-detailed-reports \
--bulk-deployment-id 42ce9c42-489b-4ed4-b905-8996aa50ef9d
```
Ausgabe:
```
{
"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"
},
...
]
}
```
Weitere Informationen finden Sie unter [Erstellen von Sammelbereitstellungen für Gruppen](https://docs.aws.amazon.com/greengrass/latest/developerguide/bulk-deploy-cli.html) im *Entwicklerhandbuch für AWS IoT Greengrass*.
+ Einzelheiten zur API finden Sie [ListBulkDeploymentDetailedReports](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-bulk-deployment-detailed-reports.html)in der *AWS CLI Befehlsreferenz*.
### `list-bulk-deployments`
Das folgende Codebeispiel zeigt die Verwendung`list-bulk-deployments`.
**AWS CLI**
**So listen Sie Sammelbereitstellungen auf**
Im folgenden Beispiel für `list-bulk-deployments` werden alle Sammelbereitstellungen aufgelistet.
```
aws greengrass list-bulk-deployments
```
Ausgabe:
```
{
"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"
}
]
}
```
Weitere Informationen finden Sie unter [Erstellen von Sammelbereitstellungen für Gruppen](https://docs.aws.amazon.com/greengrass/latest/developerguide/bulk-deploy-cli.html) im *Entwicklerhandbuch für AWS IoT Greengrass*.
+ Einzelheiten zur API finden Sie [ListBulkDeployments](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-bulk-deployments.html)in der *AWS CLI Befehlsreferenz*.
### `list-connector-definition-versions`
Das folgende Codebeispiel zeigt die Verwendung`list-connector-definition-versions`.
**AWS CLI**
**So listen Sie die für eine Konnektordefinition verfügbaren Versionen auf**
Im folgenden Beispiel für `list-connector-definition-versions` werden die Versionen aufgelistet, die für die angegebene Konnektordefinition verfügbar sind. Verwenden Sie den Befehl `list-connector-definitions`, um die Konnektordefinitions-ID abzurufen.
```
aws greengrass list-connector-definition-versions \
--connector-definition-id "b5c4ebfd-f672-49a3-83cd-31c7216a7bb8"
```
Ausgabe:
```
{
"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"
}
]
}
```
Weitere Informationen finden Sie unter [Integration mit Services und Protokollen mithilfe von Greengrass-Konnektoren](https://docs.aws.amazon.com/greengrass/latest/developerguide/connectors.html) im **Entwicklerhandbuch für AWS IoT Greengrass**.
+ Einzelheiten zur API finden Sie [ListConnectorDefinitionVersions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-connector-definition-versions.html)in der *AWS CLI Befehlsreferenz*.
### `list-connector-definitions`
Das folgende Codebeispiel zeigt die Verwendung`list-connector-definitions`.
**AWS CLI**
**So listen Sie die definierten Greengrass-Konnektoren auf**
Das folgende `list-connector-definitions` Beispiel listet alle Greengrass-Konnektoren auf, die für Ihr AWS Konto definiert sind.
```
aws greengrass list-connector-definitions
```
Ausgabe:
```
{
"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"
}
]
}
```
Weitere Informationen finden Sie unter [Integration mit Services und Protokollen mithilfe von Greengrass-Konnektoren](https://docs.aws.amazon.com/greengrass/latest/developerguide/connectors.html) im **Entwicklerhandbuch für AWS IoT Greengrass**.
+ Einzelheiten zur API finden Sie [ListConnectorDefinitions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-connector-definitions.html)in der *AWS CLI Befehlsreferenz.*
### `list-core-definition-versions`
Das folgende Codebeispiel zeigt die Verwendung`list-core-definition-versions`.
**AWS CLI**
**So listen Sie die Versionen einer Greengrass-Kerndefinition auf**
Das folgende `list-core-definitions` Beispiel listet alle Versionen der angegebenen Greengrass-Core-Definition auf. Mit dem Befehl `list-core-definitions` können Sie die Versions-ID abrufen.
```
aws greengrass list-core-definition-versions \
--core-definition-id "eaf280cb-138c-4d15-af36-6f681a1348f7"
```
Ausgabe:
```
{
"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"
}
]
}
```
+ Einzelheiten zur API finden Sie unter [ListCoreDefinitionVersions AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-core-definition-versions.html)*Befehlsreferenz.*
### `list-core-definitions`
Das folgende Codebeispiel zeigt die Verwendung`list-core-definitions`.
**AWS CLI**
**So listen Sie Greengrass-Kerndefinitionen auf**
Das folgende `list-core-definitions` Beispiel listet alle Greengrass-Kerndefinitionen für Ihr AWS Konto auf.
```
aws greengrass list-core-definitions
```
Ausgabe:
```
{
"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"
}
]
}
```
+ Einzelheiten zur API finden Sie [ListCoreDefinitions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-core-definitions.html)in der *AWS CLI Befehlsreferenz.*
### `list-deployments`
Das folgende Codebeispiel zeigt die Verwendung`list-deployments`.
**AWS CLI**
**So listen Sie die Bereitstellungen für eine Greengrass-Gruppe auf**
Im folgenden Beispiel für `list-deployments` werden die Bereitstellungen für die angegebene Greengrass-Gruppe aufgelistet. Mit dem Befehl `list-groups` können Sie Ihre Gruppen-ID abrufen.
```
aws greengrass list-deployments \
--group-id "1013db12-8b58-45ff-acc7-704248f66731"
```
Ausgabe:
```
{
"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"
}
]
}
```
+ Einzelheiten zur API finden Sie [ListDeployments](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-deployments.html)in der *AWS CLI Befehlsreferenz*.
### `list-device-definition-versions`
Das folgende Codebeispiel zeigt die Verwendung`list-device-definition-versions`.
**AWS CLI**
**So listen Sie die Versionen einer Gerätedefinition auf**
Im folgenden Beispiel für `list-device-definition-versions` werden die Geräte-Definitionsversionen angezeigt, die mit der angegebenen Gerätedefinition verknüpft sind.
```
aws greengrass list-device-definition-versions \
--device-definition-id "f9ba083d-5ad4-4534-9f86-026a45df1ccd"
```
Ausgabe:
```
{
"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"
}
]
}
```
+ Einzelheiten zur API finden Sie [ListDeviceDefinitionVersions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-device-definition-versions.html)in der *AWS CLI Befehlsreferenz*.
### `list-device-definitions`
Das folgende Codebeispiel zeigt die Verwendung`list-device-definitions`.
**AWS CLI**
**So listen Sie Ihre Gerätedefinitionen auf**
Im folgenden `list-device-definitions` Beispiel werden Details zu den Gerätedefinitionen in Ihrem AWS Konto in der angegebenen AWS Region angezeigt.
```
aws greengrass list-device-definitions \
--region us-west-2
```
Ausgabe:
```
{
"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"
}
]
}
```
+ Einzelheiten zur API finden Sie [ListDeviceDefinitions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-device-definitions.html)unter *AWS CLI Befehlsreferenz*.
### `list-function-definition-versions`
Das folgende Codebeispiel zeigt die Verwendung`list-function-definition-versions`.
**AWS CLI**
**So listen Sie die Versionen einer Lambda-Funktion auf**
Im folgenden Beispiel für `list-function-definition-versions` werden alle Versionen der angegebenen Lambda-Funktion aufgelistet. Mit dem Befehl `list-function-definitions` können Sie die ID abrufen.
```
aws greengrass list-function-definition-versions \
--function-definition-id "063f5d1a-1dd1-40b4-9b51-56f8993d0f85"
```
Ausgabe:
```
{
"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"
}
]
}
```
+ Einzelheiten zur API finden Sie [ListFunctionDefinitionVersions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-function-definition-versions.html)in der *AWS CLI Befehlsreferenz*.
### `list-function-definitions`
Das folgende Codebeispiel zeigt die Verwendung`list-function-definitions`.
**AWS CLI**
**So listen Sie Lambda-Funktionen auf**
Das folgende `list-function-definitions` Beispiel listet alle Lambda-Funktionen auf, die für Ihr AWS Konto definiert sind.
```
aws greengrass list-function-definitions
```
Ausgabe:
```
{
"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"
}
]
}
```
+ Einzelheiten zur API finden Sie [ListFunctionDefinitions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-function-definitions.html)in der *AWS CLI Befehlsreferenz.*
### `list-group-certificate-authorities`
Das folgende Codebeispiel zeigt die Verwendung`list-group-certificate-authorities`.
**AWS CLI**
**Um die aktuellen Daten CAs für eine Gruppe aufzulisten**
Das folgende `list-group-certificate-authorities` Beispiel listet die aktuellen Zertifizierungsstellen (CAs) für die angegebene Greengrass-Gruppe auf.
```
aws greengrass list-group-certificate-authorities \
--group-id "1013db12-8b58-45ff-acc7-704248f66731"
```
Ausgabe:
```
{
"GroupCertificateAuthorities": [
{
"GroupCertificateAuthorityArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/groups/1013db12-8b58-45ff-acc7-704248f66731/certificateauthorities/f0430e1736ea8ed30cc5d5de9af67a7e3586bad9ae4d89c2a44163f65fdd8cf6",
"GroupCertificateAuthorityId": "f0430e1736ea8ed30cc5d5de9af67a7e3586bad9ae4d89c2a44163f65fdd8cf6"
}
]
}
```
+ Einzelheiten zur API finden Sie unter [ListGroupCertificateAuthorities AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-group-certificate-authorities.html)*Befehlsreferenz.*
### `list-group-versions`
Das folgende Codebeispiel zeigt die Verwendung`list-group-versions`.
**AWS CLI**
**So listen Sie die Versionen einer Greengrass-Gruppe auf**
Im folgenden Beispiel für `list-group-versions` werden die Versionen der angegebenen Greengrass-Gruppe aufgelistet.
```
aws greengrass list-group-versions \
--group-id "1013db12-8b58-45ff-acc7-704248f66731"
```
Ausgabe:
```
{
"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"
}
]
}
```
+ Einzelheiten zur API finden Sie [ListGroupVersions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-group-versions.html)in der *AWS CLI Befehlsreferenz*.
### `list-groups`
Das folgende Codebeispiel zeigt die Verwendung`list-groups`.
**AWS CLI**
**So listen Sie die Greengrass-Gruppen auf**
Das folgende `list-groups` Beispiel listet alle Greengrass-Gruppen auf, die in Ihrem AWS Konto definiert sind.
```
aws greengrass list-groups
```
Ausgabe:
```
{
"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"
}
]
}
```
+ Einzelheiten zur API finden Sie [ListGroups](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-groups.html)in der *AWS CLI Befehlsreferenz.*
### `list-logger-definition-versions`
Das folgende Codebeispiel zeigt die Verwendung`list-logger-definition-versions`.
**AWS CLI**
**So rufen Sie eine Liste der Versionen einer Logger-Definition ab**
Im folgenden Beispiel für `list-logger-definition-versions` wird eine Liste aller Versionen der angegebenen Logger-Definition abgerufen.
```
aws greengrass list-logger-definition-versions \
--logger-definition-id "49eeeb66-f1d3-4e34-86e3-3617262abf23"
```
Ausgabe:
```
{
"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"
}
]
}
```
+ Einzelheiten zur API finden Sie [ListLoggerDefinitionVersions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-logger-definition-versions.html)in der *AWS CLI Befehlsreferenz*.
### `list-logger-definitions`
Das folgende Codebeispiel zeigt die Verwendung`list-logger-definitions`.
**AWS CLI**
**So rufen Sie eine Liste von Logger-Definitionen ab**
Das folgende `list-logger-definitions` Beispiel listet alle Logger-Definitionen für Ihr AWS Konto auf.
```
aws greengrass list-logger-definitions
```
Ausgabe:
```
{
"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"
}
]
}
```
+ Einzelheiten zur API finden Sie [ListLoggerDefinitions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-logger-definitions.html)in der *AWS CLI Befehlsreferenz*.
### `list-resource-definition-versions`
Das folgende Codebeispiel zeigt die Verwendung`list-resource-definition-versions`.
**AWS CLI**
**So listen Sie die Versionen einer Ressourcendefinition auf**
Im folgenden Beispiel für `list-resource-definition-versions` werden die Versionen für die angegebene Greengrass-Ressource aufgelistet.
```
aws greengrass list-resource-definition-versions \
--resource-definition-id "ad8c101d-8109-4b0e-b97d-9cc5802ab658"
```
Ausgabe:
```
{
"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"
}
]
}
```
+ Einzelheiten zur API finden Sie [ListResourceDefinitionVersions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-resource-definition-versions.html)in der *AWS CLI Befehlsreferenz*.
### `list-resource-definitions`
Das folgende Codebeispiel zeigt die Verwendung`list-resource-definitions`.
**AWS CLI**
**So listen Sie die definierten Ressourcen auf**
Das folgende `list-resource-definitions` Beispiel listet die Ressourcen auf, die für die Verwendung von AWS IoT Greengrass definiert sind.
```
aws greengrass list-resource-definitions
```
Ausgabe:
```
{
"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"
}
]
}
```
+ Einzelheiten zur API finden Sie unter [ListResourceDefinitions AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-resource-definitions.html)*Befehlsreferenz.*
### `list-subscription-definition-versions`
Das folgende Codebeispiel zeigt die Verwendung`list-subscription-definition-versions`.
**AWS CLI**
**So listen Sie die Versionen einer Abonnementdefinition auf**
Im folgenden Beispiel für `list-subscription-definition-versions` werden alle Versionen des angegebenen Abonnements aufgelistet. Mit dem Befehl `list-subscription-definitions` können Sie die Abonnement-ID abrufen.
```
aws greengrass list-subscription-definition-versions \
--subscription-definition-id "70e49321-83d5-45d2-bc09-81f4917ae152"
```
Ausgabe:
```
{
"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"
}
]
}
```
+ Einzelheiten zur API finden Sie [ListSubscriptionDefinitionVersions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-subscription-definition-versions.html)in der *AWS CLI Befehlsreferenz*.
### `list-subscription-definitions`
Das folgende Codebeispiel zeigt die Verwendung`list-subscription-definitions`.
**AWS CLI**
**So rufen Sie eine Liste der Abonnementdefinitionen ab**
Das folgende `list-subscription-definitions` Beispiel listet alle AWS IoT Greengrass-Abonnements auf, die in Ihrem AWS Konto definiert sind.
```
aws greengrass list-subscription-definitions
```
Ausgabe:
```
{
"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"
}
]
}
```
+ Einzelheiten zur API finden Sie [ListSubscriptionDefinitions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-subscription-definitions.html)in der *AWS CLI Befehlsreferenz.*
### `list-tags-for-resource`
Das folgende Codebeispiel zeigt die Verwendung`list-tags-for-resource`.
**AWS CLI**
**So listen Sie die mit einer Ressource verknüpften Tags auf**
Im folgenden Beispiel für `list-tags-for-resource` werden die Tags und ihre Werte aufgelistet, die mit der angegebenen Ressource verknüpft sind.
```
aws greengrass list-tags-for-resource \
--resource-arn "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/resources/ad8c101d-8109-4b0e-b97d-9cc5802ab658"
```
Ausgabe:
```
{
"tags": {
"ResourceSubType": "USB",
"ResourceType": "Device"
}
}
```
Weitere Informationen finden Sie unter [Versehen Ihrer Greengrass-Ressourcen mit Tags](https://docs.aws.amazon.com/greengrass/latest/developerguide/tagging.html) im **Entwicklerhandbuch für AWS IoT Greengrass**.
+ Einzelheiten zur API finden Sie [ListTagsForResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/list-tags-for-resource.html)in der *AWS CLI Befehlsreferenz*.
### `reset-deployments`
Das folgende Codebeispiel zeigt die Verwendung`reset-deployments`.
**AWS CLI**
**So bereinigen Sie Bereitstellungsinformationen für eine Greengrass-Gruppe**
Im folgenden Beispiel für `reset-deployments` werden Bereitstellungsinformationen für die angegebene Greengrass-Gruppe bereinigt. Wenn Sie die `--force option` hinzufügen, werden die Bereitstellungsinformationen zurückgesetzt, ohne auf die Antwort des Kerngeräts zu warten.
```
aws greengrass reset-deployments \
--group-id "1402daf9-71cf-4cfe-8be0-d5e80526d0d8" \
--force
```
Ausgabe:
```
{
"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"
}
```
Weitere Informationen finden Sie unter [Zurücksetzen von Bereitstellungen](https://docs.aws.amazon.com/greengrass/latest/developerguide/reset-deployments-scenario.html) im *Entwicklerhandbuch für AWS IoT Greengrass*.
+ Einzelheiten zur API finden Sie [ResetDeployments](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/reset-deployments.html)in der *AWS CLI Befehlsreferenz*.
### `start-bulk-deployment`
Das folgende Codebeispiel zeigt die Verwendung`start-bulk-deployment`.
**AWS CLI**
**So starten Sie eine Sammelbereitstellungsoperation**
Im folgenden Beispiel für `start-bulk-deployment` wird eine Sammelbereitstellungsoperation gestartet, wobei eine in einem S3-Bucket gespeicherte Datei verwendet wird, um die bereitzustellenden Gruppen anzugeben.
```
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\"}"
```
Ausgabe:
```
{
"BulkDeploymentArn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/bulk/deployments/870fb41b-6288-4e0c-bc76-a7ba4b4d3267",
"BulkDeploymentId": "870fb41b-6288-4e0c-bc76-a7ba4b4d3267"
}
```
Weitere Informationen finden Sie unter [Erstellen von Sammelbereitstellungen für Gruppen](https://docs.aws.amazon.com/greengrass/latest/developerguide/bulk-deploy-cli.html) im *Entwicklerhandbuch für AWS IoT Greengrass*.
+ Einzelheiten zur API finden Sie [StartBulkDeployment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/start-bulk-deployment.html)in der *AWS CLI Befehlsreferenz*.
### `stop-bulk-deployment`
Das folgende Codebeispiel zeigt die Verwendung`stop-bulk-deployment`.
**AWS CLI**
**So stoppen Sie eine Sammelbereitstellung**
Im folgenden Beispiel für `stop-bulk-deployment` wird die angegebene Sammelbereitstellung gestoppt. Wenn Sie versuchen, eine abgeschlossene Sammelbereitstellung zu stoppen, wird eine Fehlermeldung angezeigt: `InvalidInputException: Cannot change state of finished execution.`
```
aws greengrass stop-bulk-deployment \
--bulk-deployment-id "870fb41b-6288-4e0c-bc76-a7ba4b4d3267"
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben.
Weitere Informationen finden Sie unter [Erstellen von Sammelbereitstellungen für Gruppen](https://docs.aws.amazon.com/greengrass/latest/developerguide/bulk-deploy-cli.html) im *Entwicklerhandbuch für AWS IoT Greengrass*.
+ Einzelheiten zur API finden Sie [StopBulkDeployment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/stop-bulk-deployment.html)in der *AWS CLI Befehlsreferenz*.
### `tag-resource`
Das folgende Codebeispiel zeigt die Verwendung`tag-resource`.
**AWS CLI**
**So wenden Sie Tags auf eine Ressource an**
Im folgenden Beispiel für `tag-resource` werden zwei Tags, `ResourceType` und `ResourceSubType`, auf die angegebene Greengrass-Ressource angewendet. Diese Operation kann sowohl neue Tags und Werte hinzufügen als auch den Wert vorhandener Tags aktualisieren. Mit dem Befehl `untag-resource` können Sie ein Tag entfernen.
```
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"
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben.
Weitere Informationen finden Sie unter [Versehen Ihrer Greengrass-Ressourcen mit Tags](https://docs.aws.amazon.com/greengrass/latest/developerguide/tagging.html) im **Entwicklerhandbuch für AWS IoT Greengrass**.
+ Einzelheiten zur API finden Sie [TagResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/tag-resource.html)in der *AWS CLI Befehlsreferenz*.
### `untag-resource`
Das folgende Codebeispiel zeigt die Verwendung`untag-resource`.
**AWS CLI**
**So entfernen Sie ein Tag und dessen Wert aus einer Ressource**
Im folgenden Beispiel für `untag-resource` wird der Tag mit dem Schlüssel `Category` aus der angegebenen Greengrass-Gruppe gelöscht. Wenn der Schlüssel `Category` für die angegebene Ressource nicht existiert, wird kein Fehler zurückgegeben.
```
aws greengrass untag-resource \
--resource-arn "arn:aws:greengrass:us-west-2:123456789012:/greengrass/groups/1013db12-8b58-45ff-acc7-704248f66731" \
--tag-keys "Category"
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben.
Weitere Informationen finden Sie unter [Versehen Ihrer Greengrass-Ressourcen mit Tags](https://docs.aws.amazon.com/greengrass/latest/developerguide/tagging.html) im **Entwicklerhandbuch für AWS IoT Greengrass**.
+ Einzelheiten zur API finden Sie [UntagResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/untag-resource.html)in der *AWS CLI Befehlsreferenz*.
### `update-connectivity-info`
Das folgende Codebeispiel zeigt die Verwendung`update-connectivity-info`.
**AWS CLI**
**So aktualisieren Sie die Verbindungsinformationen für einen Greengrass-Kern**
Im folgenden Beispiel für `update-connectivity-info` werden die Endpunkte geändert, über die Geräte eine Verbindung zum angegebenen Greengrass-Kern herstellen können. Bei den Verbindungsinformationen handelt es sich um eine Liste von IP-Adressen oder Domainnamen mit den entsprechenden Portnummern und optionalen, vom Kunden definierten Metadaten. Möglicherweise müssen Sie die Verbindungsinformationen aktualisieren, wenn sich das lokale Netzwerk ändert.
```
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\"}]"
```
Ausgabe:
```
{
"Version": "312de337-59af-4cf9-a278-2a23bd39c300"
}
```
+ Einzelheiten zur API finden Sie [UpdateConnectivityInfo](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/update-connectivity-info.html)in der *AWS CLI Befehlsreferenz*.
### `update-connector-definition`
Das folgende Codebeispiel zeigt die Verwendung`update-connector-definition`.
**AWS CLI**
**So aktualisieren Sie den Namen für eine Konnektordefinition**
Im folgenden Beispiel für `update-connector-definition` wird der Name für die angegebene Konnektordefinition aktualisiert. Wenn Sie die Details für den Konnektor aktualisieren möchten, verwenden Sie den Befehl `create-connector-definition-version`, um eine neue Version zu erstellen.
```
aws greengrass update-connector-definition \
--connector-definition-id "55d0052b-0d7d-44d6-b56f-21867215e118" \
--name "GreengrassConnectors2019"
```
Weitere Informationen finden Sie unter [Integration mit Services und Protokollen mithilfe von Konnektoren](https://docs.aws.amazon.com/greengrass/latest/developerguide/connectors.html) im *Entwicklerhandbuch für AWS IoT Greengrass*.
+ Einzelheiten zur API finden Sie [UpdateConnectorDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/update-connector-definition.html)in der *AWS CLI Befehlsreferenz*.
### `update-core-definition`
Das folgende Codebeispiel zeigt die Verwendung`update-core-definition`.
**AWS CLI**
**So aktualisieren Sie eine Kerndefinition**
Im folgenden Beispiel für `update-core-definition` wird der Name der angegebenen Kerndefinition geändert. Sie können nur die Eigenschaft `name` einer Kerndefinition aktualisieren.
```
aws greengrass update-core-definition \
--core-definition-id "582efe12-b05a-409e-9a24-a2ba1bcc4a12" \
--name "MyCoreDevices"
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben.
Weitere Informationen finden [Sie unter Configure the AWS IoT Greengrass Core](https://docs.aws.amazon.com/greengrass/latest/developerguide/gg-core.html) im *AWS IoT Greengrass Developer Guide*.
+ Einzelheiten zur API finden Sie unter [UpdateCoreDefinition AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/update-core-definition.html)*Befehlsreferenz*.
### `update-device-definition`
Das folgende Codebeispiel zeigt die Verwendung`update-device-definition`.
**AWS CLI**
**So aktualisieren Sie eine Gerätedefinition**
Im folgenden Beispiel für `update-device-definition` wird der Name der angegebenen Gerätedefinition geändert. Sie können nur die Eigenschaft `name` einer Gerätedefinition aktualisieren.
```
aws greengrass update-device-definition \
--device-definition-id "f9ba083d-5ad4-4534-9f86-026a45df1ccd" \
--name "TemperatureSensors"
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben.
+ Einzelheiten zur API finden Sie [UpdateDeviceDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/update-device-definition.html)in der *AWS CLI Befehlsreferenz*.
### `update-function-definition`
Das folgende Codebeispiel zeigt die Verwendung`update-function-definition`.
**AWS CLI**
**So aktualisieren Sie den Namen für eine Funktionsdefinition**
Im folgenden Beispiel für `update-function-definition` wird der Name für die angegebene Funktionsdefinition aktualisiert. Wenn Sie die Details für die Funktion aktualisieren möchten, verwenden Sie den Befehl `create-function-definition-version`, um eine neue Version zu erstellen.
```
aws greengrass update-function-definition \
--function-definition-id "e47952bd-dea9-4e2c-a7e1-37bbe8807f46" \
--name ObsoleteFunction
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben.
Weitere Informationen finden Sie unter [Ausführen von lokalen Lambda-Funktionen](https://docs.aws.amazon.com/greengrass/latest/developerguide/lambda-functions.html) im *Entwicklerhandbuch für AWS IoT Greengrass*.
+ Einzelheiten zur API finden Sie [UpdateFunctionDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/update-function-definition.html)in der *AWS CLI Befehlsreferenz*.
### `update-group-certificate-configuration`
Das folgende Codebeispiel zeigt die Verwendung`update-group-certificate-configuration`.
**AWS CLI**
**So aktualisieren Sie den Ablauf der Zertifikate einer Gruppe**
Im folgenden Beispiel für `update-group-certificate-configuration` wird ein Ablauf von 10 Tagen für die für die angegebene Gruppe generierten Zertifikate festgelegt.
```
aws greengrass update-group-certificate-configuration \
--group-id "8eaadd72-ce4b-4f15-892a-0cc4f3a343f1" \
--certificate-expiry-in-milliseconds 864000000
```
Ausgabe:
```
{
"CertificateExpiryInMilliseconds": 864000000,
"CertificateAuthorityExpiryInMilliseconds": 2524607999000,
"GroupId": "8eaadd72-ce4b-4f15-892a-0cc4f3a343f1"
}
```
Weitere Informationen finden Sie unter [Sicherheit in AWS IoT Greengrass](https://docs.aws.amazon.com/greengrass/latest/developerguide/gg-sec.html) im *Entwicklerhandbuch für AWS IoT Greengrass*.
+ Einzelheiten zur API finden Sie [UpdateGroupCertificateConfiguration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/update-group-certificate-configuration.html)in der *AWS CLI Befehlsreferenz*.
### `update-group`
Das folgende Codebeispiel zeigt die Verwendung`update-group`.
**AWS CLI**
**So aktualisieren Sie den Gruppennamen**
Im folgenden Beispiel für `update-group` wird der Name der angegebenen Greengrass-Gruppe aktualisiert. Wenn Sie die Details für die Gruppe aktualisieren möchten, verwenden Sie den Befehl `create-group-version`, um eine neue Version zu erstellen.
```
aws greengrass update-group \
--group-id "1402daf9-71cf-4cfe-8be0-d5e80526d0d8" \
--name TestGroup4of6
```
Weitere Informationen finden [Sie unter Configure AWS IoT Greengrass on AWS IoT im AWS IoT](https://docs.aws.amazon.com/greengrass/latest/developerguide/gg-config.html) *Greengrass Developer Guide*.
+ Einzelheiten zur API finden Sie [UpdateGroup](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/update-group.html)in der *AWS CLI Befehlsreferenz*.
### `update-logger-definition`
Das folgende Codebeispiel zeigt die Verwendung`update-logger-definition`.
**AWS CLI**
**So aktualisieren Sie eine Logger-Definition**
Im folgenden Beispiel für `update-logger-definition` wird der Name der angegebenen Logger-Definition geändert. Sie können nur die Eigenschaft `name` einer Logger-Definition aktualisieren.
```
aws greengrass update-logger-definition \
--logger-definition-id "a454b62a-5d56-4ca9-bdc4-8254e1662cb0" \
--name "LoggingConfigsForSensors"
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben.
Weitere Informationen finden Sie unter [Monitoring with AWS IoT Greengrass Logs](https://docs.aws.amazon.com/greengrass/latest/developerguide/greengrass-logs-overview.html) im *AWS IoT Greengrass Developer Guide*.
+ Einzelheiten zur API finden Sie [UpdateLoggerDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/update-logger-definition.html)in der *AWS CLI Befehlsreferenz*.
### `update-resource-definition`
Das folgende Codebeispiel zeigt die Verwendung`update-resource-definition`.
**AWS CLI**
**So aktualisieren Sie den Namen für eine Ressourcendefinition**
Im folgenden Beispiel für `update-resource-definition` wird der Name für die angegebene Ressourcendefinition aktualisiert. Wenn Sie die Details für die Ressource ändern möchten, verwenden Sie den Befehl `create-resource-definition-version`, um eine neue Version zu erstellen.
```
aws greengrass update-resource-definition \
--resource-definition-id "c8bb9ebc-c3fd-40a4-9c6a-568d75569d38" \
--name GreengrassConnectorResources
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben.
Weitere Informationen finden Sie unter [Zugriff auf lokale Ressourcen mit Lambda-Funktionen und -Konnektoren](https://docs.aws.amazon.com/greengrass/latest/developerguide/access-local-resources.html) im *Entwicklerhandbuch für AWS IoT Greengrass*.
+ Einzelheiten zur API finden Sie [UpdateResourceDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/update-resource-definition.html)in der *AWS CLI Befehlsreferenz*.
### `update-subscription-definition`
Das folgende Codebeispiel zeigt die Verwendung`update-subscription-definition`.
**AWS CLI**
**So aktualisieren Sie den Namen für eine Abonnementdefinition**
Im folgenden Beispiel für `update-subscription-definition` wird der Name für die angegebene Abonnementdefinition aktualisiert. Wenn Sie Details für das Abonnement ändern möchten, verwenden Sie den Befehl `create-subscription-definition-version`, um eine neue Version zu erstellen.
```
aws greengrass update-subscription-definition \
--subscription-definition-id "fa81bc84-3f59-4377-a84b-5d0134da359b" \
--name "ObsoleteSubscription"
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben.
Weitere Informationen finden Sie unter „Titel“ im *Handbuch*.
+ Einzelheiten zur API finden Sie [UpdateSubscriptionDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/update-subscription-definition.html)in der *AWS CLI Befehlsreferenz*.
### `update-thing-runtime-configuration`
Das folgende Codebeispiel zeigt die Verwendung`update-thing-runtime-configuration`.
**AWS CLI**
**So aktivieren Sie die Telemetrie in der Laufzeitkonfiguration eines Greengrass-Kerns**
Im folgenden Beispiel für `update-thing-runtime-configuration` wird die Laufzeitkonfiguration eines Greengrass-Kerns aktualisiert, um die Telemetrie zu aktivieren.
```
aws greengrass update-thing-runtime-configuration \
--thing-name SampleGreengrassCore \
--telemetry-configuration {\"Telemetry\":\"On\"}
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben.
Weitere Informationen finden Sie unter [Konfigurieren der Telemetrieeinstellungen](https://docs.aws.amazon.com/greengrass/latest/developerguide/telemetry.html#configure-telemetry-settings) im *Entwicklerhandbuch für AWS IoT Greengrass*.
+ Einzelheiten zur API finden Sie [UpdateThingRuntimeConfiguration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/greengrass/update-thing-runtime-configuration.html)in der *AWS CLI Befehlsreferenz*.