Aviso de fin de soporte: el 7 de octubre de 2026, AWS suspenderemos el soporte para AWS IoT Greengrass Version 1. Después del 7 de octubre de 2026, ya no podrá acceder a los AWS IoT Greengrass V1 recursos. Para obtener más información, visita [Migrar desde AWS IoT Greengrass Version 1](https://docs.aws.amazon.com/greengrass/v2/developerguide/migrate-from-v1.html).
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.
# Exportación de flujos de datos a la Nube de AWS (CLI)
Este tutorial le muestra cómo usarlo AWS CLI para configurar e implementar un AWS IoT Greengrass grupo con el administrador de transmisiones habilitado. El grupo contiene una función de Lambda definida por el usuario que escribe en una secuencia en el administrador de flujos, que luego se exporta automáticamente a la Nube de AWS.
El administrador de flujos hace que la asimilación, el procesamiento y la exportación de flujos de datos de gran volumen sea más eficiente y fiable. En este tutorial, va a crear una función de Lambda de `TransferStream` que consume datos de IoT. La función Lambda usa el SDK AWS IoT Greengrass principal para crear una transmisión en el administrador de transmisiones y, a continuación, leer y escribir en ella. El administrador de flujos exporta la secuencia al Flujo de datos Kinesis. En el siguiente diagrama se muestra este flujo de trabajo.
![\[Diagrama del flujo de trabajo de administración de secuencias.\]](http://docs.aws.amazon.com/es_es/greengrass/v1/developerguide/images/stream-manager-scenario.png)
El objetivo de este tutorial es mostrar cómo las funciones Lambda definidas por el usuario utilizan `StreamManagerClient` el objeto del SDK principal para interactuar con AWS IoT Greengrass el administrador de transmisiones. Para simplificar, la función de Lambda que va a crear en este tutorial genera datos de dispositivos simulados.
Cuando utilizas la AWS IoT Greengrass API, que incluye los comandos de Greengrass en AWS CLI, para crear un grupo, el administrador de transmisiones está deshabilitado de forma predeterminada. Para habilitar el administrador de flujos en su núcleo, [cree una versión de definición de función](#stream-manager-cli-create-function-definition) que incluya la función de Lambda de `GGStreamManager` del sistema y una versión de grupo que haga referencia a la nueva versión de definición de función. A continuación, implemente el grupo.
## Requisitos previos
Para completar este tutorial, se necesita lo siguiente:
+ Un grupo de Greengrass y un núcleo de Greengrass (versión 1.10 o posterior). Para obtener información acerca de cómo crear un núcleo y un grupo de Greengrass, consulte [Empezar con AWS IoT Greengrass](gg-gs.md). El tutorial de introducción también incluye los pasos para instalar el software AWS IoT Greengrass principal.
**nota**
El administrador de transmisiones no es compatible con las OpenWrt distribuciones.
+ Java 8 Runtime (JDK 8) instalado en el dispositivo principal.
+ Para distribuciones basadas en Debian (incluido Raspbian) o distribuciones basadas en Ubuntu, ejecute el siguiente comando:
```
sudo apt install openjdk-8-jdk
```
+ Para distribuciones basadas en Red Hat (incluido Amazon Linux), ejecute el siguiente comando:
```
sudo yum install java-1.8.0-openjdk
```
Para obtener más información, consulte [ How to download and install prebuilt OpenJDK packages (Cómo descargar e instalar paquetes OpenJDK preconfigurados)](https://openjdk.java.net/install/) en la documentación de OpenJDK.
+ AWS IoT Greengrass Core SDK para Python v1.5.0 o posterior. Para usar `StreamManagerClient` en el SDK de AWS IoT Greengrass Core para Python, debe:
+ Instalar Python 3.7 o versiones posteriores en el dispositivo principal.
+ Incluya el SDK y sus dependencias en su paquete de implementación de la función de Lambda. Se incluyen las instrucciones en este tutorial.
**sugerencia**
Puede usar `StreamManagerClient` con Java o NodeJS. Para ver código de ejemplo, consulte [AWS IoT Greengrass Core SDK for Java](https://github.com/aws/aws-greengrass-core-sdk-java/blob/master/samples/StreamManagerKinesis/src/main/java/com/amazonaws/greengrass/examples/StreamManagerKinesis.java) y [AWS IoT Greengrass Core SDK for Node.js](https://github.com/aws/aws-greengrass-core-sdk-js/blob/master/greengrassExamples/StreamManagerKinesis/index.js) en GitHub.
+ Una transmisión de destino denominada **MyKinesisStream** creada en Amazon Kinesis Data Streams al Región de AWS igual que su grupo de Greengrass. Para obtener más información, consulte [Crear un flujo](https://docs.aws.amazon.com/streams/latest/dev/fundamental-stream.html#create-stream) en la *Guía para desarrolladores de Amazon Kinesis*.
**nota**
En este tutorial, el administrador de flujos exporta datos a Kinesis Data Streams, lo que deriva en cargos a su Cuenta de AWS. Para obtener información acerca de los precios, consulte [Precios de Kinesis Data Streams](https://aws.amazon.com/kinesis/data-streams/pricing/).
Para no incurrir en gastos, puede ejecutar este tutorial sin crear una secuencia de datos Kinesis. En este caso, compruebe los registros para ver si el administrador de flujos intentó exportar la secuencia al flujo de datos Kinesis.
+ Una política de IAM agregada al [Rol de grupo de Greengrass](group-role.md) que permita la acción de `kinesis:PutRecords` en el flujo de datos de destino, tal y como se muestra en el siguiente ejemplo:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"kinesis:PutRecords"
],
"Resource": [
"arn:aws:kinesis:us-east-1:123456789012:stream/MyKinesisStream"
]
}
]
}
```
------
+ La AWS CLI instalada y configurada en su ordenador. Para obtener más información, consulte [Instalación de la AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) y [Configuración de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) en la *Guía del usuario de la AWS Command Line Interface *.
Los comandos de ejemplo de este tutorial están escritos para Linux y otros sistemas basados en Unix. Si utiliza Windows, consulte [Especificar los valores de los parámetros de la interfaz de línea de AWS comandos](https://docs.aws.amazon.com/cli/latest/userguide/cli-using-param.html) para obtener más información sobre las diferencias de sintaxis.
Si el comando contiene una cadena JSON, el tutorial ofrece un ejemplo que tiene el JSON en una sola línea. En algunos sistemas, puede que sea más eficiente editar y ejecutar comandos con este formato.
El tutorial contiene los siguientes pasos generales:
1. [Creación de un paquete de implementación de la función de Lambda](#stream-manager-cli-create-deployment-package)
1. [Crear una función de Lambda](#stream-manager-cli-create-function)
1. [Crear una versión y una definición de la función](#stream-manager-cli-create-function-definition)
1. [Crear una versión y una definición del registrador](#stream-manager-cli-create-logger-definition)
1. [Obtener el ARN de la versión de la definición del núcleo](#stream-manager-cli-get-core-definition-version-arn)
1. [Cree una versión del grupo](#stream-manager-cli-create-group-version)
1. [Creación de una implementación](#stream-manager-cli-create-deployment)
1. [Pruebe la aplicación](#stream-manager-cli-test-application)
Completar el tutorial debería tomarle aproximadamente 30 minutos.
## Paso 1: Creación de un paquete de implementación de la función de Lambda
En este paso, va a crear un paquete de implementación de funciones de Lambda que contiene código de función y dependencias de Python. Cargará este paquete más adelante cuando cree la función de Lambda en AWS Lambda. La función Lambda usa el SDK AWS IoT Greengrass principal para crear transmisiones locales e interactuar con ellas.
**nota**
Sus funciones de Lambda definidas por el usuario deben utilizar el [SDK de AWS IoT Greengrass Core](lambda-functions.md#lambda-sdks-core) para interactuar con el administrador de flujos. Para obtener más información sobre los requisitos del administrador de secuencias de Greengrass, consulte [Requisitos del administrador de secuencias de Greengrass](stream-manager.md#stream-manager-requirements).
1. Descargue la versión 1.5.0 o posterior del [SDK de AWS IoT Greengrass Core para Python](lambda-functions.md#lambda-sdks-core).
1. Descomprima el paquete descargado para obtener el SDK. El SDK es la carpeta `greengrasssdk`.
1. Instale dependencias de paquetes para incluirlas con el SDK en su paquete de implementación de funciones de Lambda.
1. Vaya al directorio de SDK que contiene el archivo de `requirements.txt`. Este archivo registra las dependencias.
1. Instale las dependencias del SDK. Por ejemplo, ejecute el siguiente comando de `pip` para instalarlas en el directorio actual:
```
pip install --target . -r requirements.txt
```
1. Guarde la siguiente función de código de Python en un archivo local llamado "`transfer_stream.py`".
**sugerencia**
Para ver un ejemplo de código que utilice Java y Nodejs, consulte AWS IoT Greengrass Core [SDK for Java [AWS IoT Greengrass y Core SDK](https://github.com/aws/aws-greengrass-core-sdk-js/blob/master/greengrassExamples/StreamManagerKinesis/index.js) for](https://github.com/aws/aws-greengrass-core-sdk-java/blob/master/samples/StreamManagerKinesis/src/main/java/com/amazonaws/greengrass/examples/StreamManagerKinesis.java) Node.js en. GitHub
```
import asyncio
import logging
import random
import time
from greengrasssdk.stream_manager import (
ExportDefinition,
KinesisConfig,
MessageStreamDefinition,
ReadMessagesOptions,
ResourceNotFoundException,
StrategyOnFull,
StreamManagerClient,
)
# This example creates a local stream named "SomeStream".
# It starts writing data into that stream and then stream manager automatically exports
# the data to a customer-created Kinesis data stream named "MyKinesisStream".
# This example runs forever until the program is stopped.
# The size of the local stream on disk will not exceed the default (which is 256 MB).
# Any data appended after the stream reaches the size limit continues to be appended, and
# stream manager deletes the oldest data until the total stream size is back under 256 MB.
# The Kinesis data stream in the cloud has no such bound, so all the data from this script is
# uploaded to Kinesis and you will be charged for that usage.
def main(logger):
try:
stream_name = "SomeStream"
kinesis_stream_name = "MyKinesisStream"
# Create a client for the StreamManager
client = StreamManagerClient()
# Try deleting the stream (if it exists) so that we have a fresh start
try:
client.delete_message_stream(stream_name=stream_name)
except ResourceNotFoundException:
pass
exports = ExportDefinition(
kinesis=[KinesisConfig(identifier="KinesisExport" + stream_name, kinesis_stream_name=kinesis_stream_name)]
)
client.create_message_stream(
MessageStreamDefinition(
name=stream_name, strategy_on_full=StrategyOnFull.OverwriteOldestData, export_definition=exports
)
)
# Append two messages and print their sequence numbers
logger.info(
"Successfully appended message to stream with sequence number %d",
client.append_message(stream_name, "ABCDEFGHIJKLMNO".encode("utf-8")),
)
logger.info(
"Successfully appended message to stream with sequence number %d",
client.append_message(stream_name, "PQRSTUVWXYZ".encode("utf-8")),
)
# Try reading the two messages we just appended and print them out
logger.info(
"Successfully read 2 messages: %s",
client.read_messages(stream_name, ReadMessagesOptions(min_message_count=2, read_timeout_millis=1000)),
)
logger.info("Now going to start writing random integers between 0 and 1000 to the stream")
# Now start putting in random data between 0 and 1000 to emulate device sensor input
while True:
logger.debug("Appending new random integer to stream")
client.append_message(stream_name, random.randint(0, 1000).to_bytes(length=4, signed=True, byteorder="big"))
time.sleep(1)
except asyncio.TimeoutError:
logger.exception("Timed out while executing")
except Exception:
logger.exception("Exception while running")
def function_handler(event, context):
return
logging.basicConfig(level=logging.INFO)
# Start up this sample code
main(logger=logging.getLogger())
```
1. Comprima en un archivo ZIP los siguientes elementos en un archivo denominado "`transfer_stream_python.zip`". Este es el paquete de implementación de la función de Lambda.
+ **transfer\$1stream.py**. Lógica de la aplicación.
+ **greengrasssdk**. Biblioteca necesaria para las funciones de Lambda Greengrass de Python que publican mensajes MQTT.
Las [operaciones de Stream Manager](work-with-streams.md) están disponibles en la versión 1.5.0 o posterior del AWS IoT Greengrass Core SDK para Python.
+ Las dependencias que instalaste para el SDK AWS IoT Greengrass principal para Python (por ejemplo, los `cbor2` directorios).
Al crear el archivo de `zip`, incluya solo estos elementos, no la carpeta que los contiene.
## Paso 2: creación de una función de Lambda
1. Cree un rol de IAM para poder pasar el ARN del rol cuando cree la función.
------
#### [ JSON Expanded ]
```
aws iam create-role --role-name Lambda_empty --assume-role-policy '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}'
```
------
#### [ JSON Single-line ]
```
aws iam create-role --role-name Lambda_empty --assume-role-policy '{"Version": "2012-10-17", "Statement": [{"Effect": "Allow", "Principal": {"Service": "lambda.amazonaws.com"},"Action": "sts:AssumeRole"}]}'
```
------
**nota**
AWS IoT Greengrass no usa este rol porque los permisos para sus funciones Lambda de Greengrass se especifican en el rol de grupo de Greengrass. En este tutorial, va a crear un rol vacío.
1. Copie la `Arn` del resultado.
1. Utilice la AWS Lambda API para crear la función. `TransferStream` El siguiente comando da por hecho que el archivo ZIP está en el directorio actual.
+ Reemplace *role-arn* por el `Arn` que ha copiado.
```
aws lambda create-function \
--function-name TransferStream \
--zip-file fileb://transfer_stream_python.zip \
--role role-arn \
--handler transfer_stream.function_handler \
--runtime python3.7
```
1. Publique una versión de la función.
```
aws lambda publish-version --function-name TransferStream --description 'First version'
```
1. Cree un alias a la versión publicada.
Los grupos de Greengrass pueden hacer referencia a una función de Lambda por versión o alias (recomendado). El uso de un alias facilita la gestión de las actualizaciones del código porque no tiene que cambiar la tabla de suscripción o la definición del grupo cuando se actualiza el código de la función. En su lugar, basta con apuntar el alias a la nueva versión de la función.
```
aws lambda create-alias --function-name TransferStream --name GG_TransferStream --function-version 1
```
**nota**
AWS IoT Greengrass **no admite los alias de Lambda para las versiones \$1LATEST.**
1. Copie la `AliasArn` del resultado. Este valor se utiliza al configurar la función para. AWS IoT Greengrass
Ahora está listo para configurar la función para AWS IoT Greengrass.
## Paso 3: Crear una versión y una definición de la función
Este paso crea una versión de definición de función que hace referencia a la función de Lambda `GGStreamManager` del sistema y a la función de Lambda `TransferStream` definida por el usuario. Para habilitar el administrador de transmisiones al usar la AWS IoT Greengrass API, la versión de definición de funciones debe incluir la `GGStreamManager` función.
1. Cree una definición de función con una versión inicial que contenga las funciones de Lambda del sistema y definidas por el usuario.
Con la siguiente versión de definición se habilita al administrador de flujos con la [configuración de parámetros](configure-stream-manager.md) predeterminada. Para configurar parámetros personalizados, debe definir variables de entorno para los parámetros correspondientes del administrador de flujos. Para ver un ejemplo, consulte[Para habilitar, deshabilitar o configurar el administrador de flujos (CLI)](configure-stream-manager.md#enable-stream-manager-cli). AWS IoT Greengrass utiliza la configuración predeterminada para los parámetros que se omiten. `MemorySize`debería ser al menos`128000`. `Pinned`debe estar configurado en`true`.
**nota**
Una función Lambda de *larga duración* (o *anclada*) se inicia automáticamente después AWS IoT Greengrass del inicio y sigue ejecutándose en su propio contenedor. Esto contrasta con una función de Lambda *bajo demanda*, que se inicia cuando se la invoca y se detiene cuando no quedan tareas que ejecutar. Para obtener más información, consulte [Configuración del ciclo de vida de las funciones de Lambda de Greengrass](lambda-functions.md#lambda-lifecycle).
+ *arbitrary-function-id*Sustitúyala por un nombre para la función, como. **stream-manager**
+ *alias-arn*Sustitúyalo por el `AliasArn` que copió al crear el alias de la `TransferStream` función Lambda.
------
#### [ JSON expanded ]
```
aws greengrass create-function-definition --name MyGreengrassFunctions --initial-version '{
"Functions": [
{
"Id": "arbitrary-function-id",
"FunctionArn": "arn:aws:lambda:::function:GGStreamManager:1",
"FunctionConfiguration": {
"MemorySize": 128000,
"Pinned": true,
"Timeout": 3
}
},
{
"Id": "TransferStreamFunction",
"FunctionArn": "alias-arn",
"FunctionConfiguration": {
"Executable": "transfer_stream.function_handler",
"MemorySize": 16000,
"Pinned": true,
"Timeout": 5
}
}
]
}'
```
------
#### [ JSON single ]
```
aws greengrass create-function-definition \
--name MyGreengrassFunctions \
--initial-version '{"Functions": [{"Id": "arbitrary-function-id","FunctionArn": "arn:aws:lambda:::function:GGStreamManager:1", "FunctionConfiguration": {"Environment": {"Variables":{"STREAM_MANAGER_STORE_ROOT_DIR": "/data","STREAM_MANAGER_SERVER_PORT": "1234","STREAM_MANAGER_EXPORTER_MAX_BANDWIDTH": "20000"}},"MemorySize": 128000,"Pinned": true,"Timeout": 3}},{"Id": "TransferStreamFunction", "FunctionArn": "alias-arn", "FunctionConfiguration": {"Executable": "transfer_stream.function_handler", "MemorySize": 16000,"Pinned": true,"Timeout": 5}}]}'
```
------
**nota**
`Timeout` es necesario para la versión de definición de característica, pero `GGStreamManager` no lo usa. Para obtener más información sobre `Timeout` y otras configuraciones a nivel de grupo, consulte [Control de la ejecución de funciones de Lambda de Greengrass utilizando la configuración específica del grupo](lambda-group-config.md).
1. Copie la `LatestVersionArn` del resultado. Este valor se usa para añadir la versión de la definición de función a la versión de grupo que implementó en el núcleo.
## Paso 4: Crear una versión y una definición del registrador
Defina la configuración de registro del grupo. En este tutorial, configurará los componentes AWS IoT Greengrass del sistema, las funciones Lambda definidas por el usuario y los conectores para escribir registros en el sistema de archivos del dispositivo principal. Puede usar registros para solucionar cualquier problema que pueda surgir. Para obtener más información, consulte [Supervisión con AWS IoT Greengrass registros](greengrass-logs-overview.md).
1. Cree una definición del registro que incluya una versión inicial.
------
#### [ JSON Expanded ]
```
aws greengrass create-logger-definition --name "LoggingConfigs" --initial-version '{
"Loggers": [
{
"Id": "1",
"Component": "GreengrassSystem",
"Level": "INFO",
"Space": 10240,
"Type": "FileSystem"
},
{
"Id": "2",
"Component": "Lambda",
"Level": "INFO",
"Space": 10240,
"Type": "FileSystem"
}
]
}'
```
------
#### [ JSON Single-line ]
```
aws greengrass create-logger-definition \
--name "LoggingConfigs" \
--initial-version '{"Loggers":[{"Id":"1","Component":"GreengrassSystem","Level":"INFO","Space":10240,"Type":"FileSystem"},{"Id":"2","Component":"Lambda","Level":"INFO","Space":10240,"Type":"FileSystem"}]}'
```
------
1. Copie el `LatestVersionArn` de la definición del registro del resultado. Este valor se usa para añadir la versión de definición del registro a la versión del grupo que implementa en el núcleo.
## Paso 5: Obtener el ARN de la versión de la definición del núcleo
Obtenga el ARN de la versión de definición del núcleo para agregar a su nueva versión de grupo. Para implementar una versión de grupo, debe hacer referencia a una versión de definición de núcleo que contenga exactamente un núcleo.
1. Obtenga el grupo y IDs la versión grupal de Greengrass objetivo. En este procedimiento, suponemos que estos son el último grupo y la última versión de grupo. La siguiente consulta devuelve el grupo creado más recientemente.
```
aws greengrass list-groups --query "reverse(sort_by(Groups, &CreationTimestamp))[0]"
```
También puede hacer la consulta por nombre. No es necesario que los nombres de grupo sean únicos, por lo que podrían devolverse varios grupos.
```
aws greengrass list-groups --query "Groups[?Name=='MyGroup']"
```
**nota**
También puede encontrar estos valores en la AWS IoT consola. El ID de grupo se muestra en la página **Settings (Configuración)** del grupo. La versión del grupo IDs se muestra en la pestaña **Implementaciones** del grupo.
1. Copie el `Id` del grupo de destino de la salida. Puede utilizar esto para obtener la versión de la definición de núcleo y al implementar el grupo.
1. Copie el `LatestVersion` del resultado, que es el ID de la última versión añadida al grupo. Puede utilizar esto para obtener la versión de la definición de núcleo.
1. Obtenga el ARN de la versión de la definición principal:
1. Obtenga la versión de grupo.
+ *group-id*Sustitúyala por la `Id` que copiaste para el grupo.
+ *group-version-id*Sustitúyala por la `LatestVersion` que copiaste para el grupo.
```
aws greengrass get-group-version \
--group-id group-id \
--group-version-id group-version-id
```
1. Copie la `CoreDefinitionVersionArn` del resultado. Este valor se usa para añadir la versión de la definición del núcleo a la versión de grupo que implementó en el núcleo.
## Paso 6: Crear una versión del grupo
Ahora, puede crear una versión de grupo que contenga las entidades que desea implementar. Para ello, cree una versión de grupo que haga referencia a la versión de destino de cada tipo de componente. Para este tutorial, incluirá una versión de definición de núcleo, una versión de definición de función y una versión de definición de registrador.
1. Cree una versión de grupo.
+ *group-id*Sustitúyala por la `Id` que copiaste para el grupo.
+ *core-definition-version-arn*Sustitúyalo por el `CoreDefinitionVersionArn` que copió para la versión de definición básica.
+ *function-definition-version-arn*Sustitúyala por la `LatestVersionArn` que copiaste para la nueva versión de definición de funciones.
+ *logger-definition-version-arn*Sustitúyala por la `LatestVersionArn` que copiaste para tu nueva versión de definición de registrador.
```
aws greengrass create-group-version \
--group-id group-id \
--core-definition-version-arn core-definition-version-arn \
--function-definition-version-arn function-definition-version-arn \
--logger-definition-version-arn logger-definition-version-arn
```
1. Copie la `Version` del resultado. Este es el ID de la nueva versión del grupo.
## Paso 7: Crear una implementación
Implemente el grupo en el dispositivo del núcleo.
1. Asegúrese de que el AWS IoT Greengrass núcleo esté funcionando. Ejecute los siguientes comandos en el terminal de Raspberry Pi según sea necesario.
1. Para comprobar si el daemon está en ejecución:
```
ps aux | grep -E 'greengrass.*daemon'
```
Si la salida contiene una entrada `root` para `/greengrass/ggc/packages/ggc-version/bin/daemon`, el daemon está en ejecución.
**nota**
La versión de la ruta depende de la versión del software AWS IoT Greengrass principal que esté instalada en el dispositivo principal.
1. Inicio de daemon:
```
cd /greengrass/ggc/core/
sudo ./greengrassd start
```
1. Cree una implementación de .
+ *group-id*Sustitúyala por la `Id` que copiaste para el grupo.
+ *group-version-id*Reemplácelo por el `Version` que copió para la nueva versión del grupo.
```
aws greengrass create-deployment \
--deployment-type NewDeployment \
--group-id group-id \
--group-version-id group-version-id
```
1. Copie la `DeploymentId` del resultado.
1. Obtenga el estado de las implementaciones.
+ *group-id*Sustitúyala por la `Id` que copiaste para el grupo.
+ *deployment-id*Reemplácelo por el `DeploymentId` que copió para la implementación.
```
aws greengrass get-deployment-status \
--group-id group-id \
--deployment-id deployment-id
```
Si el estado es `Success`, la implementación fue correcta. Para obtener ayuda sobre la resolución de problemas, consulte [Solución de problemas AWS IoT Greengrass](gg-troubleshooting.md).
## Paso 8: Probar la aplicación
La función de Lambda `TransferStream` genera datos simulados del dispositivo. Escribe datos en una secuencia que el administrador de secuencias exporta a la secuencia de datos de Kinesis de destino.
1. En la consola de Amazon Kinesis, en **Kinesis data** Streams, elija. **MyKinesisStream**
**nota**
Si ejecutó el tutorial sin una secuencia de datos de Kinesis de destino, [compruebe el archivo de registro](#stream-manager-cli-logs) del administrador de secuencias (`GGStreamManager`). Si contiene `export stream MyKinesisStream doesn't exist` en un mensaje de error, la prueba se ha realizado correctamente. Este error significa que el servicio intentó exportar a la secuencia, pero que la secuencia no existe.
1. **En la **MyKinesisStream**página, elija Monitorización.** Si la prueba se realiza correctamente, debería ver los datos en los gráficos **Put Records**. En función de la conexión, es posible que tarde un minuto en mostrar los datos.
**importante**
Cuando haya terminado la prueba, elimine la secuencia de datos de Kinesis para evitar incurrir en más gastos.
O ejecute el siguiente comando para detener el daemon de Greengrass. Así evitará que el núcleo envíe mensajes hasta que esté listo para continuar las pruebas.
```
cd /greengrass/ggc/core/
sudo ./greengrassd stop
```
1. Elimine la función **TransferStream**Lambda del núcleo.
1. Siga [Paso 6: Crear una versión del grupo](#stream-manager-cli-create-group-version) para crear una nueva versión de grupo. pero elimine la opción `--function-definition-version-arn` en el comando `create-group-version`. O bien, cree una versión de definición de función que no incluya la función **TransferStream**Lambda.
**nota**
Al omitir la función de Lambda de `GGStreamManager` del sistema de la versión de grupo implementada, se deshabilita la administración de secuencias en el núcleo.
1. Siga [Paso 7: Crear una implementación](#stream-manager-cli-create-deployment) para implementar la nueva versión de grupo.
Para ver la información de registro o solucionar problemas con las secuencias, compruebe los registros para las funciones `TransferStream` y `GGStreamManager`. Debe tener `root` permisos para leer los AWS IoT Greengrass registros del sistema de archivos.
+ `TransferStream` escribe entradas de registro en `greengrass-root/ggc/var/log/user/region/account-id/TransferStream.log`.
+ `GGStreamManager` escribe entradas de registro en `greengrass-root/ggc/var/log/system/GGStreamManager.log`.
Si necesita más información sobre la solución de problemas, puede establecer el nivel de registro de `Lambda` a `DEBUG` y, a continuación, crear e implementar una nueva versión de grupo.
## Véase también
+ [Gestione los flujos de datos en el AWS IoT Greengrass núcleo](stream-manager.md)
+ [Se usa StreamManagerClient para trabajar con transmisiones](work-with-streams.md)
+ [Exportación de configuraciones para Nube de AWS destinos compatibles](stream-export-configurations.md)
+ [Configurar el administrador de AWS IoT Greengrass transmisiones](configure-stream-manager.md)
+ [Exportar flujos de datos a la Nube de AWS (consola)](stream-manager-console.md)
+ [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/cli/latest/reference/iam) de la Referencia de *AWS CLI comandos*
+ [AWS Lambda comandos](https://docs.aws.amazon.com/cli/latest/reference/lambda) de la Referencia de *AWS CLI comandos*
+ [AWS IoT Greengrass comandos](https://docs.aws.amazon.com/cli/latest/reference/greengrass/index.html) de la *Referencia de AWS CLI comandos*