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.
# Desarrollo de componentes de AWS IoT Greengrass
Puede desarrollar y probar componentes en su dispositivo principal de Greengrass. Como resultado, puede crear e iterar su software de AWS IoT Greengrass sin interactuar con la Nube de AWS. Cuando termine una versión de su componente, podrá subirla a AWS IoT Greengrass en la nube para que usted y su equipo puedan implementar el componente en otros dispositivos de su flota. Para obtener más información acerca de cómo implementar componentes, consulte [Implemente AWS IoT Greengrass componentes en los dispositivos](manage-deployments.md).
Cada componente incluye una *receta* y *artefactos*.
+ **Recetas**
Cada componente contiene un archivo de recetas que define sus metadatos. La receta también especifica los parámetros de configuración, dependencias del componente, ciclo de vida y compatibilidad de plataforma del componente. El ciclo de vida del componente define los comandos que instalan, ejecutan y apagan el componente. Para obtener más información, consulte [AWS IoT Greengrass referencia de recetas de componentes](component-recipe-reference.md).
Puede definir recetas en formato [JSON](https://en.wikipedia.org/wiki/JSON) o [YAML](https://en.wikipedia.org/wiki/YAML).
+ **Artefactos**
Los componentes pueden tener cualquier número de artefactos, que son componentes binarios. Los artefactos pueden incluir scripts, código compilado, recursos estáticos y cualquier otro archivo que utilice un componente. Los componentes también pueden utilizar artefactos de las dependencias de los componentes.
AWS IoT Greengrass proporciona componentes prediseñados que puede utilizar en sus aplicaciones e implementar en sus dispositivos. Por ejemplo, puede usar el componente administrador de flujos para cargar datos en varios servicios de AWS o puede usar el componente de métricas de CloudWatch para publicar métricas personalizadas en Amazon CloudWatch. Para obtener más información, consulte [Componentes proporcionados por AWS](public-components.md).
AWS IoT Greengrass prepara un índice de componentes de Greengrass, llamado Catálogo de software de Greengrass. Este catálogo rastrea los componentes de Greengrass desarrollados por la comunidad de Greengrass. Desde este catálogo, puede descargar, modificar e implementar componentes para crear sus aplicaciones de Greengrass. Para obtener más información, consulte [Componentes de la comunidad](greengrass-software-catalog.md).
El software AWS IoT Greengrass Core ejecuta los componentes como usuario y grupo del sistema, como `ggc_user` y `ggc_group`, que usted configura en el dispositivo principal. Esto significa que los componentes tienen los permisos de ese usuario del sistema. Si utiliza un usuario del sistema sin un directorio principal, los componentes no pueden utilizar comandos de ejecución ni código que utilice un directorio principal. Esto significa que no puede usar el comando `pip install some-library --user` para instalar paquetes de Python, por ejemplo. Si ha seguido el [tutorial de introducción](getting-started.md) para configurar su dispositivo principal, el usuario del sistema no tiene un directorio principal. Para obtener más información sobre cómo configurar el usuario y el grupo que ejecutan los componentes, consulte [Configuración del usuario que ejecuta los componentes](configure-greengrass-core-v2.md#configure-component-user).
**nota**
AWS IoT Greengrass usa versiones semánticas para los componentes. Las versiones semánticas siguen un sistema de números de *principal*.*secundario*.*parche*. Por ejemplo, la versión `1.0.0` representa el primer lanzamiento principal de un componente. Para obtener más información, consulte la [especificación semántica de la versión](https://semver.org/).
**Topics**
+ [Componente del ciclo de vida](#component-lifecycle)
+ [Tipos de componentes](#component-types)
+ [Creación de componentes de AWS IoT Greengrass](create-components.md)
+ [Prueba de los componentes de AWS IoT Greengrass con implementaciones locales](test-components.md)
+ [Publique componentes para desplegarlos en sus dispositivos principales](publish-components.md)
+ [Interacción con servicios de AWS](interact-with-aws-services.md)
+ [Ejecución de un contenedor de Docker](run-docker-container.md)
+ [AWS IoT Greengrass referencia de recetas de componentes](component-recipe-reference.md)
+ [Referencia de variable de entorno del componente](component-environment-variables.md)
## Componente del ciclo de vida
El *componente del ciclo de vida* define las etapas que el software AWS IoT Greengrass Core utiliza para instalar y ejecutar los componentes. Cada etapa define un script y otra información que especifica cómo se comporta el componente. Por ejemplo, al instalar un componente, el software AWS IoT Greengrass Core ejecuta el script del ciclo de vida `install` de ese componente. Los componentes de los dispositivos principales tienen los siguientes estados de ciclo de vida:
+ `NEW`: la receta y los artefactos del componente se cargan en el dispositivo principal, pero el componente no está instalado. Cuando un componente entra en este estado, ejecuta su [script de instalación](component-recipe-reference.md#install-lifecycle-definition).
+ `INSTALLED`: el componente está instalado en el dispositivo principal. El componente entra en este estado después de ejecutar su [script de instalación](component-recipe-reference.md#install-lifecycle-definition).
+ `STARTING`: el componente se está iniciando en el dispositivo principal. El componente entra en este estado cuando ejecuta su [script de arranque](component-recipe-reference.md#startup-lifecycle-definition). Si el arranque se realiza correctamente, el componente entra en el estado `RUNNING`.
+ `RUNNING`: el componente se está ejecutando en el dispositivo principal. El componente entra en este estado cuando ejecuta su [script de ejecución](component-recipe-reference.md#run-lifecycle-definition) o cuando tiene procesos en segundo plano activos desde su script de arranque.
+ `FINISHED`: el componente se ejecutó correctamente y completó su ejecución.
+ `STOPPING`: el componente se detiene. El componente entra en este estado cuando ejecuta su [script de apagado](component-recipe-reference.md#shutdown-lifecycle-definition).
+ `ERRORED`: el componente ha detectado un error. Cuando el componente entra en este estado, ejecuta su [script de recuperación](component-recipe-reference.md#recover-lifecycle-definition). A continuación, el componente se reinicia para intentar volver a su uso normal. Si el componente entra en el estado `ERRORED` tres veces sin ejecutarse correctamente, pasa a ser `BROKEN`.
+ `BROKEN`: el componente ha detectado errores varias veces y no se puede recuperar. Debe volver a implementar el componente para solucionarlo.
## Tipos de componentes
El *tipo de componente* especifica cómo el software AWS IoT Greengrass Core ejecuta el componente. Los componentes pueden tener los siguientes tipos:
+ **Núcleo** (`aws.greengrass.nucleus`)
El núcleo de Greengrass es el componente que proporciona la funcionalidad mínima del software AWS IoT Greengrass Core. Para obtener más información, consulte [Núcleo de Greengrass](greengrass-nucleus-component.md).
+ **Complemento** (`aws.greengrass.plugin`)
El núcleo de Greengrass ejecuta un componente de complemento en la misma máquina virtual Java (JVM) que el núcleo. El núcleo se reinicia al cambiar la versión de un componente del complemento en un dispositivo principal. Para instalar y ejecutar los componentes del complemento, debe configurar el núcleo de Greengrass para que se ejecute como un servicio del sistema. Para obtener más información, consulte [Configuración del núcleo de Greengrass como un servicio del sistema](configure-greengrass-core-v2.md#configure-system-service).
Varios componentes proporcionados por AWS son componentes de complementos, lo que les permite interactuar directamente con el núcleo de Greengrass. Los componentes del complemento usan el mismo archivo de registro que el núcleo de Greengrass. Para obtener más información, consulte [Supervisión de los registros de AWS IoT Greengrass](monitor-logs.md).
+ **Genérico** (`aws.greengrass.generic`)
El núcleo de Greengrass ejecuta los scripts de ciclo de vida de un componente genérico si el componente define un ciclo de vida.
Este tipo es el tipo predeterminado para los componentes personalizados.
+ **Lambda** (`aws.greengrass.lambda`)
El núcleo de Greengrass ejecuta un componente de función de Lambda mediante el [componente lanzador de Lambda.](lambda-launcher-component.md)
Cuando se crea un componente a partir de una función de Lambda, el componente tiene este tipo. Para obtener más información, consulte [Ejecución de funciones de AWS Lambda](run-lambda-functions.md).
**nota**
No le recomendamos que especifique el tipo de componente en una receta. AWS IoT Greengrass establece el tipo por usted al crear un componente.
# Creación de componentes de AWS IoT Greengrass
Puede desarrollar componentes de AWS IoT Greengrass personalizados en una computadora de desarrollo local o en un dispositivo principal de Greengrass. AWS IoT Greengrass proporciona la [interfaz de línea de comandos del kit de desarrollo de AWS IoT Greengrass (CLI de GDK)](greengrass-development-kit-cli.md) para ayudarlo a crear, compilar y publicar componentes a partir de plantillas de componentes predefinidas y [componentes de comunidad](greengrass-software-catalog.md). También puede ejecutar comandos de intérprete de comandos integrados para crear, compilar y publicar componentes. Elija entre las siguientes opciones para crear componentes de Greengrass personalizados:
+ **Uso de la CLI del kit de desarrollo de Greengrass**
Use la CLI de GDK para desarrollar componentes en una computadora de desarrollo local. La CLI de GDK crea y empaqueta el código de origen de los componentes en una receta y artefactos que puede publicar como un componente privado en el servicio de AWS IoT Greengrass. Puede configurar la CLI de GDK para que actualice automáticamente la versión del componente y los URI del artefacto al publicar el componente, de modo que no necesite actualizar la receta cada vez. Para desarrollar un componente mediante la CLI de GDK, puede partir de una plantilla o un componente de comunidad del [catálogo de software de Greengrass](greengrass-software-catalog.md). Para obtener más información, consulte [Interfaz de línea de comandos del kit de desarrollo de AWS IoT Greengrass](greengrass-development-kit-cli.md).
+ **Ejecute los comandos de intérprete de comandos integrados**
Puede ejecutar comandos de intérprete de comandos integrados para desarrollar componentes en una computadora de desarrollo local o en un dispositivo principal de Greengrass. Los comandos de intérprete de comandos se usan para copiar o compilar el código de origen de los componentes en artefactos. Cada vez que cree una nueva versión de un componente, debe crear o actualizar la receta con la nueva versión del componente. Al publicar el componente en el servicio de AWS IoT Greengrass, debe actualizar el URI del artefacto de cada componente de la receta.
**Topics**
+ [Creación de un componente (CLI de GDK)](#create-component-gdk-cli)
+ [Creación de un componente (comandos de intérprete de comandos)](#create-component-shell-commands)
## Creación de un componente (CLI de GDK)
Siga las instrucciones de esta sección para crear y compilar un componente mediante la CLI de GDK.
**Desarrollo de un componente de Greengrass (CLI de GDK)**
1. Si aún no lo ha hecho, instale la CLI de GDK en su computadora de desarrollo. Para obtener más información, consulte [Instalación o actualización de la interfaz de línea de comandos del kit de desarrollo de AWS IoT Greengrass](install-greengrass-development-kit-cli.md).
1. Vaya a la carpeta en la que desea crear las carpetas de componentes.
------
#### [ Linux or Unix ]
```
mkdir ~/greengrassv2
cd ~/greengrassv2
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir %USERPROFILE%\greengrassv2
cd %USERPROFILE%\greengrassv2
```
------
#### [ PowerShell ]
```
mkdir ~/greengrassv2
cd ~/greengrassv2
```
------
1. Elija una plantilla de componentes o un componente de comunidad para descargar. La CLI de GDK descarga la plantilla o el componente de comunidad, por lo que puede empezar con un ejemplo funcional. Use el comando [component list](greengrass-development-kit-cli-component.md#greengrass-development-kit-cli-component-list) para recuperar la lista de plantillas o componentes de comunidad disponibles.
+ Para mostrar una lista de las plantillas de componentes, ejecute el siguiente comando. Cada línea de la respuesta incluye el nombre de la plantilla y el lenguaje de programación.
```
gdk component list --template
```
+ Para mostrar una lista de componentes de comunidad, ejecute el siguiente comando.
```
gdk component list --repository
```
1. Cree y cambie a una carpeta de componentes en la que la CLI de GDK descargue la plantilla o el componente de comunidad. Reemplace *HelloWorld* por el nombre del componente u otro nombre que lo ayude a identificar esta carpeta de componentes.
------
#### [ Linux or Unix ]
```
mkdir HelloWorld
cd HelloWorld
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir HelloWorld
cd HelloWorld
```
------
#### [ PowerShell ]
```
mkdir HelloWorld
cd HelloWorld
```
------
1. Descargue la plantilla o el componente de comunidad en la carpeta actual. Use el comando [component init](greengrass-development-kit-cli-component.md#greengrass-development-kit-cli-component-init).
+ Para crear una carpeta de componentes a partir de una plantilla, ejecute el siguiente comando. Reemplace *HelloWorld* por el nombre de la plantilla y reemplace *python* por el nombre del lenguaje de programación.
```
gdk component init --template HelloWorld --language python
```
+ Para crear una carpeta de componentes a partir de un componente de comunidad, ejecute el siguiente comando. Reemplace *ComponentName* por el nombre del componente de comunidad.
```
gdk component init --repository ComponentName
```
**nota**
Si usa la versión 1.0.0 de la CLI de GDK, debe ejecutar este comando en una carpeta vacía. La CLI de GDK descarga la plantilla o el componente de comunidad en la carpeta actual.
Si usa la versión 1.1.0 de la CLI de GDK o una versión posterior, puede especificar el argumento `--name` para especificar la carpeta en la que la CLI de GDK descarga la plantilla o el componente de comunidad. Si usa este argumento, especifique una carpeta que no existe. La CLI de GDK crea la carpeta por usted. Si no se especifica este argumento, la CLI de GDK usa la carpeta actual, que debe estar vacía.
1. La CLI de GDK lee el [archivo de configuración de la CLI de GDK](gdk-cli-configuration-file.md), denominado `gdk-config.json`, para crear y publicar componentes. Este archivo de configuración existe en la raíz de la carpeta del componente. El paso anterior crea este archivo por usted. En este paso, se actualiza `gdk-config.json` con información acerca de su componente. Haga lo siguiente:
1. Abra `gdk-config.json` en un editor de texto.
1. (Opcional) Cambie el nombre del componente. El nombre del componente es la clave del objeto `component`.
1. Cambie el autor del componente.
1. (Opcional) Cambie la versión del componente. Especifique uno de los siguientes valores:
+ `NEXT_PATCH`: al elegir esta opción, la CLI de GDK establece la versión al publicar el componente. La CLI de GDK consulta el servicio de AWS IoT Greengrass para identificar la versión más reciente publicada del componente. A continuación, establece la versión en la siguiente versión del parche posterior a esa versión. Si no ha publicado el componente antes, la CLI de GDK usa la versión `1.0.0`.
Si elige esta opción, no podrá usar la [CLI de Greengrass](greengrass-cli-component.md) para implementar y probar localmente el componente en su computadora de desarrollo local que ejecuta el software AWS IoT Greengrass Core. Para habilitar las implementaciones locales, debe especificar una versión semántica en su lugar.
+ Una versión semántica, como **1.0.0**. Las versiones semánticas siguen un sistema de números de *major*.*minor*.*patch*. Para obtener más información, consulte la [especificación semántica de la versión](https://semver.org/).
Si desarrolla componentes en un dispositivo principal de Greengrass en el que desee implementar y probar el componente, elija esta opción. Debe compilar el componente con una versión específica para crear implementaciones locales con la [CLI de Greengrass](greengrass-cli-component.md).
1. (Opcional) Cambie la configuración de compilación del componente. La configuración de compilación define cómo la CLI de GDK compila el origen del componente en artefactos. Para `build_system`, puede elegir entre las siguientes opciones:
+ `zip`: empaqueta la carpeta del componente en un archivo ZIP para definirla como el único artefacto del componente. Elija esta opción para los siguientes tipos de componentes:
+ Componentes que usan lenguajes de programación interpretados, como Python o JavaScript.
+ Componentes que empaquetan archivos distintos del código, como modelos de machine learning u otros recursos.
La CLI de GDK comprime la carpeta del componente en un archivo zip con el mismo nombre que la carpeta del componente. Por ejemplo, si el nombre de la carpeta del componente es `HelloWorld`, la CLI de GDK crea un archivo zip denominado `HelloWorld.zip`.
**nota**
Si usa la versión 1.0.0 de la CLI de GDK en un dispositivo Windows, los nombres de las carpetas y los archivos zip de los componentes deben contener solo letras minúsculas.
Cuando la CLI de GDK comprime la carpeta del componente en un archivo zip, omite los siguientes archivos:
+ El archivo `gdk-config.json`
+ El archivo de receta (`recipe.json` o `recipe.yaml`)
+ Carpetas de compilación, como `greengrass-build`
+ `maven`: ejecuta el comando `mvn clean package` para compilar el origen del componente en artefactos. Elija esta opción para los componentes que usan [Maven](https://maven.apache.org/), como los componentes de Java.
En dispositivos Windows, esta característica está disponible para la versión 1.1.0 y posteriores de la CLI de GDK.
+ `gradle`: ejecuta el comando `gradle build` para compilar el origen del componente en artefactos. Elija esta opción para los componentes que usan [Gradle](https://gradle.org/). Esta característica está disponible para la versión 1.1.0 y posteriores de la CLI de GDK.
El sistema de compilación `gradle` admite Kotlin DSL como archivo de compilación. Esta característica está disponible para la versión 1.2.0 y versiones posteriores de la CLI de GDK.
+ `gradlew`: ejecuta el comando `gradlew` para compilar el origen del componente en artefactos. Elija esta opción para los componentes que usan el [Gradle Wrapper](https://docs.gradle.org/current/userguide/gradle_wrapper.html).
Esta característica está disponible para la versión 1.2.0 y versiones posteriores de la CLI de GDK.
+ `custom`: ejecuta un comando personalizado para compilar el origen del componente en una receta y artefactos. Especifique el comando personalizado en el parámetro `custom_build_command`.
1. Si especifica `custom` para `build_system`, agregue `custom_build_command` al objeto `build`. En `custom_build_command`, especifique una sola cadena o lista de cadenas, donde cada cadena es una palabra del comando. Por ejemplo, para ejecutar un comando de compilación personalizado para un componente de C\$1\$1, puede especificar **["cmake", "--build", "build", "--config", "Release"]**.
1. Si usa la versión 1.1.0 o posteriores de la CLI de GDK, puede especificar el argumento `--bucket` para especificar el bucket de S3 en el que la CLI de GDK carga los artefactos del componente. Si no especifica este argumento, la CLI de GDK se carga en el bucket de S3 cuyo nombre es `bucket-region-accountId`, donde *bucket* y *region* son los valores que especifica en `gdk-config.json` y *acountId* es el ID de su Cuenta de AWS. La CLI de GDK crea el bucket si no existe.
Cambie la configuración de publicación del componente. Haga lo siguiente:
1. Especifique el nombre del bucket de S3 que se usará para alojar artefactos de componentes.
1. Especifique la Región de AWS donde la CLI de GDK publica el componente.
Cuando haya terminado con este paso, el archivo `gdk-config.json` tendrá un aspecto similar al siguiente ejemplo.
```
{
"component": {
"com.example.PythonHelloWorld": {
"author": "Amazon",
"version": "NEXT_PATCH",
"build": {
"build_system" : "zip"
},
"publish": {
"bucket": "greengrass-component-artifacts",
"region": "us-west-2"
}
}
},
"gdk_version": "1.0.0"
}
```
1. Actualice el archivo de receta del componente, denominado `recipe.yaml` o `recipe.json`. Haga lo siguiente:
1. Si ha descargado una plantilla o un componente de comunidad que usa el sistema de compilación `zip`, compruebe que el nombre del artefacto zip coincide con el nombre de la carpeta del componente. La CLI de GDK comprime la carpeta del componente en un archivo zip con el mismo nombre que la carpeta del componente. La receta contiene el nombre del artefacto zip en la lista de artefactos de componentes y en los scripts de ciclo de vida que usan archivos del artefacto zip. Actualice las definiciones `Artifacts` y `Lifecycle` de forma que el nombre del archivo zip coincida con el nombre de la carpeta del componente. Los siguientes ejemplos de recetas parciales resaltan el nombre del archivo zip en las definiciones `Artifacts` y `Lifecycle`.
------
#### [ JSON ]
```
{
...
"Manifests": [
{
"Platform": {
"os": "all"
},
"Artifacts": [
{
"URI": "s3://{COMPONENT_NAME}/{COMPONENT_VERSION}/HelloWorld.zip",
"Unarchive": "ZIP"
}
],
"Lifecycle": {
"Run": "python3 -u {artifacts:decompressedPath}/HelloWorld/main.py {configuration:/Message}"
}
}
]
}
```
------
#### [ YAML ]
```
---
...
Manifests:
- Platform:
os: all
Artifacts:
- URI: "s3://BUCKET_NAME/COMPONENT_NAME/COMPONENT_VERSION/HelloWorld.zip"
Unarchive: ZIP
Lifecycle:
Run: "python3 -u {artifacts:decompressedPath}/HelloWorld/main.py {configuration:/Message}"
```
------
1. (Opcional) Actualice la descripción del componente, la configuración predeterminada, los artefactos, los scripts del ciclo de vida y el soporte de la plataforma. Para obtener más información, consulte [AWS IoT Greengrass referencia de recetas de componentes](component-recipe-reference.md).
Cuando haya terminado con este paso, el archivo de receta puede ser similar a los siguientes ejemplos.
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "{COMPONENT_NAME}",
"ComponentVersion": "{COMPONENT_VERSION}",
"ComponentDescription": "This is a simple Hello World component written in Python.",
"ComponentPublisher": "{COMPONENT_AUTHOR}",
"ComponentConfiguration": {
"DefaultConfiguration": {
"Message": "World"
}
},
"Manifests": [
{
"Platform": {
"os": "all"
},
"Artifacts": [
{
"URI": "s3://{COMPONENT_NAME}/{COMPONENT_VERSION}/HelloWorld.zip",
"Unarchive": "ZIP"
}
],
"Lifecycle": {
"Run": "python3 -u {artifacts:decompressedPath}/HelloWorld/main.py {configuration:/Message}"
}
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: "2020-01-25"
ComponentName: "{COMPONENT_NAME}"
ComponentVersion: "{COMPONENT_VERSION}"
ComponentDescription: "This is a simple Hello World component written in Python."
ComponentPublisher: "{COMPONENT_AUTHOR}"
ComponentConfiguration:
DefaultConfiguration:
Message: "World"
Manifests:
- Platform:
os: all
Artifacts:
- URI: "s3://BUCKET_NAME/COMPONENT_NAME/COMPONENT_VERSION/HelloWorld.zip"
Unarchive: ZIP
Lifecycle:
Run: "python3 -u {artifacts:decompressedPath}/HelloWorld/main.py {configuration:/Message}"
```
------
1. Desarrolle y compile el componente de Greengrass. El comando [component build](greengrass-development-kit-cli-component.md#greengrass-development-kit-cli-component-build) produce una receta y artefactos en la carpeta `greengrass-build` de la carpeta del componente. Ejecute el siguiente comando.
```
gdk component build
```
Cuando esté listo para probar el componente, use la CLI de GDK para publicarlo en el servicio de AWS IoT Greengrass. A continuación, puede implementar el componente en los dispositivos principales de Greengrass. Para obtener más información, consulte [Publique componentes para desplegarlos en sus dispositivos principales](publish-components.md).
## Creación de un componente (comandos de intérprete de comandos)
Siga las instrucciones de esta sección para crear carpetas de recetas y artefactos que contengan el código de origen y los artefactos de varios componentes.
**Desarrollo de un componente de Greengrass (comandos de intérprete de comandos)**
1. Cree una carpeta para sus componentes con subcarpetas para recetas y artefactos. Ejecute los siguientes comandos en su dispositivo principal de Greengrass para crear estas carpetas y cambiarlas a la carpeta de componentes. Reemplace *\$1/greengrassv2* o *%USERPROFILE%\$1greengrassv2* por la ruta a la carpeta que se usará para el desarrollo local.
------
#### [ Linux or Unix ]
```
mkdir -p ~/greengrassv2/{recipes,artifacts}
cd ~/greengrassv2
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir %USERPROFILE%\greengrassv2\\recipes, %USERPROFILE%\greengrassv2\\artifacts
cd %USERPROFILE%\greengrassv2
```
------
#### [ PowerShell ]
```
mkdir ~/greengrassv2/recipes, ~/greengrassv2/artifacts
cd ~/greengrassv2
```
------
1. Use un editor de texto para crear un archivo de recetas que define los metadatos, parámetros, dependencias, ciclo de vida y capacidad de plataforma de su componente. Incluya la versión del componente en el nombre del archivo de recetas para poder identificar qué receta refleja qué versión del componente. Puede elegir el formato YAML o JSON para su receta.
Por ejemplo, en un sistema basado en Linux, puede ejecutar el siguiente comando para usar GNU nano a fin de crear el archivo.
------
#### [ JSON ]
```
nano recipes/com.example.HelloWorld-1.0.0.json
```
------
#### [ YAML ]
```
nano recipes/com.example.HelloWorld-1.0.0.yaml
```
------
**nota**
AWS IoT Greengrass usa versiones semánticas para los componentes. Las versiones semánticas siguen un sistema de números de *principal*.*secundario*.*parche*. Por ejemplo, la versión `1.0.0` representa el primer lanzamiento principal de un componente. Para obtener más información, consulte la [especificación semántica de la versión](https://semver.org/).
1. Defina la receta de su componente. Para obtener más información, consulte [AWS IoT Greengrass referencia de recetas de componentes](component-recipe-reference.md).
Es posible que la receta sea similar a la siguiente receta de ejemplo de Hello World.
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.HelloWorld",
"ComponentVersion": "1.0.0",
"ComponentDescription": "My first AWS IoT Greengrass component.",
"ComponentPublisher": "Amazon",
"ComponentConfiguration": {
"DefaultConfiguration": {
"Message": "world"
}
},
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"run": "python3 -u {artifacts:path}/hello_world.py {configuration:/Message}"
}
},
{
"Platform": {
"os": "windows"
},
"Lifecycle": {
"run": "py -3 -u {artifacts:path}/hello_world.py {configuration:/Message}"
}
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.HelloWorld
ComponentVersion: '1.0.0'
ComponentDescription: My first AWS IoT Greengrass component.
ComponentPublisher: Amazon
ComponentConfiguration:
DefaultConfiguration:
Message: world
Manifests:
- Platform:
os: linux
Lifecycle:
run: |
python3 -u {artifacts:path}/hello_world.py "{configuration:/Message}"
- Platform:
os: windows
Lifecycle:
run: |
py -3 -u {artifacts:path}/hello_world.py "{configuration:/Message}"
```
------
Esta receta ejecuta un script de Python de Hello World, que puede ser similar al siguiente script de ejemplo.
```
import sys
message = "Hello, %s!" % sys.argv[1]
# Print the message to stdout, which Greengrass saves in a log file.
print(message)
```
1. Cree una carpeta para desarrollar la versión del componente. Le recomendamos que use una carpeta independiente para los artefactos de cada versión del componente, de modo que pueda identificar los artefactos de cada versión del componente. Ejecute el siguiente comando.
------
#### [ Linux or Unix ]
```
mkdir -p artifacts/com.example.HelloWorld/1.0.0
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir artifacts/com.example.HelloWorld/1.0.0
```
------
#### [ PowerShell ]
```
mkdir artifacts/com.example.HelloWorld/1.0.0
```
------
**importante**
Debe usar el siguiente formato para la ruta de la carpeta de artefactos. Incluya el nombre y la versión del componente que especifique en la receta.
```
artifacts/componentName/componentVersion/
```
1. Cree los artefactos de su componente en la carpeta creada en el paso anterior. Los artefactos pueden incluir software, imágenes y cualquier otro binario que use el componente.
Cuando el componente esté listo, [pruébelo](test-components.md).
# Prueba de los componentes de AWS IoT Greengrass con implementaciones locales
Si desarrolla un componente de Greengrass en un dispositivo principal, puede crear una implementación local para instalarlo y probarlo. Siga los pasos de esta sección para crear una implementación local.
Si desarrolla el componente en un equipo diferente, como un equipo de desarrollo local, no podrá crear una implementación local. En su lugar, publique el componente en el servicio de AWS IoT Greengrass para poder implementarlo en los dispositivos principales de Greengrass para probarlo. Para obtener más información, consulte [Publique componentes para desplegarlos en sus dispositivos principales](publish-components.md) y [Implemente AWS IoT Greengrass componentes en los dispositivos](manage-deployments.md).
**Cómo probar un componente en un dispositivo principal de Greengrass**
1. El dispositivo principal registra eventos como las actualizaciones de componentes. Puede ver este archivo de registro para detectar y solucionar errores en su componente, como una receta no válida. Este archivo de registro también muestra los mensajes que el componente imprime en formato estándar (stdout). Le recomendamos que abra una sesión de terminal adicional en su dispositivo principal para observar los nuevos mensajes de registro en tiempo real. Abra una nueva sesión de terminal, por ejemplo, mediante SSH, y ejecute el siguiente comando para ver los registros. Sustituya `/greengrass/v2` por la ruta a la carpeta raíz de AWS IoT Greengrass.
------
#### [ Linux or Unix ]
```
sudo tail -f /greengrass/v2/logs/greengrass.log
```
------
#### [ PowerShell ]
```
gc C:\greengrass\v2\logs\greengrass.log -Tail 10 -Wait
```
------
También puede ver el archivo de registro de su componente.
------
#### [ Linux or Unix ]
```
sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log
```
------
#### [ PowerShell ]
```
gc C:\greengrass\v2\logs\com.example.HelloWorld.log -Tail 10 -Wait
```
------
1. En la sesión de terminal original, ejecute el siguiente comando para actualizar el dispositivo principal con su componente. Sustituya `/greengrass/v2` por la ruta a la carpeta raíz de AWS IoT Greengrass y sustituya *\$1/greengrassv2* por la ruta a su carpeta de desarrollo local.
------
#### [ Linux or Unix ]
```
sudo /greengrass/v2/bin/greengrass-cli deployment create \
--recipeDir ~/greengrassv2/recipes \
--artifactDir ~/greengrassv2/artifacts \
--merge "com.example.HelloWorld=1.0.0"
```
------
#### [ Windows Command Prompt (CMD) ]
```
C:\greengrass\v2\bin\greengrass-cli deployment create ^
--recipeDir %USERPROFILE%\greengrassv2\recipes ^
--artifactDir %USERPROFILE%\greengrassv2\artifacts ^
--merge "com.example.HelloWorld=1.0.0"
```
------
#### [ PowerShell ]
```
C:\greengrass\v2\bin\greengrass-cli deployment create `
--recipeDir ~/greengrassv2/recipes `
--artifactDir ~/greengrassv2/artifacts `
--merge "com.example.HelloWorld=1.0.0"
```
------
**nota**
También puede usar el comando `greengrass-cli deployment create` para establecer el valor de los parámetros de configuración de su componente. Para obtener más información, consulte [crear](gg-cli-deployment.md#deployment-create).
1. Utilice el comando `greengrass-cli deployment status` para supervisar el estado de la implementación del componente.
------
#### [ Unix or Linux ]
```
sudo /greengrass/v2/bin/greengrass-cli deployment status \
-i deployment-id
```
------
#### [ Windows Command Prompt (CMD) ]
```
C:\greengrass\v2\bin\greengrass-cli deployment status ^
-i deployment-id
```
------
#### [ PowerShell ]
```
C:\greengrass\v2\bin\greengrass-cli deployment status `
-i deployment-id
```
------
1. Pruebe el componente cuando se ejecuta en el dispositivo principal de Greengrass. Cuando termine esta versión del componente, puede cargarlo en el servicio de AWS IoT Greengrass. A continuación, puede implementar el componente en otros dispositivos principales. Para obtener más información, consulte [Publique componentes para desplegarlos en sus dispositivos principales](publish-components.md).
# Publique componentes para desplegarlos en sus dispositivos principales
Después de crear o completar una versión de un componente, puede publicarla en el servicio de AWS IoT Greengrass. Luego, puede implementarlo en los dispositivos principales de Greengrass.
Si utiliza la [CLI del kit de desarrollo de Greengrass (CLI del GDK)](greengrass-development-kit-cli.md) para [desarrollar y crear un componente](create-components.md), puede [utilizar la CLI de GDK](#publish-component-gdk-cli) para publicar el componente en la Nube de AWS. De lo contrario, [utilice el intérprete de comandos integrados y la AWS CLI](#publish-component-shell-commands) para publicar el componente.
También se puede utilizar AWS CloudFormation para crear componentes y otros recursos de AWS a partir de plantillas. Para obtener más información, consulte [¿Qué es AWS CloudFormation?](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html) y [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-greengrassv2-componentversion.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-greengrassv2-componentversion.html) en la *Guía del usuario de AWS CloudFormation*.
**Topics**
+ [Publicación de un componente (CLI de GDK)](#publish-component-gdk-cli)
+ [Publicación de un componente (intérprete de comandos)](#publish-component-shell-commands)
## Publicación de un componente (CLI de GDK)
Siga las instrucciones de esta sección para publicar un componente mediante la CLI de GDK. La CLI de GDK carga los artefactos de compilación en un bucket de S3, actualiza los URI de los artefactos en la receta y crea el componente a partir de la receta. Debe especificar el bucket y la región de S3 que se van a utilizar en el [archivo de configuración de la CLI de GDK](gdk-cli-configuration-file.md).
Si usa la versión 1.1.0 o posteriores de la CLI de GDK, puede especificar el argumento `--bucket` para especificar el bucket de S3 en el que la CLI de GDK carga los artefactos del componente. Si no especifica este argumento, la CLI de GDK se carga en el bucket de S3 cuyo nombre es `bucket-region-accountId`, donde *bucket* y *region* son los valores que especifica en `gdk-config.json` y *acountId* es el ID de su Cuenta de AWS. La CLI de GDK crea el bucket si no existe.
**importante**
Los roles de los dispositivos principales no permiten el acceso a los buckets de S3 de forma predeterminada. Si es la primera vez que utiliza este bucket de S3, debe agregar permisos al rol para que los dispositivos principales puedan recuperar los artefactos de los componentes de este bucket de S3. Para obtener más información, consulte [Cómo permitir el acceso a los buckets de S3 para los artefactos del componente](device-service-role.md#device-service-role-access-s3-bucket).
**Publicación de un componente de Greengrass (CLI de GDK)**
1. Abra la carpeta del componente en una ventana del sistema o un terminal.
1. Si aún no lo ha hecho, cree el componente de Greengrass. El comando [component build](greengrass-development-kit-cli-component.md#greengrass-development-kit-cli-component-build) produce una receta y artefactos en la carpeta `greengrass-build` de la carpeta del componente. Ejecute el siguiente comando.
```
gdk component build
```
1. Publique el componente en la Nube de AWS. El comando [component publish](greengrass-development-kit-cli-component.md#greengrass-development-kit-cli-component-publish) carga los artefactos del componente en Amazon S3 y actualiza la receta del componente con el URI de cada artefacto. A continuación, crea el componente en el servicio de AWS IoT Greengrass.
**nota**
AWS IoT Greengrass calcula el resumen de cada artefacto al crear el componente. Esto significa que no puede modificar los archivos de artefactos de su bucket de S3 después de crear un componente. Si lo hace, las implementaciones que incluyan este componente fallarán porque el resumen del archivo no coincide. Si modifica un archivo de artefactos, debe crear una nueva versión del componente.
Si especifica `NEXT_PATCH` para la versión del componente en el archivo de configuración de la CLI del GDK, la CLI del GDK utilizará la siguiente versión del parche que aún no exista en el servicio de AWS IoT Greengrass.
Ejecute el siguiente comando.
```
gdk component publish
```
El resultado indica la versión del componente que creó la CLI de GDK.
Una vez publicado el componente, puede implementarlo en los dispositivos principales. Para obtener más información, consulte [Implemente AWS IoT Greengrass componentes en los dispositivos](manage-deployments.md).
## Publicación de un componente (intérprete de comandos)
Utilice el siguiente procedimiento para publicar un componente mediante los intérprete de comandos y la AWS Command Line Interface (AWS CLI). Al publicar un componente, puede hacer lo siguiente:
1. Publique artefactos de componentes en un bucket de S3.
1. Agregue el URI de Amazon S3 de cada artefacto a la receta del componente.
1. Cree una versión del componente en AWS IoT Greengrass a partir de la receta del componente.
**nota**
Cada versión de componente que cargue debe ser única. Asegúrese de cargar la versión del componente correcta, ya que no podrá editarla después de cargarla.
Puede seguir estos pasos para publicar un componente desde su computadora de desarrollo o su dispositivo principal de Greengrass.
**Publicación de un componente (intérprete de comandos)**
1. Si el componente usa una versión que existe en el servicio de AWS IoT Greengrass, debe cambiarla. Abra la receta en un editor de texto, incremente la versión y guarde el archivo. Elija una nueva versión que refleje los cambios que ha realizado en el componente.
**nota**
AWS IoT Greengrass usa versiones semánticas para los componentes. Las versiones semánticas siguen un sistema de números de *principal*.*secundario*.*parche*. Por ejemplo, la versión `1.0.0` representa el primer lanzamiento principal de un componente. Para obtener más información, consulte la [especificación semántica de la versión](https://semver.org/).
1. Si el componente tiene artefactos, haga lo siguiente:
1. Publique los artefactos del componente en un bucket de S3 en su Cuenta de AWS.
**sugerencia**
Le recomendamos que incluya el nombre y la versión del componente en la ruta al artefacto del bucket de S3. Este esquema de nomenclatura puede ayudarlo a conservar los artefactos que utilizan las versiones anteriores del componente, de forma que pueda seguir admitiendo las versiones anteriores del componente.
Ejecute el siguiente comando para publicar un archivo de artefacto en un bucket de S3. Sustituya amzn-s3-demo-bucket por el nombre del bucket y sustituya *artifacts/com.example.helloworld/1.0.0/artifact.py* por la ruta al archivo del artefacto.
```
aws s3 cp artifacts/com.example.HelloWorld/1.0.0/artifact.py s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/artifact.py
```
**importante**
Los roles de los dispositivos principales no permiten el acceso a los buckets de S3 de forma predeterminada. Si es la primera vez que utiliza este bucket de S3, debe agregar permisos al rol para que los dispositivos principales puedan recuperar los artefactos de los componentes de este bucket de S3. Para obtener más información, consulte [Cómo permitir el acceso a los buckets de S3 para los artefactos del componente](device-service-role.md#device-service-role-access-s3-bucket).
1. Agregue una lista llamada `Artifacts` a la receta del componente si no está presente. La lista `Artifacts` aparece en cada manifiesto, donde se definen los requisitos del componente en cada plataforma compatible (o los requisitos predeterminados del componente para todas las plataformas).
1. Agregue cada artefacto a la lista de artefactos o actualice el URI de los artefactos existentes. El URI de Amazon S3 está compuesto por el nombre del bucket y la ruta al objeto artefacto del bucket. Los URI de Amazon S3 de sus artefactos deberían ser similares al siguiente ejemplo.
```
s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/artifact.py
```
Después de completar estos pasos, la receta debería tener una lista `Artifacts` similar a la siguiente.
------
#### [ JSON ]
```
{
...
"Manifests": [
{
"Lifecycle": {
...
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/MyGreengrassComponent/1.0.0/artifact.py",
"Unarchive": "NONE"
}
]
}
]
}
```
**nota**
Puede agregar la opción `"Unarchive": "ZIP"` para que un artefacto ZIP configure el software AWS IoT Greengrass Core de forma que descomprima el artefacto cuando se implemente el componente.
------
#### [ YAML ]
```
...
Manifests:
- Lifecycle:
...
Artifacts:
- URI: s3://amzn-s3-demo-bucket/artifacts/MyGreengrassComponent/1.0.0/artifact.py
Unarchive: NONE
```
**nota**
Puede utilizar la opción `Unarchive: ZIP` para configurar el software AWS IoT Greengrass Core para descomprimir un artefacto ZIP cuando se implemente el componente. Para obtener más información sobre cómo utilizar los artefactos ZIP en un componente, consulte [la variable de receta artifacts:decompressedPath](component-recipe-reference.md#component-recipe-artifacts-decompressed-path).
------
Para obtener más información acerca de las recetas, consulte [AWS IoT Greengrass referencia de recetas de componentes](component-recipe-reference.md).
1. Utilice la consola de AWS IoT Greengrass para crear un componente a partir del archivo de recetas.
Utilice el siguiente comando para crear un componente a partir del archivo de recetas. Este comando crea el componente y lo publica como un componente de AWS IoT Greengrass privado en su Cuenta de AWS. Sustituya *path/to/recipeFile* por la ruta del archivo de receta.
```
aws greengrassv2 create-component-version --inline-recipe fileb://path/to/recipeFile
```
Copie el `arn` de la respuesta para comprobar el estado del componente en el paso siguiente.
**nota**
AWS IoT Greengrass calcula el resumen de cada artefacto al crear el componente. Esto significa que no puede modificar los archivos de artefactos de su bucket de S3 después de crear un componente. Si lo hace, las implementaciones que incluyan este componente fallarán porque el resumen del archivo no coincide. Si modifica un archivo de artefactos, debe crear una nueva versión del componente.
1. Cada componente del servicio de AWS IoT Greengrass tiene un estado. Ejecute el siguiente comando para confirmar el estado de la versión del componente que publique en este procedimiento. Sustituya *com.example.HelloWorld* y *1.0.0* por la versión del componente que desee consultar. Sustituya `arn` por el ARN del paso anterior.
```
aws greengrassv2 describe-component --arn "arn:aws:greengrass:region:account-id:components:com.example.HelloWorld:versions:1.0.0"
```
La operación devuelve una respuesta que contiene los metadatos del componente. Los metadatos contienen un objeto `status` que contiene el estado del componente y cualquier error, si corresponde.
Cuando el estado del componente es `DEPLOYABLE`, puede implementar el componente en los dispositivos. Para obtener más información, consulte [Implemente AWS IoT Greengrass componentes en los dispositivos](manage-deployments.md).
# Interacción con servicios de AWS
Los dispositivos principales de Greengrass usan certificados X.509 para conectarse a AWS IoT Core mediante protocolos de autenticación mutua de TLS. Estos certificados permiten a los dispositivos interactuar con AWS IoT sin credenciales de AWS, que normalmente constan de un ID de clave de acceso y de una clave de acceso secreta. Otros servicios de AWS requieren credenciales de AWS en lugar de certificados X.509 para llamar a operaciones de la API en los puntos de conexión del servicio. AWS IoT Core tiene un proveedor de credenciales que permite a los dispositivos utilizar su certificado X.509 para autenticar las solicitudes de AWS. El proveedor de credenciales de AWS IoT autentica los dispositivos mediante un certificado X.509 y emite credenciales de AWS en forma de un token de seguridad temporal con privilegios limitados. Los dispositivos pueden utilizar este token para firmar y autenticar cualquier solicitud de AWS. Esto elimina la necesidad de almacenar credenciales de AWS en los dispositivos principales de Greengrass. Para obtener más información, consulte [Autorización de llamadas a los servicios de AWS](https://docs.aws.amazon.com/iot/latest/developerguide/authorizing-direct-aws.html) en la *Guía para desarrolladores de AWS IoT Core*.
Para obtener las credenciales de AWS IoT, los dispositivos principales de Greengrass utilizan un alias de rol AWS IoT que apunta a un rol de IAM. Este rol de IAM se denomina *rol de intercambio de token*. El alias del rol y el rol de intercambio de token se crean al instalar el software AWS IoT Greengrass Core. Para especificar el alias de rol que utiliza un dispositivo principal, configure el parámetro `iotRoleAlias` del [Núcleo de Greengrass](greengrass-nucleus-component.md).
El proveedor de credenciales de AWS IoT asume el rol de intercambio de token en su nombre para proporcionar credenciales de AWS a los dispositivos principales. Puede adjuntar las políticas de IAM adecuadas a este rol para permitir que sus dispositivos principales accedan a sus recursos de AWS, como los artefactos de componentes en buckets de S3. Para obtener más información acerca de cómo configurar el rol de intercambio de token, consulte [Autorizar a los dispositivos principales a interactuar con AWS los servicios](device-service-role.md).
Los dispositivos principales de Greengrass almacenan credenciales de AWS en la memoria y, de forma predeterminada, las credenciales caducan después de una hora. Si el software AWS IoT Greengrass Core se reinicia, debe volver a obtener las credenciales. Puede utilizar la operación [UpdateRoleAlias](https://docs.aws.amazon.com/iot/latest/apireference/API_UpdateRoleAlias.html) para configurar el periodo de validez de las credenciales.
AWS IoT Greengrass proporciona un componente público, el componente del servicio de intercambio de token, que puede definir como una dependencia en su componente personalizado para interactuar con los servicios de AWS. El servicio de intercambio de token proporciona al componente una variable de entorno, `AWS_CONTAINER_CREDENTIALS_FULL_URI`, que define el URI de un servidor local que proporciona las credenciales de AWS. Al crear un cliente del SDK de AWS, el cliente comprueba esta variable de entorno y se conecta al servidor local para recuperar las credenciales de AWS y las utiliza para firmar las solicitudes de la API. Esto le permite usar los SDK de AWS y otras herramientas para llamar a los servicios de AWS en sus componentes. Para obtener más información, consulte [Servicio de intercambio de token](token-exchange-service-component.md).
**importante**
La compatibilidad para adquirir credenciales de AWS de esta manera se agregó a los SDK de AWS el 13 de julio de 2016. Su componente debe utilizar una versión del SDK de AWS creada en esa fecha o después. Para obtener más información, consulte [Uso de un SDK de AWS compatible](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html#task-iam-roles-minimum-sdk) en la *Guía para desarrolladores de Amazon Elastic Container Service*.
Para adquirir credenciales de AWS en su componente personalizado, defina `aws.greengrass.TokenExchangeService` como una dependencia en la receta del componente. El siguiente ejemplo de receta define un componente que instala [boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) y ejecuta un script de Python que usa las credenciales de AWS del servicio de intercambio de token para enumerar los buckets de Amazon S3.
**nota**
Para ejecutar este ejemplo de componente, el dispositivo debe tener el permiso `s3:ListAllMyBuckets`. Para obtener más información, consulte [Autorizar a los dispositivos principales a interactuar con AWS los servicios](device-service-role.md).
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.ListS3Buckets",
"ComponentVersion": "1.0.0",
"ComponentDescription": "A component that uses the token exchange service to list S3 buckets.",
"ComponentPublisher": "Amazon",
"ComponentDependencies": {
"aws.greengrass.TokenExchangeService": {
"VersionRequirement": "^2.0.0",
"DependencyType": "HARD"
}
},
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"install": "pip3 install --user boto3",
"Run": "python3 -u {artifacts:path}/list_s3_buckets.py"
}
},
{
"Platform": {
"os": "windows"
},
"Lifecycle": {
"install": "pip3 install --user boto3",
"Run": "py -3 -u {artifacts:path}/list_s3_buckets.py"
}
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.ListS3Buckets
ComponentVersion: '1.0.0'
ComponentDescription: A component that uses the token exchange service to list S3 buckets.
ComponentPublisher: Amazon
ComponentDependencies:
aws.greengrass.TokenExchangeService:
VersionRequirement: '^2.0.0'
DependencyType: HARD
Manifests:
- Platform:
os: linux
Lifecycle:
install:
pip3 install --user boto3
Run: |-
python3 -u {artifacts:path}/list_s3_buckets.py
- Platform:
os: windows
Lifecycle:
install:
pip3 install --user boto3
Run: |-
py -3 -u {artifacts:path}/list_s3_buckets.py
```
------
Este ejemplo de componente ejecuta el siguiente script de Python, `list_s3_buckets.py`, que muestra una lista de los buckets de Amazon S3.
```
import boto3
import os
try:
print("Creating boto3 S3 client...")
s3 = boto3.client('s3')
print("Successfully created boto3 S3 client")
except Exception as e:
print("Failed to create boto3 s3 client. Error: " + str(e))
exit(1)
try:
print("Listing S3 buckets...")
response = s3.list_buckets()
for bucket in response['Buckets']:
print(f'\t{bucket["Name"]}')
print("Successfully listed S3 buckets")
except Exception as e:
print("Failed to list S3 buckets. Error: " + str(e))
exit(1)
```
# Ejecución de un contenedor de Docker
Puede configurar AWS IoT Greengrass los componentes para que ejecuten un contenedor [Docker](https://www.docker.com/) a partir de imágenes almacenadas en las siguientes ubicaciones:
+ Repositorios de imágenes públicos y privados en Amazon Elastic Container Registry (Amazon ECR)
+ Repositorio público de Docker Hub
+ Registro público de confianza de Docker
+ Bucket de S3
En su componente personalizado, incluya el URI de la imagen de Docker como un artefacto para recuperar la imagen y ejecutarla en el dispositivo principal. En el caso de las imágenes de Amazon ECR y Docker Hub, puede utilizar el componente [administrador de aplicaciones de Docker](docker-application-manager-component.md) para descargar las imágenes y administrar las credenciales de los repositorios privados de Amazon ECR.
**Topics**
+ [Requisitos](#run-docker-container-requirements)
+ [Ejecute un contenedor de Docker desde una imagen pública en Amazon ECR o Docker Hub](#run-docker-container-public-ecr-dockerhub)
+ [Ejecución de un contenedor de Docker desde una imagen privada en Amazon ECR](#run-docker-container-private-ecr)
+ [Ejecute un contenedor de Docker desde una imagen en Amazon S3](#run-docker-container-s3)
+ [Uso de la comunicación entre procesos en los componentes del contenedor de Docker](#docker-container-ipc)
+ [Utilice AWS las credenciales en los componentes del contenedor de Docker (Linux)](#docker-container-token-exchange-service)
+ [Uso del administrador de flujos en los componentes del contenedor de Docker (Linux)](#docker-container-stream-manager)
## Requisitos
Para ejecutar un contenedor de Docker en un componente, necesita lo siguiente:
+ Un dispositivo principal de Greengrass. Si no dispone de una, consulte [Tutorial: Introducción a AWS IoT Greengrass V2](getting-started.md).
+ Versión 1.9.1 o posterior de [Docker Engine](https://docs.docker.com/engine/) instalada en el dispositivo principal de Greengrass. La versión 20.10 es la última versión que se ha comprobado que funciona con el software AWS IoT Greengrass Core. Debe instalar Docker directamente en el dispositivo principal antes de implementar componentes que ejecuten contenedores de Docker.
**sugerencia**
También puede configurar el dispositivo principal para instalar Docker Engine cuando se instale el componente. Por ejemplo, el siguiente script de instalación instala Docker Engine antes de cargar la imagen de Docker. Este script de instalación funciona en distribuciones de Linux basadas en Debian, como Ubuntu. Si configura el componente para instalar Docker Engine con este comando, puede que tenga que configurar `RequiresPrivilege` en `true` en el script del ciclo de vida para ejecutar la instalación y los comandos `docker`. Para obtener más información, consulte [AWS IoT Greengrass referencia de recetas de componentes](component-recipe-reference.md).
```
apt-get install docker-ce docker-ce-cli containerd.io && docker load -i {artifacts:path}/hello-world.tar
```
+ El usuario del sistema que ejecute un componente contenedor de Docker debe tener permisos de raíz o administrador, o bien debe configurar Docker para que se ejecute como un usuario no de raíz o no administrador.
+ En los dispositivos Linux, debe agregar un usuario al grupo de `docker` para llamar comandos `docker` sin `sudo`.
+ En los dispositivos Windows, puede agregar un usuario al grupo de `docker-users` para llamar comandos `docker` sin privilegios de administrador.
------
#### [ Linux or Unix ]
Para agregar `ggc_user`, o el usuario no raíz que utilice para ejecutar los componentes del contenedor de Docker, al grupo de `docker`, ejecute el siguiente comando.
```
sudo usermod -aG docker ggc_user
```
Para obtener más información, consulte [Administrar Docker como un usuario no raíz](https://docs.docker.com/engine/install/linux-postinstall/#manage-docker-as-a-non-root-user).
------
#### [ Windows Command Prompt (CMD) ]
Para agregar `ggc_user`, o el usuario que utilice para ejecutar los componentes del contenedor de Docker, al grupo de `docker-users`, ejecute el siguiente comando como un administrador.
```
net localgroup docker-users ggc_user /add
```
------
#### [ Windows PowerShell ]
Para agregar `ggc_user`, o el usuario que utilice para ejecutar los componentes del contenedor de Docker, al grupo de `docker-users`, ejecute el siguiente comando como un administrador.
```
Add-LocalGroupMember -Group docker-users -Member ggc_user
```
------
+ Los archivos a los que accede el componente contenedor de Docker se [montan como un volumen](https://docs.docker.com/storage/volumes/) en el contenedor de Docker.
+ Si [configura el software AWS IoT Greengrass Core para usar un proxy de red](configure-greengrass-core-v2.md#configure-alpn-network-proxy), debe [configurar Docker para que use el mismo servidor proxy](https://docs.docker.com/network/proxy/).
Además de estos requisitos, también debe cumplir con los siguientes requisitos si se aplican a su entorno:
+ Para usar [Docker Compose](https://docs.docker.com/compose/) para crear e iniciar sus contenedores de Docker, instale Docker Compose en su dispositivo principal de Greengrass y cargue el archivo de Docker Compose en un bucket de S3. Debe almacenar el archivo Compose en un depósito de S3 en el mismo componente Cuenta de AWS y Región de AWS como él. Para ver un ejemplo en el que se usa el comando `docker-compose up` en un componente personalizado, consulte [Ejecute un contenedor de Docker desde una imagen pública en Amazon ECR o Docker Hub](#run-docker-container-public-ecr-dockerhub).
+ Si utilizas un proxy AWS IoT Greengrass de red, configura el daemon de Docker para que utilice un [servidor proxy](https://docs.docker.com/network/proxy/).
+ Si sus imágenes de Docker están almacenadas en Amazon ECR o Docker Hub, incluya el [componente administrador de componentes de Docker](docker-application-manager-component.md) como una dependencia en su componente de contenedor de Docker. Debe iniciar el daemon Docker en el dispositivo principal antes de implementar su componente.
Además, incluya la imagen URIs como elemento componente. La imagen URIs debe tener el formato `docker:registry/image[:tag|@digest]` que se muestra en los siguientes ejemplos:
+ Imagen privada de Amazon ECR: `docker:account-id.dkr.ecr.region.amazonaws.com/repository/image[:tag|@digest]`
+ Imagen pública de Amazon ECR: `docker:public.ecr.aws/repository/image[:tag|@digest]`
+ Imagen pública de Docker Hub: `docker:name[:tag|@digest]`
Para obtener más información sobre cómo ejecutar contenedores de Docker a partir de imágenes almacenadas en repositorios públicos, consulte [Ejecute un contenedor de Docker desde una imagen pública en Amazon ECR o Docker Hub](#run-docker-container-public-ecr-dockerhub).
+ Si sus imágenes de Docker están almacenadas en un registro privado de Amazon ECR, debe incluir el componente del servicio de intercambio de token como una dependencia en el componente contenedor de Docker. Además, el [rol de dispositivo de Greengrass](device-service-role.md) debe permitir las acciones `ecr:GetAuthorizationToken`, `ecr:BatchGetImage` y `ecr:GetDownloadUrlForLayer` como se muestra en el siguiente ejemplo de política de IAM.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"ecr:GetAuthorizationToken",
"ecr:BatchGetImage",
"ecr:GetDownloadUrlForLayer"
],
"Resource": [
"*"
],
"Effect": "Allow"
}
]
}
```
------
Para obtener más información sobre cómo ejecutar contenedores de Docker a partir de imágenes almacenadas en repositorios privados de Amazon ECR, consulte [Ejecución de un contenedor de Docker desde una imagen privada en Amazon ECR](#run-docker-container-private-ecr).
+ Para usar imágenes de Docker almacenadas en un repositorio privado de Amazon ECR, el repositorio privado debe estar en el Región de AWS mismo lugar que el dispositivo principal.
+ Si sus imágenes de Docker o archivos de Compose se almacenan en un bucket de S3, el [rol del dispositivo de Greengrass](device-service-role.md) debe conceder el permiso `s3:GetObject` para que los dispositivos principales descarguen las imágenes como artefactos de componentes, como se muestra en el siguiente ejemplo de política de IAM.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"s3:GetObject"
],
"Resource": [
"*"
],
"Effect": "Allow"
}
]
}
```
------
Para obtener más información sobre cómo ejecutar contenedores de Docker a partir de imágenes almacenadas en Amazon S3, consulte [Ejecute un contenedor de Docker desde una imagen en Amazon S3](#run-docker-container-s3).
+ Para usar la comunicación entre procesos (IPC), las credenciales de AWS o el administrador de flujos en el componente contenedor de Docker, debe especificar opciones adicionales al ejecutar el contenedor de Docker. Para obtener más información, consulte los siguientes temas:
+ [Uso de la comunicación entre procesos en los componentes del contenedor de Docker](#docker-container-ipc)
+ [Utilice AWS las credenciales en los componentes del contenedor de Docker (Linux)](#docker-container-token-exchange-service)
+ [Uso del administrador de flujos en los componentes del contenedor de Docker (Linux)](#docker-container-stream-manager)
## Ejecute un contenedor de Docker desde una imagen pública en Amazon ECR o Docker Hub
En esta sección, se describe cómo crear un componente personalizado que utilice Docker Compose para ejecutar un contenedor de Docker a partir de imágenes de Docker almacenadas en Amazon ECR y Docker Hub.
**Cómo ejecutar un contenedor de Docker mediante Docker Compose**
1. Cree y cargue un archivo de Docker Compose en un bucket de Amazon S3. Asegúrese de que el [rol de dispositivo de Greengrass](device-service-role.md) otorgue el permiso `s3:GetObject` para permitir que el dispositivo acceda al archivo de Compose. El archivo Compose de ejemplo que se muestra en el siguiente ejemplo incluye la imagen de Amazon CloudWatch Agent de Amazon ECR y la imagen de MySQL de Docker Hub.
```
version: "3"
services:
cloudwatchagent:
image: "public.ecr.aws/cloudwatch-agent/cloudwatch-agent:latest"
mysql:
image: "mysql:8.0"
```
1. [Cree un componente personalizado](create-components.md) en su dispositivo AWS IoT Greengrass principal. La receta de ejemplo que se muestra en el ejemplo siguiente incluye las siguientes propiedades:
+ El componente del administrador de aplicaciones de Docker como dependencia. Este componente permite a AWS IoT Greengrass descargar imágenes de los repositorios públicos de Amazon ECR y Docker Hub.
+ Un artefacto componente que especifica una imagen de Docker en un repositorio público de Amazon ECR.
+ Un artefacto componente que especifica una imagen de Docker en un repositorio público de Docker Hub.
+ Un artefacto componente que especifica el archivo de Docker Compose que incluye los contenedores para las imágenes de Docker que quiere ejecutar.
+ Un script de ejecución de ciclo de vida que usa [docker-compose up](https://docs.docker.com/compose/reference/up/) para crear e iniciar un contenedor a partir de las imágenes especificadas.
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.MyDockerComposeComponent",
"ComponentVersion": "1.0.0",
"ComponentDescription": "A component that uses Docker Compose to run images from public Amazon ECR and Docker Hub.",
"ComponentPublisher": "Amazon",
"ComponentDependencies": {
"aws.greengrass.DockerApplicationManager": {
"VersionRequirement": "~2.0.0"
}
},
"Manifests": [
{
"Platform": {
"os": "all"
},
"Lifecycle": {
"Run": "docker-compose -f {artifacts:path}/docker-compose.yaml up"
},
"Artifacts": [
{
"URI": "docker:public.ecr.aws/cloudwatch-agent/cloudwatch-agent:latest"
},
{
"URI": "docker:mysql:8.0"
},
{
"URI": "s3://amzn-s3-demo-bucket/folder/docker-compose.yaml"
}
]
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.MyDockerComposeComponent
ComponentVersion: '1.0.0'
ComponentDescription: 'A component that uses Docker Compose to run images from public Amazon ECR and Docker Hub.'
ComponentPublisher: Amazon
ComponentDependencies:
aws.greengrass.DockerApplicationManager:
VersionRequirement: ~2.0.0
Manifests:
- Platform:
os: all
Lifecycle:
Run: docker-compose -f {artifacts:path}/docker-compose.yaml up
Artifacts:
- URI: "docker:public.ecr.aws/cloudwatch-agent/cloudwatch-agent:latest"
- URI: "docker:mysql:8.0"
- URI: "s3://amzn-s3-demo-bucket/folder/docker-compose.yaml"
```
------
**nota**
Para usar la comunicación entre procesos (IPC), las credenciales de AWS o el administrador de flujos en el componente contenedor de Docker, debe especificar opciones adicionales al ejecutar el contenedor de Docker. Para obtener más información, consulte los siguientes temas:
[Uso de la comunicación entre procesos en los componentes del contenedor de Docker](#docker-container-ipc)
[Utilice AWS las credenciales en los componentes del contenedor de Docker (Linux)](#docker-container-token-exchange-service)
[Uso del administrador de flujos en los componentes del contenedor de Docker (Linux)](#docker-container-stream-manager)
1. [Pruebe el componente](test-components.md) para comprobar que funciona según lo previsto.
**importante**
Debe instalar e iniciar el daemon Docker antes de implementar su componente.
Tras implementar el componente localmente, puede ejecutar el comando [docker container ls](https://docs.docker.com/engine/reference/commandline/container_ls/) para comprobar que el contenedor se ejecuta.
```
docker container ls
```
1. Cuando el componente esté listo, cárguelo AWS IoT Greengrass para implementarlo en otros dispositivos principales. Para obtener más información, consulte [Publique componentes para desplegarlos en sus dispositivos principales](publish-components.md).
## Ejecución de un contenedor de Docker desde una imagen privada en Amazon ECR
En esta sección, se describe cómo crear un componente personalizado que ejecute un contenedor de Docker desde una imagen de Docker almacenada en un repositorio privado en Amazon ECR.
**Cómo ejecutar un contenedor de Docker**
1. [Cree un componente personalizado](create-components.md) en su dispositivo AWS IoT Greengrass principal. Utilice la siguiente receta de ejemplo, que incluye las siguientes propiedades:
+ El componente del administrador de aplicaciones de Docker como dependencia. Este componente permite a AWS IoT Greengrass administrar las credenciales para descargar imágenes de repositorios privados.
+ El componente del servicio de intercambio de token como dependencia. Este componente permite AWS IoT Greengrass recuperar AWS credenciales para interactuar con Amazon ECR.
+ Un artefacto componente que especifica una imagen de Docker en un repositorio público de Amazon ECR.
+ Un script de ejecución de ciclo de vida que utiliza [docker run](https://docs.docker.com/engine/reference/commandline/run/) para crear e iniciar un contenedor desde la imagen.
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.MyPrivateDockerComponent",
"ComponentVersion": "1.0.0",
"ComponentDescription": "A component that runs a Docker container from a private Amazon ECR image.",
"ComponentPublisher": "Amazon",
"ComponentDependencies": {
"aws.greengrass.DockerApplicationManager": {
"VersionRequirement": "~2.0.0"
},
"aws.greengrass.TokenExchangeService": {
"VersionRequirement": "~2.0.0"
}
},
"Manifests": [
{
"Platform": {
"os": "all"
},
"Lifecycle": {
"Run": "docker run account-id.dkr.ecr.region.amazonaws.com/repository[:tag|@digest]"
},
"Artifacts": [
{
"URI": "docker:account-id.dkr.ecr.region.amazonaws.com/repository[:tag|@digest]"
}
]
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.MyPrivateDockerComponent
ComponentVersion: '1.0.0'
ComponentDescription: 'A component that runs a Docker container from a private Amazon ECR image.'
ComponentPublisher: Amazon
ComponentDependencies:
aws.greengrass.DockerApplicationManager:
VersionRequirement: ~2.0.0
aws.greengrass.TokenExchangeService:
VersionRequirement: ~2.0.0
Manifests:
- Platform:
os: all
Lifecycle:
Run: docker run account-id.dkr.ecr.region.amazonaws.com/repository[:tag|@digest]
Artifacts:
- URI: "docker:account-id.dkr.ecr.region.amazonaws.com/repository[:tag|@digest]"
```
------
**nota**
Para usar la comunicación entre procesos (IPC), las credenciales de AWS o el administrador de flujos en el componente contenedor de Docker, debe especificar opciones adicionales al ejecutar el contenedor de Docker. Para obtener más información, consulte los siguientes temas:
[Uso de la comunicación entre procesos en los componentes del contenedor de Docker](#docker-container-ipc)
[Utilice AWS las credenciales en los componentes del contenedor de Docker (Linux)](#docker-container-token-exchange-service)
[Uso del administrador de flujos en los componentes del contenedor de Docker (Linux)](#docker-container-stream-manager)
1. [Pruebe el componente](test-components.md) para comprobar que funciona según lo previsto.
**importante**
Debe instalar e iniciar el daemon Docker antes de implementar su componente.
Tras implementar el componente localmente, puede ejecutar el comando [docker container ls](https://docs.docker.com/engine/reference/commandline/container_ls/) para comprobar que el contenedor se ejecuta.
```
docker container ls
```
1. Cargue el componente AWS IoT Greengrass para implementarlo en otros dispositivos principales. Para obtener más información, consulte [Publique componentes para desplegarlos en sus dispositivos principales](publish-components.md).
## Ejecute un contenedor de Docker desde una imagen en Amazon S3
En esta sección, se describe cómo ejecutar un contenedor de Docker en un componente desde una imagen de Docker almacenada en Amazon S3.
**Cómo ejecutar un contenedor de Docker en un componente desde una imagen en Amazon S3**
1. Ejecute el comando [docker save](https://docs.docker.com/engine/reference/commandline/save/) para crear una copia de seguridad de un contenedor de Docker. Esta copia de seguridad se proporciona como un artefacto componente en el que ejecutar el contenedor en AWS IoT Greengrass. *hello-world*Sustitúyalo por el nombre de la imagen y *hello-world.tar* sustitúyalo por el nombre del archivo comprimido que se va a crear.
```
docker save hello-world > artifacts/com.example.MyDockerComponent/1.0.0/hello-world.tar
```
1. [Cree un componente personalizado](create-components.md) en su dispositivo AWS IoT Greengrass principal. Utilice la siguiente receta de ejemplo, que incluye las siguientes propiedades:
+ Un script de instalación del ciclo de vida que usa [docker load para cargar](https://docs.docker.com/engine/reference/commandline/load/) una imagen de Docker desde un archivo.
+ Un script de ejecución de ciclo de vida que utiliza [docker run](https://docs.docker.com/engine/reference/commandline/run/) para crear e iniciar un contenedor desde la imagen. La opción `--rm` limpia el contenedor cuando sale.
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.MyS3DockerComponent",
"ComponentVersion": "1.0.0",
"ComponentDescription": "A component that runs a Docker container from an image in an S3 bucket.",
"ComponentPublisher": "Amazon",
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"install": {
"Script": "docker load -i {artifacts:path}/hello-world.tar"
},
"Run": {
"Script": "docker run --rm hello-world"
}
}
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.MyS3DockerComponent
ComponentVersion: '1.0.0'
ComponentDescription: 'A component that runs a Docker container from an image in an S3 bucket.'
ComponentPublisher: Amazon
Manifests:
- Platform:
os: linux
Lifecycle:
install:
Script: docker load -i {artifacts:path}/hello-world.tar
Run:
Script: docker run --rm hello-world
```
------
**nota**
Para usar la comunicación entre procesos (IPC), las credenciales de AWS o el administrador de flujos en el componente contenedor de Docker, debe especificar opciones adicionales al ejecutar el contenedor de Docker. Para obtener más información, consulte los siguientes temas:
[Uso de la comunicación entre procesos en los componentes del contenedor de Docker](#docker-container-ipc)
[Utilice AWS las credenciales en los componentes del contenedor de Docker (Linux)](#docker-container-token-exchange-service)
[Uso del administrador de flujos en los componentes del contenedor de Docker (Linux)](#docker-container-stream-manager)
1. [Pruebe el componente](test-components.md) para comprobar que funciona según lo previsto.
Tras implementar el componente localmente, puede ejecutar el comando [docker container ls](https://docs.docker.com/engine/reference/commandline/container_ls/) para comprobar que el contenedor se ejecuta.
```
docker container ls
```
1. Cuando el componente esté listo, sube el archivo de imágenes de Docker a un bucket de S3 y agregue su URI a la receta del componente. A continuación, puede cargar el componente AWS IoT Greengrass para implementarlo en otros dispositivos principales. Para obtener más información, consulte [Publique componentes para desplegarlos en sus dispositivos principales](publish-components.md).
Al terminar, la receta del componente tendrá un aspecto semejante al de este ejemplo.
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.MyS3DockerComponent",
"ComponentVersion": "1.0.0",
"ComponentDescription": "A component that runs a Docker container from an image in an S3 bucket.",
"ComponentPublisher": "Amazon",
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"install": {
"Script": "docker load -i {artifacts:path}/hello-world.tar"
},
"Run": {
"Script": "docker run --rm hello-world"
}
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.MyDockerComponent/1.0.0/hello-world.tar"
}
]
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.MyS3DockerComponent
ComponentVersion: '1.0.0'
ComponentDescription: 'A component that runs a Docker container from an image in an S3 bucket.'
ComponentPublisher: Amazon
Manifests:
- Platform:
os: linux
Lifecycle:
install:
Script: docker load -i {artifacts:path}/hello-world.tar
Run:
Script: docker run --rm hello-world
Artifacts:
- URI: s3://amzn-s3-demo-bucket/artifacts/com.example.MyDockerComponent/1.0.0/hello-world.tar
```
------
## Uso de la comunicación entre procesos en los componentes del contenedor de Docker
Puede utilizar la biblioteca de comunicación entre procesos (IPC) de Greengrass SDK para dispositivos con AWS IoT para comunicarse con el núcleo de Greengrass, otros componentes de Greengrass y. AWS IoT Core Para obtener más información, consulte [Úselo SDK para dispositivos con AWS IoT para comunicarse con el núcleo de Greengrass, otros componentes y AWS IoT CoreComuníquese con el núcleo de Greengrass, otros componentes y AWS IoT Core](interprocess-communication.md).
Para usar el IPC en un componente de contenedor de Docker, debe ejecutar el contenedor de Docker con los siguientes parámetros:
+ Monte el socket IPC en el contenedor. El núcleo de Greengrass proporciona la ruta del archivo del socket IPC en la variable de entorno `AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT`.
+ Establezca las variables de entorno `SVCUID` y `AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT` en los valores que el núcleo de Greengrass proporciona a los componentes. Su componente utiliza estas variables de entorno para autenticar las conexiones al núcleo de Greengrass.
**Example Receta de ejemplo: publicar un mensaje MQTT en AWS IoT Core (Python)**
La siguiente receta define un ejemplo de componente contenedor de Docker en el que se publica un mensaje MQTT. AWS IoT Core Esta receta tiene las siguientes propiedades:
+ Una política de autorización (`accessControl`) que permite al componente publicar mensajes MQTT AWS IoT Core sobre todos los temas. Para obtener más información, consulte [Autorización de los componentes para realizar operaciones de IPC](interprocess-communication.md#ipc-authorization-policies) y [Autorización de IPC en AWS IoT Core MQTT](ipc-iot-core-mqtt.md#ipc-iot-core-mqtt-authorization).
+ Un artefacto de componente que especifica una imagen de Docker como un archivo TAR en Amazon S3.
+ Un script de instalación del ciclo de vida que carga la imagen de Docker desde el archivo TAR.
+ Un script de ejecución de ciclo de vida que ejecuta un contenedor de Docker desde la imagen. El comando [Docker run](https://docs.docker.com/engine/reference/run/) tiene los siguientes argumentos:
+ El argumento `-v` monta el conector IPC de Greengrass en el contenedor.
+ Los dos primeros argumentos `-e` establecen las variables de entorno necesarias en el contenedor de Docker.
+ Los argumentos `-e` adicionales establecen las variables de entorno utilizadas en este ejemplo.
+ El argumento `--rm` limpia el contenedor al salir.
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.python.docker.PublishToIoTCore",
"ComponentVersion": "1.0.0",
"ComponentDescription": "Uses interprocess communication to publish an MQTT message to IoT Core.",
"ComponentPublisher": "Amazon",
"ComponentConfiguration": {
"DefaultConfiguration": {
"topic": "test/topic/java",
"message": "Hello, World!",
"qos": "1",
"accessControl": {
"aws.greengrass.ipc.mqttproxy": {
"com.example.python.docker.PublishToIoTCore:pubsub:1": {
"policyDescription": "Allows access to publish to IoT Core on all topics.",
"operations": [
"aws.greengrass#PublishToIoTCore"
],
"resources": [
"*"
]
}
}
}
}
},
"Manifests": [
{
"Platform": {
"os": "all"
},
"Lifecycle": {
"install": "docker load -i {artifacts:path}/publish-to-iot-core.tar",
"Run": "docker run -v $AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT:$AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT -e SVCUID -e AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT -e MQTT_TOPIC=\"{configuration:/topic}\" -e MQTT_MESSAGE=\"{configuration:/message}\" -e MQTT_QOS=\"{configuration:/qos}\" --rm publish-to-iot-core"
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.python.docker.PublishToIoTCore/1.0.0/publish-to-iot-core.tar"
}
]
}
]
}
```
```
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.python.docker.PublishToIoTCore
ComponentVersion: 1.0.0
ComponentDescription: Uses interprocess communication to publish an MQTT message to IoT Core.
ComponentPublisher: Amazon
ComponentConfiguration:
DefaultConfiguration:
topic: 'test/topic/java'
message: 'Hello, World!'
qos: '1'
accessControl:
aws.greengrass.ipc.mqttproxy:
'com.example.python.docker.PublishToIoTCore:pubsub:1':
policyDescription: Allows access to publish to IoT Core on all topics.
operations:
- 'aws.greengrass#PublishToIoTCore'
resources:
- '*'
Manifests:
- Platform:
os: all
Lifecycle:
install: 'docker load -i {artifacts:path}/publish-to-iot-core.tar'
Run: |
docker run \
-v $AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT:$AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT \
-e SVCUID \
-e AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT \
-e MQTT_TOPIC="{configuration:/topic}" \
-e MQTT_MESSAGE="{configuration:/message}" \
-e MQTT_QOS="{configuration:/qos}" \
--rm publish-to-iot-core
Artifacts:
- URI: s3://amzn-s3-demo-bucket/artifacts/com.example.python.docker.PublishToIoTCore/1.0.0/publish-to-iot-core.tar
```
## Utilice AWS las credenciales en los componentes del contenedor de Docker (Linux)
Puede usar el [componente del servicio de intercambio de fichas](token-exchange-service-component.md) para interactuar con AWS los servicios de los componentes de Greengrass. Este componente proporciona las credenciales de AWS del [rol de intercambio de token](device-service-role.md) del dispositivo principal mediante un servidor contenedor local. Para obtener más información, consulte [Interacción con servicios de AWS](interact-with-aws-services.md).
**nota**
El ejemplo de esta sección solo funciona en los dispositivos principales de Linux.
Para usar AWS las credenciales del servicio de intercambio de fichas en un componente de contenedor de Docker, debe ejecutar el contenedor de Docker con los siguientes parámetros:
+ Proporcione acceso a la red host mediante el argumento `--network=host`. Esta opción permite que el contenedor de Docker se conecte al servicio de intercambio de tokens local para recuperar las credenciales. AWS Este argumento solo funciona en Docker para Linux.
**aviso**
Esta opción proporciona al contenedor acceso a todas las interfaces de red locales del host, por lo que es menos segura que si se ejecutan contenedores de Docker sin este acceso a la red del host. Tenga esto en cuenta al desarrollar y ejecutar componentes de contenedores de Docker que utilizan esta opción. Para obtener más información, consulte [Red: host](https://docs.docker.com/engine/reference/run/#network-host) en la *documentación de Docker*.
+ Establezca las variables `AWS_CONTAINER_CREDENTIALS_FULL_URI` y de `AWS_CONTAINER_AUTHORIZATION_TOKEN` entorno en los valores que el núcleo de Greengrass proporciona a los componentes. AWS SDKs utilice estas variables de entorno para recuperar las AWS credenciales.
**Example Receta de ejemplo: enumerar buckets de S3 en un componente contenedor de Docker (Python)**
La siguiente receta define un ejemplo de componente de contenedor de Docker que muestra los buckets de S3 de su Cuenta de AWS. Esta receta tiene las siguientes propiedades:
+ El componente del servicio de intercambio de token como dependencia. Esta dependencia permite al componente recuperar AWS credenciales para interactuar con otros AWS servicios.
+ Un artefacto componente que especifica una imagen de Docker como un archivo tar en Amazon S3.
+ Un script de instalación del ciclo de vida que carga la imagen de Docker desde el archivo TAR.
+ Un script de ejecución de ciclo de vida que ejecuta un contenedor de Docker desde la imagen. El comando [Docker run](https://docs.docker.com/engine/reference/run/) tiene los siguientes argumentos:
+ El argumento `--network=host` proporciona al contenedor acceso a la red de host, de modo que el contenedor puede conectarse al servicio de intercambio de token.
+ El argumento `-e` establece las variables de entorno necesarias en el contenedor de Docker.
+ El argumento `--rm` limpia el contenedor al salir.
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.python.docker.ListS3Buckets",
"ComponentVersion": "1.0.0",
"ComponentDescription": "Uses the token exchange service to lists your S3 buckets.",
"ComponentPublisher": "Amazon",
"ComponentDependencies": {
"aws.greengrass.TokenExchangeService": {
"VersionRequirement": "^2.0.0",
"DependencyType": "HARD"
}
},
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"install": "docker load -i {artifacts:path}/list-s3-buckets.tar",
"Run": "docker run --network=host -e AWS_CONTAINER_AUTHORIZATION_TOKEN -e AWS_CONTAINER_CREDENTIALS_FULL_URI --rm list-s3-buckets"
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.python.docker.ListS3Buckets/1.0.0/list-s3-buckets.tar"
}
]
}
]
}
```
```
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.python.docker.ListS3Buckets
ComponentVersion: 1.0.0
ComponentDescription: Uses the token exchange service to lists your S3 buckets.
ComponentPublisher: Amazon
ComponentDependencies:
aws.greengrass.TokenExchangeService:
VersionRequirement: ^2.0.0
DependencyType: HARD
Manifests:
- Platform:
os: linux
Lifecycle:
install: 'docker load -i {artifacts:path}/list-s3-buckets.tar'
Run: |
docker run \
--network=host \
-e AWS_CONTAINER_AUTHORIZATION_TOKEN \
-e AWS_CONTAINER_CREDENTIALS_FULL_URI \
--rm list-s3-buckets
Artifacts:
- URI: s3://amzn-s3-demo-bucket/artifacts/com.example.python.docker.ListS3Buckets/1.0.0/list-s3-buckets.tar
```
## Uso del administrador de flujos en los componentes del contenedor de Docker (Linux)
Puede usar el [componente administrador de flujos](stream-manager-component.md) para administrar flujos de datos en los componentes de Greengrass. Este componente le permite procesar flujos de datos y transferir datos de IoT de gran volumen al Nube de AWS. AWS IoT Greengrass proporciona un SDK de administrador de transmisiones que se utiliza para interactuar con el componente de administrador de transmisiones. Para obtener más información, consulte [Administración de flujos de datos en los dispositivos principales de Greengrass](manage-data-streams.md).
**nota**
El ejemplo de esta sección solo funciona en los dispositivos principales de Linux.
Para utilizar el SDK del administrador de flujos en un componente de contenedor de Docker, debe ejecutar el contenedor de Docker con los siguientes parámetros:
+ Proporcione acceso a la red host mediante el argumento `--network=host`. Esta opción permite que el contenedor de Docker interactúe con el componente del administrador de flujos a través de una conexión TLS local. Este argumento solo funciona en Docker para Linux
**aviso**
Esta opción proporciona al contenedor acceso a todas las interfaces de red locales del host, por lo que es menos segura que si se ejecutan contenedores de Docker sin este acceso a la red del host. Tenga esto en cuenta al desarrollar y ejecutar componentes de contenedores de Docker que utilizan esta opción. Para obtener más información, consulte [Red: host](https://docs.docker.com/engine/reference/run/#network-host) en la *documentación de Docker*.
+ Si configura el componente del administrador de flujos para que requiera autenticación, que es el comportamiento predeterminado, establezca la variable de entorno `AWS_CONTAINER_CREDENTIALS_FULL_URI` en el valor que el núcleo de Greengrass proporciona a los componentes. Para obtener más información, consulte la configuración del [administrador de flujos](stream-manager-component.md#stream-manager-component-configuration).
+ Si configura el componente del administrador de flujos para que utilice un puerto que no sea el predeterminado, utilice la [comunicación entre procesos (IPC)](interprocess-communication.md) para obtener el puerto desde la configuración del componente administrador de flujos. Debe ejecutar el contenedor de Docker con opciones adicionales para usar el IPC. Para obtener más información, consulte los siguientes temas:
+ [Conexión al administrador de flujos en el código de la aplicación](use-stream-manager-in-custom-components.md#connect-to-stream-manager)
+ [Uso de la comunicación entre procesos en los componentes del contenedor de Docker](#docker-container-ipc)
**Example Receta de ejemplo: transmitir un archivo a un bucket de S3 en un componente contenedor de Docker (Python)**
La siguiente receta define un ejemplo de componente contenedor de Docker que crea un archivo y lo transmite a un bucket de S3. Esta receta tiene las siguientes propiedades:
+ El componente del administrador de flujos como dependencia. Esta dependencia permite que el componente utilice el SDK del administrador de flujos para interactuar con el componente administrador de flujos.
+ Un artefacto de componente que especifica una imagen de Docker como un archivo TAR en Amazon S3.
+ Un script de instalación del ciclo de vida que carga la imagen de Docker desde el archivo TAR.
+ Un script de ejecución de ciclo de vida que ejecuta un contenedor de Docker desde la imagen. El comando [Docker run](https://docs.docker.com/engine/reference/run/) tiene los siguientes argumentos:
+ El argumento `--network=host` proporciona al contenedor acceso a la red host, de modo que el contenedor puede conectarse al componente administrador de flujos.
+ El primer argumento `-e` establece la variable de entorno `AWS_CONTAINER_AUTHORIZATION_TOKEN` requerida en el contenedor de Docker.
+ Los argumentos `-e` adicionales establecen las variables de entorno utilizadas en este ejemplo.
+ El argumento `-v` monta la [carpeta de trabajo](component-recipe-reference.md#component-recipe-work-path) del componente en el contenedor. En este ejemplo, se crea un archivo en la carpeta de trabajo para subirlo a Amazon S3 mediante el administrador de flujos.
+ El argumento `--rm` limpia el contenedor al salir.
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.python.docker.StreamFileToS3",
"ComponentVersion": "1.0.0",
"ComponentDescription": "Creates a text file and uses stream manager to stream the file to S3.",
"ComponentPublisher": "Amazon",
"ComponentDependencies": {
"aws.greengrass.StreamManager": {
"VersionRequirement": "^2.0.0",
"DependencyType": "HARD"
}
},
"ComponentConfiguration": {
"DefaultConfiguration": {
"bucketName": ""
}
},
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"install": "docker load -i {artifacts:path}/stream-file-to-s3.tar",
"Run": "docker run --network=host -e AWS_CONTAINER_AUTHORIZATION_TOKEN -e BUCKET_NAME=\"{configuration:/bucketName}\" -e WORK_PATH=\"{work:path}\" -v {work:path}:{work:path} --rm stream-file-to-s3"
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.python.docker.StreamFileToS3/1.0.0/stream-file-to-s3.tar"
}
]
}
]
}
```
```
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.python.docker.StreamFileToS3
ComponentVersion: 1.0.0
ComponentDescription: Creates a text file and uses stream manager to stream the file to S3.
ComponentPublisher: Amazon
ComponentDependencies:
aws.greengrass.StreamManager:
VersionRequirement: ^2.0.0
DependencyType: HARD
ComponentConfiguration:
DefaultConfiguration:
bucketName: ''
Manifests:
- Platform:
os: linux
Lifecycle:
install: 'docker load -i {artifacts:path}/stream-file-to-s3.tar'
Run: |
docker run \
--network=host \
-e AWS_CONTAINER_AUTHORIZATION_TOKEN \
-e BUCKET_NAME="{configuration:/bucketName}" \
-e WORK_PATH="{work:path}" \
-v {work:path}:{work:path} \
--rm stream-file-to-s3
Artifacts:
- URI: s3://amzn-s3-demo-bucket/artifacts/com.example.python.docker.StreamFileToS3/1.0.0/stream-file-to-s3.tar
```
# AWS IoT Greengrass referencia de recetas de componentes
La receta del componente es un archivo que define los detalles, las dependencias, los artefactos y los ciclos de vida de un componente. El *ciclo de vida* del componente especifica los comandos que se deben ejecutar para instalar, ejecutar y apagar el componente, por ejemplo. El AWS IoT Greengrass núcleo utiliza los ciclos de vida que usted define en la receta para instalar y ejecutar los componentes. El AWS IoT Greengrass servicio utiliza la receta para identificar las dependencias y los artefactos que se van a implementar en los dispositivos principales al implementar el componente.
En la receta, puede definir dependencias y ciclos de vida únicos para cada plataforma compatible con un componente. Puede usar esta capacidad para implementar un componente en dispositivos con varias plataformas que tengan requisitos diferentes. También puedes usarlo para AWS IoT Greengrass evitar que se instale un componente en dispositivos que no lo admitan.
Cada receta contiene una lista de *manifiestos*. Cada manifiesto especifica un conjunto de requisitos de plataforma, así como el ciclo de vida y los artefactos que usarán los dispositivos principales cuya plataforma cumpla con esos requisitos. El dispositivo principal usa el primer manifiesto con los requisitos de plataforma que cumple el dispositivo. Especifique un manifiesto sin ningún requisito de plataforma que coincida con cualquier dispositivo principal.
También puede especificar un ciclo de vida global que no esté en un manifiesto. En el ciclo de vida global, puede usar *claves de selección* que identifiquen las subsecciones del ciclo de vida. Luego, puede especificar estas claves de selección en un manifiesto para usar esas secciones del ciclo de vida global además del ciclo de vida del manifiesto. El dispositivo principal usa las claves de selección del manifiesto solo si el manifiesto no define un ciclo de vida. Puede usar la selección `all` de un manifiesto para hacer coincidir las secciones del ciclo de vida global sin claves de selección.
Una vez que el software AWS IoT Greengrass principal selecciona un manifiesto que coincide con el dispositivo principal, hace lo siguiente para identificar los pasos del ciclo de vida que se deben seguir:
+ Si el manifiesto seleccionado define un ciclo de vida, el dispositivo principal usa ese ciclo de vida.
+ Si el manifiesto seleccionado no define un ciclo de vida, el dispositivo principal usa el ciclo de vida global. El dispositivo principal hace lo siguiente para identificar qué secciones del ciclo de vida global debe usar:
+ Si el manifiesto define las claves de selección, el dispositivo principal usa las secciones del ciclo de vida global que contienen las claves de selección del manifiesto.
+ Si el manifiesto no define las claves de selección, el dispositivo principal usa las secciones del ciclo de vida global que no tienen claves de selección. Este comportamiento equivale a un manifiesto que define la selección `all`.
**importante**
Un dispositivo principal debe cumplir como mínimo los requisitos de plataforma de un manifiesto para instalar el componente. Si ningún manifiesto coincide con el dispositivo principal, el software AWS IoT Greengrass principal no instala el componente y se produce un error en la implementación.
Puede definir recetas en formato [JSON](https://en.wikipedia.org/wiki/JSON) o [YAML](https://en.wikipedia.org/wiki/YAML). La sección de ejemplos de recetas incluye recetas en cada formato.
**Topics**
+ [Validación de receta](#recipe-validation)
+ [Formato de receta](#recipe-format)
+ [Variables de receta](#recipe-variables)
+ [Ejemplos de receta](#recipe-examples)
## Validación de receta
Greengrass valida la receta de un componente JSON o YAML al crear una versión del componente. Esta validación de recetas comprueba la receta de sus componentes JSON o YAML para detectar errores comunes a fin de evitar posibles problemas de implementación. La validación comprueba la receta para detectar errores comunes (p. ej., falta de comas, corchetes y campos) y se asegura de que la receta esté bien formada.
Si recibe un mensaje de error al validar una receta, compruebe si en ella faltan comas, corchetes o campos. Compruebe que no le falte ningún campo consultando el [formato de la receta](#recipe-format).
## Formato de receta
Al definir una receta para un componente, se especifica la siguiente información en el documento de receta. La misma estructura se aplica a las recetas en los formatos YAML y JSON.
`RecipeFormatVersion`
La versión de plantilla para la receta. Elija la opción siguiente:
+ `2020-01-25`
`ComponentName`
El nombre del componente que define esta receta. El nombre del componente debe ser único Cuenta de AWS en cada región.
**Consejos**
+ Use el formato de nombre de dominio inverso para evitar colisiones de nombres dentro de su empresa. Por ejemplo, si su empresa es propietaria de `example.com` y usted trabaja en un proyecto de energía solar, puede nombrar a su componente Hello World `com.example.solar.HelloWorld`. Esto ayuda a evitar colisiones entre los nombres de los componentes dentro de su empresa.
+ Evite el prefijo `aws.greengrass` en los nombres de sus componentes. AWS IoT Greengrass usa este prefijo para los [componentes públicos](public-components.md) que proporciona. Si elige el mismo nombre que un componente público, su componente reemplazará a ese componente. A continuación, AWS IoT Greengrass proporciona su componente en lugar del componente público cuando despliega componentes que dependen de ese componente público. Esta característica le permite anular el comportamiento de los componentes públicos, pero también puede interrumpir otros componentes si no tiene intención de anular un componente público.
`ComponentVersion`
Esta es la versión del componente. El valor máximo para los valores principales, secundarios y de parche es 999999.
AWS IoT Greengrass usa versiones semánticas para los componentes. Las versiones semánticas siguen un sistema de números de *principal*.*secundario*.*parche*. Por ejemplo, la versión `1.0.0` representa el primer lanzamiento principal de un componente. Para obtener más información, consulte la [especificación semántica de la versión](https://semver.org/).
`ComponentDescription`
(Opcional) La descripción del componente.
`ComponentPublisher`
El publicador o el autor del componente.
`ComponentConfiguration`
(Opcional) Un objeto que define la configuración o los parámetros del componente. Defina la configuración predeterminada y, a continuación, al implementar el componente, puede especificar el objeto de configuración que se va a proporcionar al componente. La configuración de los componentes admite parámetros y estructuras anidados. Este objeto contiene la siguiente información:
`DefaultConfiguration`
Un objeto que define la configuración predeterminada del componente. Usted define la estructura de este objeto.
AWS IoT Greengrass usa JSON para los valores de configuración. JSON especifica un tipo de número, pero no diferencia entre números enteros y flotantes. Como resultado, los valores de configuración pueden convertirse en valores flotantes en AWS IoT Greengrass. Para garantizar que su componente use el tipo de datos correcto, le recomendamos que defina los valores de configuración numéricos como cadenas. A continuación, pida a su componente que los analice como enteros o flotantes. Esto garantiza que los valores de configuración sean del mismo tipo en la configuración y en el dispositivo principal.
`ComponentDependencies`
(Opcional) Un diccionario de objetos, cada uno de los cuales define una dependencia de un componente para el componente. La clave de cada objeto identifica el nombre de la dependencia del componente. AWS IoT Greengrass instala las dependencias de los componentes cuando se instala el componente. AWS IoT Greengrass espera a que se inicien las dependencias antes de iniciar el componente. Cada objeto contiene la siguiente información:
`VersionRequirement`
La restricción de versión semántica de estilo npm que define las versiones de los componentes compatibles para esta dependencia. Puede especificar una versión o un rango de versiones. Para obtener más información, consulte [calculador de versión semántica de npm](https://semver.npmjs.com/).
`DependencyType`
(Opcional) El tipo de esta dependencia. Puede elegir entre las siguientes opciones.
+ `SOFT` — El componente no se reinicia si la dependencia cambia de estado.
+ `HARD` — El componente se reinicia si la dependencia cambia de estado.
El valor predeterminado es `HARD`.
`ComponentType`
(Opcional) El tipo de componente.
No se recomienda especificar el tipo de componente en una receta. AWS IoT Greengrass establece el tipo automáticamente al crear un componente.
Puede tratarse de uno de los siguientes tipos:
+ `aws.greengrass.generic`: el componente ejecuta comandos o proporciona artefactos.
+ `aws.greengrass.lambda`: el componente ejecuta una función de Lambda mediante el [componente lanzador de Lambda](lambda-launcher-component.md). El parámetro `ComponentSource` especifica el ARN de la función de Lambda que ejecuta este componente.
No se recomienda utilizar esta opción, ya que se establece AWS IoT Greengrass al crear un componente a partir de una función Lambda. Para obtener más información, consulte [Ejecución de funciones de AWS Lambda](run-lambda-functions.md).
+ `aws.greengrass.plugin`: el componente se ejecuta en la misma máquina virtual de Java (JVM) que el núcleo de Greengrass. Si implementa o reinicia un componente del complemento, el núcleo de Greengrass se reinicia.
Los componentes del complemento usan el mismo archivo de registro que el núcleo de Greengrass. Para obtener más información, consulte [Supervisión de los registros de AWS IoT Greengrass](monitor-logs.md).
No se recomienda utilizar esta opción en las recetas de componentes, ya que está AWS pensada para componentes proporcionados y escritos en Java que interactúan directamente con el núcleo de Greengrass. Para obtener más información sobre qué componentes públicos son complementos, consulte [Componentes proporcionados por AWS](public-components.md).
+ `aws.greengrass.nucleus`: el componente del núcleo. Para obtener más información, consulte [Núcleo de Greengrass](greengrass-nucleus-component.md).
No le recomendamos que use esta opción en las recetas de componentes. Está diseñado para el componente núcleo de Greengrass, que proporciona la funcionalidad mínima del software AWS IoT Greengrass Core.
El valor predeterminado es `aws.greengrass.generic` cuando se crea un componente a partir de una receta o `aws.greengrass.lambda` cuando se crea un componente a partir de una función de Lambda.
Para obtener más información, consulte [Tipos de componentes](develop-greengrass-components.md#component-types).
`ComponentSource`
(Opcional) El ARN de la función de Lambda que ejecuta un componente.
No se recomienda especificar la fuente del componente en una receta. AWS IoT Greengrass establece este parámetro cuando crea un componente a partir de una función Lambda. Para obtener más información, consulte [Ejecución de funciones de AWS Lambda](run-lambda-functions.md).
`Manifests`
Una lista de objetos, cada uno de los cuales define el ciclo de vida, los parámetros y los requisitos del componente para una plataforma. Si un dispositivo principal cumple con los requisitos de plataforma de varios manifiestos, AWS IoT Greengrass utiliza el primer manifiesto que coincida con el dispositivo principal. Para garantizar que los dispositivos principales usen el manifiesto correcto, defina primero los manifiestos con requisitos de plataforma más estrictos. Un manifiesto que se aplique a todas las plataformas debe ser el último manifiesto de la lista.
Un dispositivo principal debe cumplir como mínimo los requisitos de plataforma de un manifiesto para instalar el componente. Si ningún manifiesto coincide con el dispositivo principal, el software AWS IoT Greengrass principal no instala el componente y se produce un error en la implementación.
Cada objeto contiene la siguiente información:
`Name`
(Opcional) Un nombre fácil de recordar para la plataforma que define este manifiesto.
Si omite este parámetro, AWS IoT Greengrass crea un nombre a partir de la plataforma `os` y`architecture`.
`Platform`
(Opcional) Un objeto que define la plataforma a la que se aplica este manifiesto. Omita este parámetro para definir un manifiesto que se aplique a todas las plataformas.
Este objeto especifica los pares clave-valor sobre la plataforma en la que se ejecuta un dispositivo principal. Al implementar este componente, el software AWS IoT Greengrass Core compara estos pares clave-valor con los atributos de la plataforma en el dispositivo principal. El software AWS IoT Greengrass principal siempre define `os` y`architecture`, y puede definir, atributos adicionales. Puede especificar atributos de plataforma personalizados para un dispositivo principal cuando implementa el componente núcleo de Greengrass. Para obtener más información, consulte el [parámetro de anulación de plataforma](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration-platform-overrides) del [componente núcleo de Greengrass](greengrass-nucleus-component.md).
Puede especificar uno de los siguientes valores para cada par clave-valor:
+ Un valor exacto, como `linux` o `windows`. Los valores exactos deben comenzar por una letra o un número.
+ `*`, que coincide con cualquier valor. Esto también coincide cuando un valor no está presente.
+ Una expresión regular de estilo Java, como `/windows|linux/`. La expresión regular debe empezar y terminar con un carácter de barra inclinada (`/`). Por ejemplo, la expresión regular `/.+/` coincide con cualquier valor que no esté en blanco.
Este objeto contiene la siguiente información:
`runtime`
El [tiempo de ejecución del núcleo de Greengrass](https://docs.aws.amazon.com/greengrass/v2/developerguide/how-it-works.html#concept-overview) para la plataforma compatible con este manifiesto. Al definir varios manifiestos con la plataforma `runtime`, los valores del tiempo de ejecución compatibles con una receta serán `aws_nucleus_lite` y `*` únicamente. Para dirigirse a un dispositivo clásico, el campo de tiempo de ejecución NO DEBE especificarse en la receta. Los tiempos de ejecución del núcleo de Greengrass compatibles incluyen los siguientes valores:
+ `*`
+ `aws_nucleus_lite`
`os`
(Opcional) El nombre del sistema operativo de la plataforma compatible con este manifiesto. Las plataformas comunes incluyen los siguientes valores:
+ `linux`
+ `windows`
+ `darwin` (macOS)
`architecture`
(Opcional) La arquitectura de procesador de la plataforma compatible con este manifiesto. Las arquitecturas comunes incluyen los siguientes valores:
+ `amd64`
+ `arm`
+ `aarch64`
+ `x86`
`architecture.detail`
(Opcional) El detalle de la arquitectura del procesador de la plataforma compatible con este manifiesto. Los detalles de la arquitectura común incluyen los siguientes valores:
+ `arm61`
+ `arm71`
+ `arm81`
`key`
(Opcional) Un atributo de plataforma que defina para este manifiesto. *Key*Sustitúyalo por el nombre del atributo de la plataforma. El software AWS IoT Greengrass Core hace coincidir este atributo de plataforma con los pares clave-valor que especifique en la configuración del componente núcleo de Greengrass. Para obtener más información, consulte el [parámetro de anulación de plataforma](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration-platform-overrides) del [componente núcleo de Greengrass](greengrass-nucleus-component.md).
Use el formato de nombre de dominio inverso para evitar colisiones de nombres dentro de su empresa. Por ejemplo, si su empresa es propietaria de `example.com` y usted trabaja en un proyecto de radio, puede asignar un nombre a un atributo de plataforma personalizado `com.example.radio.RadioModule`. Esto ayuda a evitar colisiones entre los nombres de los atributos de la plataforma en su empresa.
Por ejemplo, puede definir un atributo de plataforma, `com.example.radio.RadioModule`, para especificar un manifiesto diferente en función del módulo de radio que esté disponible en un dispositivo principal. Cada manifiesto puede incluir diferentes artefactos que se apliquen a distintas configuraciones de hardware, de modo que se pueda implementar el conjunto mínimo de software en el dispositivo principal.
`Lifecycle`
Un objeto o cadena que define cómo instalar y ejecutar el componente en la plataforma que define este manifiesto. También puede definir un [ciclo de vida global](#global-lifecycle-definition) que se aplique a todas las plataformas. El dispositivo principal usa el ciclo de vida global solo si el manifiesto que se va a usar no especifica un ciclo de vida.
Este ciclo de vida se define en un manifiesto. Los pasos del ciclo de vida que especifique aquí se aplican únicamente a la plataforma que define este manifiesto. También puede definir un [ciclo de vida global](#global-lifecycle-definition) que se aplique a todas las plataformas.
Este objeto o cadena contiene la siguiente información:
`Setenv`
(Opcional) Un diccionario de variables de entorno para proporcionarlo a todos los scripts del ciclo de vida. Puede anular estas variables de entorno con `Setenv` en cada script de ciclo de vida.
`install`
(Opcional) Un objeto o una cadena que define el script que se ejecutará cuando se instale el componente. El software AWS IoT Greengrass Core también ejecuta este paso del ciclo de vida cada vez que se lanza el software.
Si el script de `install` se cierra con un código de éxito, el componente entra en el estado `INSTALLED`.
Este objeto o cadena contiene la siguiente información:
`Script`
El script a ejecutar.
`RequiresPrivilege`
(Opcional) Puede ejecutar el script con privilegios de raíz. Si establece esta opción en`true`, el software AWS IoT Greengrass Core ejecutará este script de ciclo de vida como root en lugar de como el usuario del sistema que usted configure para ejecutar este componente. El valor predeterminado es `false`.
`Skipif`
(Opcional) La comprobación para determinar si se debe ejecutar o no el script. Puede definir que desea comprobar si hay un ejecutable en la ruta o si existe un archivo. Si el resultado es verdadero, el software AWS IoT Greengrass Core omite este paso. Elija una de las siguientes comprobaciones:
+ `onpath runnable`: comprueba si hay un ejecutable en la ruta del sistema. Por ejemplo, use **onpath python3** para omitir este paso del ciclo de vida si Python 3 está disponible.
+ `exists file`: comprueba si existe un archivo. Por ejemplo, use **exists /tmp/my-configuration.db** para omitir este paso del ciclo de vida si `/tmp/my-configuration.db` está presente.
`Timeout`
(Opcional) La cantidad máxima de tiempo en segundos que el script puede ejecutar antes de que el software AWS IoT Greengrass Core termine el proceso.
Valor predeterminado: 120 segundos
`Setenv`
(Opcional) El diccionario de variables de entorno que se va a proporcionar al script. Estas variables de entorno anulan las variables que usted proporciona en `Lifecycle.Setenv`.
`run`
(Opcional) Un objeto o una cadena que define el script que se ejecutará cuando se inicie el componente.
El componente entra en el estado `RUNNING` cuando se ejecuta este paso del ciclo de vida. Si el script de `run` se cierra con un código de éxito, el componente entra en el estado `STOPPING`. Si se especifica un script `shutdown`, se ejecuta; de lo contrario, el componente entra en estado `FINISHED`.
Los componentes que dependen de este componente se inician cuando se ejecuta este paso del ciclo de vida. Para ejecutar un proceso en segundo plano, como un servicio que usa los componentes dependientes, utilice el paso del ciclo de vida `startup` en su lugar.
Al implementar componentes con un ciclo de vida `run`, el dispositivo principal puede declarar que la implementación se ha completado en cuanto se ejecute este script de ciclo de vida. Como resultado, la implementación puede completarse y realizarse correctamente incluso si el script del ciclo de vida `run` falla poco después de ejecutarse. Si desea que el estado de la implementación dependa del resultado del script de inicio del componente, use el paso del ciclo de vida `startup` en su lugar.
Puede definir solo un ciclo de vida, `startup` o `run`.
Este objeto o cadena contiene la siguiente información:
`Script`
El script a ejecutar.
`RequiresPrivilege`
(Opcional) Puede ejecutar el script con privilegios de raíz. Si establece esta opción en`true`, el software AWS IoT Greengrass Core ejecutará este script de ciclo de vida como root en lugar de como el usuario del sistema que usted configure para ejecutar este componente. El valor predeterminado es `false`.
`Skipif`
(Opcional) La comprobación para determinar si se debe ejecutar o no el script. Puede definir que desea comprobar si hay un ejecutable en la ruta o si existe un archivo. Si el resultado es verdadero, el software AWS IoT Greengrass Core omite el paso. Elija una de las siguientes comprobaciones:
+ `onpath runnable`: comprueba si hay un ejecutable en la ruta del sistema. Por ejemplo, use **onpath python3** para omitir este paso del ciclo de vida si Python 3 está disponible.
+ `exists file`: comprueba si existe un archivo. Por ejemplo, use **exists /tmp/my-configuration.db** para omitir este paso del ciclo de vida si `/tmp/my-configuration.db` está presente.
`Timeout`
(Opcional) El tiempo máximo en segundos que puede ejecutarse el script antes de que el software AWS IoT Greengrass principal finalice el proceso.
Este paso del ciclo de vida no agota el tiempo de espera de forma predeterminada. Si omite este tiempo de espera, el script `run` se ejecutará hasta que salga.
`Setenv`
(Opcional) El diccionario de variables de entorno que se va a proporcionar al script. Estas variables de entorno anulan las variables que usted proporciona en `Lifecycle.Setenv`.
`startup`
(Opcional) Un objeto o cadena que define el proceso en segundo plano que se ejecutará cuando se inicie el componente.
Use `startup` para ejecutar un comando que debe salir correctamente o para actualizar el estado del componente a `RUNNING` antes de que puedan iniciarse los componentes dependientes. Utilice la operación [UpdateState](ipc-component-lifecycle.md#ipc-operation-updatestate)IPC para establecer el estado del componente como `RUNNING` o `ERRORED` cuando el componente inicie un script que no se cierre. Por ejemplo, puede definir un paso `startup` que inicie el proceso de MySQL con `/etc/init.d/mysqld start`.
El componente entra en el estado `STARTING` cuando se ejecuta este paso del ciclo de vida. Si el script de `startup` se cierra con un código de éxito, el componente entra en el estado `RUNNING`. A continuación, pueden iniciarse los componentes dependientes.
Al implementar componentes con un ciclo de vida `startup`, el dispositivo principal puede declarar que la implementación se ha completado una vez que este script de ciclo de vida sale o informa de su estado. En otras palabras, el estado de la implementación es `IN_PROGRESS` hasta que los scripts de startup de todos los componentes salgan o informen un estado.
Puede definir solo un ciclo de vida, `startup` o `run`.
Este objeto o cadena contiene la siguiente información:
`Script`
El script a ejecutar.
`RequiresPrivilege`
(Opcional) Puede ejecutar el script con privilegios de raíz. Si establece esta opción en`true`, el software AWS IoT Greengrass principal ejecutará este script de ciclo de vida como root en lugar de como el usuario del sistema que haya configurado para ejecutar este componente. El valor predeterminado es `false`.
`Skipif`
(Opcional) La comprobación para determinar si se debe ejecutar o no el script. Puede definir que desea comprobar si hay un ejecutable en la ruta o si existe un archivo. Si el resultado es verdadero, el software AWS IoT Greengrass Core omite el paso. Elija una de las siguientes comprobaciones:
+ `onpath runnable`: comprueba si hay un ejecutable en la ruta del sistema. Por ejemplo, use **onpath python3** para omitir este paso del ciclo de vida si Python 3 está disponible.
+ `exists file`: comprueba si existe un archivo. Por ejemplo, use **exists /tmp/my-configuration.db** para omitir este paso del ciclo de vida si `/tmp/my-configuration.db` está presente.
`Timeout`
(Opcional) La cantidad máxima de tiempo en segundos que el script puede ejecutar antes de que el software AWS IoT Greengrass Core termine el proceso.
Valor predeterminado: 120 segundos
`Setenv`
(Opcional) El diccionario de variables de entorno que se va a proporcionar al script. Estas variables de entorno anulan las variables que usted proporciona en `Lifecycle.Setenv`.
`shutdown`
(Opcional) Un objeto o una cadena que define el script que se ejecutará cuando el componente se apague. Use el ciclo de vida de apagado para ejecutar el código que desee ejecutar cuando el componente esté en el estado `STOPPING`. El ciclo de vida de apagado se puede usar para detener un proceso iniciado por el `startup` o por los scripts `run`.
Si inicia un proceso en segundo plano en `startup`, use el paso `shutdown` para detener ese proceso cuando el componente se apague. Por ejemplo, puede definir un paso `shutdown` que detenga el proceso de MySQL con `/etc/init.d/mysqld stop`.
El script `shutdown` se ejecuta después de que el componente entre en el estado `STOPPING`. Si el script se completa de forma satisfactoria, el componente entra en el estado `FINISHED`.
Este objeto o cadena contiene la siguiente información:
`Script`
El script a ejecutar.
`RequiresPrivilege`
(Opcional) Puede ejecutar el script con privilegios de raíz. Si establece esta opción en`true`, el software AWS IoT Greengrass principal ejecutará este script de ciclo de vida como root en lugar de como el usuario del sistema que usted configure para ejecutar este componente. El valor predeterminado es `false`.
`Skipif`
(Opcional) La comprobación para determinar si se debe ejecutar o no el script. Puede definir que desea comprobar si hay un ejecutable en la ruta o si existe un archivo. Si el resultado es verdadero, el software AWS IoT Greengrass Core omite el paso. Elija una de las siguientes comprobaciones:
+ `onpath runnable`: comprueba si hay un ejecutable en la ruta del sistema. Por ejemplo, use **onpath python3** para omitir este paso del ciclo de vida si Python 3 está disponible.
+ `exists file`: comprueba si existe un archivo. Por ejemplo, use **exists /tmp/my-configuration.db** para omitir este paso del ciclo de vida si `/tmp/my-configuration.db` está presente.
`Timeout`
(Opcional) El tiempo máximo en segundos que puede ejecutarse el script antes de que el software AWS IoT Greengrass principal finalice el proceso.
Valor predeterminado: 15 segundos
`Setenv`
(Opcional) El diccionario de variables de entorno que se va a proporcionar al script. Estas variables de entorno anulan las variables que usted proporciona en `Lifecycle.Setenv`.
`recover`
(Opcional) Un objeto o una cadena que define el script que se ejecutará cuando el componente detecte un error.
Este paso se ejecuta cuando un componente entra en el estado `ERRORED`. Si el componente pasa a `ERRORED` tres veces sin recuperarse correctamente, el componente cambia al estado `BROKEN`. Para corregir un componente `BROKEN`, debe volver a implementarlo.
Este objeto o cadena contiene la siguiente información:
`Script`
El script a ejecutar.
`RequiresPrivilege`
(Opcional) Puede ejecutar el script con privilegios de raíz. Si establece esta opción en`true`, el software AWS IoT Greengrass principal ejecutará este script de ciclo de vida como root en lugar de como el usuario del sistema que haya configurado para ejecutar este componente. El valor predeterminado es `false`.
`Skipif`
(Opcional) La comprobación para determinar si se debe ejecutar o no el script. Puede definir que desea comprobar si hay un ejecutable en la ruta o si existe un archivo. Si el resultado es verdadero, el software AWS IoT Greengrass Core omite el paso. Elija una de las siguientes comprobaciones:
+ `onpath runnable`: comprueba si hay un ejecutable en la ruta del sistema. Por ejemplo, use **onpath python3** para omitir este paso del ciclo de vida si Python 3 está disponible.
+ `exists file`: comprueba si existe un archivo. Por ejemplo, use **exists /tmp/my-configuration.db** para omitir este paso del ciclo de vida si `/tmp/my-configuration.db` está presente.
`Timeout`
(Opcional) El tiempo máximo en segundos que puede ejecutarse el script antes de que el software AWS IoT Greengrass principal finalice el proceso.
Valor predeterminado: 60 segundos.
`Setenv`
(Opcional) El diccionario de variables de entorno que se va a proporcionar al script. Estas variables de entorno anulan las variables que usted proporciona en `Lifecycle.Setenv`.
`bootstrap`
(Opcional) Un objeto o una cadena que define un script que requiere el reinicio del software AWS IoT Greengrass Core o del dispositivo principal. Esto le permite desarrollar un componente que se reinicie después de instalar las actualizaciones del sistema operativo o las actualizaciones del tiempo de ejecución, por ejemplo.
Para instalar actualizaciones o dependencias que no requieran el reinicio del software o dispositivo AWS IoT Greengrass principal, usa el ciclo de vida de [instalación](#install-lifecycle-definition).
Este paso del ciclo de vida se ejecuta antes del paso del ciclo de vida de la instalación en los siguientes casos cuando el software AWS IoT Greengrass principal implementa el componente:
+ El componente se implementa en el dispositivo principal por primera vez.
+ La versión del componente cambia.
+ El script de arranque cambia como resultado de una actualización de la configuración del componente.
Una vez que el software AWS IoT Greengrass principal complete el paso de arranque de todos los componentes que tengan un paso de arranque en una implementación, el software se reinicia.
Debe configurar el software AWS IoT Greengrass Core como un servicio del sistema para reiniciar el software AWS IoT Greengrass Core o el dispositivo principal. Si no configura el software AWS IoT Greengrass principal como un servicio del sistema, el software no se reiniciará. Para obtener más información, consulte [Configuración del núcleo de Greengrass como un servicio del sistema](configure-greengrass-core-v2.md#configure-system-service).
Este objeto o cadena contiene la siguiente información:
`BootstrapOnRollback`
Cuando esta característica está habilitada, solo `BootstrapOnRollback` se ejecutará en los componentes que hayan completado o intentado ejecutar los pasos del ciclo de vida del arranque como parte de una implementación de destino fallida. Esta característica está disponible para las versiones 2.12.0 y posteriores del núcleo de Greengrass.
(Opcional) Puede ejecutar los pasos del ciclo de vida de arranque como parte de una implementación de reversión. Si configura esta opción en `true`, se ejecutarán los pasos del ciclo de vida de arranque definidos en una implementación de reversión. Cuando se produce un error en una implementación, la versión anterior del ciclo de vida de arranque del componente se volverá a ejecutar durante una implementación de reversión.
El valor predeterminado es `false`.
`Script`
El script a ejecutar. El código de salida de este script define la instrucción de reinicio. Use los siguientes códigos de salida:
+ `0`— No reinicies el software AWS IoT Greengrass principal ni el dispositivo principal. El software AWS IoT Greengrass principal se sigue reiniciando después del arranque de todos los componentes.
+ `100`— Solicitud para reiniciar el software AWS IoT Greengrass Core.
+ `101`: solicitud para reiniciar el dispositivo principal.
Los códigos de salida 100 a 199 están reservados para un comportamiento especial. Otros códigos de salida representan errores de script.
`RequiresPrivilege`
(Opcional) Puede ejecutar el script con privilegios de raíz. Si establece esta opción en`true`, el software AWS IoT Greengrass principal ejecutará este script de ciclo de vida como root en lugar de como el usuario del sistema que usted configure para ejecutar este componente. El valor predeterminado es `false`.
`Timeout`
(Opcional) La cantidad máxima de tiempo en segundos que el script puede ejecutar antes de que el software AWS IoT Greengrass Core termine el proceso.
Valor predeterminado: 120 segundos
`Setenv`
(Opcional) El diccionario de variables de entorno que se va a proporcionar al script. Estas variables de entorno anulan las variables que usted proporciona en `Lifecycle.Setenv`.
`Selections`
(Opcional) Una lista de claves de selección que especifican las secciones del [ciclo de vida global](#global-lifecycle-definition) que se van a ejecutar en este manifiesto. En el ciclo de vida global, puede definir los pasos del ciclo de vida con claves de selección en cualquier nivel para seleccionar subsecciones del ciclo de vida. A continuación, el dispositivo principal usa las secciones que coinciden con las claves de selección de este manifiesto. Para obtener más información, consulte los [ejemplos del ciclo de vida global](#global-lifecycle-definition).
El dispositivo principal usa las selecciones del ciclo de vida global solo si este manifiesto no define un ciclo de vida.
Puede especificar la clave de selección `all` para ejecutar secciones del ciclo de vida global que no tienen claves de selección.
`Artifacts`
(Opcional) Una lista de objetos que definen cada uno un artefacto binario para el componente de la plataforma que define este manifiesto. Por ejemplo, puede definir código o imágenes como artefactos.
Cuando el componente se implementa, el software AWS IoT Greengrass principal descarga el artefacto en una carpeta del dispositivo principal. También puede definir los artefactos como archivos de almacenamiento que el software extrae después de descargarlos.
Puede usar [variables de receta](#recipe-variables) para obtener las rutas a las carpetas en las que se instalan los artefactos en el dispositivo principal.
+ Archivos normales: use la [variable de receta artifacts:path](#component-recipe-artifacts-path) para obtener la ruta a la carpeta que contiene los artefactos. Por ejemplo, especifique `{artifacts:path}/my_script.py` en una receta para obtener la ruta a un artefacto que tenga el URI `s3://amzn-s3-demo-bucket/path/to/my_script.py`.
+ Archivos extraídos: use la [variable de receta artifacts:decompressedPath](#component-recipe-artifacts-decompressed-path) para obtener la ruta a la carpeta que contiene los artefactos de archivo extraídos. El software AWS IoT Greengrass Core extrae cada archivo a una carpeta con el mismo nombre que el archivo. Por ejemplo, especifique `{artifacts:decompressedPath}/my_archive/my_script.py` en una receta para obtener la ruta a `my_script.py` en el artefacto de archivo que contiene el URI `s3://amzn-s3-demo-bucket/path/to/my_archive.zip`.
Al desarrollar un componente con un artefacto de archivo en un dispositivo principal local, es posible que no disponga de un URI para ese artefacto. Para probar el componente con una opción `Unarchive` que extraiga el artefacto, especifique un URI en el que el nombre del archivo coincida con el nombre del archivo del artefacto archivado. Puede especificar el URI en el que desea cargar el artefacto de archivo o puede especificar un nuevo URI de marcador de posición. Por ejemplo, para extraer el artefacto `my_archive.zip` durante una implementación local, puede especificar `s3://amzn-s3-demo-bucket/my_archive.zip`.
Cada objeto contiene la siguiente información:
`Uri`
El URI de un artefacto en un bucket de S3. El software AWS IoT Greengrass Core obtiene el artefacto de este URI cuando se instala el componente, a menos que el artefacto ya exista en el dispositivo. Cada artefacto debe tener un nombre de archivo único en cada manifiesto.
`Unarchive`
(Opcional) El tipo de archivo que se va a desempaquetar. Puede elegir entre las siguientes opciones:
+ `NONE`: el archivo no es un archivo para desempaquetar. El software AWS IoT Greengrass Core instala el artefacto en una carpeta del dispositivo principal. Puede usar la [variable de receta artifacts:path](#component-recipe-artifacts-path) para obtener la ruta a esta carpeta.
+ `ZIP`: el archivo es un archivo ZIP. El software AWS IoT Greengrass Core extrae el archivo a una carpeta con el mismo nombre que el archivo. Puede usar la [variable de receta artifacts:decompressedPath](#component-recipe-artifacts-decompressed-path) para obtener la ruta a la carpeta que contiene esta carpeta.
El valor predeterminado es `NONE`.
`Permission`
(Opcional) Un objeto que define los permisos de acceso que se van a establecer para este archivo de artefacto. Puede establecer el permiso de lectura y el permiso de ejecución.
No puede configurar el permiso de escritura porque el software AWS IoT Greengrass Core no permite que los componentes editen los archivos de artefactos de la carpeta de artefactos. Para editar un archivo de artefactos de un componente, cópielo en otra ubicación o publique e implemente un nuevo archivo de artefacto.
Si defines un artefacto como un archivo para desempaquetar, el software AWS IoT Greengrass Core establece estos permisos de acceso en los archivos que desempaqueta del archivo. El software AWS IoT Greengrass Core establece los permisos de acceso de la carpeta en para `ALL` y. `Read` `Execute` Esto permite a los componentes ver los archivos desempaquetados de la carpeta. Para establecer los permisos en los archivos individuales del archivo, puede configurarlos en el [script del ciclo de vida de instalación](#install-lifecycle-definition).
Este objeto contiene la siguiente información:
`Read`
(Opcional) El permiso de lectura que se debe configurar para este archivo de artefacto. Para permitir que otros componentes accedan a este artefacto, como los componentes que dependen de este componente, especifique `ALL`. Puede elegir entre las siguientes opciones:
+ `NONE`: el archivo no se puede leer.
+ `OWNER`: el archivo se puede leer por el usuario del sistema que haya configurado para ejecutar este componente.
+ `ALL`: el archivo se puede leer por todos los usuarios.
El valor predeterminado es `OWNER`.
`Execute`
(Opcional) El permiso de ejecución que se debe configurar para este archivo de artefacto. El permiso `Execute` implica el permiso `Read`. Por ejemplo, si especifica `ALL` para `Execute`, todos los usuarios podrán leer y ejecutar este archivo de artefacto.
Puede elegir entre las siguientes opciones:
+ `NONE`: el archivo no se puede ejecutar.
+ `OWNER`: el archivo se puede ejecutar por el usuario del sistema que usted configure para ejecutar el componente.
+ `ALL`: el archivo se puede ejecutar por todos los usuarios.
El valor predeterminado es `NONE`.
`Digest`
(Solo lectura) El hash criptográfico resumido del artefacto. Al crear un componente, AWS IoT Greengrass utiliza un algoritmo de hash para calcular el hash del archivo del artefacto. A continuación, al implementar el componente, el núcleo de Greengrass calcula el hash del artefacto descargado y lo compara con este resumen para verificar el artefacto antes de la instalación. Si el hash no coincide con el resumen, se produce un error en la implementación.
Si establece este parámetro, AWS IoT Greengrass reemplaza el valor que estableció al crear el componente.
`Algorithm`
(Solo lectura) El algoritmo de hash que se AWS IoT Greengrass utiliza para calcular el hash resumido del artefacto.
Si establece este parámetro, AWS IoT Greengrass reemplaza el valor que estableció al crear el componente.
`Lifecycle`
Un objeto que define cómo instalar y ejecutar el componente. El dispositivo principal usa el ciclo de vida global solo si el [manifiesto](#manifest-definition) que se va a usar no especifica un ciclo de vida.
Este ciclo de vida se define fuera de un manifiesto. También puede definir un [ciclo de vida del manifiesto](#manifest-lifecycle-definition) que se aplique a las plataformas que coincidan con ese manifiesto.
En el ciclo de vida global, puede especificar los ciclos de vida que se ejecutan para determinadas [claves de selección](#manifest-selections-definition) que especifica en cada manifiesto. Las claves de selección son cadenas que identifican las secciones del ciclo de vida global que se van a ejecutar en cada manifiesto.
La clave de selección `all` es la predeterminada en cualquier sección sin una clave de selección. Esto significa que puede especificar la clave de selección `all` en un manifiesto para ejecutar las secciones del ciclo de vida global sin claves de selección. No es necesario especificar la clave de selección `all` en el ciclo de vida global.
Si un manifiesto no define un ciclo de vida o claves de selección, el dispositivo principal usará la selección `all` de forma predeterminada. Esto significa que, en este caso, el dispositivo principal usa las secciones del ciclo de vida global que no usan claves de selección.
Este objeto contiene la misma información que el [ciclo de vida del manifiesto](#manifest-lifecycle-definition), pero puede especificar las claves de selección en cualquier nivel para seleccionar subsecciones del ciclo de vida.
Le recomendamos que use solo letras minúsculas para cada clave de selección para evitar conflictos entre las claves de selección y las claves del ciclo de vida. Las claves del ciclo de vida comienzan por una letra mayúscula.
**Example Ejemplo de ciclo de vida global con claves de selección de nivel superior**
```
Lifecycle:
key1:
install:
SkipIf: either onpath executable or exists file
Script: command1
key2:
install:
Script: command2
all:
install:
Script: command3
```
**Example Ejemplo de ciclo de vida global con claves de selección de nivel inferior**
```
Lifecycle:
install:
Script:
key1: command1
key2: command2
all: command3
```
**Example Ejemplo de ciclo de vida global con claves de selección de varios niveles**
```
Lifecycle:
key1:
install:
SkipIf: either onpath executable or exists file
Script: command1
key2:
install:
Script: command2
all:
install:
Script:
key3: command3
key4: command4
all: command5
```
## Variables de receta
Las variables de receta exponen la información del componente y el núcleo actuales para que la use en sus recetas. Por ejemplo, puede usar una variable de receta para pasar los parámetros de configuración de los componentes a una aplicación que ejecute en un script de ciclo de vida.
Puede usar variables de receta en las siguientes secciones de recetas de componentes:
+ Definiciones del ciclo de vida.
+ Definiciones de configuración de componentes, si utiliza [Greengrass nucleus](greengrass-nucleus-component.md) v2.6.0 o posterior y establece la [interpolateComponentConfiguration](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration-interpolate-component-configuration)opción de configuración en. `true` También puede usar variables de receta al [implementar las actualizaciones de configuración de los componentes](update-component-configurations.md#merge-configuration-update-recipe-variables).
Las variables de receta usan la sintaxis `{recipe_variable}`. Los corchetes indican una variable de receta.
AWS IoT Greengrass admite las siguientes variables de receta:
`component_dependency_name:configuration:json_pointer`
El valor de un parámetro de configuración para el componente que define esta receta o para un componente del que depende este componente.
Puede usar esta variable para proporcionar un parámetro a un script que ejecute en el ciclo de vida del componente.
AWS IoT Greengrass admite esta variable de receta solo en las definiciones del ciclo de vida de los componentes.
Esta variable de receta tiene las siguientes entradas:
+ `component_dependency_name`: (opcional) el nombre de la dependencia del componente que se consultará. Omita este segmento para consultar el componente que define esta receta. Puede especificar solo las dependencias directas.
+ `json_pointer`: el puntero JSON al valor de configuración que se va a evaluar. Los punteros JSON comienzan con una barra diagonal `/`. Para identificar un valor en una configuración de componentes anidados, use barras diagonales (`/`) para separar las claves de cada nivel de la configuración. Puede usar un número como clave para especificar un índice en una lista. Para obtener más información, consulte la [especificación de puntero JSON](https://tools.ietf.org/html/rfc6901).
AWS IoT Greengrass Core usa punteros JSON para recetas en formato YAML.
El puntero JSON puede hacer referencia a los siguientes tipos de nodos:
+ Un nodo de valor. AWS IoT Greengrass Core reemplaza la variable de receta por la representación en cadena del valor. Los valores nulos se convierten a `null` como una cadena.
+ Un nodo de objeto. AWS IoT Greengrass Core reemplaza la variable de receta por la representación de cadena JSON serializada de ese objeto.
+ Sin nodo. AWS IoT Greengrass Core no reemplaza la variable de receta.
Por ejemplo, la variable de receta `{configuration:/Message}` recupera el valor de la clave `Message` en la configuración del componente. La variable de receta `{com.example.MyComponentDependency:configuration:/server/port}` recupera el valor de `port` en el objeto de configuración `server` de una dependencia de un componente.
`component_dependency_name:artifacts:path`
La ruta raíz de los artefactos del componente que define esta receta o de un componente del que depende este componente.
Cuando se instala un componente, AWS IoT Greengrass copia los artefactos del componente en la carpeta que expone esta variable. Puede usar esta variable para identificar la ubicación de un script que se va a ejecutar en el ciclo de vida del componente, por ejemplo.
La carpeta de esta ruta es de solo lectura. Para modificar los archivos de artefactos, cópielos en otra ubicación, como el directorio de trabajo actual (`$PWD` o `.`). A continuación, modifique los archivos allí.
Para leer o ejecutar un artefacto desde una dependencia de un componente, el permiso del artefacto `Read` o `Execute` debe ser `ALL`. Para obtener más información, consulta los [permisos de artefactos](#component-artifact-permission) que define en la receta del componente.
Esta variable de receta tiene las siguientes entradas:
+ `component_dependency_name`: (opcional) el nombre de la dependencia del componente que se consultará. Omita este segmento para consultar el componente que define esta receta. Puede especificar solo las dependencias directas.
`component_dependency_name:artifacts:decompressedPath`
La ruta raíz de los artefactos de archivo descomprimidos para el componente que define esta receta o para un componente del que depende este componente.
Cuando se instala un componente, AWS IoT Greengrass desempaqueta los artefactos archivados del componente en la carpeta que expone esta variable. Puede usar esta variable para identificar la ubicación de un script que se va a ejecutar en el ciclo de vida del componente, por ejemplo.
Cada artefacto se descomprime en una carpeta dentro de la ruta descomprimida, donde la carpeta tiene el mismo nombre que el artefacto menos su extensión. Por ejemplo, un artefacto ZIP denominado `models.zip` se descomprime en la carpeta `{artifacts:decompressedPath}/models`.
La carpeta de esta ruta es de solo lectura. Para modificar los archivos de artefactos, cópielos en otra ubicación, como el directorio de trabajo actual (`$PWD` o `.`). A continuación, modifique los archivos allí.
Para leer o ejecutar un artefacto desde una dependencia de un componente, el permiso del artefacto `Read` o `Execute` debe ser `ALL`. Para obtener más información, consulta los [permisos de artefactos](#component-artifact-permission) que define en la receta del componente.
Esta variable de receta tiene las siguientes entradas:
+ `component_dependency_name`: (opcional) el nombre de la dependencia del componente que se consultará. Omita este segmento para consultar el componente que define esta receta. Puede especificar solo las dependencias directas.
`component_dependency_name:work:path`
Esta característica está disponible para la versión 2.0.4 y versiones posteriores del [componente núcleo de Greengrass](greengrass-nucleus-component.md).
La ruta de trabajo del componente que define esta receta o de un componente del que depende este componente. El valor de esta variable de receta equivale a la salida de la variable de entorno `$PWD` y del comando [pwd](https://en.wikipedia.org/wiki/Pwd) cuando se ejecuta desde el contexto del componente.
Puede usar esta variable de receta para compartir archivos entre un componente y una dependencia.
El componente que define esta receta y los demás componentes que se ejecutan como el mismo usuario y grupo pueden leer y escribir en la carpeta de esta ruta.
Esta variable de receta tiene las siguientes entradas:
+ `component_dependency_name`: (opcional) el nombre de la dependencia del componente que se consultará. Omita este segmento para consultar el componente que define esta receta. Puede especificar solo las dependencias directas.
`kernel:rootPath`
La ruta raíz AWS IoT Greengrass principal.
`iot:thingName`
Esta característica está disponible para la versión 2.3.0 y versiones posteriores del [componente núcleo de Greengrass](greengrass-nucleus-component.md).
El nombre del dispositivo AWS IoT principal.
## Ejemplos de receta
Puede hacer referencia a los siguientes ejemplos de recetas para ayudarlo a crear recetas para sus componentes.
AWS IoT Greengrass selecciona un índice de componentes de Greengrass, denominado Catálogo de software de Greengrass. Este catálogo rastrea los componentes de Greengrass desarrollados por la comunidad de Greengrass. Desde este catálogo, puede descargar, modificar e implementar componentes para crear sus aplicaciones de Greengrass. Para obtener más información, consulte [Componentes de la comunidad](greengrass-software-catalog.md).
**Topics**
+ [Receta de componentes Hello World](#recipe-example-hello-world)
+ [Ejemplo de componente de tiempo de ejecución de Python](#recipe-example-python-runtime)
+ [Receta de componente que especifica varios campos](#recipe-example-all-fields)
### Receta de componentes Hello World
En la siguiente receta, se describe un componente Hello World que ejecuta un script de Python. Este componente es compatible con todas las plataformas y acepta un parámetro `Message` que AWS IoT Greengrass pasa como argumento al script de Python. Esta es la receta del componente Hello World del [tutorial de introducción](getting-started.md).
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.HelloWorld",
"ComponentVersion": "1.0.0",
"ComponentDescription": "My first AWS IoT Greengrass component.",
"ComponentPublisher": "Amazon",
"ComponentConfiguration": {
"DefaultConfiguration": {
"Message": "world"
}
},
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"run": "python3 -u {artifacts:path}/hello_world.py {configuration:/Message}"
}
},
{
"Platform": {
"os": "windows"
},
"Lifecycle": {
"run": "py -3 -u {artifacts:path}/hello_world.py {configuration:/Message}"
}
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.HelloWorld
ComponentVersion: '1.0.0'
ComponentDescription: My first AWS IoT Greengrass component.
ComponentPublisher: Amazon
ComponentConfiguration:
DefaultConfiguration:
Message: world
Manifests:
- Platform:
os: linux
Lifecycle:
run: |
python3 -u {artifacts:path}/hello_world.py "{configuration:/Message}"
- Platform:
os: windows
Lifecycle:
run: |
py -3 -u {artifacts:path}/hello_world.py "{configuration:/Message}"
```
------
### Ejemplo de componente de tiempo de ejecución de Python
La siguiente receta describe un componente que instala Python. Este componente es compatible con dispositivos Linux de 64 bits.
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.PythonRuntime",
"ComponentDescription": "Installs Python 3.7",
"ComponentPublisher": "Amazon",
"ComponentVersion": "3.7.0",
"Manifests": [
{
"Platform": {
"os": "linux",
"architecture": "amd64"
},
"Lifecycle": {
"install": "apt-get update\napt-get install python3.7"
}
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.PythonRuntime
ComponentDescription: Installs Python 3.7
ComponentPublisher: Amazon
ComponentVersion: '3.7.0'
Manifests:
- Platform:
os: linux
architecture: amd64
Lifecycle:
install: |
apt-get update
apt-get install python3.7
```
------
### Receta de componente que especifica varios campos
La siguiente receta de componentes usa varios campos de receta.
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.FooService",
"ComponentDescription": "Complete recipe for AWS IoT Greengrass components",
"ComponentPublisher": "Amazon",
"ComponentVersion": "1.0.0",
"ComponentConfiguration": {
"DefaultConfiguration": {
"TestParam": "TestValue"
}
},
"ComponentDependencies": {
"BarService": {
"VersionRequirement": "^1.1.0",
"DependencyType": "SOFT"
},
"BazService": {
"VersionRequirement": "^2.0.0"
}
},
"Manifests": [
{
"Platform": {
"os": "linux",
"architecture": "amd64"
},
"Lifecycle": {
"install": {
"Skipif": "onpath git",
"Script": "sudo apt-get install git"
},
"Setenv": {
"environment_variable1": "variable_value1",
"environment_variable2": "variable_value2"
}
},
"Artifacts": [
{
"Uri": "s3://amzn-s3-demo-bucket/hello_world.zip",
"Unarchive": "ZIP"
},
{
"Uri": "s3://amzn-s3-demo-bucket/hello_world_linux.py"
}
]
},
{
"Lifecycle": {
"install": {
"Skipif": "onpath git",
"Script": "sudo apt-get install git",
"RequiresPrivilege": "true"
}
},
"Artifacts": [
{
"Uri": "s3://amzn-s3-demo-bucket/hello_world.py"
}
]
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.FooService
ComponentDescription: Complete recipe for AWS IoT Greengrass components
ComponentPublisher: Amazon
ComponentVersion: 1.0.0
ComponentConfiguration:
DefaultConfiguration:
TestParam: TestValue
ComponentDependencies:
BarService:
VersionRequirement: ^1.1.0
DependencyType: SOFT
BazService:
VersionRequirement: ^2.0.0
Manifests:
- Platform:
os: linux
architecture: amd64
Lifecycle:
install:
SkipIf: onpath git
Script: sudo apt-get install git
SetEnv:
environment_variable1: variable_value1
environment_variable2: variable_value2
Artifacts:
- Uri: 's3://amzn-s3-demo-bucket/hello_world.zip'
Unarchive: ZIP
- Uri: 's3://amzn-s3-demo-bucket/hello_world_linux.py'
- Lifecycle:
install:
SkipIf: onpath git
Script: sudo apt-get install git
RequiresPrivilege: 'true'
Artifacts:
- Uri: 's3://amzn-s3-demo-bucket/hello_world.py'
```
------
# Referencia de variable de entorno del componente
El software AWS IoT Greengrass principal establece las variables de entorno cuando ejecuta los scripts del ciclo de vida de los componentes. Puede incluir estas variables de entorno en sus componentes para obtener el nombre de la cosa y la Región de AWS versión del núcleo de Greengrass. El software también establece las variables de entorno que su componente necesita para usar [el SDK de comunicación entre procesos](interprocess-communication.md) y para [interactuar con los servicios de AWS](interact-with-aws-services.md).
También puede configurar variables de entorno personalizadas para los scripts del ciclo de vida de su componente. Para obtener más información, consulte [Setenv](component-recipe-reference.md#lifecycle-setenv-definition).
El software AWS IoT Greengrass Core establece las siguientes variables de entorno:
`AWS_IOT_THING_NAME`
El nombre de AWS IoT lo que representa este dispositivo central de Greengrass.
`AWS_REGION`
Es Región de AWS donde funciona este dispositivo central de Greengrass.
AWS SDKs Usan esta variable de entorno para identificar la región que se va a utilizar por defecto. Esta variable es equivalente a `AWS_DEFAULT_REGION`.
`AWS_DEFAULT_REGION`
Es Región de AWS donde funciona este dispositivo central de Greengrass.
AWS CLI Utiliza esta variable de entorno para identificar la región predeterminada que se va a utilizar. Esta variable es equivalente a `AWS_REGION`.
`GGC_VERSION`
La versión del [componente de núcleo de Greengrass](greengrass-nucleus-component.md) que se ejecuta en este dispositivo principal de Greengrass.
`GG_ROOT_CA_PATH`
Esta característica está disponible para la versión 2.5.5 y versiones posteriores del [componente de núcleo de Greengrass](greengrass-nucleus-component.md).
La ruta a la autoridad del certificado (CA) raíz certifica que usa el núcleo de Greengrass.
`AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT`
La ruta al socket IPC que utilizan los componentes para comunicarse con el software AWS IoT Greengrass Core. Para obtener más información, consulte [Úselo SDK para dispositivos con AWS IoT para comunicarse con el núcleo de Greengrass, otros componentes y AWS IoT CoreComuníquese con el núcleo de Greengrass, otros componentes y AWS IoT Core](interprocess-communication.md).
`SVCUID`
El token secreto que utilizan los componentes para conectarse al socket IPC y comunicarse con el software AWS IoT Greengrass Core. Para obtener más información, consulte [Úselo SDK para dispositivos con AWS IoT para comunicarse con el núcleo de Greengrass, otros componentes y AWS IoT CoreComuníquese con el núcleo de Greengrass, otros componentes y AWS IoT Core](interprocess-communication.md).
`AWS_CONTAINER_AUTHORIZATION_TOKEN`
El token secreto que usan los componentes para recuperar las credenciales del [componente del servicio de intercambio de tokens](token-exchange-service-component.md).
`AWS_CONTAINER_CREDENTIALS_FULL_URI`
El URI que solicitan los componentes para recuperar las credenciales del [componente del servicio de intercambio de tokens](token-exchange-service-component.md).