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.

# Benutzergeführte Einrichtung zur Einbindung und Bedienung von Geräten
<a name="managedintegrations-sdk-v2-cookbook-ugs"></a>

Richten Sie Ihre Geräte so ein, dass sie in Ihren Managed Integrations Hub integriert werden, indem Sie ein verwaltetes Objekt erstellen und es mit Ihrem Hub verbinden. In diesem Abschnitt werden die Schritte beschrieben, um den Onboarding-Prozess für Geräte mithilfe der benutzergeführten Einrichtung abzuschließen.

## Voraussetzungen
<a name="managedintegrations-sdk-v2-cookbook-ugs-prereq"></a>

Gehen Sie wie folgt vor, bevor Sie versuchen, ein Gerät an Bord zu nehmen:
+ Integrieren Sie ein Hub-Gerät in den Managed Integrations Hub.
+ Installieren Sie die neueste Version von AWS CLI aus der [Managed Integrations AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/iot-managed-integrations/) Command Reference
+ Abonnieren Sie [DEVICE\_DISCOVERY\_STATUS-Ereignisbenachrichtigungen](managedintegrations-notifications.md#managedintegrations-notification-setup).

**Topics**
+ [Voraussetzungen](#managedintegrations-sdk-v2-cookbook-ugs-prereq)
+ [Voraussetzung: Aktivieren Sie den Pairing-Modus auf Ihrem Z Wave-Gerät](#managedintegrations-sdk-v2-cookbook-pairing-mode)
+ [Schritt 1: Starten Sie die Geräteerkennung](#managedintegrations-sdk-v2-cookbook-device-discovery)
+ [Schritt 2: Fragen Sie die Discovery-Job-ID ab](#managedintegrations-sdk-v2-cookbook-query-discovery)
+ [Schritt 3: Erstellen Sie ein verwaltetes Objekt für Ihr Gerät](#managedintegrations-sdk-v2-cookbook-ugs-managed-thing)
+ [Schritt 4: Fragen Sie das verwaltete Ding ab](#managedintegrations-sdk-v2-cookbook-query-managed-thing)
+ [Schritt 5: Holen Sie sich die Funktionen für verwaltete Dinge](#managedintegrations-sdk-v2-cookbook-check-device-capabilties)
+ [Schritt 6: Senden Sie einen Befehl an das verwaltete Ding](#managedintegrations-sdk-v2-cookbook-ugs-control-device)
+ [Schritt 7: Überprüfen Sie den Status des verwalteten Objekts](#managedintegrations-sdk-v2-cookbook-ugs-device-state)
+ [Schritt 8: Entfernen Sie das verwaltete Ding von Ihrem Hub](#managedintegrations-sdk-v2-cookbook-ugs-clean-up)

## Voraussetzung: Aktivieren Sie den Pairing-Modus auf Ihrem Z Wave-Gerät
<a name="managedintegrations-sdk-v2-cookbook-pairing-mode"></a>

Aktivieren Sie den Pairing-Modus auf dem Z-wave Gerät. Der Pairing-Modus kann für jedes Z-Wave Gerät unterschiedlich sein. Lesen Sie daher in den Anweisungen des Geräts nach, um den Pairing-Modus richtig einzurichten. In der Regel handelt es sich um eine Taste, die der Benutzer drücken muss. 

## Schritt 1: Starten Sie die Geräteerkennung
<a name="managedintegrations-sdk-v2-cookbook-device-discovery"></a>

Starten Sie die Geräteerkennung für Ihren Hub, um eine Discovery-Job-ID zu erhalten, die zum Onboarding Ihres Geräts verwendet wird.

**Um die Geräteerkennung zu starten**
+ Verwenden Sie den Befehl [start-device-discovery](https://docs.aws.amazon.com/cli/latest/reference/iot-managed-integrations/start-device-discovery.html), um die Discovery-Job-ID abzurufen.

  **start-device-discovery-Beispiel**

  ```
  #For Zigbee
    aws iot-managed-integrations start-device-discovery --discovery-type ZIGBEE \
    --controller-identifier {{HUB_MANAGED_THING_ID}}
    
    #For Zwave
    aws iot-managed-integrations start-device-discovery --discovery-type ZWAVE \
    --controller-identifier {{HUB_MANAGED_THING}} \
    --authentication-material-type ZWAVE_INSTALL_CODE \
    --authentication-material 13333
    
    #For Cloud
    aws iot-managed-integrations start-device-discovery --discovery-type CLOUD \
    --account-association-id {{C2C_ASSOCIATION_ID}} \
    
    #For Custom
    aws iot-managed-thing start-device-discovery --discovery-type CUSTOM \
    --controller-identifier {{HUB_MANAGED_THING_ID}} \
    --custom-protocol-detail {{NAME : NON_EMPTY_STRING}} \
  ```

  **Antwort:**

  ```
  {
        "Id": {{DISCOVERY_JOB_ID}},
        "StartedAt": "2025-06-03T14:43:12.726000-07:00"
    }
  ```
**Anmerkung**  
Es gibt separate Befehle für Z-wave und Zigbee-Geräte.

  *Weitere Informationen finden Sie in der [Start-Device-Discovery-API](https://docs.aws.amazon.com/cli/latest/reference/iot-managed-integrations/start-device-discovery.html) in der Managed Integrations Command Reference. AWS CLI *

## Schritt 2: Fragen Sie die Discovery-Job-ID ab
<a name="managedintegrations-sdk-v2-cookbook-query-discovery"></a>

Verwenden Sie den `list-discovered-devices` Befehl, um das Authentifizierungsmaterial Ihres Geräts abzurufen.

**Um Ihre Discovery-Job-ID abzufragen**
+ Verwenden Sie die Discovery-Job-ID zusammen mit dem Befehl list-discovered-devices, um das Authentifizierungsmaterial Ihres Geräts abzurufen.

  ```
  aws iot-managed-integrations list-discovered-devices --identifier {{DISCOVERY_JOB_ID}}
  ```

**Antwort:**

```
"Items": [
    {
        "DeviceTypes": [],
        "DiscoveredAt": "2025-06-03T14:43:37.619000-07:00",
        "AuthenticationMaterial": {{AUTHENTICATION_MATERIAL}}
    }
]
```

### Geben Sie Marke und Modell für die erkannten Geräte ein
<a name="managedintegrations-sdk-v2-cookbook-brand-model"></a>

Bei der Geräteerkennung können erkannte Geräte optional Marken- und Modellinformationen über den Matter Basic Information Cluster melden. Diese Werte werden dann in den [ListManagedThings](https://docs.aws.amazon.com/iot-mi/latest/APIReference/API_ListManagedThings.html#API_ListManagedThings_ResponseSyntax)Antworten [ListDiscoveredDevices](https://docs.aws.amazon.com/iot-mi/latest/APIReference/API_ListDiscoveredDevices.html#API_ListDiscoveredDevices_ResponseSyntax)und zurückgegeben.

Melden Sie den Basisinformations-Cluster (Cluster`0x0028`) auf dem Root-Endpunkt des Geräts (`0`) und ordnen Sie Folgendes zu:
+ `VendorName`(Attribut`0x0001`) → `Brand`
+ `ProductName`(Attribut`0x0003`) → `Model`

Das folgende Beispiel zeigt, wie der Basisinformations-Cluster auf dem Root-Endpunkt gemeldet wird:

```
"endpoints": [{
    "id": "0",
    "clusters": [{
        "id": "0x0028",
        "attributes": [{
            "id": "0x0001",
            "value": "ExampleBrand"
        }, {
            "id": "0x0003",
            "value": "ExampleModel-X1"
        }]
    }]
}]
```

Beide Werte sind Zeichenketten mit einer maximalen Länge von 32 Zeichen. Wenn der Basisinformations-Cluster oder eines der Attribute nicht gemeldet wird, wird das entsprechende Feld in der Antwort weggelassen.

## Schritt 3: Erstellen Sie ein verwaltetes Objekt für Ihr Gerät
<a name="managedintegrations-sdk-v2-cookbook-ugs-managed-thing"></a>

Verwenden Sie den `create-managed-thing` Befehl, um ein verwaltetes Objekt für Ihr Gerät zu erstellen. Jedes Gerät benötigt sein eigenes verwaltetes Ding. 

**Um ein verwaltetes Ding zu erstellen**
+ Verwenden Sie den `create-managed-thing` Befehl, um ein verwaltetes Ding für Ihr Gerät zu erstellen.

  **create-managed-thing-Beispiel**

  ```
  aws iot-managed-integrations create-managed-thing \
    --role  DEVICE --authentication-material-type DISCOVERED_DEVICE \
    --authentication-material "{{AUTHENTICATION_MATERIAL}}"
  ```

  **Antwort:**

  ```
  {    
      "Id": "{{DEVICE_MANAGED_THING_ID}}"
      "Arn": "arn:aws:iotmanagedintegrations:{{AWS_REGION}}:{{AWS_ACCOUNT_ID}}:managed-thing/{{DEVICE_MANAGED_THING_ID}}"
      "CreatedAt": "2025-06-09T13:58:52.977000+08:00"
    }
  ```

  *Weitere Informationen finden Sie unter dem Befehl [create-managed-thing](https://docs.aws.amazon.com/cli/latest/reference/iot-managed-integrations/create-managed-thing.html) in der Befehlsreferenz für verwaltete Integrationen. AWS CLI *

## Schritt 4: Fragen Sie das verwaltete Ding ab
<a name="managedintegrations-sdk-v2-cookbook-query-managed-thing"></a>

Mit dem `get-managed-thing` Befehl können Sie überprüfen, ob ein verwaltetes Ding aktiviert ist. 

**Um eine verwaltete Sache abzufragen**
+ Verwenden Sie den `get-managed-thing` Befehl, um zu überprüfen, ob der Bereitstellungsstatus des verwalteten Objekts auf `ACTIVATED` gesetzt ist. Weitere Informationen zum Bereitstellungsstatus finden Sie unter [Gerätebereitstellung](https://docs.aws.amazon.com/iot-mi/latest/devguide/device-provisioning.html).

  **get-managed-thing-Beispiel**

  ```
  aws iot-managed-integrations get-managed-thing \
    --identifier "{{DEVICE_MANAGED_THING_ID}}"
  ```

  **Antwort:**

  ```
  {
        "Id": "{{DEVICE_MANAGED_THING_ID}}",
        "Arn": "arn:aws:iotmanagedintegrations:{{AWS_REGION}}:{{AWS_ACCOUNT_ID}}:managed-thing/{{DEVICE_MANAGED_THING_ID}},
        "Role": "DEVICE",
        "ProvisioningStatus": "ACTIVATED",
        "MacAddress": "{{MAC_ADDRESS}}",
        "ParentControllerId": "{{PARENT_CONTROLLER_ID}}",
        "CreatedAt": "2025-06-03T14:46:35.149000-07:00",
        "UpdatedAt": "2025-06-03T14:46:37.500000-07:00",
        "Tags": {}
    }
  ```

  *Weitere Informationen finden Sie unter dem Befehl [get-managed-thing](https://docs.aws.amazon.com/cli/latest/reference/iot-managed-integrations/get-managed-thing.html) in der Befehlsreferenz für verwaltete Integrationen. AWS CLI *

## Schritt 5: Holen Sie sich die Funktionen für verwaltete Dinge
<a name="managedintegrations-sdk-v2-cookbook-check-device-capabilties"></a>

Sie können eine Liste der verfügbaren Aktionen für ein verwaltetes Ding anzeigen, indem Sie den verwenden`get-managed-thing-capabiltiies`. 

**Um die Funktionen eines Geräts abzurufen**
+ Verwenden Sie den `get-managed-thing-capabilities` Befehl, um die Endpunkt-ID abzurufen. Beachten Sie auch die Liste der möglichen Aktionen.

  **get-managed-thing-capabilities-Beispiel**

  ```
  aws iot-managed-integrations get-managed-thing-capabilities \
    --identifier "{{DEVICE_MANAGED_THING_ID}}"
  ```

  **Antwort:**

  ```
  {
        "ManagedThingId": "{{DEVICE_MANAGED_THING_ID}}",
        "CapabilityReport": {
            "version": "1.0.0",
            "nodeId": "zb.539D+4A1D",
            "endpoints": [
                {
                    "id": "1",
                    "deviceTypes": [
                        "Unknown Device"
                    ],
                    "capabilities": [
                        {
                            "id": "matter.OnOff@1.4",
                            "name": "On/Off",
                            "version": "6",
                            "properties": [
                                "OnOff",
                                "OnOff",
                                "OnTime",
                                "OffWaitTime"
                            ],
                            "actions": [
                                "Off",
                                "On",
                                "Toggle",
                                "OffWithEffect",
                                "OnWithRecallGlobalScene",
                                "OnWithTimedOff"
                            ],
                            ...
    }
  ```

  *Weitere Informationen finden Sie unter dem Befehl [get-managed-thing-capabilities](https://docs.aws.amazon.com/cli/latest/reference/iot-managed-integrations/get-managed-thing-capabilities.html) in der Befehlsreferenz für verwaltete Integrationen. AWS CLI*

## Schritt 6: Senden Sie einen Befehl an das verwaltete Ding
<a name="managedintegrations-sdk-v2-cookbook-ugs-control-device"></a>

Sie können den Befehl send-managed-thing-command verwenden, um einen Toggle-Action-Befehl an Ihr verwaltetes Ding zu senden. 

**Senden Sie mithilfe einer Umschaltaktion einen Befehl an das verwaltete Ding.**
+ Verwenden Sie den `send-managed-thing-command` Befehl, um einen Befehl zum Umschalten zu senden.

  **send-managed-thing-command-Beispiel**

  ```
  json=$(jq -cr '.|@json') <<EOF
    [
      {
        "endpointId": "1",
        "capabilities": [
          {
            "id": "matter.OnOff@1.4",
            "name": "On/Off",
            "version": "1",
            "actions": [
              {
                "name": "Toggle",
                "parameters": {}
              }
            ]
          }
        ]
      }
    ]
    EOF
    aws iot-managed-integrations send-managed-thing-command \
    --managed-thing-id ${device_managed_thing_id} --endpoints {{ENDPOINT_ID}}
  ```
**Anmerkung**  
In diesem Beispiel wird jq cli verwendet, aber Sie können auch die gesamte Zeichenfolge übergeben `endpointId`

  **Antwort:**

  ```
  {    
    "TraceId": {{TRACE_ID}}
    }
  ```

  *Weitere Informationen finden Sie unter dem Befehl [send-managed-thing-command in der Managed Integrations Command Reference](https://docs.aws.amazon.com/cli/latest/reference/iot-managed-integrations/send-managed-thing-command.html). AWS CLI *

## Schritt 7: Überprüfen Sie den Status des verwalteten Objekts
<a name="managedintegrations-sdk-v2-cookbook-ugs-device-state"></a>

Überprüfen Sie den Status des verwalteten Dings, um zu überprüfen, ob die Umschaltaktion erfolgreich war.

**Um den Gerätestatus eines verwalteten Objekts zu überprüfen**
+ Verwenden Sie den `get-managed-thing-state` Befehl, um zu überprüfen, ob die Umschaltaktion erfolgreich war.

  **get-managed-thing-state-Beispiel**

  ```
    aws iot-managed-integrations get-managed-thing-state --managed-thing-id {{DEVICE_MANAGED_THING_ID}}
  ```

  **Antwort:**

  ```
  {
        "Endpoints": [
            {
                "endpointId": "1",
                "capabilities": [
                    {
                        "id": "matter.OnOff@1.4",
                        "name": "On/Off",
                        "version": "1.4",
                        "properties": [
                            {
                                "name": "OnOff",
                                "value": {
                                    "propertyValue": true,
                                    "lastChangedAt": "2025-06-03T21:50:39.886Z"
                                }
                            }
                        ]
                    }
                ]
            }
        ]
    }
  ```

  *Weitere Informationen finden Sie unter dem Befehl [get-managed-thing-state](https://docs.aws.amazon.com/cli/latest/reference/iot-managed-integrations/get-managed-thing-state.html) in der Befehlsreferenz für verwaltete Integrationen. AWS CLI*

## Schritt 8: Entfernen Sie das verwaltete Ding von Ihrem Hub
<a name="managedintegrations-sdk-v2-cookbook-ugs-clean-up"></a>

Bereinigen Sie Ihren Hub, indem Sie das verwaltete Ding entfernen.

**Um ein verwaltetes Ding zu löschen**
+ Verwenden Sie den Befehl [delete-managed-thing, um ein verwaltetes Ding](https://docs.aws.amazon.com/cli/latest/reference/iot-managed-integrations/delete-managed-thing.html) zu entfernen. 

  **delete-managed-thing-Beispiel**

  ```
  aws iot-managed-integrations delete-managed-thing \
    --identifier {{MANAGED_THING_ID}}
  ```

  *Weitere Informationen finden Sie unter dem Befehl [delete-managed-thing in der Befehlsreferenz](https://docs.aws.amazon.com/cli/latest/reference/iot-managed-integrations/delete-managed-thing.html) für verwaltete Integrationen. AWS CLI *
**Anmerkung**  
Wenn das Gerät in einem bestimmten `DELETE_IN_PROGRESS` Zustand feststeckt, hängen Sie das Kennzeichen an den Befehl an. `--force` `delete-managed-thing`
**Anmerkung**  
Bei Z-wave Geräten müssen Sie das Gerät nach der Ausführung des Befehls in den Pairing-Modus versetzen.