

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Simulación de comunicaciones del servicio Device Shadow
<a name="using-device-shadows"></a>

En este tema se muestra cómo el servicio Device Shadow actúa como intermediario y permite que los dispositivos y aplicaciones utilicen una sombra para actualizar, almacenar y recuperar el estado de un dispositivo.

Para demostrar la interacción descrita en este tema y explorarla más a fondo, necesitará un Cuenta de AWS sistema en el que pueda ejecutarla AWS CLI. Si no dispone de ello, aún puede ver la interacción en los ejemplos de código.

En este ejemplo, la AWS IoT consola representa el dispositivo. AWS CLI Representa la aplicación o el servicio que accede al dispositivo a través de la sombra. La AWS CLI interfaz es muy similar a la API con la que una aplicación puede comunicarse AWS IoT. El dispositivo de este ejemplo es una bombilla inteligente y la aplicación muestra el estado de la bombilla y puede cambiar el estado de la bombilla.

## Configuración de la simulación
<a name="using-device-shadows-setup"></a>

Estos procedimientos inicializan la simulación abriendo la [consola de AWS IoT](https://console.aws.amazon.com/iot/home), que simula su dispositivo, y la ventana de línea de comandos que simula su aplicación.

**Para configurar el entorno de simulación**

1. Necesitarás ejecutar Cuenta de AWS los ejemplos de este tema por tu cuenta. Si no tiene uno Cuenta de AWS, cree uno, tal y como se describe en[Configurar Cuenta de AWS](setting-up.md).

1. Abra la [consola de AWS IoT](https://console.aws.amazon.com/iot/home) y, en el menú de la izquierda, elija **Probar** para abrir el **cliente MQTT**.

1. En otra ventana, abra una ventana de terminal en un sistema que tenga instalada la AWS CLI .

Debería tener dos ventanas abiertas: una con la AWS IoT consola en la página de **pruebas** y otra con una línea de comandos.

## Inicializar el dispositivo
<a name="using-device-shadows-init-device"></a>

En esta simulación, trabajaremos con un objeto llamado *mySimulatedThing*, y su sombra llamada *SimShadow1*. 

**Creación de un objeto y de su política de IoT**  
Para crear un objeto, haga lo siguiente en la **consola AWS IoT **:

1. Seleccione **Administrar** y **Objetos**. 

1. Haga clic en el botón **Crear** si hay cosas en la lista; de lo contrario, haga clic en **Registrar una sola cosa** para crear una sola AWS IoT cosa. 

1. Introduzca el nombre `mySimulatedThing`, deje los demás ajustes con los valores predeterminados y haga clic en **Siguiente**.

1. Utilice la creación de certificados en un clic para generar los certificados que autenticarán la conexión del dispositivo a AWS IoT. Haga clic en **Activar** para activar el certificado.

1. Puede asociar la política `My_IoT_Policy` que le daría permiso al dispositivo para publicar en los temas reservados de MQTT y suscribirse a estos. Para obtener pasos más detallados sobre cómo crear una AWS IoT cosa y cómo crear esta política, consulte[Crear un objeto](create-iot-resources.md#create-aws-thing).

**Creación de una sombra con nombre para el objeto**  
Puede crear una sombra con nombre para un objeto publicando una solicitud de actualización en el tema `$aws/things/mySimulatedThing/shadow/name/simShadow1/update`, tal y como se describe a continuación.

O para crear una sombra con nombre:

1. En la **consola AWS IoT **, seleccione el objeto que desee de la lista de objetos y seleccione **Sombras**.

1. Seleccione **Agregar una sombra**, introduzca el nombre `simShadow1` y seleccione **Crear** para agregar la sombra con nombre.

**Suscripción a temas reservados de MQTT y publicación en estos**  
En la consola, suscríbase a los temas de sombras MQTT reservados. Estos temas son las respuestas a las acciones `get`, `update` y `delete` para que el dispositivo esté listo para recibir las respuestas después de publicar una acción. 

**Para suscribirse a un tema MQTT en el **cliente MQTT****

1. En el **Cliente de MQTT**, elija **Suscribirse a un tema**.

1. Introduzca los temas `get`, `update` y `delete` a los que desea suscribirse. Copie un tema a la vez de la siguiente lista, péguelo en el campo **Filtro de temas** y haga clic en **Suscribirse**. Los temas deberían aparecer en **Suscripciones**.
   + `$aws/things/mySimulatedThing/shadow/name/simShadow1/delete/accepted`
   + `$aws/things/mySimulatedThing/shadow/name/simShadow1/delete/rejected`
   + `$aws/things/mySimulatedThing/shadow/name/simShadow1/get/accepted`
   + `$aws/things/mySimulatedThing/shadow/name/simShadow1/get/rejected`
   + `$aws/things/mySimulatedThing/shadow/name/simShadow1/update/accepted`
   + `$aws/things/mySimulatedThing/shadow/name/simShadow1/update/rejected`
   + `$aws/things/mySimulatedThing/shadow/name/simShadow1/update/delta`
   + `$aws/things/mySimulatedThing/shadow/name/simShadow1/update/documents`

   En este punto, el dispositivo simulado está listo para recibir los temas a medida que los publica AWS IoT.

**Para publicar en un tema MQTT, en el **Cliente de MQTT****  
Después de que un dispositivo se haya inicializado y suscrito a los temas de respuesta, debe consultar las sombras que admite. Esta simulación solo admite una sombra, la sombra que soporta un objeto llamado *SimShadow1*. *mySimulatedThing*

**Para obtener el estado actual de la sombra desde el **Cliente MQTT****

1. En el **cliente MQTT**, elija **Publicar en un tema**.

1. En **Publicar**, introduzca el siguiente tema y elimine cualquier contenido de la ventana del cuerpo del mensaje, debajo del lugar en el que ha introducido el tema que desea obtener. A continuación, seleccione **Publicar en tema** para publicar la solicitud `$aws/things/mySimulatedThing/shadow/name/simShadow1/get`.

   Si no ha creado la sombra con nombre `simShadow1`, recibirá un mensaje en el tema `$aws/things/mySimulatedThing/shadow/name/simShadow1/get/rejected` y el `code` será `404`, como se ve en este ejemplo en el que no se ha creado una sombra; a continuación, vamos a crearla.

   ```
   {
     "code": 404,
     "message": "No shadow exists with name: 'simShadow1'"
   }
   ```

**Para crear una sombra con el estado actual del dispositivo**

1. En **Cliente de MQTT**, elija **Publicar en tema** e introduzca este tema:

   ```
   $aws/things/mySimulatedThing/shadow/name/simShadow1/update
   ```

1. En la ventana del cuerpo del mensaje debajo donde introdujo el tema, escriba este documento de sombra para mostrar que el dispositivo está notificando su ID y su color actual en valores RGB. Seleccione **Publicar** para publicar la solicitud.

   ```
   {
     "state": {
       "reported": {
         "ID": "SmartLamp21",
         "ColorRGB": [
           128,
           128,
           128
         ]
       }
     },
     "clientToken": "426bfd96-e720-46d3-95cd-014e3ef12bb6"
   }
   ```

A continuación, se describe el significado de los mensajes recibidos en el tema. 
+ `$aws/things/mySimulatedThing/shadow/name/simShadow1/update/accepted`: significa que la sombra se ha creado y que el cuerpo del mensaje contiene el documento de sombra actual.
+ `$aws/things/mySimulatedThing/shadow/name/simShadow1/update/rejected`: revise el error en el cuerpo del mensaje.
+ `$aws/things/mySimulatedThing/shadow/name/simShadow1/get/accepted`: la sombra ya existe y el cuerpo del mensaje tiene el estado de sombra actual, como en este ejemplo. Con esto, puedes configurar su dispositivo o confirmar que coincide con el estado de sombra.

  ```
  {
    "state": {
      "reported": {
        "ID": "SmartLamp21",
        "ColorRGB": [
          128,
          128,
          128
        ]
      }
    },
    "metadata": {
      "reported": {
        "ID": {
          "timestamp": 1591140517
        },
        "ColorRGB": [
          {
            "timestamp": 1591140517
          },
          {
            "timestamp": 1591140517
          },
          {
            "timestamp": 1591140517
          }
        ]
      }
    },
    "version": 3,
    "timestamp": 1591140517,
    "clientToken": "426bfd96-e720-46d3-95cd-014e3ef12bb6"
  }
  ```

## Enviar una actualización desde la aplicación
<a name="using-device-shadows-app-update"></a>

En esta sección se utiliza AWS CLI para demostrar cómo una aplicación puede interactuar con una sombra.

**Para obtener el estado actual de la sombra, utilice el AWS CLI**  
Desde la línea de comandos, escriba este comando:

```
aws iot-data get-thing-shadow --thing-name mySimulatedThing --shadow-name simShadow1 /dev/stdout
```

En las plataformas Windows, puede utilizar `con` en lugar de `/dev/stdout`.

```
aws iot-data get-thing-shadow --thing-name mySimulatedThing --shadow-name simShadow1 con
```

Dado que la sombra existe y la ha inicializado el dispositivo para reflejar su estado actual, debe devolver el siguiente documento de sombra.

```
{
  "state": {
    "reported": {
      "ID": "SmartLamp21",
      "ColorRGB": [
        128,
        128,
        128
      ]
    }
  },
  "metadata": {
    "reported": {
      "ID": {
        "timestamp": 1591140517
      },
      "ColorRGB": [
        {
          "timestamp": 1591140517
        },
        {
          "timestamp": 1591140517
        },
        {
          "timestamp": 1591140517
        }
      ]
    }
  },
  "version": 3,
  "timestamp": 1591141111
}
```

La aplicación puede usar esta respuesta para inicializar su representación del estado del dispositivo.

Si la aplicación actualiza el estado, como cuando un usuario final cambia el color de nuestra bombilla inteligente a amarillo, la aplicación enviará un comando **update-thing-shadow**. Este comando corresponde a la API REST `UpdateThingShadow`.

**Para actualizar una sombra desde una aplicación**  
Desde la línea de comandos, escriba este comando:

------
#### [ AWS CLI v2.x ]

```
aws iot-data update-thing-shadow --thing-name mySimulatedThing --shadow-name simShadow1 \
    --cli-binary-format raw-in-base64-out \
    --payload '{"state":{"desired":{"ColorRGB":[255,255,0]}},"clientToken":"21b21b21-bfd2-4279-8c65-e2f697ff4fab"}' /dev/stdout
```

------
#### [ AWS CLI v1.x ]

```
aws iot-data update-thing-shadow --thing-name mySimulatedThing --shadow-name simShadow1 \
    --payload '{"state":{"desired":{"ColorRGB":[255,255,0]}},"clientToken":"21b21b21-bfd2-4279-8c65-e2f697ff4fab"}' /dev/stdout
```

------

Si tiene éxito, este comando debe devolver el siguiente documento de sombra.

```
{
  "state": {
    "desired": {
      "ColorRGB": [
        255,
        255,
        0
      ]
    }
  },
  "metadata": {
    "desired": {
      "ColorRGB": [
        {
          "timestamp": 1591141596
        },
        {
          "timestamp": 1591141596
        },
        {
          "timestamp": 1591141596
        }
      ]
    }
  },
  "version": 4,
  "timestamp": 1591141596,
  "clientToken": "21b21b21-bfd2-4279-8c65-e2f697ff4fab"
}
```

## Responder a la actualización en el dispositivo
<a name="using-device-shadows-device-update"></a>

Volviendo al **cliente MQTT** de la AWS consola, debería ver los mensajes AWS IoT publicados que reflejan el comando de actualización emitido en la sección anterior.

**Para ver los mensajes de actualización en el **Cliente MQTT****  
En el **cliente MQTT**, elija **\$1 aws/things/mySimulatedThing/shadow/name/simShadow1/update/delta** en la columna **Suscripciones**. Si el nombre del tema está truncado, puede ponerlo en pausa para ver el tema completo. En el registro de temas para este tema, debería ver un mensaje `/delta` similar a este.

```
{
  "version": 4,
  "timestamp": 1591141596,
  "state": {
    "ColorRGB": [
      255,
      255,
      0
    ]
  },
  "metadata": {
    "ColorRGB": [
      {
        "timestamp": 1591141596
      },
      {
        "timestamp": 1591141596
      },
      {
        "timestamp": 1591141596
      }
    ]
  },
  "clientToken": "21b21b21-bfd2-4279-8c65-e2f697ff4fab"
}
```

El dispositivo procesaría el contenido de este mensaje para establecer el estado del dispositivo para que coincida con el estado `desired` del mensaje.

Una vez que el dispositivo actualice el estado para que coincida con el `desired` estado del mensaje, debe devolver el nuevo estado informado AWS IoT mediante la publicación de un mensaje de actualización. Este procedimiento simula esto en el **cliente MQTT**.

**Para actualizar la sombra desde el dispositivo**

1. En el **cliente MQTT**, elija **Publicar en un tema**.

1. En el campo de temas situado encima de la ventana del cuerpo del mensaje, introduzca el tema de la sombra seguido de la acción `/update` `$aws/things/mySimulatedThing/shadow/name/simShadow1/update`; en el cuerpo del mensaje, introduzca este documento de sombra actualizado, que describe el estado actual del dispositivo. Elija **Publicar** para publicar el estado actualizado del dispositivo.

   ```
   {
     "state": {
       "reported": {
         "ColorRGB": [255,255,0]
         }
     },
     "clientToken": "a4dc2227-9213-4c6a-a6a5-053304f60258"
   }
   ```

   Si el mensaje se ha recibido correctamente AWS IoT, debería aparecer una nueva respuesta en el registro de aws/things/mySimulatedThing/shadow/name/simShadow1/update/accepted mensajes **\$1** del **cliente MQTT** con el estado de sombra actual, como en este ejemplo.

   ```
   {
     "state": {
       "reported": {
         "ColorRGB": [
           255,
           255,
           0
         ]
       }
     },
     "metadata": {
       "reported": {
         "ColorRGB": [
           {
             "timestamp": 1591142747
           },
           {
             "timestamp": 1591142747
           },
           {
             "timestamp": 1591142747
           }
         ]
       }
     },
     "version": 5,
     "timestamp": 1591142747,
     "clientToken": "a4dc2227-9213-4c6a-a6a5-053304f60258"
   }
   ```

Si se actualiza correctamente el estado registrado del dispositivo, también se AWS IoT envía una descripción completa del estado de sombra en un mensaje dedicado al `update/documents` tema, como el cuerpo del mensaje resultante de la actualización oculta realizada por el dispositivo en el procedimiento anterior.

```
{
  "previous": {
    "state": {
      "desired": {
        "ColorRGB": [
          255,
          255,
          0
        ]
      },
      "reported": {
        "ID": "SmartLamp21",
        "ColorRGB": [
          128,
          128,
          128
        ]
      }
    },
    "metadata": {
      "desired": {
        "ColorRGB": [
          {
            "timestamp": 1591141596
          },
          {
            "timestamp": 1591141596
          },
          {
            "timestamp": 1591141596
          }
        ]
      },
      "reported": {
        "ID": {
          "timestamp": 1591140517
        },
        "ColorRGB": [
          {
            "timestamp": 1591140517
          },
          {
            "timestamp": 1591140517
          },
          {
            "timestamp": 1591140517
          }
        ]
      }
    },
    "version": 4
  },
  "current": {
    "state": {
      "desired": {
        "ColorRGB": [
          255,
          255,
          0
        ]
      },
      "reported": {
        "ID": "SmartLamp21",
        "ColorRGB": [
          255,
          255,
          0
        ]
      }
    },
    "metadata": {
      "desired": {
        "ColorRGB": [
          {
            "timestamp": 1591141596
          },
          {
            "timestamp": 1591141596
          },
          {
            "timestamp": 1591141596
          }
        ]
      },
      "reported": {
        "ID": {
          "timestamp": 1591140517
        },
        "ColorRGB": [
          {
            "timestamp": 1591142747
          },
          {
            "timestamp": 1591142747
          },
          {
            "timestamp": 1591142747
          }
        ]
      }
    },
    "version": 5
  },
  "timestamp": 1591142747,
  "clientToken": "a4dc2227-9213-4c6a-a6a5-053304f60258"
}
```

## Ver la actualización en la aplicación
<a name="using-device-shadows-view-result"></a>

La aplicación ahora puede consultar la sombra del estado actual según haya notificado el dispositivo.

**Para obtener el estado actual de la sombra, utilice el AWS CLI**

1. Desde la línea de comandos, escriba este comando:

   ```
   aws iot-data get-thing-shadow --thing-name mySimulatedThing --shadow-name simShadow1 /dev/stdout
   ```

   En las plataformas Windows, puede utilizar `con` en lugar de `/dev/stdout`.

   ```
   aws iot-data get-thing-shadow --thing-name mySimulatedThing --shadow-name simShadow1 con
   ```

1. Dado que el dispositivo acaba de actualizar la sombra para reflejar su estado actual, debe devolver el siguiente documento de sombra.

   ```
   {
     "state": {
       "desired": {
         "ColorRGB": [
           255,
           255,
           0
         ]
       },
       "reported": {
         "ID": "SmartLamp21",
         "ColorRGB": [
           255,
           255,
           0
         ]
       }
     },
     "metadata": {
       "desired": {
         "ColorRGB": [
           {
             "timestamp": 1591141596
           },
           {
             "timestamp": 1591141596
           },
           {
             "timestamp": 1591141596
           }
         ]
       },
       "reported": {
         "ID": {
           "timestamp": 1591140517
         },
         "ColorRGB": [
           {
             "timestamp": 1591142747
           },
           {
             "timestamp": 1591142747
           },
           {
             "timestamp": 1591142747
           }
         ]
       }
     },
     "version": 5,
     "timestamp": 1591143269
   }
   ```

## Más allá de la simulación
<a name="using-device-shadows-next-steps"></a>

Experimente con la interacción entre la AWS CLI (que representa a la aplicación) y la consola (que representa al dispositivo) a fin de modelar su solución de IoT.