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.
# Configuración de los dispositivos AWS IoT Greengrass principales
Complete las tareas de esta sección para instalar, configurar y ejecutar el software AWS IoT Greengrass principal.
**nota**
En esta sección se describe la instalación y configuración avanzadas del software AWS IoT Greengrass principal. Estos pasos no se aplican a Nucleus Lite. Si es la primera vez que lo utiliza AWS IoT Greengrass V2, le recomendamos que complete primero el [tutorial de introducción](getting-started.md) a la configuración de un dispositivo principal y explore sus funciones. AWS IoT Greengrass
**Topics**
+ [Plataformas admitidas](#supported-platforms)
+ [Requisitos de los dispositivos](#device-requirements)
+ [Requisitos de la función de Lambda](#greengrass-v2-lambda-requirements)
+ [Configura un Cuenta de AWS](#set-up-aws-account)
+ [Instalación del software AWS IoT Greengrass Core](install-greengrass-core-v2.md)
+ [Ejecute el software AWS IoT Greengrass principal](run-greengrass-core-v2.md)
+ [Ejecute AWS IoT Greengrass el software principal en un contenedor de Docker](run-greengrass-docker.md)
+ [Configurar el software AWS IoT Greengrass principal](configure-greengrass-core-v2.md)
+ [Actualización del software AWS IoT Greengrass Core (OTA)](update-greengrass-core-v2.md)
+ [Desinstalación del software AWS IoT Greengrass Core](uninstall-greengrass-core-v2.md)
## Plataformas admitidas
+ [Plataformas compatibles con el núcleo de Greengrass](https://docs.aws.amazon.com/greengrass/v2/developerguide/greengrass-nucleus-component.html)
+ [Plataformas compatibles con la versión lite del núcleo de Greengrass](https://docs.aws.amazon.com/greengrass/v2/developerguide/greengrass-nucleus-lite-component.html)
## Requisitos de los dispositivos
+ [Requisitos del dispositivo del núcleo de Greengrass](https://docs.aws.amazon.com/greengrass/v2/developerguide/greengrass-nucleus-component.html)
+ [Requisitos del dispositivo de la versión lite del núcleo de Greengrass](https://docs.aws.amazon.com/greengrass/v2/developerguide/greengrass-nucleus-lite-component.html)
## Requisitos de la función de Lambda
**importante**
Actualmente, las funciones de Lambda de Greengrass no son compatibles con la versión lite del núcleo de Greengrass.
El dispositivo debe cumplir los siguientes requisitos para ejecutar las funciones de Lambda:
+ Sistema operativo basado en Linux.
+ El dispositivo debe tener el intérprete de comandos `mkfifo`.
+ El dispositivo debe ejecutar las bibliotecas de lenguajes de programación que requiere una función de Lambda. Las bibliotecas necesarias deben instalarse en el dispositivo y agregarse a la variable de entorno `PATH`. Greengrass es compatible con todas las versiones compatibles con Lambda de los tiempos de ejecución de Python, Node.js y Java. Greengrass no aplica ninguna restricción adicional a las versiones de tiempo de ejecución de Lambda obsoletas. Para obtener más información sobre la AWS IoT Greengrass compatibilidad con los tiempos de ejecución de Lambda, consulte. [Ejecución de funciones de AWS Lambda](run-lambda-functions.md)
+ Para ejecutar funciones de Lambda en contenedores, su dispositivo debe cumplir los siguientes requisitos:
+ Kernel de Linux versión 4.4 o posterior.
+ El núcleo debe ser compatible con [cgroups](https://en.wikipedia.org/wiki/Cgroups) v1 y usted debe habilitar y montar los siguientes cgroups:
+ El grupo de *memoria* AWS IoT Greengrass para establecer el límite de memoria para las funciones Lambda en contenedores.
+ El cgroup de *dispositivos* para funciones de Lambda en contenedores con el fin de acceder a los dispositivos o volúmenes del sistema.
El software AWS IoT Greengrass Core no es compatible con cgroups v2.
Para cumplir con este requisito, arranque el dispositivo con los siguientes parámetros del núcleo de Linux.
```
cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0
```
**sugerencia**
En una Raspberry Pi, edite el archivo `/boot/cmdline.txt` para configurar los parámetros del núcleo del dispositivo.
+ Las siguientes configuraciones del núcleo de Linux deben estar habilitadas en el dispositivo:
+ Espacio de nombres:
+ `CONFIG_IPC_NS`
+ `CONFIG_UTS_NS`
+ `CONFIG_USER_NS`
+ `CONFIG_PID_NS`
+ Grupos de control:
+ `CONFIG_CGROUP_DEVICE`
+ `CONFIG_CGROUPS`
+ `CONFIG_MEMCG`
+ Otros:
+ `CONFIG_POSIX_MQUEUE`
+ `CONFIG_OVERLAY_FS`
+ `CONFIG_HAVE_ARCH_SECCOMP_FILTER`
+ `CONFIG_SECCOMP_FILTER`
+ `CONFIG_KEYS`
+ `CONFIG_SECCOMP`
+ `CONFIG_SHMEM`
**sugerencia**
Consulte la documentación de la distribución de Linux para saber cómo verificar y configurar los parámetros del núcleo de Linux. También puede utilizar AWS IoT Device Tester for AWS IoT Greengrass para comprobar que el dispositivo cumple estos requisitos. Para obtener más información, consulte [Uso de AWS IoT Device Tester para la versión 2 de AWS IoT Greengrass](device-tester-for-greengrass-ug.md).
## Configura un Cuenta de AWS
Si no tiene uno Cuenta de AWS, complete los siguientes pasos para crearlo.
**Para suscribirte a una Cuenta de AWS**
1. Abrir [https://portal.aws.amazon.com/billing/registro](https://portal.aws.amazon.com/billing/signup).
1. Siga las instrucciones que se le indiquen.
Parte del procedimiento de registro consiste en recibir una llamada telefónica o mensaje de texto e indicar un código de verificación en el teclado del teléfono.
Cuando te registras en un Cuenta de AWS, *Usuario raíz de la cuenta de AWS*se crea un. El usuario raíz tendrá acceso a todos los Servicios de AWS y recursos de esa cuenta. Como práctica recomendada de seguridad, asigne acceso administrativo a un usuario y utilice únicamente el usuario raíz para realizar [tareas que requieren acceso de usuario raíz](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).
Para crear un usuario administrador, elija una de las siguientes opciones.
****
| Elegir una forma de administrar el administrador | Para | Haga esto | También puede |
| --- | --- | --- | --- |
| En IAM Identity Center (recomendado) | Usar credenciales a corto plazo para acceder a AWS.Esto se ajusta a las prácticas recomendadas de seguridad. Para obtener información sobre las prácticas recomendadas, consulta [Prácticas recomendadas de seguridad en IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#bp-users-federation-idp) en la *Guía del usuario de IAM*. | Siga las instrucciones en [Introducción](https://docs.aws.amazon.com//singlesignon/latest/userguide/getting-started.html) en la Guía del usuario de AWS IAM Identity Center . | Configure el acceso programático [configurando el AWS CLI que se utilizará AWS IAM Identity Center](https://docs.aws.amazon.com//cli/latest/userguide/cli-configure-sso.html) en la Guía del AWS Command Line Interface usuario. |
| En IAM (no recomendado) | Usar credenciales a largo plazo para acceder a AWS. | Siguiendo las instrucciones de [Crear un usuario de IAM para acceso de emergencia](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started-emergency-iam-user.html) de la Guía del usuario de IAM. | Configure el acceso programático mediante [Administrar las claves de acceso de los usuarios de IAM](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_credentials_access-keys.html) en la Guía del usuario de IAM. |
# Instalación del software AWS IoT Greengrass Core
AWS IoT Greengrass lleva AWS a los dispositivos de periferia, de modo que puedan actuar en función de los datos que generan, al mismo tiempo que utilizan la Nube de AWS para tareas de administración, análisis y almacenamiento duradero. Instale el software AWS IoT Greengrass Core en los dispositivos de periferia para integrarlo con AWS IoT Greengrass y la Nube de AWS.
**importante**
Antes de descargar e instalar el software AWS IoT Greengrass Core, compruebe que su dispositivo principal cumpla los [requisitos](greengrass-nucleus-component.md#greengrass-v2-requirements) para instalar y ejecutar el software AWS IoT Greengrass Core versión 2.0.
El software AWS IoT Greengrass Core incluye un instalador que configura su dispositivo como un dispositivo principal de Greengrass. Al ejecutar el instalador, puede configurar las opciones, como la carpeta raíz y la carpeta Región de AWS a utilizar. Puede elegir que el instalador cree los recursos AWS IoT y de IAM necesarios para su caso. También puede optar por implementar herramientas de desarrollo local para configurar un dispositivo que utilice para el desarrollo de componentes personalizados.
El software AWS IoT Greengrass Core requiere lo siguiente AWS IoT y los recursos de IAM para conectarse a la Nube de AWS y funcionar:
+ Un objeto de AWS IoT. Cuando registre un dispositivo como un objeto AWS IoT, ese dispositivo puede usar un certificado digital para autenticarse con AWS. Este certificado permite que el dispositivo se comunique con AWS IoT y AWS IoT Greengrass. Para obtener más información, consulte [Autenticación y autorización de dispositivos para AWS IoT Greengrass](device-auth.md).
+ (Opcional) Un grupo de objetos AWS IoT. Los grupos de objetos se usan para administrar las flotas de dispositivos principales de Greengrass. Al implementar componentes de software en sus dispositivos, puede optar por implementarlos en dispositivos individuales o en grupos de dispositivos. Puede agregar un dispositivo a un grupo de objetos para implementar los componentes de software de ese grupo de objetos en el dispositivo. Para obtener más información, consulte [Implemente AWS IoT Greengrass componentes en los dispositivos](manage-deployments.md).
+ Un rol de IAM. Los dispositivos principales de Greengrass utilizan el proveedor de credenciales de AWS IoT Core para autorizar las llamadas a los servicios de AWS con un rol de IAM. Este rol le permite a su dispositivo interactuar con AWS IoT, enviar registros a los Registros de Amazon CloudWatch y descargar artefactos de componentes personalizados de Amazon Simple Storage Service (Amazon S3). Para obtener más información, consulte [Autorizar a los dispositivos principales a interactuar con AWS los servicios](device-service-role.md).
+ Un alias de rol de AWS IoT. Los dispositivos principales de Greengrass utilizan el alias del rol para identificar el rol de IAM que se va a utilizar. El alias del rol le permite cambiar el rol de IAM, pero mantener la misma configuración del dispositivo. 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*.
Elija una de las siguientes opciones para instalar el software AWS IoT Greengrass Core en un dispositivo principal.
+ **Instalación rápida**
Elija esta opción para configurar un dispositivo principal de Greengrass en el menor número de pasos posible. El instalador crea los recursos AWS IoT de IAM necesarios para usted. Esta opción requiere que proporcione credenciales de AWS al instalador para crear recursos en su Cuenta de AWS.
No puede usar esta opción para realizar la instalación detrás de un firewall o un proxy de red. Si sus dispositivos están protegidos por un firewall o un proxy de red, considere [instalarlos manualmente](manual-installation.md).
Para obtener más información, consulte [Instale el software AWS IoT Greengrass principal con aprovisionamiento automático de recursos](quick-installation.md).
+ **Instalación manual**
Elija esta opción para crear los recursos de AWS necesarios manualmente o para instalarlos detrás de un firewall o un proxy de red. Al realizar una instalación manual, no es necesario dar permiso al instalador para crear recursos en su Cuenta de AWS, ya que crea los recursos de AWS IoT y de IAM necesarios. También puede configurar el dispositivo para que se conecte al puerto 443 o a través de un proxy de red. También puede configurar el software AWS IoT Greengrass Core para que utilice una clave privada y un certificado que se almacenen en un módulo de seguridad de hardware (HSM), un módulo de plataforma segura (TPM) u otro elemento criptográfico.
Para obtener más información, consulte [Instale el software AWS IoT Greengrass principal con aprovisionamiento manual de recursos](manual-installation.md).
+ **Instalación con aprovisionamiento de flota AWS IoT**
Elija esta opción para crear los recursos de AWS necesarios a partir de una plantilla de aprovisionamiento de flotas AWS IoT. Puede elegir esta opción para crear dispositivos similares en una flota o si fabrica dispositivos que sus clientes activen más adelante, como vehículos o dispositivos domésticos inteligentes. Los dispositivos utilizan certificados identificativos para autenticar y aprovisionar recursos de AWS, incluido un certificado de cliente X.509 que el dispositivo utiliza la Nube de AWS para conectarse al sistema operativo normal. Puede incrustar o archivar los certificados de reclamación en el equipo del dispositivo durante la fabricación y puede utilizar el mismo certificado de reclamación y la misma clave para aprovisionar varios dispositivos. También puede configurar dispositivos para que se conecte al puerto 443 o a través de un proxy de red.
Para obtener más información, consulte [Instale el software AWS IoT Greengrass principal con aprovisionamiento AWS IoT de flota](fleet-provisioning.md).
+ **Instalación con aprovisionamiento personalizado**
Elija esta opción para desarrollar una aplicación Java personalizada que aprovisione los recursos de AWS necesarios. Puede elegir esta opción si [crea sus propios certificados de cliente X.509](https://docs.aws.amazon.com/iot/latest/developerguide/device-certs-your-own.html) o si desea tener más control sobre el proceso de aprovisionamiento. AWS IoT Greengrass proporciona una interfaz que puede implementar para intercambiar información entre su aplicación de aprovisionamiento personalizada y el instalador del software AWS IoT Greengrass Core.
Para obtener más información, consulte [Instale el software AWS IoT Greengrass principal con aprovisionamiento de recursos personalizado](custom-provisioning.md).
AWS IoT Greengrass también proporciona entornos en contenedores que ejecutan el software de AWS IoT Greengrass Core. Puede usar un archivo Docker para [ejecutar AWS IoT Greengrass en un contenedor de Docker](run-greengrass-docker.md).
**Topics**
+ [Instalación con aprovisionamiento automático](quick-installation.md)
+ [Instalación con aprovisionamiento manual](manual-installation.md)
+ [Instalación con el aprovisionamiento de flotas](fleet-provisioning.md)
+ [Instalación con aprovisionamiento personalizado](custom-provisioning.md)
+ [Argumentos del instalador](configure-installer.md)
# Instale el software AWS IoT Greengrass principal con aprovisionamiento automático de recursos
El software AWS IoT Greengrass Core incluye un instalador que configura su dispositivo como un dispositivo principal de Greengrass. Para configurar un dispositivo rápidamente, el instalador puede proporcionar la AWS IoT AWS IoT cosa, el grupo de cosas, la función de IAM y el alias de la AWS IoT función que el dispositivo principal necesita para funcionar. El instalador también puede implementar las herramientas de desarrollo locales en el dispositivo principal, de modo que usted pueda usar el dispositivo para desarrollar y probar componentes de software personalizados. El instalador necesita AWS credenciales para aprovisionar estos recursos y crear la implementación.
Si no puede proporcionar AWS las credenciales al dispositivo, puede aprovisionar los AWS recursos que el dispositivo principal necesita para funcionar. También puede implementar las herramientas de desarrollo en un dispositivo principal para usarlas como dispositivo de desarrollo. Esto le permite conceder menos permisos al dispositivo al ejecutar el instalador. Para obtener más información, consulte [Instale el software AWS IoT Greengrass principal con aprovisionamiento manual de recursos](manual-installation.md).
**importante**
Antes de descargar el software AWS IoT Greengrass Core, compruebe que su dispositivo principal cumpla los [requisitos](greengrass-nucleus-component.md#greengrass-v2-requirements) para instalar y ejecutar el software AWS IoT Greengrass Core v2.0.
**Topics**
+ [Configuración del entorno del dispositivo](#set-up-device-environment)
+ [Proporcione AWS las credenciales al dispositivo](#provide-installer-aws-credentials)
+ [Descargue el software AWS IoT Greengrass principal](#download-greengrass-core-v2)
+ [Instale el software principal AWS IoT Greengrass](#run-greengrass-core-v2-installer)
## Configuración del entorno del dispositivo
Siga los pasos de esta sección para configurar un dispositivo Linux o Windows para usarlo como su dispositivo principal de AWS IoT Greengrass .
### Configuración de un dispositivo Linux
**Para configurar un dispositivo Linux para AWS IoT Greengrass V2**
1. Instale el motor de ejecución de Java, que el software AWS IoT Greengrass principal necesita para ejecutarse. Le recomendamos que utilice las versiones de compatibilidad a largo plazo de [Amazon Corretto](https://aws.amazon.com/corretto/) u [OpenJDK](https://openjdk.java.net/). Se requiere la versión 8 o posterior. Los siguientes comandos muestran cómo instalar OpenJDK en su dispositivo.
+ Para distribuciones basadas en Debian o en Ubuntu:
```
sudo apt install default-jdk
```
+ Para distribuciones basadas en Red Hat:
```
sudo yum install java-11-openjdk-devel
```
+ En Amazon Linux 2:
```
sudo amazon-linux-extras install java-openjdk11
```
+ En Amazon Linux 2023:
```
sudo dnf install java-11-amazon-corretto -y
```
Cuando se complete la instalación, ejecute el siguiente comando para comprobar que Java se ejecuta en su dispositivo Linux.
```
java -version
```
El comando imprime la versión de Java que se ejecuta en el dispositivo. Por ejemplo, en una distribución basada en Debian, el resultado podría ser similar al siguiente ejemplo.
```
openjdk version "11.0.9.1" 2020-11-04
OpenJDK Runtime Environment (build 11.0.9.1+1-post-Debian-1deb10u2)
OpenJDK 64-Bit Server VM (build 11.0.9.1+1-post-Debian-1deb10u2, mixed mode)
```
1. (Opcional) Cree el usuario y el grupo predeterminado del sistema que ejecutan los componentes del dispositivo. También puede optar por permitir que el instalador del software AWS IoT Greengrass principal cree este usuario y grupo durante la instalación con el argumento del `--component-default-user` instalador. Para obtener más información, consulte [Argumentos del instalador](configure-installer.md).
```
sudo useradd --system --create-home ggc_user
sudo groupadd --system ggc_group
```
1. Compruebe que el usuario que ejecuta el software AWS IoT Greengrass principal (normalmente`root`) tiene permiso para ejecutar `sudo` con cualquier usuario y grupo.
1. Ejecute el siguiente comando para abrir el archivo `/etc/sudoers`.
```
sudo visudo
```
1. Compruebe que el permiso del usuario se parezca al siguiente ejemplo.
```
root ALL=(ALL:ALL) ALL
```
1. (Opcional) Para [ejecutar funciones de Lambda en contenedores](run-lambda-functions.md), debe habilitar la versión 1 de [cgroups](https://en.wikipedia.org/wiki/Cgroups), y habilitar y montar los cgroups de *memoria* y de *dispositivos*. Si no tiene previsto ejecutar funciones de Lambda en contenedores, puede omitir este paso.
Para habilitar estas opciones de cgroups, arranque el dispositivo con los siguientes parámetros del kernel de Linux.
```
cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0
```
Para obtener más información acerca de cómo ver y configurar los parámetros del kernel de su dispositivo, consulte la documentación del sistema operativo y del gestor de arranque. Siga las instrucciones para configurar permanentemente los parámetros del kernel.
1. Instale todas las demás dependencias necesarias en su dispositivo tal y como se indica en la lista de requisitos de [Requisitos de los dispositivos](greengrass-nucleus-component.md#greengrass-v2-requirements).
### Configuración de un dispositivo de Windows
**nota**
Esta característica está disponible para la versión 2.5.0 y versiones posteriores del [componente núcleo de Greengrass](greengrass-nucleus-component.md).
**Para configurar un dispositivo Windows para AWS IoT Greengrass V2**
1. Instale el motor de ejecución de Java, que el software AWS IoT Greengrass principal necesita para ejecutarse. Le recomendamos que utilice las versiones de compatibilidad a largo plazo de [Amazon Corretto](https://aws.amazon.com/corretto/) u [OpenJDK](https://openjdk.java.net/). Se requiere la versión 8 o posterior.
1. Compruebe si Java está disponible en la variable del sistema [PATH](https://en.wikipedia.org/wiki/PATH_(variable)) y agréguelo si no lo está. La LocalSystem cuenta ejecuta el software AWS IoT Greengrass principal, por lo que debe agregar Java a la variable de sistema PATH en lugar de a la variable de usuario PATH de su usuario. Haga lo siguiente:
1. Pulse la tecla Windows para abrir el menú de inicio.
1. Escriba **environment variables** para buscar las opciones del sistema en el menú de inicio.
1. En los resultados de la búsqueda del menú de inicio, elija **Editar las variables de entorno del sistema** para abrir la ventana de **Propiedades del sistema**.
1. Elija **Variables de entorno...** para abrir la ventana **Variables de entorno**.
1. En **Variables del sistema**, elija **Ruta** y, luego, **Editar**. En la ventana **Editar variables de entorno**, puede ver cada ruta en una línea independiente.
1. Compruebe si la ruta a la carpeta de la instalación de Java `bin` está presente. La ruta puede tener un aspecto similar al siguiente ejemplo.
```
C:\\Program Files\\Amazon Corretto\\jdk11.0.13_8\\bin
```
1. Si la carpeta de la instalación de Java `bin` no aparece en **Ruta**, elija **Nueva** para agregarla y, a continuación, pulse **Aceptar**.
1. Abra el símbolo del sistema de Windows (`cmd.exe`) como administrador.
1. Cree el usuario predeterminado en la LocalSystem cuenta del dispositivo Windows. *password*Sustitúyalo por una contraseña segura.
```
net user /add ggc_user password
```
**sugerencia**
Según su configuración de Windows, es posible que la contraseña del usuario caduque en una fecha futura. Para garantizar que sus aplicaciones de Greengrass sigan funcionando, controle cuándo caduca la contraseña y actualícela antes de que caduque. También puede configurar la contraseña del usuario para que nunca caduque.
Para comprobar cuándo caducan un usuario y su contraseña, ejecute el siguiente comando.
```
net user ggc_user | findstr /C:expires
```
Para configurar la contraseña de un usuario para que no caduque nunca, ejecute el siguiente comando.
```
wmic UserAccount where "Name='ggc_user'" set PasswordExpires=False
```
Si utilizas Windows 10 o una versión posterior, donde el [`wmic`comando está en desuso](https://learn.microsoft.com/en-us/windows/win32/wmisdk/wmic), ejecuta el siguiente PowerShell comando.
```
Get-CimInstance -Query "SELECT * from Win32_UserAccount WHERE name = 'ggc_user'" | Set-CimInstance -Property @{PasswordExpires="False"}
```
1. Descargue e instale la [PsExecutilidad](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec) de Microsoft en el dispositivo.
1. Utilice la PsExec utilidad para almacenar el nombre de usuario y la contraseña del usuario predeterminado en la instancia de Credential Manager de la LocalSystem cuenta. *password*Sustitúyala por la contraseña de usuario que configuraste anteriormente.
```
psexec -s cmd /c cmdkey /generic:ggc_user /user:ggc_user /pass:password
```
Si **PsExec License Agreement** se abre, elija **Accept** para aceptar la licencia y ejecute el comando.
**nota**
En los dispositivos Windows, la LocalSystem cuenta ejecuta el núcleo de Greengrass y debe usar la PsExec utilidad para almacenar la información de usuario predeterminada en la LocalSystem cuenta. El uso de la aplicación Credential Manager almacena esta información en la cuenta de Windows del usuario que ha iniciado sesión actualmente, en lugar de en la LocalSystem cuenta.
## Proporcione AWS las credenciales al dispositivo
Proporcione AWS las credenciales del dispositivo para que el instalador pueda aprovisionar los AWS recursos necesarios. Para obtener más información sobre los permisos necesarios, consulte [Política de IAM mínima para que el instalador aprovisione recursos](provision-minimal-iam-policy.md).
**Para proporcionar AWS credenciales al dispositivo**
+ Proporcione sus AWS credenciales al dispositivo para que el instalador pueda aprovisionar los recursos de IAM AWS IoT y los de su dispositivo principal. Para aumentar la seguridad, le recomendamos que obtenga credenciales temporales para un rol de IAM que permita únicamente los permisos mínimos necesarios para el aprovisionamiento. Para obtener más información, consulte [Política de IAM mínima para que el instalador aprovisione recursos](provision-minimal-iam-policy.md).
**nota**
El instalador no guarda ni almacena sus credenciales.
En el dispositivo, realice una de las siguientes acciones para recuperar las credenciales y ponerlas a disposición del instalador del software AWS IoT Greengrass principal:
+ (Recomendado) Utilice credenciales temporales de AWS IAM Identity Center
1. Proporcione el ID de clave de acceso, la clave de acceso secreta y el token de sesión desde IAM Identity Center. Para obtener más información, consulte la **Actualización manual de credenciales** en [Obtener y actualizar las credenciales temporales](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtogetcredentials.html#how-to-get-temp-credentials) en la *Guía del usuario de IAM Identity Center.*
1. Ejecute los siguientes comandos para proporcionar las credenciales al software AWS IoT Greengrass principal.
------
#### [ Linux or Unix ]
```
export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
export AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE=
```
------
#### [ Windows Command Prompt (CMD) ]
```
set AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
set AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
set AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE=
```
------
#### [ PowerShell ]
```
$env:AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
$env:AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
$env:AWS_SESSION_TOKEN="AQoDYXdzEJr1K...o5OytwEXAMPLE="
```
------
+ Use credenciales de seguridad temporales de un rol de (IAM):
1. Proporcione el ID de clave de acceso, la clave de acceso secreta y el token de sesión desde un rol de IAM que asuma. Para obtener más información acerca de cómo recuperar estas credenciales, consulte [Solicitud de credenciales de seguridad temporales](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html) en la *Guía del usuario de IAM*.
1. Ejecute los siguientes comandos para proporcionar las credenciales al software AWS IoT Greengrass principal.
------
#### [ Linux or Unix ]
```
export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
export AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE=
```
------
#### [ Windows Command Prompt (CMD) ]
```
set AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
set AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
set AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE=
```
------
#### [ PowerShell ]
```
$env:AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
$env:AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
$env:AWS_SESSION_TOKEN="AQoDYXdzEJr1K...o5OytwEXAMPLE="
```
------
+ Use credenciales a largo plazo de un usuario de IAM:
1. Proporcione el ID de clave de acceso y la clave de acceso secreta del usuario de IAM. Puede crear un usuario de IAM para el aprovisionamiento y luego eliminarlo. Para la política de IAM que debe proporcionarse al usuario, consulte [Política de IAM mínima para que el instalador aprovisione recursos](provision-minimal-iam-policy.md). Para obtener información acerca de cómo recuperar credenciales a largo plazo, consulte [Administración de las claves de acceso de los usuarios de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html) en la *Guía de usuario de IAM*.
1. Ejecute los siguientes comandos para proporcionar las credenciales al software AWS IoT Greengrass principal.
------
#### [ Linux or Unix ]
```
export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
```
------
#### [ Windows Command Prompt (CMD) ]
```
set AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
set AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
```
------
#### [ PowerShell ]
```
$env:AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
$env:AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
```
------
1. (Opcional) Si creó un usuario de IAM para aprovisionar su dispositivo de Greengrass, elimínelo.
1. (Opcional) Si utilizó el ID de clave de acceso y la clave de acceso secreta de un usuario de IAM existente, actualice las claves del usuario para que dejen de ser válidas. Para obtener más información, consulte [Actualización de claves de acceso](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html#Using_RotateAccessKey) en la *Guía de usuario de AWS Identity and Access Management *.
## Descargue el software AWS IoT Greengrass principal
Puede descargar la última versión del software AWS IoT Greengrass Core desde la siguiente ubicación:
+ [https://d2s8p88vqu9w66.cloudfront. net/releases/greengrass](https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip)-nucleus-latest.zip
**nota**
Puede descargar una versión específica del software AWS IoT Greengrass Core desde la siguiente ubicación. *version*Sustitúyala por la versión que se va a descargar.
```
https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-version.zip
```
**Para descargar el software AWS IoT Greengrass principal**
1. En su dispositivo principal, descargue el software AWS IoT Greengrass Core en un archivo denominado`greengrass-nucleus-latest.zip`.
------
#### [ Linux or Unix ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
iwr -Uri https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip -OutFile greengrass-nucleus-latest.zip
```
------
Al descargar este software, acepta el [acuerdo de licencia del software de Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf).
1. (Opcional) Verificación de la firma del software del núcleo de Greengrass
**nota**
Esta característica está disponible en la versión 2.9.5 y versiones posteriores del núcleo de Greengrass.
1. Use el siguiente comando para verificar la firma del artefacto del núcleo de Greengrass:
------
#### [ Linux or Unix ]
```
jarsigner -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
El nombre del archivo puede tener un aspecto diferente según la versión de JDK que instale. Reemplace *`jdk17.0.6_10`* por la versión de JDK que instaló.
```
"C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe" -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
El nombre del archivo puede tener un aspecto diferente según la versión de JDK que instale. Reemplace *`jdk17.0.6_10`* por la versión de JDK que instaló.
```
'C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe' -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
1. La invocación `jarsigner` produce un resultado que indica los resultados de la verificación.
1. Si el archivo zip del núcleo de Greengrass está firmado, el resultado contiene la siguiente declaración:
```
jar verified.
```
1. Si el archivo zip del núcleo de Greengrass no está firmado, el resultado contiene la siguiente declaración:
```
jar is unsigned.
```
1. Si ha proporcionado la opción `-certs` Jarsigner junto con las opciones `-verify` y `-verbose`, el resultado también incluye información detallada del certificado de firmante.
1. Descomprime el software AWS IoT Greengrass Core en una carpeta de tu dispositivo. *GreengrassInstaller*Sustitúyalo por la carpeta que desee usar.
------
#### [ Linux or Unix ]
```
unzip greengrass-nucleus-latest.zip -d GreengrassInstaller && rm greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir GreengrassInstaller && tar -xf greengrass-nucleus-latest.zip -C GreengrassInstaller && del greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
Expand-Archive -Path greengrass-nucleus-latest.zip -DestinationPath .\\GreengrassInstaller
rm greengrass-nucleus-latest.zip
```
------
1. (Opcional) Ejecute el siguiente comando para ver la versión del software AWS IoT Greengrass principal.
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
**importante**
Si instala una versión del núcleo de Greengrass anterior a la v2.4.0, no elimine esta carpeta después de instalar el software Core. AWS IoT Greengrass El software AWS IoT Greengrass Core utiliza los archivos de esta carpeta para ejecutarse.
Si descargó la última versión del software, instale la versión 2.4.0 o posterior y podrá eliminar esta carpeta después de instalar el software AWS IoT Greengrass principal.
## Instale el software principal AWS IoT Greengrass
Ejecute el instalador con argumentos que especifiquen lo siguiente:
+ Cree los AWS recursos que el dispositivo principal necesita para funcionar.
+ Especifique si desea usar el usuario del sistema `ggc_user` para ejecutar los componentes de software en el dispositivo principal. En los dispositivos Linux, este comando también especifica el uso del grupo del sistema `ggc_group` y el instalador crea el usuario y el grupo del sistema por usted.
+ Configure el software AWS IoT Greengrass Core como un servicio del sistema que se ejecute durante el arranque. En los dispositivos Linux, esto requiere el sistema de inicio [Systemd](https://en.wikipedia.org/wiki/Systemd).
**importante**
En los dispositivos principales de Windows, debe configurar el software AWS IoT Greengrass principal como un servicio del sistema.
Para configurar un dispositivo de desarrollo con herramientas de desarrollo local, especifique el argumento `--deploy-dev-tools true`. Una vez finalizada la instalación, la implementación de las herramientas de desarrollo local puede tardar hasta un minuto.
Para obtener más información acerca de los argumentos que puede especificar, consulte [Argumentos del instalador](configure-installer.md).
**nota**
Si utilizas un AWS IoT Greengrass dispositivo con memoria limitada, puedes controlar la cantidad de memoria que utiliza el software AWS IoT Greengrass Core. Para controlar la asignación de memoria, puede configurar las opciones de tamaño de montón de la JVM en el parámetro de configuración `jvmOptions` del componente núcleo. Para obtener más información, consulte [Control de la asignación de memoria con las opciones de JVM](configure-greengrass-core-v2.md#jvm-tuning).
**Para instalar el software AWS IoT Greengrass Core**
1. Ejecute el instalador AWS IoT Greengrass principal. Reemplace los valores de los argumentos en su comando de la siguiente manera.
**nota**
Windows tiene una limitación de longitud de ruta de 260 caracteres. Si usa Windows, use una carpeta raíz como `C:\greengrass\v2` o `D:\greengrass\v2` para mantener las rutas de los componentes de Greengrass por debajo del límite de 260 caracteres.
1. `/greengrass/v2`o bien*C:\$1greengrass\$1v2*: la ruta a la carpeta raíz que se utilizará para instalar el software AWS IoT Greengrass Core.
1. *GreengrassInstaller*. La ruta a la carpeta en la que desempaquetó el instalador del software AWS IoT Greengrass Core.
1. *region*. El Región de AWS lugar en el que encontrar o crear recursos.
1. *MyGreengrassCore*. El nombre del AWS IoT dispositivo principal de Greengrass. Si el objeto no existe, el instalador la crea. El instalador descarga los certificados para autenticarse como tal. AWS IoT Para obtener más información, consulte [Autenticación y autorización de dispositivos para AWS IoT Greengrass](device-auth.md).
**nota**
El nombre del objeto no puede contener dos puntos (`:`).
1. *MyGreengrassCoreGroup*. El nombre del grupo de AWS IoT cosas de su dispositivo principal de Greengrass. Si el grupo de objetos no existe, el instalador lo crea y le agrega un objeto. Si el grupo de objetos existe y tiene una implementación activa, el dispositivo principal descarga y ejecuta el software que especifique la implementación.
**nota**
El nombre del grupo de objetos no puede contener dos puntos (`:`).
1. *GreengrassV2IoTThingPolicy*. El nombre de la AWS IoT política que permite a los dispositivos principales de Greengrass comunicarse con AWS IoT y. AWS IoT Greengrass Si la AWS IoT política no existe, el instalador crea una AWS IoT política permisiva con este nombre. Puede restringir los permisos de esta política según su caso de uso. Para obtener más información, consulte [AWS IoT Política mínima para los dispositivos AWS IoT Greengrass V2 principales](device-auth.md#greengrass-core-minimal-iot-policy).
1. *GreengrassV2TokenExchangeRole*. El nombre de la función de IAM que permite al dispositivo principal de Greengrass obtener AWS credenciales temporales. Si el rol no existe, el instalador lo crea y asocia una política denominada `GreengrassV2TokenExchangeRoleAccess`. Para obtener más información, consulte [Autorizar a los dispositivos principales a interactuar con AWS los servicios](device-service-role.md).
1. *GreengrassCoreTokenExchangeRoleAlias*. El alias de la función de IAM que permite al dispositivo principal de Greengrass obtener credenciales temporales más adelante. Si el alias del rol no existe, el instalador lo crea y lo dirige al rol de IAM que especifique. Para obtener más información, consulte [Autorizar a los dispositivos principales a interactuar con AWS los servicios](device-service-role.md).
------
#### [ Linux or Unix ]
```
sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
-jar ./GreengrassInstaller/lib/Greengrass.jar \
--aws-region region \
--thing-name MyGreengrassCore \
--thing-group-name MyGreengrassCoreGroup \
--thing-policy-name GreengrassV2IoTThingPolicy \
--tes-role-name GreengrassV2TokenExchangeRole \
--tes-role-alias-name GreengrassCoreTokenExchangeRoleAlias \
--component-default-user ggc_user:ggc_group \
--provision true \
--setup-system-service true
```
------
#### [ Windows Command Prompt (CMD) ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" ^
-jar ./GreengrassInstaller/lib/Greengrass.jar ^
--aws-region region ^
--thing-name MyGreengrassCore ^
--thing-group-name MyGreengrassCoreGroup ^
--thing-policy-name GreengrassV2IoTThingPolicy ^
--tes-role-name GreengrassV2TokenExchangeRole ^
--tes-role-alias-name GreengrassCoreTokenExchangeRoleAlias ^
--component-default-user ggc_user ^
--provision true ^
--setup-system-service true
```
------
#### [ PowerShell ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" `
-jar ./GreengrassInstaller/lib/Greengrass.jar `
--aws-region region `
--thing-name MyGreengrassCore `
--thing-group-name MyGreengrassCoreGroup `
--thing-policy-name GreengrassV2IoTThingPolicy `
--tes-role-name GreengrassV2TokenExchangeRole `
--tes-role-alias-name GreengrassCoreTokenExchangeRoleAlias `
--component-default-user ggc_user `
--provision true `
--setup-system-service true
```
------
**importante**
En los dispositivos principales de Windows, debe especificar si `--setup-system-service true` desea configurar el software AWS IoT Greengrass Core como un servicio del sistema.
El instalador imprime los siguientes mensajes si la operación es exitosa:
+ Si especifica `--provision`, el instalador imprime `Successfully configured Nucleus with provisioned resource details` si configuró los recursos correctamente.
+ Si especifica `--deploy-dev-tools`, el instalador imprime `Configured Nucleus to deploy aws.greengrass.Cli component` si creó la implementación correctamente.
+ Si especifica `--setup-system-service true`, el instalador imprime `Successfully set up Nucleus as a system service` si configuró y ejecutó el software como un servicio.
+ Si no especifica `--setup-system-service true`, el instalador imprime `Launched Nucleus successfully` si se ejecutó correctamente y ejecutó el software.
1. Omita este paso si instaló la versión 2.0.4 o una versión posterior de [Núcleo de Greengrass](greengrass-nucleus-component.md). Si descargó la versión más reciente del software, instaló la versión 2.0.4 o una versión posterior.
Ejecute el siguiente comando para establecer los permisos de archivo necesarios para la carpeta raíz del software AWS IoT Greengrass principal. `/greengrass/v2`Sustitúyala por la carpeta raíz que especificó en el comando de instalación y */greengrass* sustitúyala por la carpeta principal de la carpeta raíz.
```
sudo chmod 755 /greengrass/v2 && sudo chmod 755 /greengrass
```
Si instaló el software AWS IoT Greengrass principal como un servicio del sistema, el instalador ejecutará el software automáticamente. De no ser así, debe ejecutar el software manualmente. Para obtener más información, consulte [Ejecute el software AWS IoT Greengrass principal](run-greengrass-core-v2.md).
**nota**
De forma predeterminada, el rol de IAM que crea el instalador no permite el acceso a los artefactos de componentes de los buckets de S3. Para implementar componentes personalizados que definan artefactos en Amazon S3, debe agregar permisos al rol para permitir que su dispositivo principal recupere artefactos de componentes. 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).
Si aún no tiene un bucket de S3 para los artefactos de los componentes, puede agregar estos permisos más adelante, después de crear un bucket.
**nota**
Cuando el software AWS IoT Greengrass Core se conecte a la nube, su dispositivo será reconocido como un dispositivo Core.
Para obtener más información sobre cómo configurar y usar el software AWS IoT Greengrass, consulte lo siguiente:
+ [Configurar el software AWS IoT Greengrass principal](configure-greengrass-core-v2.md)
+ [Desarrollo de componentes de AWS IoT Greengrass](develop-greengrass-components.md)
+ [Implemente AWS IoT Greengrass componentes en los dispositivos](manage-deployments.md)
+ [Interfaz de la línea de comandos de Greengrass](gg-cli.md)
# Instale el software AWS IoT Greengrass principal con aprovisionamiento manual de recursos
El software AWS IoT Greengrass Core incluye un instalador que configura su dispositivo como un dispositivo principal de Greengrass. Para configurar un dispositivo manualmente, puede crear los recursos de IAM AWS IoT y los necesarios para que los utilice el dispositivo. Si crea estos recursos manualmente, no necesita proporcionar AWS las credenciales al instalador.
Al instalar manualmente el software AWS IoT Greengrass Core, también puede configurar el dispositivo para que utilice un proxy de red o se conecte AWS al puerto 443. Es posible que tenga que especificar estas opciones de configuración si su dispositivo funciona con un firewall o un proxy de red, por ejemplo. Para obtener más información, consulte [Realizar la conexión en el puerto 443 o a través de un proxy de red](configure-greengrass-core-v2.md#configure-alpn-network-proxy).
También puede configurar el software AWS IoT Greengrass Core para que utilice un módulo de seguridad de hardware (HSM) a través de la interfaz [PKCS \$111](https://en.wikipedia.org/wiki/PKCS_11). Esta característica le permite almacenar de forma segura los archivos de certificados y claves privadas para que no queden expuestos ni duplicados en el software. Puede almacenar claves privadas y certificados en un módulo de hardware, como un HSM, un módulo de plataforma segura (TPM) u otro elemento criptográfico. Esta característica solo está disponible en dispositivos Linux. Para obtener más información sobre la seguridad del hardware y los requisitos para su uso, consulte [Integración de la seguridad de hardware](hardware-security.md).
**importante**
Antes de descargar el software AWS IoT Greengrass Core, compruebe que su dispositivo principal cumpla los [requisitos](greengrass-nucleus-component.md#greengrass-v2-requirements) para instalar y ejecutar el software AWS IoT Greengrass Core v2.0.
**Topics**
+ [Recupere los puntos finales AWS IoT](#retrieve-iot-endpoints)
+ [Crea cualquier AWS IoT cosa](#create-iot-thing)
+ [Creación del certificado del objeto](#create-thing-certificate)
+ [Configuración del certificado del objeto](#configure-thing-certificate)
+ [Creación de un rol de intercambio de token](#create-token-exchange-role)
+ [Descarga de certificados al dispositivo](#download-thing-certificates)
+ [Configuración del entorno del dispositivo](#set-up-device-environment)
+ [Descargue el software AWS IoT Greengrass principal](#download-greengrass-core-v2)
+ [Instale el software principal AWS IoT Greengrass](#run-greengrass-core-v2-installer-manual)
## Recupere los puntos finales AWS IoT
Obtenga sus AWS IoT Cuenta de AWS puntos finales y guárdelos para usarlos más tarde. El dispositivo usa estos puntos de conexión para conectarse a AWS IoT. Haga lo siguiente:
1. Obtenga el punto final AWS IoT de datos para su. Cuenta de AWS
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
Si la solicitud se realiza exitosamente, la respuesta se parece al siguiente ejemplo.
```
{
"endpointAddress": "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
}
```
1. Obtenga el punto final de AWS IoT credenciales para su Cuenta de AWS.
```
aws iot describe-endpoint --endpoint-type iot:CredentialProvider
```
Si la solicitud se realiza exitosamente, la respuesta se parece al siguiente ejemplo.
```
{
"endpointAddress": "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
}
```
## Crea cualquier AWS IoT cosa
AWS IoT *las cosas* representan dispositivos y entidades lógicas a las que se conectan AWS IoT. Los dispositivos principales de Greengrass son AWS IoT cosas. Cuando registras un dispositivo como una AWS IoT cosa, ese dispositivo puede usar un certificado digital para autenticarse. AWS
En esta sección, crearás AWS IoT algo que represente tu dispositivo.
**Para crear cualquier AWS IoT cosa**
1. Crea cualquier AWS IoT cosa para tu dispositivo. En su equipo de desarrollo, ejecute el siguiente comando.
+ *MyGreengrassCore*Sustitúyalo por el nombre de la cosa a utilizar. Este nombre también es el nombre de su dispositivo principal de Greengrass.
**nota**
El nombre del objeto no puede contener dos puntos (`:`).
```
aws iot create-thing --thing-name MyGreengrassCore
```
Si la solicitud se realiza exitosamente, la respuesta se parece al siguiente ejemplo.
```
{
"thingName": "MyGreengrassCore",
"thingArn": "arn:aws:iot:us-west-2:123456789012:thing/MyGreengrassCore",
"thingId": "8cb4b6cd-268e-495d-b5b9-1713d71dbf42"
}
```
1. (Opcional) Añada la AWS IoT cosa a un grupo de cosas nuevo o existente. Los grupos de objetos se usan para administrar las flotas de dispositivos principales de Greengrass. Al implementar componentes de software en sus dispositivos, puede dirigirlos a dispositivos individuales o a grupos de dispositivos. Puede agregar un dispositivo a un grupo de objetos con una implementación activa de Greengrass para implementar los componentes de software de ese grupo de objetos en el dispositivo. Haga lo siguiente:
1. (Opcional) Cree un grupo de AWS IoT cosas.
+ *MyGreengrassCoreGroup*Sustitúyalo por el nombre del grupo de cosas que desee crear.
**nota**
El nombre del grupo de objetos no puede contener dos puntos (`:`).
```
aws iot create-thing-group --thing-group-name MyGreengrassCoreGroup
```
Si la solicitud se realiza exitosamente, la respuesta se parece al siguiente ejemplo.
```
{
"thingGroupName": "MyGreengrassCoreGroup",
"thingGroupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/MyGreengrassCoreGroup",
"thingGroupId": "4df721e1-ff9f-4f97-92dd-02db4e3f03aa"
}
```
1. Añada la AWS IoT cosa a un grupo de cosas.
+ *MyGreengrassCore*Sustitúyala por el nombre de la AWS IoT cosa.
+ *MyGreengrassCoreGroup*Sustitúyalo por el nombre del grupo de cosas.
```
aws iot add-thing-to-thing-group --thing-name MyGreengrassCore --thing-group-name MyGreengrassCoreGroup
```
El comando no tiene ningún resultado si la solicitud se realiza correctamente.
## Creación del certificado del objeto
Al registrar un dispositivo como una AWS IoT cosa, ese dispositivo puede utilizar un certificado digital para autenticarse AWS. Este certificado permite que el dispositivo se comunique con AWS IoT y AWS IoT Greengrass.
En esta sección, puede crear y descargar certificados que el dispositivo puede usar para conectarse a AWS.
Si desea configurar el software AWS IoT Greengrass principal para que utilice un módulo de seguridad de hardware (HSM) para almacenar de forma segura la clave privada y el certificado, siga los pasos para crear el certificado a partir de una clave privada de un HSM. De lo contrario, siga los pasos para crear el certificado y la clave privada en el AWS IoT servicio. La característica de seguridad de hardware solo está disponible en dispositivos Linux. Para obtener más información sobre la seguridad del hardware y los requisitos para su uso, consulte [Integración de la seguridad de hardware](hardware-security.md).
### Cree el certificado y la clave privada en el AWS IoT servicio
**Creación del certificado del objeto**
1. Crea una carpeta donde descargues los certificados de la AWS IoT cosa.
```
mkdir greengrass-v2-certs
```
1. Crea y descarga los certificados de la AWS IoT cosa.
```
aws iot create-keys-and-certificate --set-as-active --certificate-pem-outfile greengrass-v2-certs/device.pem.crt --public-key-outfile greengrass-v2-certs/public.pem.key --private-key-outfile greengrass-v2-certs/private.pem.key
```
Si la solicitud se realiza exitosamente, la respuesta se parece al siguiente ejemplo.
```
{
"certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificateId": "aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificatePem": "-----BEGIN CERTIFICATE-----
MIICiTCCAfICCQD6m7oRw0uXOjANBgkqhkiG9w
0BAQUFADCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZ
WF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIw
EAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5
jb20wHhcNMTEwNDI1MjA0NTIxWhcNMTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBh
MCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBb
WF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMx
HzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5jb20wgZ8wDQYJKoZIhvcNAQE
BBQADgY0AMIGJAoGBAMaK0dn+a4GmWIWJ21uUSfwfEvySWtC2XADZ4nB+BLYgVI
k60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9TrDHudUZg3qX4waLG5M43q7Wgc/MbQ
ITxOUSQv7c7ugFFDzQGBzZswY6786m86gpEIbb3OhjZnzcvQAaRHhdlQWIMm2nr
AgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4nUhVVxYUntneD9+h8Mg9q6q+auN
KyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0FkbFFBjvSfpJIlJ00zbhNYS5f6Guo
EDmFJl0ZxBHjJnyp378OD8uTs7fLvjx79LjSTbNYiytVbZPQUQ5Yaxu2jXnimvw
3rrszlaEXAMPLE=
-----END CERTIFICATE-----",
"keyPair": {
"PublicKey": "-----BEGIN PUBLIC KEY-----\
MIIBIjANBgkqhkEXAMPLEQEFAAOCAQ8AMIIBCgKCAQEAEXAMPLE1nnyJwKSMHw4h\
MMEXAMPLEuuN/dMAS3fyce8DW/4+EXAMPLEyjmoF/YVF/gHr99VEEXAMPLE5VF13\
59VK7cEXAMPLE67GK+y+jikqXOgHh/xJTwo+sGpWEXAMPLEDz18xOd2ka4tCzuWEXAMPLEahJbYkCPUBSU8opVkR7qkEXAMPLE1DR6sx2HocliOOLtu6Fkw91swQWEXAMPLE\\GB3ZPrNh0PzQYvjUStZeccyNCx2EXAMPLEvp9mQOUXP6plfgxwKRX2fEXAMPLEDa\
hJLXkX3rHU2xbxJSq7D+XEXAMPLEcw+LyFhI5mgFRl88eGdsAEXAMPLElnI9EesG\
FQIDAQAB\
-----END PUBLIC KEY-----\
",
"PrivateKey": "-----BEGIN RSA PRIVATE KEY-----\
key omitted for security reasons\
-----END RSA PRIVATE KEY-----\
"
}
}
```
Guarde el nombre de recurso de Amazon (ARN) del certificado para usarlo para configurar el certificado más adelante.
### Creación del certificado a partir de una clave privada en un HSM
**nota**
Esta función está disponible para la versión 2.5.3 y versiones posteriores del componente núcleo de [Greengrass](greengrass-nucleus-component.md). AWS IoT Greengrass actualmente no admite esta función en los dispositivos principales de Windows.
**Creación del certificado del objeto**
1. En el dispositivo principal, inicialice un token PKCS\$111 en el HSM y genere una clave privada. La clave privada debe ser una clave RSA con un tamaño de clave RSA-2048 (o mayor) o una clave ECC.
**nota**
Para utilizar un módulo de seguridad de hardware con claves ECC, debe utilizar la versión del [núcleo de Greengrass](greengrass-nucleus-component.md) 2.5.6 o posterior.
Para usar un módulo de seguridad de hardware y el [administrador de secretos](secret-manager-component.md), debe usar un módulo de seguridad de hardware con claves RSA.
Consulte la documentación de su HSM para obtener información sobre cómo inicializar el token y generar la clave privada. Si su HSM admite objetos IDs, especifique un ID de objeto al generar la clave privada. Guarde el ID de ranura, el PIN de usuario, la etiqueta del objeto y el ID del objeto (si su HSM utiliza alguno) que especifique al inicializar el token y generar la clave privada. Estos valores se utilizan más adelante cuando se importa el certificado de la cosa al HSM y se configura el software AWS IoT Greengrass principal.
1. Cree una solicitud de firma de certificado (CSR) a partir de la clave privada. AWS IoT usa esta CSR para crear un certificado específico para la clave privada que generaste en el HSM. Para obtener información sobre cómo crear una CSR de la clave privada, consulte la documentación de su HSM. La CSR es un archivo, como `iotdevicekey.csr`.
1. Copie la CSR del dispositivo a su computadora de desarrollo. Si SSH y SCP están habilitados en la computadora de desarrollo y en el dispositivo, puede utilizar el comando `scp` de la computadora de desarrollo para transferir la CSR. *device-ip-address*Sustitúyalo por la dirección IP del dispositivo y *\$1/iotdevicekey.csr* sustitúyalo por la ruta al archivo CSR del dispositivo.
```
scp device-ip-address:~/iotdevicekey.csr iotdevicekey.csr
```
1. En tu ordenador de desarrollo, crea una carpeta en la que descargues el certificado del dispositivo AWS IoT .
```
mkdir greengrass-v2-certs
```
1. Utilice el archivo CSR para crear y descargar el certificado del dispositivo en AWS IoT su ordenador de desarrollo.
```
aws iot create-certificate-from-csr --set-as-active --certificate-signing-request=file://iotdevicekey.csr --certificate-pem-outfile greengrass-v2-certs/device.pem.crt
```
Si la solicitud se realiza exitosamente, la respuesta se parece al siguiente ejemplo.
```
{
"certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificateId": "aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificatePem": "-----BEGIN CERTIFICATE-----
MIICiTCCAfICCQD6m7oRw0uXOjANBgkqhkiG9w
0BAQUFADCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZ
WF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIw
EAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5
jb20wHhcNMTEwNDI1MjA0NTIxWhcNMTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBh
MCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBb
WF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMx
HzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5jb20wgZ8wDQYJKoZIhvcNAQE
BBQADgY0AMIGJAoGBAMaK0dn+a4GmWIWJ21uUSfwfEvySWtC2XADZ4nB+BLYgVI
k60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9TrDHudUZg3qX4waLG5M43q7Wgc/MbQ
ITxOUSQv7c7ugFFDzQGBzZswY6786m86gpEIbb3OhjZnzcvQAaRHhdlQWIMm2nr
AgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4nUhVVxYUntneD9+h8Mg9q6q+auN
KyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0FkbFFBjvSfpJIlJ00zbhNYS5f6Guo
EDmFJl0ZxBHjJnyp378OD8uTs7fLvjx79LjSTbNYiytVbZPQUQ5Yaxu2jXnimvw
3rrszlaEXAMPLE=
-----END CERTIFICATE-----"
}
```
Guarde el ARN del certificado para usarlo más adelante para configurarlo.
## Configuración del certificado del objeto
Adjunte el certificado del AWS IoT objeto al elemento que creó anteriormente y añada una AWS IoT política al certificado para definir los AWS IoT permisos del dispositivo principal.
**Configuración del certificado del objeto**
1. Adjunte el certificado a la AWS IoT cosa.
+ Reemplácelo *MyGreengrassCore* con el nombre de su AWS IoT cosa.
+ Reemplace el nombre de recurso de Amazon (ARN) del certificado por el ARN del certificado que creó en el paso anterior.
```
aws iot attach-thing-principal --thing-name MyGreengrassCore --principal arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
```
El comando no tiene ningún resultado si la solicitud se realiza correctamente.
1. Cree y adjunte una AWS IoT política que defina los AWS IoT permisos de su dispositivo principal de Greengrass. La siguiente política permite el acceso a todos los temas de MQTT y a las operaciones de Greengrass, de modo que su dispositivo funcione con aplicaciones personalizadas y con cambios futuros que requieran nuevas operaciones de Greengrass. Puede restringir esta política en función del caso de uso. Para obtener más información, consulte [AWS IoT Política mínima para los dispositivos AWS IoT Greengrass V2 principales](device-auth.md#greengrass-core-minimal-iot-policy).
Si ya ha configurado un dispositivo principal de Greengrass, puede adjuntar su AWS IoT política en lugar de crear una nueva.
Haga lo siguiente:
1. Cree un archivo que contenga el documento AWS IoT de política que requieren los dispositivos principales de Greengrass.
Por ejemplo, en un sistema basado en Linux, puede ejecutar el siguiente comando para usar GNU nano a fin de crear el archivo.
```
nano greengrass-v2-iot-policy.json
```
Copie el siguiente JSON en el archivo.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Publish",
"iot:Subscribe",
"iot:Receive",
"iot:Connect",
"greengrass:*"
],
"Resource": [
"*"
]
}
]
}
```
1. Cree una AWS IoT política a partir del documento de política.
+ *GreengrassV2IoTThingPolicy*Sustitúyala por el nombre de la política que se va a crear.
```
aws iot create-policy --policy-name GreengrassV2IoTThingPolicy --policy-document file://greengrass-v2-iot-policy.json
```
Si la solicitud se realiza exitosamente, la respuesta se parece al siguiente ejemplo.
```
{
"policyName": "GreengrassV2IoTThingPolicy",
"policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GreengrassV2IoTThingPolicy",
"policyDocument": "{
\\"Version\\": \\"2012-10-17 \\",
\\"Statement\\": [
{
\\"Effect\\": \\"Allow\\",
\\"Action\\": [
\\"iot:Publish\\",
\\"iot:Subscribe\\",
\\"iot:Receive\\",
\\"iot:Connect\\",
\\"greengrass:*\\"
],
\\"Resource\\": [
\\"*\\"
]
}
]
}",
"policyVersionId": "1"
}
```
1. Adjunta la AWS IoT política al certificado de la AWS IoT cosa.
+ *GreengrassV2IoTThingPolicy*Sustitúyala por el nombre de la política que se va a adjuntar.
+ Reemplace el ARN de destino por el ARN del certificado de su objeto AWS IoT .
```
aws iot attach-policy --policy-name GreengrassV2IoTThingPolicy --target arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
```
El comando no tiene ningún resultado si la solicitud se realiza correctamente.
## Creación de un rol de intercambio de token
Los dispositivos principales de Greengrass utilizan una función de servicio de IAM, denominada función de *intercambio de fichas*, para autorizar las llamadas a los servicios. AWS El dispositivo utiliza el proveedor de AWS IoT credenciales para obtener AWS credenciales temporales para esta función, lo que permite al dispositivo interactuar con Amazon Logs AWS IoT, enviar registros a Amazon CloudWatch Logs y descargar artefactos de componentes personalizados de Amazon S3. Para obtener más información, consulte [Autorizar a los dispositivos principales a interactuar con AWS los servicios](device-service-role.md).
Se utiliza un *alias de AWS IoT rol* para configurar el rol de intercambio de fichas para los dispositivos principales de Greengrass. Los alias de rol le permiten cambiar el rol de intercambio de token de un dispositivo, pero mantener la configuración del dispositivo igual. 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 *.
En esta sección, creará un rol de IAM de intercambio de tokens y un alias de AWS IoT rol que apunte al rol. Si ya ha configurado un dispositivo principal de Greengrass, puede usar su rol de intercambio de token y su alias de rol en lugar de crear otros nuevos. A continuación, configure el objeto AWS IoT del dispositivo para que use ese rol y ese alias.
**Creación de un rol de IAM de intercambio de token**
1. Creación de un rol de IAM que su dispositivo puede usar como rol de intercambio de token. Haga lo siguiente:
1. Creación de un archivo que contenga el documento de política de confianza que requiere el rol de intercambio de token.
Por ejemplo, en un sistema basado en Linux, puede ejecutar el siguiente comando para usar GNU nano a fin de crear el archivo.
```
nano device-role-trust-policy.json
```
Copie el siguiente JSON en el archivo.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
1. Creación del rol de intercambio de token con el documento de política de confianza.
+ *GreengrassV2TokenExchangeRole*Sustitúyalo por el nombre del rol de IAM que se va a crear.
```
aws iam create-role --role-name GreengrassV2TokenExchangeRole --assume-role-policy-document file://device-role-trust-policy.json
```
Si la solicitud se realiza exitosamente, la respuesta se parece al siguiente ejemplo.
```
{
"Role": {
"Path": "/",
"RoleName": "GreengrassV2TokenExchangeRole",
"RoleId": "AROAZ2YMUHYHK5OKM77FB",
"Arn": "arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole",
"CreateDate": "2021-02-06T00:13:29+00:00",
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
}
```
1. Creación de un archivo que contenga el documento de política de acceso que requiere el rol de intercambio de token.
Por ejemplo, en un sistema basado en Linux, puede ejecutar el siguiente comando para usar GNU nano a fin de crear el archivo.
```
nano device-role-access-policy.json
```
Copie el siguiente JSON en el archivo.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents",
"logs:DescribeLogStreams",
"s3:GetBucketLocation"
],
"Resource": "*"
}
]
}
```
**nota**
Esta política de acceso no permite el acceso a los artefactos de componentes en los buckets de S3. Para implementar componentes personalizados que definan artefactos en Amazon S3, debe agregar permisos al rol para permitir que su dispositivo principal recupere artefactos de componentes. 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).
Si aún no tiene un bucket de S3 para los artefactos de los componentes, puede agregar estos permisos más adelante, después de crear un bucket.
1. Creación de la política de IAM a partir del documento de política.
+ *GreengrassV2TokenExchangeRoleAccess*Sustitúyalo por el nombre de la política de IAM que se va a crear.
```
aws iam create-policy --policy-name GreengrassV2TokenExchangeRoleAccess --policy-document file://device-role-access-policy.json
```
Si la solicitud se realiza exitosamente, la respuesta se parece al siguiente ejemplo.
```
{
"Policy": {
"PolicyName": "GreengrassV2TokenExchangeRoleAccess",
"PolicyId": "ANPAZ2YMUHYHACI7C5Z66",
"Arn": "arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess",
"Path": "/",
"DefaultVersionId": "v1",
"AttachmentCount": 0,
"PermissionsBoundaryUsageCount": 0,
"IsAttachable": true,
"CreateDate": "2021-02-06T00:37:17+00:00",
"UpdateDate": "2021-02-06T00:37:17+00:00"
}
}
```
1. Adjunte la política de IAM al rol de intercambio de token.
+ Reemplace *GreengrassV2TokenExchangeRole* por el nombre del rol de IAM.
+ Reemplace el ARN de la política por el ARN de la política de IAM que creó en el paso anterior.
```
aws iam attach-role-policy --role-name GreengrassV2TokenExchangeRole --policy-arn arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess
```
El comando no tiene ningún resultado si la solicitud se realiza correctamente.
1. Cree un alias de AWS IoT rol que apunte al rol de intercambio de fichas.
+ *GreengrassCoreTokenExchangeRoleAlias*Sustitúyalo por el nombre del alias del rol que se va a crear.
+ Reemplace el ARN del rol por el ARN del rol de IAM que creó en el paso anterior.
```
aws iot create-role-alias --role-alias GreengrassCoreTokenExchangeRoleAlias --role-arn arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole
```
Si la solicitud se realiza exitosamente, la respuesta se parece al siguiente ejemplo.
```
{
"roleAlias": "GreengrassCoreTokenExchangeRoleAlias",
"roleAliasArn": "arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
```
**nota**
Para crear un alias de rol, debe tener el permiso para transferir el rol de IAM de intercambio de token a AWS IoT. Si recibe un mensaje de error al intentar crear un alias de rol, compruebe que el AWS usuario tiene este permiso. Para obtener más información, consulte [Conceder permisos a un usuario para transferir un rol a un AWS servicio](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_passrole.html) en la *Guía del AWS Identity and Access Management usuario*.
1. Cree y adjunte una AWS IoT política que permita a su dispositivo principal de Greengrass utilizar el alias del rol para asumir el rol de intercambio de fichas. Si ya ha configurado un dispositivo principal de Greengrass, puede adjuntar su AWS IoT política de alias de rol en lugar de crear una nueva. Haga lo siguiente:
1. (Opcional) Cree un archivo que contenga el documento AWS IoT de política que requiere el alias del rol.
Por ejemplo, en un sistema basado en Linux, puede ejecutar el siguiente comando para usar GNU nano a fin de crear el archivo.
```
nano greengrass-v2-iot-role-alias-policy.json
```
Copie el siguiente JSON en el archivo.
+ Reemplace el ARN del recurso por el ARN del alias de rol.
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iot:AssumeRoleWithCertificate",
"Resource": "arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
]
}
```
1. Cree una AWS IoT política a partir del documento de política.
+ *GreengrassCoreTokenExchangeRoleAliasPolicy*Sustitúyala por el nombre de la AWS IoT política que se va a crear.
```
aws iot create-policy --policy-name GreengrassCoreTokenExchangeRoleAliasPolicy --policy-document file://greengrass-v2-iot-role-alias-policy.json
```
Si la solicitud se realiza exitosamente, la respuesta se parece al siguiente ejemplo.
```
{
"policyName": "GreengrassCoreTokenExchangeRoleAliasPolicy",
"policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GreengrassCoreTokenExchangeRoleAliasPolicy",
"policyDocument": "{
\\"Version\\":\\"2012-10-17 \\",
\\"Statement\\": [
{
\\"Effect\\": \\"Allow\\",
\\"Action\\": \\"iot:AssumeRoleWithCertificate\\",
\\"Resource\\": \\"arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias\\"
}
]
}",
"policyVersionId": "1"
}
```
1. Adjunta la AWS IoT política al certificado de la AWS IoT cosa.
+ *GreengrassCoreTokenExchangeRoleAliasPolicy*Sustitúyala por el nombre de la AWS IoT política de alias del rol.
+ Reemplace el ARN de destino por el ARN del certificado de su objeto AWS IoT .
```
aws iot attach-policy --policy-name GreengrassCoreTokenExchangeRoleAliasPolicy --target arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
```
El comando no tiene ningún resultado si la solicitud se realiza correctamente.
## Descarga de certificados al dispositivo
Anteriormente, descargó el certificado de su dispositivo en su computadora de desarrollo. En esta sección, copie el certificado en el dispositivo principal para configurar el dispositivo con los certificados que usa para conectarse a AWS IoT. También descargue el certificado de la autoridad del certificado raíz (CA) de Amazon. Si usa un HSM, también importe el archivo de certificado al HSM en esta sección.
+ Si anteriormente creó el elemento certificado y clave privada en el AWS IoT servicio, siga los pasos para descargar los certificados con la clave privada y los archivos de certificado.
+ Si anteriormente creó el certificado del objeto de una clave privada en un módulo de seguridad de hardware (HSM), siga los pasos para descargar los certificados con la clave privada y el certificado en un HSM.
### Descargar certificados con clave privada y archivos de certificado
**Descarga de certificados al dispositivo**
1. Copia el AWS IoT certificado del objeto desde tu ordenador de desarrollo al dispositivo. Si SSH y SCP están habilitados en la computadora de desarrollo y en el dispositivo, puede utilizar el comando `scp` de la computadora de desarrollo para transferir el certificado. *device-ip-address*Sustitúyalo por la dirección IP de tu dispositivo.
```
scp -r greengrass-v2-certs/ device-ip-address:~
```
1. Cree la carpeta raíz de Greengrass en el dispositivo. Más adelante instalarás el software AWS IoT Greengrass principal en esta carpeta.
**nota**
Windows tiene una limitación de longitud de ruta de 260 caracteres. Si usa Windows, use una carpeta raíz como `C:\greengrass\v2` o `D:\greengrass\v2` para mantener las rutas de los componentes de Greengrass por debajo del límite de 260 caracteres.
------
#### [ Linux or Unix ]
+ Reemplace `/greengrass/v2` por la carpeta que desee utilizar.
```
sudo mkdir -p /greengrass/v2
```
------
#### [ Windows Command Prompt ]
+ Reemplace *C:\$1greengrass\$1v2* por la carpeta que desee utilizar.
```
mkdir C:\greengrass\v2
```
------
#### [ PowerShell ]
+ Reemplace *C:\$1greengrass\$1v2* por la carpeta que desee utilizar.
```
mkdir C:\greengrass\v2
```
------
1. (Solo para Linux) Establezca los permisos de la carpeta principal de la carpeta raíz de Greengrass.
+ */greengrass*Sustitúyalo por el elemento principal de la carpeta raíz.
```
sudo chmod 755 /greengrass
```
1. Copia los certificados de la AWS IoT cosa a la carpeta raíz de Greengrass.
------
#### [ Linux or Unix ]
+ Reemplace `/greengrass/v2` por la carpeta raíz de Greengrass.
```
sudo cp -R ~/greengrass-v2-certs/* /greengrass/v2
```
------
#### [ Windows Command Prompt ]
+ Reemplace *C:\$1greengrass\$1v2* por la carpeta que desee utilizar.
```
robocopy %USERPROFILE%\greengrass-v2-certs C:\greengrass\v2 /E
```
------
#### [ PowerShell ]
+ Reemplace *C:\$1greengrass\$1v2* por la carpeta que desee utilizar.
```
cp -Path ~\greengrass-v2-certs\* -Destination C:\greengrass\v2
```
------
1. Descarga el certificado de la autoridad de certificación raíz (CA) de Amazon. AWS IoT Los certificados están asociados al certificado de CA raíz de Amazon de forma predeterminada.
------
#### [ Linux or Unix ]
```
sudo curl -o /greengrass/v2/AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -o C:\greengrass\v2\\AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ PowerShell ]
```
iwr -Uri https://www.amazontrust.com/repository/AmazonRootCA1.pem -OutFile C:\greengrass\v2\\AmazonRootCA1.pem
```
------
### Descarga de certificados con la clave privada y el certificado en un HSM
**nota**
Esta función está disponible para la versión 2.5.3 y versiones posteriores del componente núcleo de [Greengrass](greengrass-nucleus-component.md). AWS IoT Greengrass actualmente no admite esta función en los dispositivos principales de Windows.
**Descarga de certificados al dispositivo**
1. Copia AWS IoT el certificado de la máquina de desarrollo al dispositivo. Si SSH y SCP están habilitados en la computadora de desarrollo y en el dispositivo, puede utilizar el comando `scp` de la computadora de desarrollo para transferir el certificado. *device-ip-address*Sustitúyalo por la dirección IP de tu dispositivo.
```
scp -r greengrass-v2-certs/ device-ip-address:~
```
1. Cree la carpeta raíz de Greengrass en el dispositivo. Más adelante instalarás el software AWS IoT Greengrass principal en esta carpeta.
**nota**
Windows tiene una limitación de longitud de ruta de 260 caracteres. Si usa Windows, use una carpeta raíz como `C:\greengrass\v2` o `D:\greengrass\v2` para mantener las rutas de los componentes de Greengrass por debajo del límite de 260 caracteres.
------
#### [ Linux or Unix ]
+ Reemplace `/greengrass/v2` por la carpeta que desee utilizar.
```
sudo mkdir -p /greengrass/v2
```
------
#### [ Windows Command Prompt ]
+ Reemplace *C:\$1greengrass\$1v2* por la carpeta que desee utilizar.
```
mkdir C:\greengrass\v2
```
------
#### [ PowerShell ]
+ Reemplace *C:\$1greengrass\$1v2* por la carpeta que desee utilizar.
```
mkdir C:\greengrass\v2
```
------
1. (Solo para Linux) Establezca los permisos de la carpeta principal de la carpeta raíz de Greengrass.
+ */greengrass*Sustitúyalo por el elemento principal de la carpeta raíz.
```
sudo chmod 755 /greengrass
```
1. Importe el archivo de certificado del objeto `~/greengrass-v2-certs/device.pem.crt`, al HSM. Consulte la documentación de su HSM para saber cómo importar certificados allí. Importe el certificado con el mismo token, ID de ranura, PIN de usuario, etiqueta de objeto e ID de objeto (si su HSM usa alguno) con los que generó la clave privada en el HSM anteriormente.
**nota**
Si generó la clave privada anteriormente sin un ID de objeto y el certificado tiene un ID de objeto, establezca el ID de objeto de la clave privada con el mismo valor que el certificado. Consulte la documentación de su HSM para obtener información sobre cómo configurar el identificador de objeto para el objeto de clave privada.
1. (Opcional) Elimine el archivo de certificado del objeto para que solo exista en el HSM.
```
rm ~/greengrass-v2-certs/device.pem.crt
```
1. Descarga el certificado de la autoridad de certificación raíz (CA) de Amazon. AWS IoT Los certificados están asociados al certificado de CA raíz de Amazon de forma predeterminada.
------
#### [ Linux or Unix ]
```
sudo curl -o /greengrass/v2/AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -o C:\greengrass\v2\\AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ PowerShell ]
```
iwr -Uri https://www.amazontrust.com/repository/AmazonRootCA1.pem -OutFile C:\greengrass\v2\\AmazonRootCA1.pem
```
------
## Configuración del entorno del dispositivo
Siga los pasos de esta sección para configurar un dispositivo Linux o Windows para usarlo como su dispositivo principal de AWS IoT Greengrass .
### Configuración de un dispositivo Linux
**Para configurar un dispositivo Linux para AWS IoT Greengrass V2**
1. Instale el motor de ejecución de Java, que el software AWS IoT Greengrass principal necesita para ejecutarse. Le recomendamos que utilice las versiones de compatibilidad a largo plazo de [Amazon Corretto](https://aws.amazon.com/corretto/) u [OpenJDK](https://openjdk.java.net/). Se requiere la versión 8 o posterior. Los siguientes comandos muestran cómo instalar OpenJDK en su dispositivo.
+ Para distribuciones basadas en Debian o en Ubuntu:
```
sudo apt install default-jdk
```
+ Para distribuciones basadas en Red Hat:
```
sudo yum install java-11-openjdk-devel
```
+ En Amazon Linux 2:
```
sudo amazon-linux-extras install java-openjdk11
```
+ En Amazon Linux 2023:
```
sudo dnf install java-11-amazon-corretto -y
```
Cuando se complete la instalación, ejecute el siguiente comando para comprobar que Java se ejecuta en su dispositivo Linux.
```
java -version
```
El comando imprime la versión de Java que se ejecuta en el dispositivo. Por ejemplo, en una distribución basada en Debian, el resultado podría ser similar al siguiente ejemplo.
```
openjdk version "11.0.9.1" 2020-11-04
OpenJDK Runtime Environment (build 11.0.9.1+1-post-Debian-1deb10u2)
OpenJDK 64-Bit Server VM (build 11.0.9.1+1-post-Debian-1deb10u2, mixed mode)
```
1. (Opcional) Cree el usuario y el grupo predeterminado del sistema que ejecutan los componentes del dispositivo. También puede optar por permitir que el instalador del software AWS IoT Greengrass principal cree este usuario y grupo durante la instalación con el argumento del `--component-default-user` instalador. Para obtener más información, consulte [Argumentos del instalador](configure-installer.md).
```
sudo useradd --system --create-home ggc_user
sudo groupadd --system ggc_group
```
1. Compruebe que el usuario que ejecuta el software AWS IoT Greengrass principal (normalmente`root`) tiene permiso para ejecutar `sudo` con cualquier usuario y grupo.
1. Ejecute el siguiente comando para abrir el archivo `/etc/sudoers`.
```
sudo visudo
```
1. Compruebe que el permiso del usuario se parezca al siguiente ejemplo.
```
root ALL=(ALL:ALL) ALL
```
1. (Opcional) Para [ejecutar funciones de Lambda en contenedores](run-lambda-functions.md), debe habilitar la versión 1 de [cgroups](https://en.wikipedia.org/wiki/Cgroups), y habilitar y montar los cgroups de *memoria* y de *dispositivos*. Si no tiene previsto ejecutar funciones de Lambda en contenedores, puede omitir este paso.
Para habilitar estas opciones de cgroups, arranque el dispositivo con los siguientes parámetros del kernel de Linux.
```
cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0
```
Para obtener más información acerca de cómo ver y configurar los parámetros del kernel de su dispositivo, consulte la documentación del sistema operativo y del gestor de arranque. Siga las instrucciones para configurar permanentemente los parámetros del kernel.
1. Instale todas las demás dependencias necesarias en su dispositivo tal y como se indica en la lista de requisitos de [Requisitos de los dispositivos](greengrass-nucleus-component.md#greengrass-v2-requirements).
### Configuración de un dispositivo de Windows
**nota**
Esta característica está disponible para la versión 2.5.0 y versiones posteriores del [componente núcleo de Greengrass](greengrass-nucleus-component.md).
**Para configurar un dispositivo Windows para AWS IoT Greengrass V2**
1. Instale el motor de ejecución de Java, que el software AWS IoT Greengrass principal necesita para ejecutarse. Le recomendamos que utilice las versiones de compatibilidad a largo plazo de [Amazon Corretto](https://aws.amazon.com/corretto/) u [OpenJDK](https://openjdk.java.net/). Se requiere la versión 8 o posterior.
1. Compruebe si Java está disponible en la variable del sistema [PATH](https://en.wikipedia.org/wiki/PATH_(variable)) y agréguelo si no lo está. La LocalSystem cuenta ejecuta el software AWS IoT Greengrass principal, por lo que debe agregar Java a la variable de sistema PATH en lugar de a la variable de usuario PATH de su usuario. Haga lo siguiente:
1. Pulse la tecla Windows para abrir el menú de inicio.
1. Escriba **environment variables** para buscar las opciones del sistema en el menú de inicio.
1. En los resultados de la búsqueda del menú de inicio, elija **Editar las variables de entorno del sistema** para abrir la ventana de **Propiedades del sistema**.
1. Elija **Variables de entorno...** para abrir la ventana **Variables de entorno**.
1. En **Variables del sistema**, elija **Ruta** y, luego, **Editar**. En la ventana **Editar variables de entorno**, puede ver cada ruta en una línea independiente.
1. Compruebe si la ruta a la carpeta de la instalación de Java `bin` está presente. La ruta puede tener un aspecto similar al siguiente ejemplo.
```
C:\\Program Files\\Amazon Corretto\\jdk11.0.13_8\\bin
```
1. Si la carpeta de la instalación de Java `bin` no aparece en **Ruta**, elija **Nueva** para agregarla y, a continuación, pulse **Aceptar**.
1. Abra el símbolo del sistema de Windows (`cmd.exe`) como administrador.
1. Cree el usuario predeterminado en la LocalSystem cuenta del dispositivo Windows. *password*Sustitúyalo por una contraseña segura.
```
net user /add ggc_user password
```
**sugerencia**
Según su configuración de Windows, es posible que la contraseña del usuario caduque en una fecha futura. Para garantizar que sus aplicaciones de Greengrass sigan funcionando, controle cuándo caduca la contraseña y actualícela antes de que caduque. También puede configurar la contraseña del usuario para que nunca caduque.
Para comprobar cuándo caducan un usuario y su contraseña, ejecute el siguiente comando.
```
net user ggc_user | findstr /C:expires
```
Para configurar la contraseña de un usuario para que no caduque nunca, ejecute el siguiente comando.
```
wmic UserAccount where "Name='ggc_user'" set PasswordExpires=False
```
Si utilizas Windows 10 o una versión posterior, donde el [`wmic`comando está en desuso](https://learn.microsoft.com/en-us/windows/win32/wmisdk/wmic), ejecuta el siguiente PowerShell comando.
```
Get-CimInstance -Query "SELECT * from Win32_UserAccount WHERE name = 'ggc_user'" | Set-CimInstance -Property @{PasswordExpires="False"}
```
1. Descargue e instale la [PsExecutilidad](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec) de Microsoft en el dispositivo.
1. Utilice la PsExec utilidad para almacenar el nombre de usuario y la contraseña del usuario predeterminado en la instancia de Credential Manager de la LocalSystem cuenta. *password*Sustitúyala por la contraseña de usuario que configuraste anteriormente.
```
psexec -s cmd /c cmdkey /generic:ggc_user /user:ggc_user /pass:password
```
Si **PsExec License Agreement** se abre, elija **Accept** para aceptar la licencia y ejecute el comando.
**nota**
En los dispositivos Windows, la LocalSystem cuenta ejecuta el núcleo de Greengrass y debe usar la PsExec utilidad para almacenar la información de usuario predeterminada en la LocalSystem cuenta. El uso de la aplicación Credential Manager almacena esta información en la cuenta de Windows del usuario que ha iniciado sesión actualmente, en lugar de en la LocalSystem cuenta.
## Descargue el software AWS IoT Greengrass principal
Puede descargar la última versión del software AWS IoT Greengrass Core desde la siguiente ubicación:
+ [https://d2s8p88vqu9w66.cloudfront. net/releases/greengrass](https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip)-nucleus-latest.zip
**nota**
Puede descargar una versión específica del software AWS IoT Greengrass Core desde la siguiente ubicación. *version*Sustitúyala por la versión que se va a descargar.
```
https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-version.zip
```
**Para descargar el software AWS IoT Greengrass principal**
1. En su dispositivo principal, descargue el software AWS IoT Greengrass Core en un archivo denominado`greengrass-nucleus-latest.zip`.
------
#### [ Linux or Unix ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
iwr -Uri https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip -OutFile greengrass-nucleus-latest.zip
```
------
Al descargar este software, acepta el [acuerdo de licencia del software de Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf).
1. (Opcional) Verificación de la firma del software del núcleo de Greengrass
**nota**
Esta característica está disponible en la versión 2.9.5 y versiones posteriores del núcleo de Greengrass.
1. Use el siguiente comando para verificar la firma del artefacto del núcleo de Greengrass:
------
#### [ Linux or Unix ]
```
jarsigner -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
El nombre del archivo puede tener un aspecto diferente según la versión de JDK que instale. Reemplace *`jdk17.0.6_10`* por la versión de JDK que instaló.
```
"C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe" -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
El nombre del archivo puede tener un aspecto diferente según la versión de JDK que instale. Reemplace *`jdk17.0.6_10`* por la versión de JDK que instaló.
```
'C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe' -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
1. La invocación `jarsigner` produce un resultado que indica los resultados de la verificación.
1. Si el archivo zip del núcleo de Greengrass está firmado, el resultado contiene la siguiente declaración:
```
jar verified.
```
1. Si el archivo zip del núcleo de Greengrass no está firmado, el resultado contiene la siguiente declaración:
```
jar is unsigned.
```
1. Si ha proporcionado la opción `-certs` Jarsigner junto con las opciones `-verify` y `-verbose`, el resultado también incluye información detallada del certificado de firmante.
1. Descomprime el software AWS IoT Greengrass Core en una carpeta de tu dispositivo. *GreengrassInstaller*Sustitúyalo por la carpeta que desee usar.
------
#### [ Linux or Unix ]
```
unzip greengrass-nucleus-latest.zip -d GreengrassInstaller && rm greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir GreengrassInstaller && tar -xf greengrass-nucleus-latest.zip -C GreengrassInstaller && del greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
Expand-Archive -Path greengrass-nucleus-latest.zip -DestinationPath .\\GreengrassInstaller
rm greengrass-nucleus-latest.zip
```
------
1. (Opcional) Ejecute el siguiente comando para ver la versión del software AWS IoT Greengrass principal.
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
**importante**
Si instala una versión del núcleo de Greengrass anterior a la v2.4.0, no elimine esta carpeta después de instalar el software Core. AWS IoT Greengrass El software AWS IoT Greengrass Core utiliza los archivos de esta carpeta para ejecutarse.
Si descargó la última versión del software, instale la versión 2.4.0 o posterior y podrá eliminar esta carpeta después de instalar el software AWS IoT Greengrass principal.
## Instale el software principal AWS IoT Greengrass
Ejecute el instalador con argumentos que especifiquen las siguientes acciones:
+ Instálelo desde un archivo de configuración parcial que especifique el uso de AWS los recursos y certificados que creó anteriormente. El software AWS IoT Greengrass Core utiliza un archivo de configuración que especifica la configuración de todos los componentes de Greengrass del dispositivo. El instalador crea un archivo de configuración completo a partir del archivo de configuración parcial que usted proporciona.
+ Especifique si desea usar el usuario del sistema `ggc_user` para ejecutar los componentes de software en el dispositivo principal. En los dispositivos Linux, este comando también especifica el uso del grupo del sistema `ggc_group` y el instalador crea el usuario y el grupo del sistema por usted.
+ Configure el software AWS IoT Greengrass Core como un servicio del sistema que se ejecute durante el arranque. En los dispositivos Linux, esto requiere el sistema de inicio [Systemd](https://en.wikipedia.org/wiki/Systemd).
**importante**
En los dispositivos principales de Windows, debe configurar el software AWS IoT Greengrass principal como un servicio del sistema.
Para obtener más información acerca de los argumentos que puede especificar, consulte [Argumentos del instalador](configure-installer.md).
**nota**
Si utilizas un AWS IoT Greengrass dispositivo con memoria limitada, puedes controlar la cantidad de memoria que utiliza el software AWS IoT Greengrass Core. Para controlar la asignación de memoria, puede configurar las opciones de tamaño de montón de la JVM en el parámetro de configuración `jvmOptions` del componente núcleo. Para obtener más información, consulte [Control de la asignación de memoria con las opciones de JVM](configure-greengrass-core-v2.md#jvm-tuning).
+ Si creó anteriormente el certificado y la clave privada en el AWS IoT servicio, siga los pasos para instalar el software AWS IoT Greengrass Core con los archivos de clave privada y certificado.
+ Si anteriormente creó el certificado Thing a partir de una clave privada en un módulo de seguridad de hardware (HSM), siga los pasos para instalar el software AWS IoT Greengrass Core con la clave privada y el certificado en un HSM.
### Instale el software AWS IoT Greengrass principal con la clave privada y los archivos de certificado
**Para instalar el software AWS IoT Greengrass Core**
1. Compruebe la versión del software AWS IoT Greengrass principal.
+ *GreengrassInstaller*Sustitúyala por la ruta a la carpeta que contiene el software.
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
1. Use un editor de texto para crear un archivo de configuración llamado `config.yaml` para proporcionárselo al instalador.
Por ejemplo, en un sistema basado en Linux, puede ejecutar el siguiente comando para usar GNU nano a fin de crear el archivo.
```
nano GreengrassInstaller/config.yaml
```
Copie el siguiente contenido YAML en el archivo. Este archivo de configuración parcial especifica los parámetros del sistema y los parámetros del núcleo de Greengrass.
```
---
system:
certificateFilePath: "/greengrass/v2/device.pem.crt"
privateKeyPath: "/greengrass/v2/private.pem.key"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
rootpath: "/greengrass/v2"
thingName: "MyGreengrassCore"
services:
aws.greengrass.Nucleus:
componentType: "NUCLEUS"
version: "2.16.1"
configuration:
awsRegion: "us-west-2"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
```
A continuación, proceda del modo siguiente:
+ Reemplace cada instancia de `/greengrass/v2` por la carpeta raíz de Greengrass.
+ *MyGreengrassCore*Sustitúyalo por el nombre de la AWS IoT cosa.
+ *2.16.1*Sustitúyala por la versión del software AWS IoT Greengrass principal.
+ *us-west-2*Sustitúyala por la Región de AWS ubicación en la que creaste los recursos.
+ *GreengrassCoreTokenExchangeRoleAlias*Sustitúyalo por el nombre del alias de la función de intercambio de fichas.
+ `iotDataEndpoint`Sustitúyalo por el punto final de AWS IoT datos.
+ Sustituya el `iotCredEndpoint` punto final por el de sus AWS IoT credenciales.
**nota**
En este archivo de configuración, puede personalizar otras opciones de configuración del núcleo, como los puertos y el proxy de red que se utilizarán, tal como se muestra en el siguiente ejemplo. Para obtener más información, consulte la [Configuración del núcleo de Greengrass](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration).
```
---
system:
certificateFilePath: "/greengrass/v2/device.pem.crt"
privateKeyPath: "/greengrass/v2/private.pem.key"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
rootpath: "/greengrass/v2"
thingName: "MyGreengrassCore"
services:
aws.greengrass.Nucleus:
componentType: "NUCLEUS"
version: "2.16.1"
configuration:
awsRegion: "us-west-2"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
iotCredEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
mqtt:
port: 443
greengrassDataPlanePort: 443
networkProxy:
noProxyAddresses: "http://192.168.0.1,www.example.com"
proxy:
url: "https://my-proxy-server:1100"
username: "Mary_Major"
password: "pass@word1357"
```
1. Ejecute el instalador y especifique `--init-config` para proporcionar el archivo de configuración.
+ Sustituya `/greengrass/v2` o *C:\$1greengrass\$1v2* por la carpeta raíz de Greengrass.
+ Sustituya cada instancia de por *GreengrassInstaller* la carpeta en la que desempaquetó el instalador.
------
#### [ Linux or Unix ]
```
sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
-jar ./GreengrassInstaller/lib/Greengrass.jar \
--init-config ./GreengrassInstaller/config.yaml \
--component-default-user ggc_user:ggc_group \
--setup-system-service true
```
------
#### [ Windows Command Prompt (CMD) ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" ^
-jar ./GreengrassInstaller/lib/Greengrass.jar ^
--init-config ./GreengrassInstaller/config.yaml ^
--component-default-user ggc_user ^
--setup-system-service true
```
------
#### [ PowerShell ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" `
-jar ./GreengrassInstaller/lib/Greengrass.jar `
--init-config ./GreengrassInstaller/config.yaml `
--component-default-user ggc_user `
--setup-system-service true
```
------
**importante**
En los dispositivos principales de Windows, debe especificar si `--setup-system-service true` desea configurar el software AWS IoT Greengrass principal como un servicio del sistema.
Si especifica `--setup-system-service true`, el instalador imprime `Successfully set up Nucleus as a system service` si configuró y ejecutó el software como un servicio del sistema. De lo contrario, el instalador no mostrará ningún mensaje si instala el software correctamente.
**nota**
No puede usar el argumento `deploy-dev-tools` para implementar herramientas de desarrollo locales cuando ejecuta el instalador sin el argumento `--provision true`. Para obtener información sobre cómo implementar la CLI de Greengrass directamente en su dispositivo, consulte [Interfaz de la línea de comandos de Greengrass](gg-cli.md).
1. Verifique la instalación mediante la consulta de los archivos de la carpeta raíz.
------
#### [ Linux or Unix ]
```
ls /greengrass/v2
```
------
#### [ Windows Command Prompt (CMD) ]
```
dir C:\greengrass\v2
```
------
#### [ PowerShell ]
```
ls C:\greengrass\v2
```
------
Si la instalación se realizó correctamente, la carpeta raíz contiene varias carpetas, como `config`, `packages` y `logs`.
### Instale el software AWS IoT Greengrass Core con la clave privada y el certificado en un HSM
**nota**
Esta función está disponible para la versión 2.5.3 y versiones posteriores del componente núcleo de [Greengrass](greengrass-nucleus-component.md). AWS IoT Greengrass actualmente no admite esta función en los dispositivos principales de Windows.
**Para instalar el software AWS IoT Greengrass principal**
1. Compruebe la versión del software AWS IoT Greengrass principal.
+ *GreengrassInstaller*Sustitúyala por la ruta a la carpeta que contiene el software.
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
1. Para permitir que el software AWS IoT Greengrass principal utilice la clave privada y el certificado del HSM, instale el [componente de proveedor PKCS \$111](pkcs11-provider-component.md) al instalar el software AWS IoT Greengrass principal. El componente de proveedor PKCS\$111 es un complemento que puede configurar durante la instalación. Puede descargar la versión más reciente del componente de proveedor PKCS\$111 de la siguiente ubicación:
+ [https://d2s8p88vqu9w66.cloudfront. net/releases/Pkcs11Provider/aws.greengrass.crypto.pkcs11Provider-latest.jar](https://d2s8p88vqu9w66.cloudfront.net/releases/Pkcs11Provider/aws.greengrass.crypto.Pkcs11Provider-latest.jar)
Descargue el complemento de proveedor PKCS\$111 en un archivo denominado `aws.greengrass.crypto.Pkcs11Provider.jar`. Sustitúyala por la carpeta que quieras usar. *GreengrassInstaller*
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/Pkcs11Provider/aws.greengrass.crypto.Pkcs11Provider-latest.jar > GreengrassInstaller/aws.greengrass.crypto.Pkcs11Provider.jar
```
Al descargar este software, acepta el [acuerdo de licencia del software de Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf).
1. Use un editor de texto para crear un archivo de configuración llamado `config.yaml` para proporcionárselo al instalador.
Por ejemplo, en un sistema basado en Linux, puede ejecutar el siguiente comando para usar GNU nano a fin de crear el archivo.
```
nano GreengrassInstaller/config.yaml
```
Copie el siguiente contenido YAML en el archivo. Este archivo de configuración parcial especifica los parámetros del sistema, los parámetros del núcleo de Greengrass y los parámetros del proveedor PKCS\$111.
```
---
system:
certificateFilePath: "pkcs11:object=iotdevicekey;type=cert"
privateKeyPath: "pkcs11:object=iotdevicekey;type=private"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
rootpath: "/greengrass/v2"
thingName: "MyGreengrassCore"
services:
aws.greengrass.Nucleus:
componentType: "NUCLEUS"
version: "2.16.1"
configuration:
awsRegion: "us-west-2"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
aws.greengrass.crypto.Pkcs11Provider:
configuration:
name: "softhsm_pkcs11"
library: "/usr/local/Cellar/softhsm/2.6.1/lib/softhsm/libsofthsm2.so"
slot: 1
userPin: "1234"
```
A continuación, proceda del modo siguiente:
+ Sustituya cada instancia del PKCS \$111 URIs por la etiqueta de objeto *iotdevicekey* en la que creó la clave privada e importó el certificado.
+ Reemplace cada instancia de `/greengrass/v2` por la carpeta raíz de Greengrass.
+ *MyGreengrassCore*Sustitúyala por el nombre de la AWS IoT cosa.
+ *2.16.1*Sustitúyala por la versión del software AWS IoT Greengrass principal.
+ *us-west-2*Sustitúyala por la Región de AWS ubicación en la que creaste los recursos.
+ *GreengrassCoreTokenExchangeRoleAlias*Sustitúyalo por el nombre del alias de la función de intercambio de fichas.
+ `iotDataEndpoint`Sustitúyalo por el punto final de AWS IoT datos.
+ Sustituya el `iotCredEndpoint` punto final por el de sus AWS IoT credenciales.
+ Reemplace los parámetros de configuración del componente `aws.greengrass.crypto.Pkcs11Provider` por los valores de la configuración del HSM en el dispositivo principal.
**nota**
En este archivo de configuración, puede personalizar otras opciones de configuración del núcleo, como los puertos y el proxy de red que se utilizarán, tal como se muestra en el siguiente ejemplo. Para obtener más información, consulte la [Configuración del núcleo de Greengrass](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration).
```
---
system:
certificateFilePath: "pkcs11:object=iotdevicekey;type=cert"
privateKeyPath: "pkcs11:object=iotdevicekey;type=private"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
rootpath: "/greengrass/v2"
thingName: "MyGreengrassCore"
services:
aws.greengrass.Nucleus:
componentType: "NUCLEUS"
version: "2.16.1"
configuration:
awsRegion: "us-west-2"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
mqtt:
port: 443
greengrassDataPlanePort: 443
networkProxy:
noProxyAddresses: "http://192.168.0.1,www.example.com"
proxy:
url: "https://my-proxy-server:1100"
username: "Mary_Major"
password: "pass@word1357"
aws.greengrass.crypto.Pkcs11Provider:
configuration:
name: "softhsm_pkcs11"
library: "/usr/local/Cellar/softhsm/2.6.1/lib/softhsm/libsofthsm2.so"
slot: 1
userPin: "1234"
```
1. Ejecute el instalador y especifique `--init-config` para proporcionar el archivo de configuración.
+ Reemplace `/greengrass/v2` por la carpeta raíz de Greengrass.
+ Sustituya cada instancia de *GreengrassInstaller* por la carpeta en la que desempaquetó el instalador.
```
sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
-jar ./GreengrassInstaller/lib/Greengrass.jar \
--trusted-plugin ./GreengrassInstaller/aws.greengrass.crypto.Pkcs11Provider.jar \
--init-config ./GreengrassInstaller/config.yaml \
--component-default-user ggc_user:ggc_group \
--setup-system-service true
```
**importante**
En los dispositivos principales de Windows, debe especificar si `--setup-system-service true` desea configurar el software AWS IoT Greengrass principal como un servicio del sistema.
Si especifica `--setup-system-service true`, el instalador imprime `Successfully set up Nucleus as a system service` si configuró y ejecutó el software como un servicio del sistema. De lo contrario, el instalador no mostrará ningún mensaje si instala el software correctamente.
**nota**
No puede usar el argumento `deploy-dev-tools` para implementar herramientas de desarrollo locales cuando ejecuta el instalador sin el argumento `--provision true`. Para obtener información sobre cómo implementar la CLI de Greengrass directamente en su dispositivo, consulte [Interfaz de la línea de comandos de Greengrass](gg-cli.md).
1. Verifique la instalación mediante la consulta de los archivos de la carpeta raíz.
------
#### [ Linux or Unix ]
```
ls /greengrass/v2
```
------
#### [ Windows Command Prompt (CMD) ]
```
dir C:\greengrass\v2
```
------
#### [ PowerShell ]
```
ls C:\greengrass\v2
```
------
Si la instalación se realizó correctamente, la carpeta raíz contiene varias carpetas, como `config`, `packages` y `logs`.
Si instaló el software AWS IoT Greengrass Core como un servicio del sistema, el instalador ejecutará el software automáticamente. De no ser así, debe ejecutar el software manualmente. Para obtener más información, consulte [Ejecute el software AWS IoT Greengrass principal](run-greengrass-core-v2.md).
**nota**
Cuando el software AWS IoT Greengrass Core se conecte a la nube, su dispositivo será reconocido como un dispositivo Core.
Para obtener más información sobre cómo configurar y usar el software AWS IoT Greengrass, consulte lo siguiente:
+ [Configurar el software AWS IoT Greengrass principal](configure-greengrass-core-v2.md)
+ [Desarrollo de componentes de AWS IoT Greengrass](develop-greengrass-components.md)
+ [Implemente AWS IoT Greengrass componentes en los dispositivos](manage-deployments.md)
+ [Interfaz de la línea de comandos de Greengrass](gg-cli.md)
# Instale el software AWS IoT Greengrass principal con aprovisionamiento AWS IoT de flota
Esta característica está disponible para la versión 2.4.0 y versiones posteriores del [componente núcleo de Greengrass](greengrass-nucleus-component.md).
Con el aprovisionamiento de AWS IoT flotas, puede configurarlo AWS IoT para generar y entregar de forma segura certificados de dispositivo X.509 y claves privadas a sus dispositivos cuando se conecten a ellos AWS IoT por primera vez. AWS IoT proporciona certificados de cliente firmados por la autoridad de certificación (CA) raíz de Amazon. También puede configurarlo AWS IoT para especificar grupos de cosas, tipos de cosas y permisos para los dispositivos principales de Greengrass que aprovisiona con el aprovisionamiento de flotas. Defina una *plantilla de aprovisionamiento* para definir cómo AWS IoT aprovisiona cada dispositivo. En la plantilla de aprovisionamiento se especifica el objeto, la política y los recursos de certificado que se van a crear para un dispositivo durante el aprovisionamiento. Para más información, consulte [Plantillas de aprovisionamiento](https://docs.aws.amazon.com/iot/latest/developerguide/provision-template.html) en la *Guía para desarrolladores de AWS IoT Core *.
AWS IoT Greengrass proporciona un complemento de aprovisionamiento de AWS IoT flotas que puede usar para instalar el software AWS IoT Greengrass principal utilizando los AWS recursos creados por el aprovisionamiento de AWS IoT flotas. El complemento de aprovisionamiento de flotas utiliza el *aprovisionamiento por reclamación*. Los dispositivos utilizan un certificado de aprovisionamiento y una clave privada para obtener un certificado de dispositivo X.509 único y una clave privada que pueden utilizar para operaciones habituales. Puede incrustar el certificado de reclamación y la clave privada en cada dispositivo durante la fabricación, de modo que luego los clientes puedan activar los dispositivos, cuando cada dispositivo esté en funcionamiento. Puede utilizar el mismo certificado de reclamación y clave privada para varios dispositivos. Para obtener más información, consulte [Aprovisionamiento por reclamación](https://docs.aws.amazon.com/iot/latest/developerguide/provision-wo-cert.html#claim-based) en la *Guía para desarrolladores de AWS IoT Core *.
**nota**
Actualmente, el complemento de aprovisionamiento de flota no admite el almacenamiento de archivos de certificados y claves privadas en un módulo de seguridad de hardware (HSM). Para usar un HSM, [instale el software AWS IoT Greengrass Core con](manual-installation.md) aprovisionamiento manual.
Para instalar el software AWS IoT Greengrass Core con el aprovisionamiento de AWS IoT flota, debe configurar los recursos Cuenta de AWS que AWS IoT utiliza para aprovisionar los dispositivos principales de Greengrass. Estos recursos incluyen una plantilla de aprovisionamiento, certificados de reclamación y un [rol de IAM para el intercambio de token](device-service-role.md). Después de crear estos recursos, puede reutilizarlos para aprovisionar varios dispositivos principales de una flota. Para obtener más información, consulte [Configurar el aprovisionamiento de AWS IoT flota para los dispositivos principales de Greengrass](fleet-provisioning-setup.md).
**importante**
Antes de descargar el software AWS IoT Greengrass Core, compruebe que su dispositivo principal cumpla los [requisitos](greengrass-nucleus-component.md#greengrass-v2-requirements) para instalar y ejecutar el software AWS IoT Greengrass Core v2.0.
**Topics**
+ [Requisitos previos](#fleet-provisioning-prerequisites)
+ [Recupere los puntos finales AWS IoT](#retrieve-iot-endpoints)
+ [Descarga de certificados al dispositivo](#download-claim-certificates)
+ [Configuración del entorno del dispositivo](#set-up-device-environment)
+ [Descargue el software AWS IoT Greengrass principal](#download-greengrass-core-v2)
+ [Descargue el complemento de aprovisionamiento AWS IoT de flotas](#download-fleet-provisioning-plugin)
+ [Instale el software AWS IoT Greengrass principal](#run-greengrass-core-v2-installer-fleet)
+ [Configurar el aprovisionamiento de AWS IoT flota para los dispositivos principales de Greengrass](fleet-provisioning-setup.md)
+ [Configurar el complemento de aprovisionamiento de AWS IoT flotas](fleet-provisioning-configuration.md)
+ [Registro de cambios del complemento de aprovisionamiento de flotas AWS IoT](fleet-provisioning-changelog.md)
## Requisitos previos
Para instalar el software AWS IoT Greengrass Core con el aprovisionamiento de AWS IoT flota, primero debe [configurar el aprovisionamiento de AWS IoT flota para los dispositivos principales de Greengrass](fleet-provisioning-setup.md). Tras completar estos pasos una vez, puede utilizar el aprovisionamiento de flotas para instalar el software AWS IoT Greengrass Core en cualquier número de dispositivos.
## Recupere los puntos finales AWS IoT
Obtenga los AWS IoT puntos finales que desee y guárdelos para usarlos más adelante. Cuenta de AWS El dispositivo usa estos puntos de conexión para conectarse a AWS IoT. Haga lo siguiente:
1. Obtenga el punto final AWS IoT de datos para su. Cuenta de AWS
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
Si la solicitud se realiza exitosamente, la respuesta se parece al siguiente ejemplo.
```
{
"endpointAddress": "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
}
```
1. Obtenga el punto final de AWS IoT credenciales para su Cuenta de AWS.
```
aws iot describe-endpoint --endpoint-type iot:CredentialProvider
```
Si la solicitud se realiza exitosamente, la respuesta se parece al siguiente ejemplo.
```
{
"endpointAddress": "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
}
```
## Descarga de certificados al dispositivo
El dispositivo utiliza un certificado de reclamación y una clave privada para autenticar su solicitud de aprovisionamiento de AWS recursos y adquirir un certificado de dispositivo X.509. Puede incrustar el certificado de reclamación y la clave privada en el dispositivo durante la fabricación o copiar el certificado y la clave en el dispositivo durante la instalación. En esta sección, debe copiar el certificado de reclamación y la clave privada en el dispositivo. También descargue el certificado de la autoridad del certificado raíz (CA) de Amazon en el dispositivo.
**importante**
Las claves privadas de la notificación de aprovisionamiento deben estar protegidas en todo momento, también en el dispositivo principal de Greengrass. Te recomendamos que utilices CloudWatch las estadísticas y los registros de Amazon para detectar indicios de uso indebido, como el uso no autorizado del certificado de reclamación para aprovisionar dispositivos. Si detecta un uso incorrecto, deshabilite el certificado de notificación de aprovisionamiento para que no se pueda utilizar para el aprovisionamiento de dispositivos. Para obtener más información, consulte [Monitorear AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/monitoring_overview.html) en la *Guía para desarrolladores de AWS IoT Core *.
Para ayudarte a gestionar mejor el número de dispositivos y los dispositivos que se registran automáticamente en el tuyo Cuenta de AWS, puedes especificar un enlace previo al aprovisionamiento al crear una plantilla de aprovisionamiento de flotas. Un enlace de preaprovisionamiento es una AWS Lambda función que valida los parámetros de plantilla que proporcionan los dispositivos durante el registro. Por ejemplo, puede crear un enlace previo al aprovisionamiento que compruebe un ID de un dispositivo con una base de datos para comprobar que el dispositivo tiene permiso de aprovisionamiento. Para obtener más información, consulte los [enlaces previos al aprovisionamiento](https://docs.aws.amazon.com/iot/latest/developerguide/pre-provisioning-hook.html) en la *Guía para desarrolladores de AWS IoT Core *.
**Cómo descargar los certificados de reclamación al dispositivo**
1. Copie el certificado de reclamación y la clave privada en el dispositivo. Si SSH y SCP están habilitados en la computadora de desarrollo y en el dispositivo, puede utilizar el comando `scp` de la computadora de desarrollo para transferir el certificado de reclamación y la clave privada. El siguiente comando de ejemplo transfiere estos archivos a una carpeta denominada `claim-certs` en la computadora de desarrollo al dispositivo. *device-ip-address*Sustitúyala por la dirección IP de tu dispositivo.
```
scp -r claim-certs/ device-ip-address:~
```
1. Cree la carpeta raíz de Greengrass en el dispositivo. Más adelante instalarás el software AWS IoT Greengrass principal en esta carpeta.
**nota**
Windows tiene una limitación de longitud de ruta de 260 caracteres. Si usa Windows, use una carpeta raíz como `C:\greengrass\v2` o `D:\greengrass\v2` para mantener las rutas de los componentes de Greengrass por debajo del límite de 260 caracteres.
------
#### [ Linux or Unix ]
+ Reemplace `/greengrass/v2` por la carpeta que desee utilizar.
```
sudo mkdir -p /greengrass/v2
```
------
#### [ Windows Command Prompt ]
+ Reemplace *C:\$1greengrass\$1v2* por la carpeta que desee utilizar.
```
mkdir C:\greengrass\v2
```
------
#### [ PowerShell ]
+ Reemplace *C:\$1greengrass\$1v2* por la carpeta que desee utilizar.
```
mkdir C:\greengrass\v2
```
------
1. (Solo para Linux) Establezca los permisos de la carpeta principal de la carpeta raíz de Greengrass.
+ */greengrass*Sustitúyalo por el elemento principal de la carpeta raíz.
```
sudo chmod 755 /greengrass
```
1. Mueva los certificados de reclamación a la carpeta raíz de Greengrass.
+ Sustituya `/greengrass/v2` o *C:\$1greengrass\$1v2* por la carpeta raíz de Greengrass.
------
#### [ Linux or Unix ]
```
sudo mv ~/claim-certs /greengrass/v2
```
------
#### [ Windows Command Prompt (CMD) ]
```
move %USERPROFILE%\claim-certs C:\greengrass\v2
```
------
#### [ PowerShell ]
```
mv -Path ~\claim-certs -Destination C:\greengrass\v2
```
------
1. Descarga el certificado de la autoridad de certificación raíz (CA) de Amazon. AWS IoT Los certificados están asociados al certificado de CA raíz de Amazon de forma predeterminada.
------
#### [ Linux or Unix ]
```
sudo curl -o /greengrass/v2/AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -o C:\greengrass\v2\\AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ PowerShell ]
```
iwr -Uri https://www.amazontrust.com/repository/AmazonRootCA1.pem -OutFile C:\greengrass\v2\\AmazonRootCA1.pem
```
------
## Configuración del entorno del dispositivo
Siga los pasos de esta sección para configurar un dispositivo Linux o Windows para usarlo como su dispositivo principal de AWS IoT Greengrass .
### Configuración de un dispositivo Linux
**Para configurar un dispositivo Linux para AWS IoT Greengrass V2**
1. Instale el motor de ejecución de Java, que el software AWS IoT Greengrass principal necesita para ejecutarse. Le recomendamos que utilice las versiones de compatibilidad a largo plazo de [Amazon Corretto](https://aws.amazon.com/corretto/) u [OpenJDK](https://openjdk.java.net/). Se requiere la versión 8 o posterior. Los siguientes comandos muestran cómo instalar OpenJDK en su dispositivo.
+ Para distribuciones basadas en Debian o en Ubuntu:
```
sudo apt install default-jdk
```
+ Para distribuciones basadas en Red Hat:
```
sudo yum install java-11-openjdk-devel
```
+ En Amazon Linux 2:
```
sudo amazon-linux-extras install java-openjdk11
```
+ En Amazon Linux 2023:
```
sudo dnf install java-11-amazon-corretto -y
```
Cuando se complete la instalación, ejecute el siguiente comando para comprobar que Java se ejecuta en su dispositivo Linux.
```
java -version
```
El comando imprime la versión de Java que se ejecuta en el dispositivo. Por ejemplo, en una distribución basada en Debian, el resultado podría ser similar al siguiente ejemplo.
```
openjdk version "11.0.9.1" 2020-11-04
OpenJDK Runtime Environment (build 11.0.9.1+1-post-Debian-1deb10u2)
OpenJDK 64-Bit Server VM (build 11.0.9.1+1-post-Debian-1deb10u2, mixed mode)
```
1. (Opcional) Cree el usuario y el grupo predeterminado del sistema que ejecutan los componentes del dispositivo. También puede optar por permitir que el instalador del software AWS IoT Greengrass principal cree este usuario y grupo durante la instalación con el argumento del `--component-default-user` instalador. Para obtener más información, consulte [Argumentos del instalador](configure-installer.md).
```
sudo useradd --system --create-home ggc_user
sudo groupadd --system ggc_group
```
1. Compruebe que el usuario que ejecuta el software AWS IoT Greengrass principal (normalmente`root`) tiene permiso para ejecutar `sudo` con cualquier usuario y grupo.
1. Ejecute el siguiente comando para abrir el archivo `/etc/sudoers`.
```
sudo visudo
```
1. Compruebe que el permiso del usuario se parezca al siguiente ejemplo.
```
root ALL=(ALL:ALL) ALL
```
1. (Opcional) Para [ejecutar funciones de Lambda en contenedores](run-lambda-functions.md), debe habilitar la versión 1 de [cgroups](https://en.wikipedia.org/wiki/Cgroups), y habilitar y montar los cgroups de *memoria* y de *dispositivos*. Si no tiene previsto ejecutar funciones de Lambda en contenedores, puede omitir este paso.
Para habilitar estas opciones de cgroups, arranque el dispositivo con los siguientes parámetros del kernel de Linux.
```
cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0
```
Para obtener más información acerca de cómo ver y configurar los parámetros del kernel de su dispositivo, consulte la documentación del sistema operativo y del gestor de arranque. Siga las instrucciones para configurar permanentemente los parámetros del kernel.
1. Instale todas las demás dependencias necesarias en su dispositivo tal y como se indica en la lista de requisitos de [Requisitos de los dispositivos](greengrass-nucleus-component.md#greengrass-v2-requirements).
### Configuración de un dispositivo de Windows
**nota**
Esta característica está disponible para la versión 2.5.0 y versiones posteriores del [componente núcleo de Greengrass](greengrass-nucleus-component.md).
**Para configurar un dispositivo Windows para AWS IoT Greengrass V2**
1. Instale el motor de ejecución de Java, que el software AWS IoT Greengrass principal necesita para ejecutarse. Le recomendamos que utilice las versiones de compatibilidad a largo plazo de [Amazon Corretto](https://aws.amazon.com/corretto/) u [OpenJDK](https://openjdk.java.net/). Se requiere la versión 8 o posterior.
1. Compruebe si Java está disponible en la variable del sistema [PATH](https://en.wikipedia.org/wiki/PATH_(variable)) y agréguelo si no lo está. La LocalSystem cuenta ejecuta el software AWS IoT Greengrass principal, por lo que debe agregar Java a la variable de sistema PATH en lugar de a la variable de usuario PATH de su usuario. Haga lo siguiente:
1. Pulse la tecla Windows para abrir el menú de inicio.
1. Escriba **environment variables** para buscar las opciones del sistema en el menú de inicio.
1. En los resultados de la búsqueda del menú de inicio, elija **Editar las variables de entorno del sistema** para abrir la ventana de **Propiedades del sistema**.
1. Elija **Variables de entorno...** para abrir la ventana **Variables de entorno**.
1. En **Variables del sistema**, elija **Ruta** y, luego, **Editar**. En la ventana **Editar variables de entorno**, puede ver cada ruta en una línea independiente.
1. Compruebe si la ruta a la carpeta de la instalación de Java `bin` está presente. La ruta puede tener un aspecto similar al siguiente ejemplo.
```
C:\\Program Files\\Amazon Corretto\\jdk11.0.13_8\\bin
```
1. Si la carpeta de la instalación de Java `bin` no aparece en **Ruta**, elija **Nueva** para agregarla y, a continuación, pulse **Aceptar**.
1. Abra el símbolo del sistema de Windows (`cmd.exe`) como administrador.
1. Cree el usuario predeterminado en la LocalSystem cuenta del dispositivo Windows. *password*Sustitúyalo por una contraseña segura.
```
net user /add ggc_user password
```
**sugerencia**
Según su configuración de Windows, es posible que la contraseña del usuario caduque en una fecha futura. Para garantizar que sus aplicaciones de Greengrass sigan funcionando, controle cuándo caduca la contraseña y actualícela antes de que caduque. También puede configurar la contraseña del usuario para que nunca caduque.
Para comprobar cuándo caducan un usuario y su contraseña, ejecute el siguiente comando.
```
net user ggc_user | findstr /C:expires
```
Para configurar la contraseña de un usuario para que no caduque nunca, ejecute el siguiente comando.
```
wmic UserAccount where "Name='ggc_user'" set PasswordExpires=False
```
Si utilizas Windows 10 o una versión posterior, donde el [`wmic`comando está en desuso](https://learn.microsoft.com/en-us/windows/win32/wmisdk/wmic), ejecuta el siguiente PowerShell comando.
```
Get-CimInstance -Query "SELECT * from Win32_UserAccount WHERE name = 'ggc_user'" | Set-CimInstance -Property @{PasswordExpires="False"}
```
1. Descargue e instale la [PsExecutilidad](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec) de Microsoft en el dispositivo.
1. Utilice la PsExec utilidad para almacenar el nombre de usuario y la contraseña del usuario predeterminado en la instancia de Credential Manager de la LocalSystem cuenta. *password*Sustitúyala por la contraseña de usuario que configuraste anteriormente.
```
psexec -s cmd /c cmdkey /generic:ggc_user /user:ggc_user /pass:password
```
Si **PsExec License Agreement** se abre, elija **Accept** para aceptar la licencia y ejecute el comando.
**nota**
En los dispositivos Windows, la LocalSystem cuenta ejecuta el núcleo de Greengrass y debe usar la PsExec utilidad para almacenar la información de usuario predeterminada en la LocalSystem cuenta. El uso de la aplicación Credential Manager almacena esta información en la cuenta de Windows del usuario que ha iniciado sesión actualmente, en lugar de en la LocalSystem cuenta.
## Descargue el software AWS IoT Greengrass principal
Puede descargar la última versión del software AWS IoT Greengrass Core desde la siguiente ubicación:
+ [https://d2s8p88vqu9w66.cloudfront. net/releases/greengrass](https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip)-nucleus-latest.zip
**nota**
Puede descargar una versión específica del software AWS IoT Greengrass Core desde la siguiente ubicación. *version*Sustitúyala por la versión que se va a descargar.
```
https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-version.zip
```
**Para descargar el software AWS IoT Greengrass principal**
1. En su dispositivo principal, descargue el software AWS IoT Greengrass Core en un archivo denominado`greengrass-nucleus-latest.zip`.
------
#### [ Linux or Unix ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
iwr -Uri https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip -OutFile greengrass-nucleus-latest.zip
```
------
Al descargar este software, acepta el [acuerdo de licencia del software de Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf).
1. (Opcional) Verificación de la firma del software del núcleo de Greengrass
**nota**
Esta característica está disponible en la versión 2.9.5 y versiones posteriores del núcleo de Greengrass.
1. Use el siguiente comando para verificar la firma del artefacto del núcleo de Greengrass:
------
#### [ Linux or Unix ]
```
jarsigner -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
El nombre del archivo puede tener un aspecto diferente según la versión de JDK que instale. Reemplace *`jdk17.0.6_10`* por la versión de JDK que instaló.
```
"C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe" -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
El nombre del archivo puede tener un aspecto diferente según la versión de JDK que instale. Reemplace *`jdk17.0.6_10`* por la versión de JDK que instaló.
```
'C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe' -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
1. La invocación `jarsigner` produce un resultado que indica los resultados de la verificación.
1. Si el archivo zip del núcleo de Greengrass está firmado, el resultado contiene la siguiente declaración:
```
jar verified.
```
1. Si el archivo zip del núcleo de Greengrass no está firmado, el resultado contiene la siguiente declaración:
```
jar is unsigned.
```
1. Si ha proporcionado la opción `-certs` Jarsigner junto con las opciones `-verify` y `-verbose`, el resultado también incluye información detallada del certificado de firmante.
1. Descomprime el software AWS IoT Greengrass Core en una carpeta de tu dispositivo. *GreengrassInstaller*Sustitúyalo por la carpeta que desee usar.
------
#### [ Linux or Unix ]
```
unzip greengrass-nucleus-latest.zip -d GreengrassInstaller && rm greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir GreengrassInstaller && tar -xf greengrass-nucleus-latest.zip -C GreengrassInstaller && del greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
Expand-Archive -Path greengrass-nucleus-latest.zip -DestinationPath .\\GreengrassInstaller
rm greengrass-nucleus-latest.zip
```
------
1. (Opcional) Ejecute el siguiente comando para ver la versión del software AWS IoT Greengrass principal.
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
**importante**
Si instala una versión del núcleo de Greengrass anterior a la v2.4.0, no elimine esta carpeta después de instalar el software Core. AWS IoT Greengrass El software AWS IoT Greengrass Core utiliza los archivos de esta carpeta para ejecutarse.
Si descargó la última versión del software, instale la versión 2.4.0 o posterior y podrá eliminar esta carpeta después de instalar el software AWS IoT Greengrass principal.
## Descargue el complemento de aprovisionamiento AWS IoT de flotas
Puedes descargar la última versión del complemento de aprovisionamiento de AWS IoT flotas desde la siguiente ubicación:
+ [https://d2s8p88vqu9w66.cloudfront. net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim](https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-latest.jar)-latest.jar
**nota**
Puede descargar una versión específica del complemento de aprovisionamiento de AWS IoT flotas desde la siguiente ubicación. *version*Sustitúyala por la versión que se va a descargar. Para obtener más información sobre cada versión del complemento de aprovisionamiento de flota, consulte [Registro de cambios del complemento de aprovisionamiento de flotas AWS IoT](fleet-provisioning-changelog.md).
```
https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-version.jar
```
El complemento de aprovisionamiento de flota es de código abierto. Para ver su código fuente, consulta el [complemento de aprovisionamiento de AWS IoT flotas](https://github.com/aws-greengrass/aws-greengrass-fleet-provisioning-by-claim) en GitHub.
**Para descargar el complemento de aprovisionamiento de AWS IoT flotas**
+ En su dispositivo, descargue el complemento de aprovisionamiento de AWS IoT flotas en un archivo denominado. `aws.greengrass.FleetProvisioningByClaim.jar` *GreengrassInstaller*Sustitúyalo por la carpeta que desee usar.
------
#### [ Linux or Unix ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-latest.jar > GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-latest.jar > GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar
```
------
#### [ PowerShell ]
```
iwr -Uri https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-latest.jar -OutFile GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar
```
------
Al descargar este software, acepta el [acuerdo de licencia del software de Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf).
## Instale el software AWS IoT Greengrass principal
Ejecute el instalador con argumentos que especifiquen las siguientes acciones:
+ Instálelo desde un archivo de configuración parcial que especifique el uso del complemento de aprovisionamiento de flotas para aprovisionar AWS recursos. El software AWS IoT Greengrass Core utiliza un archivo de configuración que especifica la configuración de todos los componentes de Greengrass del dispositivo. El instalador crea un archivo de configuración completo a partir del archivo de configuración parcial que usted proporciona y de los recursos de AWS que crea el complemento de aprovisionamiento de flota.
+ Especifique si desea usar el usuario del sistema `ggc_user` para ejecutar los componentes de software en el dispositivo principal. En los dispositivos Linux, este comando también especifica el uso del grupo del sistema `ggc_group` y el instalador crea el usuario y el grupo del sistema por usted.
+ Configure el software AWS IoT Greengrass Core como un servicio del sistema que se ejecute durante el arranque. En los dispositivos Linux, esto requiere el sistema de inicio [Systemd](https://en.wikipedia.org/wiki/Systemd).
**importante**
En los dispositivos principales de Windows, debe configurar el software AWS IoT Greengrass principal como un servicio del sistema.
Para obtener más información acerca de los argumentos que puede especificar, consulte [Argumentos del instalador](configure-installer.md).
**nota**
Si utilizas un AWS IoT Greengrass dispositivo con memoria limitada, puedes controlar la cantidad de memoria que utiliza el software AWS IoT Greengrass Core. Para controlar la asignación de memoria, puede configurar las opciones de tamaño de montón de la JVM en el parámetro de configuración `jvmOptions` del componente núcleo. Para obtener más información, consulte [Control de la asignación de memoria con las opciones de JVM](configure-greengrass-core-v2.md#jvm-tuning).
**Para instalar el software AWS IoT Greengrass Core**
1. Compruebe la versión del software AWS IoT Greengrass principal.
+ *GreengrassInstaller*Sustitúyala por la ruta a la carpeta que contiene el software.
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
1. Use un editor de texto para crear un archivo de configuración llamado `config.yaml` para proporcionárselo al instalador.
Por ejemplo, en un sistema basado en Linux, puede ejecutar el siguiente comando para usar GNU nano a fin de crear el archivo.
```
nano GreengrassInstaller/config.yaml
```
Copie el siguiente contenido YAML en el archivo. Este archivo de configuración parcial especifica los parámetros del complemento de aprovisionamiento de flota. Para obtener más información acerca de las opciones que puede especificar, consulte [Configurar el complemento de aprovisionamiento de AWS IoT flotas](fleet-provisioning-configuration.md).
------
#### [ Linux or Unix ]
```
---
services:
aws.greengrass.Nucleus:
version: "2.16.1"
aws.greengrass.FleetProvisioningByClaim:
configuration:
rootPath: "/greengrass/v2"
awsRegion: "us-west-2"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredentialEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
provisioningTemplate: "GreengrassFleetProvisioningTemplate"
claimCertificatePath: "/greengrass/v2/claim-certs/claim.pem.crt"
claimCertificatePrivateKeyPath: "/greengrass/v2/claim-certs/claim.private.pem.key"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
templateParameters:
ThingName: "MyGreengrassCore"
ThingGroupName: "MyGreengrassCoreGroup"
```
------
#### [ Windows ]
```
---
services:
aws.greengrass.Nucleus:
version: "2.16.1"
aws.greengrass.FleetProvisioningByClaim:
configuration:
rootPath: "C:\\greengrass\\v2"
awsRegion: "us-west-2"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredentialEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
provisioningTemplate: "GreengrassFleetProvisioningTemplate"
claimCertificatePath: "C:\\greengrass\\v2\\claim-certs\\claim.pem.crt"
claimCertificatePrivateKeyPath: "C:\\greengrass\\v2\\claim-certs\\claim.private.pem.key"
rootCaPath: "C:\\greengrass\\v2\\AmazonRootCA1.pem"
templateParameters:
ThingName: "MyGreengrassCore"
ThingGroupName: "MyGreengrassCoreGroup"
```
------
A continuación, proceda del modo siguiente:
+ *2.16.1*Sustitúyala por la versión del software AWS IoT Greengrass principal.
+ Sustituya cada instancia de `/greengrass/v2` o *C:\$1greengrass\$1v2* por la carpeta raíz de Greengrass.
**nota**
En los dispositivos Windows, debe especificar los separadores de rutas como barras invertidas dobles (`\\`), como `C:\\greengrass\\v2`.
+ *us-west-2*Sustitúyala por la AWS región en la que creaste la plantilla de aprovisionamiento y otros recursos.
+ `iotDataEndpoint`Sustitúyalo por su punto final AWS IoT de datos.
+ Sustituya el `iotCredentialEndpoint` punto final por el de sus AWS IoT credenciales.
+ *GreengrassCoreTokenExchangeRoleAlias*Sustitúyalo por el nombre del alias de la función de intercambio de fichas.
+ *GreengrassFleetProvisioningTemplate*Sustitúyalo por el nombre de la plantilla de aprovisionamiento de flota.
+ Sustituya `claimCertificatePath` por la ruta al certificado de reclamación del dispositivo.
+ Sustituya `claimCertificatePrivateKeyPath` por la ruta a la clave privada del certificado de reclamación del dispositivo.
+ Sustituya los parámetros de la plantilla (`templateParameters`) por los valores que se usan para aprovisionar el dispositivo. Este ejemplo hace referencia a la [plantilla de ejemplo](fleet-provisioning-setup.md#example-fleet-provisioning-template) que define los parámetros `ThingName` y `ThingGroupName`.
**nota**
En este archivo de configuración, puede personalizar otras opciones de configuración, como los puertos y el proxy de red que utilice, tal como se muestra en el siguiente ejemplo. Para obtener más información, consulte la [Configuración del núcleo de Greengrass](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration).
```
---
services:
aws.greengrass.Nucleus:
version: "2.16.1"
configuration:
mqtt:
port: 443
greengrassDataPlanePort: 443
networkProxy:
noProxyAddresses: "http://192.168.0.1,www.example.com"
proxy:
url: "http://my-proxy-server:1100"
username: "Mary_Major"
password: "pass@word1357"
aws.greengrass.FleetProvisioningByClaim:
configuration:
rootPath: "/greengrass/v2"
awsRegion: "us-west-2"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredentialEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
provisioningTemplate: "GreengrassFleetProvisioningTemplate"
claimCertificatePath: "/greengrass/v2/claim-certs/claim.pem.crt"
claimCertificatePrivateKeyPath: "/greengrass/v2/claim-certs/claim.private.pem.key"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
templateParameters:
ThingName: "MyGreengrassCore"
ThingGroupName: "MyGreengrassCoreGroup"
mqttPort: 443
proxyUrl: "http://my-proxy-server:1100"
proxyUserName: "Mary_Major"
proxyPassword: "pass@word1357"
```
```
---
services:
aws.greengrass.Nucleus:
version: "2.16.1"
configuration:
mqtt:
port: 443
greengrassDataPlanePort: 443
networkProxy:
noProxyAddresses: "http://192.168.0.1,www.example.com"
proxy:
url: "http://my-proxy-server:1100"
username: "Mary_Major"
password: "pass@word1357"
aws.greengrass.FleetProvisioningByClaim:
configuration:
rootPath: "C:\\greengrass\\v2"
awsRegion: "us-west-2"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredentialEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
provisioningTemplate: "GreengrassFleetProvisioningTemplate"
claimCertificatePath: "C:\\greengrass\\v2\\claim-certs\\claim.pem.crt"
claimCertificatePrivateKeyPath: "C:\\greengrass\\v2\\claim-certs\\claim.private.pem.key"
rootCaPath: "C:\\greengrass\\v2\\AmazonRootCA1.pem"
templateParameters:
ThingName: "MyGreengrassCore"
ThingGroupName: "MyGreengrassCoreGroup"
mqttPort: 443
proxyUrl: "http://my-proxy-server:1100"
proxyUserName: "Mary_Major"
proxyPassword: "pass@word1357"
```
Para utilizar un proxy HTTPS, debe utilizar la versión 1.1.0 o posterior del complemento de aprovisionamiento de flotas. Además, debe especificar la `rootCaPath` de `system`, como se muestra en el siguiente ejemplo.
```
---
system:
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
services:
...
```
```
---
system:
rootCaPath: "C:\\greengrass\\v2\\AmazonRootCA1.pem"
services:
...
```
1. Ejecute el instalador. Especifique `--trusted-plugin` si desea proporcionar el complemento de aprovisionamiento de flota y especifique `--init-config` si desea proporcionar el archivo de configuración.
+ Reemplace `/greengrass/v2` por la carpeta raíz de Greengrass.
+ Sustituya cada instancia de por *GreengrassInstaller* la carpeta en la que desempaquetó el instalador.
------
#### [ Linux or Unix ]
```
sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
-jar ./GreengrassInstaller/lib/Greengrass.jar \
--trusted-plugin ./GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar \
--init-config ./GreengrassInstaller/config.yaml \
--component-default-user ggc_user:ggc_group \
--setup-system-service true
```
------
#### [ Windows Command Prompt (CMD) ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" ^
-jar ./GreengrassInstaller/lib/Greengrass.jar ^
--trusted-plugin ./GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar ^
--init-config ./GreengrassInstaller/config.yaml ^
--component-default-user ggc_user ^
--setup-system-service true
```
------
#### [ PowerShell ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" `
-jar ./GreengrassInstaller/lib/Greengrass.jar `
--trusted-plugin ./GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar `
--init-config ./GreengrassInstaller/config.yaml `
--component-default-user ggc_user `
--setup-system-service true
```
------
**importante**
En los dispositivos principales de Windows, debe especificar si `--setup-system-service true` desea configurar el software AWS IoT Greengrass principal como un servicio del sistema.
Si especifica `--setup-system-service true`, el instalador imprime `Successfully set up Nucleus as a system service` si configuró y ejecutó el software como un servicio del sistema. De lo contrario, el instalador no mostrará ningún mensaje si instala el software correctamente.
**nota**
No puede usar el argumento `deploy-dev-tools` para implementar herramientas de desarrollo locales cuando ejecuta el instalador sin el argumento `--provision true`. Para obtener información sobre cómo implementar la CLI de Greengrass directamente en su dispositivo, consulte [Interfaz de la línea de comandos de Greengrass](gg-cli.md).
1. Verifique la instalación mediante la consulta de los archivos de la carpeta raíz.
------
#### [ Linux or Unix ]
```
ls /greengrass/v2
```
------
#### [ Windows Command Prompt (CMD) ]
```
dir C:\greengrass\v2
```
------
#### [ PowerShell ]
```
ls C:\greengrass\v2
```
------
Si la instalación se realizó correctamente, la carpeta raíz contiene varias carpetas, como `config`, `packages` y `logs`.
Si instaló el software AWS IoT Greengrass Core como un servicio del sistema, el instalador ejecutará el software automáticamente. De no ser así, debe ejecutar el software manualmente. Para obtener más información, consulte [Ejecute el software AWS IoT Greengrass principal](run-greengrass-core-v2.md).
Para obtener más información sobre cómo configurar y utilizar el software AWS IoT Greengrass, consulte lo siguiente:
+ [Configurar el software AWS IoT Greengrass principal](configure-greengrass-core-v2.md)
+ [Desarrollo de componentes de AWS IoT Greengrass](develop-greengrass-components.md)
+ [Implemente AWS IoT Greengrass componentes en los dispositivos](manage-deployments.md)
+ [Interfaz de la línea de comandos de Greengrass](gg-cli.md)
# Configurar el aprovisionamiento de AWS IoT flota para los dispositivos principales de Greengrass
Para [instalar el software AWS IoT Greengrass Core con el aprovisionamiento de flotas](fleet-provisioning.md), primero debe configurar los siguientes recursos en su. Cuenta de AWS Estos recursos permiten que los dispositivos se registren AWS IoT y funcionen como dispositivos principales de Greengrass. Siga los pasos de esta sección una vez para crear y configurar estos recursos en su Cuenta de AWS.
+ Un rol de IAM de intercambio de token, que los dispositivos principales utilizan para autorizar las llamadas a los servicios de AWS .
+ Un alias de AWS IoT rol que apunta al rol de intercambio de fichas.
+ (Opcional) Una AWS IoT política que los dispositivos principales utilizan para autorizar las llamadas a los AWS IoT Greengrass servicios AWS IoT y. Esta AWS IoT política debe permitir el `iot:AssumeRoleWithCertificate` permiso para el alias de la AWS IoT función que apunta a la función de intercambio de fichas.
Puede usar una AWS IoT política única para todos los dispositivos principales de su flota, o puede configurar la plantilla de aprovisionamiento de la flota para crear una AWS IoT política para cada dispositivo principal.
+ Una plantilla de aprovisionamiento de AWS IoT flota. Esta plantilla debe especificar lo siguiente:
+ Cualquier AWS IoT cosa, un recurso. Puede especificar una lista de grupos de objetos existentes para implementar componentes en cada dispositivo cuando esté en línea.
+ Un recurso AWS IoT político. Este recurso puede definir al menos una de las siguientes propiedades:
+ El nombre de una AWS IoT política existente. Si elige esta opción, los dispositivos principales que cree a partir de esta plantilla utilizarán la misma AWS IoT política y podrá gestionar sus permisos como una flota.
+ Un documento AWS IoT de política. Si elige esta opción, cada dispositivo principal que cree a partir de esta plantilla utilizará una AWS IoT política única y podrá administrar los permisos de cada dispositivo principal individual.
+ Un recurso AWS IoT de certificados. Este recurso de certificado debe usar el parámetro `AWS::IoT::Certificate::Id` para adjuntar el certificado al dispositivo principal. Para obtener más información, consulte el [Just-in-time aprovisionamiento](https://docs.aws.amazon.com/iot/latest/developerguide/jit-provisioning.html) en la *Guía para AWS IoT desarrolladores*.
+ Un certificado de notificación de AWS IoT aprovisionamiento y una clave privada para la plantilla de aprovisionamiento de flotas. Puede incrustar este certificado y esta clave privada en los dispositivos durante la fabricación, de modo que los dispositivos puedan registrarse y aprovisionarse por sí mismos cuando se conecten a Internet.
**importante**
Las claves privadas de la notificación de aprovisionamiento deben estar protegidas en todo momento, también en el dispositivo principal de Greengrass. Te recomendamos que utilices CloudWatch las estadísticas y los registros de Amazon para detectar indicios de uso indebido, como el uso no autorizado del certificado de reclamación para aprovisionar dispositivos. Si detecta un uso incorrecto, deshabilite el certificado de notificación de aprovisionamiento para que no se pueda utilizar para el aprovisionamiento de dispositivos. Para obtener más información, consulte [Monitorear AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/monitoring_overview.html) en la *Guía para desarrolladores de AWS IoT Core *.
Para ayudarte a gestionar mejor el número de dispositivos y los dispositivos que se registran automáticamente en el tuyo Cuenta de AWS, puedes especificar un enlace previo al aprovisionamiento al crear una plantilla de aprovisionamiento de flotas. Un enlace de preaprovisionamiento es una AWS Lambda función que valida los parámetros de plantilla que proporcionan los dispositivos durante el registro. Por ejemplo, puede crear un enlace previo al aprovisionamiento que compruebe un ID de un dispositivo con una base de datos para comprobar que el dispositivo tiene permiso de aprovisionamiento. Para obtener más información, consulte los [enlaces previos al aprovisionamiento](https://docs.aws.amazon.com/iot/latest/developerguide/pre-provisioning-hook.html) en la *Guía para desarrolladores de AWS IoT Core *.
+ AWS IoT Política que se adjunta al certificado de notificación de aprovisionamiento para permitir que los dispositivos se registren y utilicen la plantilla de aprovisionamiento de flota.
**Topics**
+ [Creación de un rol de intercambio de token](#create-token-exchange-role)
+ [Cree una AWS IoT política](#create-iot-policy)
+ [Creación de una plantilla de aprovisionamiento de flota](#create-provisioning-template)
+ [Creación de un certificado de notificación de aprovisionamiento y una clave privada](#create-claim-certificates)
## Creación de un rol de intercambio de token
Los dispositivos principales de Greengrass utilizan una función de servicio de IAM, denominada función de *intercambio de fichas*, para autorizar las llamadas a los servicios. AWS El dispositivo utiliza el proveedor de AWS IoT credenciales para obtener AWS credenciales temporales para esta función, lo que permite al dispositivo interactuar con Amazon Logs AWS IoT, enviar registros a Amazon CloudWatch Logs y descargar artefactos de componentes personalizados de Amazon S3. Para obtener más información, consulte [Autorizar a los dispositivos principales a interactuar con AWS los servicios](device-service-role.md).
Se utiliza un *alias de AWS IoT rol* para configurar el rol de intercambio de fichas para los dispositivos principales de Greengrass. Los alias de rol le permiten cambiar el rol de intercambio de token de un dispositivo, pero mantener la configuración del dispositivo igual. 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 *.
En esta sección, creará un rol de IAM de intercambio de tokens y un alias de AWS IoT rol que apunte al rol. Si ya ha configurado un dispositivo principal de Greengrass, puede usar su rol de intercambio de token y su alias de rol en lugar de crear otros nuevos.
**Creación de un rol de IAM de intercambio de token**
1. Creación de un rol de IAM que su dispositivo puede usar como rol de intercambio de token. Haga lo siguiente:
1. Creación de un archivo que contenga el documento de política de confianza que requiere el rol de intercambio de token.
Por ejemplo, en un sistema basado en Linux, puede ejecutar el siguiente comando para usar GNU nano a fin de crear el archivo.
```
nano device-role-trust-policy.json
```
Copie el siguiente JSON en el archivo.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
1. Creación del rol de intercambio de token con el documento de política de confianza.
+ *GreengrassV2TokenExchangeRole*Sustitúyalo por el nombre del rol de IAM que se va a crear.
```
aws iam create-role --role-name GreengrassV2TokenExchangeRole --assume-role-policy-document file://device-role-trust-policy.json
```
Si la solicitud se realiza exitosamente, la respuesta se parece al siguiente ejemplo.
```
{
"Role": {
"Path": "/",
"RoleName": "GreengrassV2TokenExchangeRole",
"RoleId": "AROAZ2YMUHYHK5OKM77FB",
"Arn": "arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole",
"CreateDate": "2021-02-06T00:13:29+00:00",
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
}
```
1. Creación de un archivo que contenga el documento de política de acceso que requiere el rol de intercambio de token.
Por ejemplo, en un sistema basado en Linux, puede ejecutar el siguiente comando para usar GNU nano a fin de crear el archivo.
```
nano device-role-access-policy.json
```
Copie el siguiente JSON en el archivo.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents",
"logs:DescribeLogStreams",
"s3:GetBucketLocation"
],
"Resource": "*"
}
]
}
```
**nota**
Esta política de acceso no permite el acceso a los artefactos de componentes en los buckets de S3. Para implementar componentes personalizados que definan artefactos en Amazon S3, debe agregar permisos al rol para permitir que su dispositivo principal recupere artefactos de componentes. 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).
Si aún no tiene un bucket de S3 para los artefactos de los componentes, puede agregar estos permisos más adelante, después de crear un bucket.
1. Creación de la política de IAM a partir del documento de política.
+ *GreengrassV2TokenExchangeRoleAccess*Sustitúyalo por el nombre de la política de IAM que se va a crear.
```
aws iam create-policy --policy-name GreengrassV2TokenExchangeRoleAccess --policy-document file://device-role-access-policy.json
```
Si la solicitud se realiza exitosamente, la respuesta se parece al siguiente ejemplo.
```
{
"Policy": {
"PolicyName": "GreengrassV2TokenExchangeRoleAccess",
"PolicyId": "ANPAZ2YMUHYHACI7C5Z66",
"Arn": "arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess",
"Path": "/",
"DefaultVersionId": "v1",
"AttachmentCount": 0,
"PermissionsBoundaryUsageCount": 0,
"IsAttachable": true,
"CreateDate": "2021-02-06T00:37:17+00:00",
"UpdateDate": "2021-02-06T00:37:17+00:00"
}
}
```
1. Adjunte la política de IAM al rol de intercambio de token.
+ Reemplace *GreengrassV2TokenExchangeRole* por el nombre del rol de IAM.
+ Reemplace el ARN de la política por el ARN de la política de IAM que creó en el paso anterior.
```
aws iam attach-role-policy --role-name GreengrassV2TokenExchangeRole --policy-arn arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess
```
El comando no tiene ningún resultado si la solicitud se realiza correctamente.
1. Cree un alias de AWS IoT rol que apunte al rol de intercambio de fichas.
+ *GreengrassCoreTokenExchangeRoleAlias*Sustitúyalo por el nombre del alias del rol que se va a crear.
+ Reemplace el ARN del rol por el ARN del rol de IAM que creó en el paso anterior.
```
aws iot create-role-alias --role-alias GreengrassCoreTokenExchangeRoleAlias --role-arn arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole
```
Si la solicitud se realiza exitosamente, la respuesta se parece al siguiente ejemplo.
```
{
"roleAlias": "GreengrassCoreTokenExchangeRoleAlias",
"roleAliasArn": "arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
```
**nota**
Para crear un alias de rol, debe tener el permiso para transferir el rol de IAM de intercambio de token a AWS IoT. Si recibe un mensaje de error al intentar crear un alias de rol, compruebe que el AWS usuario tiene este permiso. Para obtener más información, consulte [Conceder permisos a un usuario para transferir un rol a un AWS servicio](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_passrole.html) en la *Guía del AWS Identity and Access Management usuario*.
## Cree una AWS IoT política
Después de registrar un dispositivo como una AWS IoT cosa, ese dispositivo puede usar un certificado digital para autenticarse AWS. Este certificado incluye una o más AWS IoT políticas que definen los permisos que un dispositivo puede usar con el certificado. Estas políticas permiten que el dispositivo se comunique con AWS IoT y AWS IoT Greengrass.
Con el aprovisionamiento de AWS IoT flotas, los dispositivos se conectan AWS IoT para crear y descargar un certificado de dispositivo. En la plantilla de aprovisionamiento de flotas que cree en la siguiente sección, puede especificar si desea AWS IoT adjuntar la misma AWS IoT política a todos los certificados de los dispositivos o crear una nueva política para cada dispositivo.
En esta sección, creará una AWS IoT política que se AWS IoT adjunte a los certificados de todos los dispositivos. Con este enfoque, puede administrar los permisos de todos los dispositivos como una flota. Si prefieres crear una AWS IoT política nueva para cada dispositivo, puedes saltarte esta sección y consultar la política que contiene cuando definas la plantilla de tu flota.
**Para crear una AWS IoT política**
+ Cree una AWS IoT política que defina los AWS IoT permisos para su flota de dispositivos principales de Greengrass. La siguiente política permite el acceso a todos los temas de MQTT y a las operaciones de Greengrass, de modo que su dispositivo funcione con aplicaciones personalizadas y con cambios futuros que requieran nuevas operaciones de Greengrass. Esta política también concede el permiso `iot:AssumeRoleWithCertificate`, que permite a los dispositivos utilizar el rol de intercambio de token que creó en la sección anterior. Puede restringir esta política en función del caso de uso. Para obtener más información, consulte [AWS IoT Política mínima para los dispositivos AWS IoT Greengrass V2 principales](device-auth.md#greengrass-core-minimal-iot-policy).
Haga lo siguiente:
1. Cree un archivo que contenga el documento AWS IoT de política que requieren los dispositivos principales de Greengrass.
Por ejemplo, en un sistema basado en Linux, puede ejecutar el siguiente comando para usar GNU nano a fin de crear el archivo.
```
nano greengrass-v2-iot-policy.json
```
Copie el siguiente JSON en el archivo.
+ Sustituya el `iot:AssumeRoleWithCertificate` recurso por el ARN del alias de AWS IoT rol que creó en la sección anterior.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Publish",
"iot:Subscribe",
"iot:Receive",
"iot:Connect",
"greengrass:*"
],
"Resource": [
"*"
]
},
{
"Effect": "Allow",
"Action": "iot:AssumeRoleWithCertificate",
"Resource": "arn:aws:iot:us-east-1:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
]
}
```
------
1. Cree una AWS IoT política a partir del documento de política.
+ *GreengrassV2IoTThingPolicy*Sustitúyala por el nombre de la política que se va a crear.
```
aws iot create-policy --policy-name GreengrassV2IoTThingPolicy --policy-document file://greengrass-v2-iot-policy.json
```
Si la solicitud se realiza exitosamente, la respuesta se parece al siguiente ejemplo.
------
#### [ JSON ]
****
```
{
"policyName": "GreengrassV2IoTThingPolicy",
"policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GreengrassV2IoTThingPolicy",
"policyDocument": "{
\"Version\": \"2012-10-17\",
\"Statement\": [
{
\"Effect\": \"Allow\",
\"Action\": [
\"iot:Publish\",
\"iot:Subscribe\",
\"iot:Receive\",
\"iot:Connect\",
\"greengrass:*\"
],
\"Resource\": [
\"*\"
]
},
{
\"Effect\": \"Allow\",
\"Action\": \"iot:AssumeRoleWithCertificate\",
\"Resource\": \"arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias\"
}
]
}",
"policyVersionId": "1"
}
```
------
## Creación de una plantilla de aprovisionamiento de flota
AWS IoT Las plantillas de aprovisionamiento de flotas definen cómo aprovisionar AWS IoT los artículos, las políticas y los certificados. Para aprovisionar los dispositivos principales de Greengrass con el complemento de aprovisionamiento de flotas, debe crear una plantilla en la que se especifique lo siguiente:
+ Cualquier AWS IoT cosa, un recurso. Puede especificar una lista de grupos de objetos existentes para implementar componentes en cada dispositivo cuando esté en línea.
+ Un recurso AWS IoT político. Este recurso puede definir al menos una de las siguientes propiedades:
+ El nombre de una AWS IoT política existente. Si elige esta opción, los dispositivos principales que cree a partir de esta plantilla utilizarán la misma AWS IoT política y podrá gestionar sus permisos como una flota.
+ Un documento AWS IoT de política. Si elige esta opción, cada dispositivo principal que cree a partir de esta plantilla utilizará una AWS IoT política única y podrá administrar los permisos de cada dispositivo principal individual.
+ Un recurso AWS IoT de certificados. Este recurso de certificado debe usar el parámetro `AWS::IoT::Certificate::Id` para adjuntar el certificado al dispositivo principal. Para obtener más información, consulte el [Just-in-time aprovisionamiento](https://docs.aws.amazon.com/iot/latest/developerguide/jit-provisioning.html) en la *Guía para AWS IoT desarrolladores*.
En la plantilla, puede especificar si desea añadirlo a una lista de grupos de cosas existentes. AWS IoT Cuando el dispositivo principal se conecta AWS IoT Greengrass por primera vez, recibe despliegues de Greengrass para cada grupo de elementos del que es miembro. Puede usar grupos de objetos para implementar el software más reciente en cada dispositivo tan pronto como esté en línea. Para obtener más información, consulte [Implemente AWS IoT Greengrass componentes en los dispositivos](manage-deployments.md).
El AWS IoT servicio requiere permisos para crear y actualizar sus AWS IoT recursos Cuenta de AWS al aprovisionar sus dispositivos. Para dar acceso al AWS IoT servicio, debe crear un rol de IAM y proporcionarlo al crear la plantilla. AWS IoT proporciona una política gestionada, el [AWSIoTThingsregistro](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/service-role/AWSIoTThingsRegistration), que permite el acceso a todos los permisos que se AWS IoT puedan utilizar al aprovisionar dispositivos. Puede usar esta política administrada o crear una política personalizada que limite los permisos de la política administrada para el caso de uso.
En esta sección, se crea una función de IAM que permite AWS IoT aprovisionar recursos para los dispositivos y se crea una plantilla de aprovisionamiento de flotas que utiliza esa función de IAM.
**Cómo crear una plantilla de aprovisionamiento de flotas**
1. Cree una función de IAM que AWS IoT pueda asumir como aprovisionamiento de recursos en su empresa. Cuenta de AWS Haga lo siguiente:
1. Cree un archivo que contenga el documento de política de confianza que le AWS IoT permita asumir el rol.
Por ejemplo, en un sistema basado en Linux, puede ejecutar el siguiente comando para usar GNU nano a fin de crear el archivo.
```
nano aws-iot-trust-policy.json
```
Copie el siguiente JSON en el archivo.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Cree un rol de IAM con un documento de política de confianza.
+ *GreengrassFleetProvisioningRole*Sustitúyalo por el nombre del rol de IAM que se va a crear.
```
aws iam create-role --role-name GreengrassFleetProvisioningRole --assume-role-policy-document file://aws-iot-trust-policy.json
```
Si la solicitud se realiza exitosamente, la respuesta se parece al siguiente ejemplo.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Connect",
"iot:Publish",
"iot:Subscribe",
"iot:Receive"
],
"Resource": "*"
}
]
}
```
------
1. Revise la política [AWSIoTThingsde registro](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/service-role/AWSIoTThingsRegistration), que permite el acceso a todos los permisos que se AWS IoT puedan utilizar al aprovisionar dispositivos. Puede usar esta política administrada o crear una política personalizada que defina los permisos restringidos para el caso de uso. Si decide crear una política personalizada, hágalo ahora.
1. Adjunte la política de IAM al rol de aprovisionamiento de flotas.
+ Reemplace *GreengrassFleetProvisioningRole* por el nombre del rol de IAM.
+ Si creó una política personalizada en el paso anterior, sustituya el ARN de la política por el ARN de la política de IAM que vaya a utilizar.
```
aws iam attach-role-policy --role-name GreengrassFleetProvisioningRole --policy-arn arn:aws:iam::aws:policy/service-role/AWSIoTThingsRegistration
```
El comando no tiene ningún resultado si la solicitud se realiza correctamente.
1. (Opcional) Cree un *enlace de aprovisionamiento previo*, que es una función de AWS Lambda que valida los parámetros de plantilla que los dispositivos proporcionan durante el registro. Puede usar un enlace de aprovisionamiento previo para tener más control sobre cómo y cuántos dispositivos están integrados en la Cuenta de AWS. Para obtener más información, consulte los [enlaces previos al aprovisionamiento](https://docs.aws.amazon.com/iot/latest/developerguide/pre-provisioning-hook.html) en la *Guía para desarrolladores de AWS IoT Core *.
1. Cree una plantilla de aprovisionamiento de flotas. Haga lo siguiente:
1. Cree un archivo que contenga el documento de plantilla de aprovisionamiento.
Por ejemplo, en un sistema basado en Linux, puede ejecutar el siguiente comando para usar GNU nano a fin de crear el archivo.
```
nano greengrass-fleet-provisioning-template.json
```
Escriba el documento de plantilla de aprovisionamiento. Puedes empezar con el siguiente ejemplo de plantilla de aprovisionamiento, que especifica la creación de AWS IoT algo con las siguientes propiedades:
+ El nombre del objeto es el valor que se especifica en el parámetro de la plantilla `ThingName`.
+ El objeto es una parte del grupo de objetos que se especifica en el parámetro `ThingGroupName` de plantilla. El grupo de cosas debe existir en su. Cuenta de AWS
+ El certificado de la cosa lleva `GreengrassV2IoTThingPolicy` adjunto el nombre de la AWS IoT política.
Para más información, consulte [Plantillas de aprovisionamiento](https://docs.aws.amazon.com/iot/latest/developerguide/provision-template.html) en la *Guía para desarrolladores de AWS IoT Core *.
```
{
"Parameters": {
"ThingName": {
"Type": "String"
},
"ThingGroupName": {
"Type": "String"
},
"AWS::IoT::Certificate::Id": {
"Type": "String"
}
},
"Resources": {
"MyThing": {
"OverrideSettings": {
"AttributePayload": "REPLACE",
"ThingGroups": "REPLACE",
"ThingTypeName": "REPLACE"
},
"Properties": {
"AttributePayload": {},
"ThingGroups": [
{
"Ref": "ThingGroupName"
}
],
"ThingName": {
"Ref": "ThingName"
}
},
"Type": "AWS::IoT::Thing"
},
"MyPolicy": {
"Properties": {
"PolicyName": "GreengrassV2IoTThingPolicy"
},
"Type": "AWS::IoT::Policy"
},
"MyCertificate": {
"Properties": {
"CertificateId": {
"Ref": "AWS::IoT::Certificate::Id"
},
"Status": "Active"
},
"Type": "AWS::IoT::Certificate"
}
}
}
```
**nota**
*MyThing**MyPolicy*, y *MyCertificate* son nombres arbitrarios que identifican cada especificación de recurso de la plantilla de aprovisionamiento de flota. AWS IoT no utiliza estos nombres en los recursos que crea a partir de la plantilla. Puede utilizar estos nombres o sustituirlos por valores que lo ayuden a identificar cada recurso de la plantilla.
1. Cree la plantilla de aprovisionamiento de flotas a partir del documento de plantilla de aprovisionamiento.
+ Sustituya *GreengrassFleetProvisioningTemplate* por el nombre de la plantilla a crear.
+ Sustituya la descripción de la plantilla por una descripción de la plantilla.
+ Sustituya rol del ARN de aprovisionamiento por el ARN del rol creó anteriormente.
------
#### [ Linux or Unix ]
```
aws iot create-provisioning-template \
--template-name GreengrassFleetProvisioningTemplate \
--description "A provisioning template for Greengrass core devices." \
--provisioning-role-arn "arn:aws:iam::123456789012:role/GreengrassFleetProvisioningRole" \
--template-body file://greengrass-fleet-provisioning-template.json \
--enabled
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws iot create-provisioning-template ^
--template-name GreengrassFleetProvisioningTemplate ^
--description "A provisioning template for Greengrass core devices." ^
--provisioning-role-arn "arn:aws:iam::123456789012:role/GreengrassFleetProvisioningRole" ^
--template-body file://greengrass-fleet-provisioning-template.json ^
--enabled
```
------
#### [ PowerShell ]
```
aws iot create-provisioning-template `
--template-name GreengrassFleetProvisioningTemplate `
--description "A provisioning template for Greengrass core devices." `
--provisioning-role-arn "arn:aws:iam::123456789012:role/GreengrassFleetProvisioningRole" `
--template-body file://greengrass-fleet-provisioning-template.json `
--enabled
```
------
**nota**
Si creó un enlace de aprovisionamiento previo, especifique el ARN de la función de Lambda del enlace de aprovisionamiento previo con el argumento `--pre-provisioning-hook`.
```
--pre-provisioning-hook targetArn=arn:aws:lambda:us-west-2:123456789012:function:GreengrassPreProvisioningHook
```
Si la solicitud se realiza exitosamente, la respuesta se parece al siguiente ejemplo.
```
{
"templateArn": "arn:aws:iot:us-west-2:123456789012:provisioningtemplate/GreengrassFleetProvisioningTemplate",
"templateName": "GreengrassFleetProvisioningTemplate",
"defaultVersionId": 1
}
```
## Creación de un certificado de notificación de aprovisionamiento y una clave privada
Los certificados de reclamación son certificados X.509 que permiten a los dispositivos registrarse como AWS IoT objetos y recuperar un certificado de dispositivo X.509 exclusivo para utilizarlo en las operaciones habituales. Tras crear un certificado de reclamación, debe adjuntar una AWS IoT política que permita a los dispositivos utilizarlo para crear certificados de dispositivos únicos y aprovisionarlos con una plantilla de aprovisionamiento de flota. Los dispositivos con el certificado de reclamación se pueden aprovisionar únicamente con la plantilla de aprovisionamiento que usted permita en la política AWS IoT .
En esta sección, usted crea el certificado de reclamación y lo configura para que los dispositivos lo usen con la plantilla de aprovisionamiento de flotas que creó en la sección anterior.
**importante**
Las claves privadas de la notificación de aprovisionamiento deben estar protegidas en todo momento, también en el dispositivo principal de Greengrass. Te recomendamos que utilices CloudWatch las estadísticas y los registros de Amazon para detectar indicios de uso indebido, como el uso no autorizado del certificado de reclamación para aprovisionar dispositivos. Si detecta un uso incorrecto, deshabilite el certificado de notificación de aprovisionamiento para que no se pueda utilizar para el aprovisionamiento de dispositivos. Para obtener más información, consulte [Monitorear AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/monitoring_overview.html) en la *Guía para desarrolladores de AWS IoT Core *.
Para ayudarte a gestionar mejor el número de dispositivos y los dispositivos que se registran automáticamente en el tuyo Cuenta de AWS, puedes especificar un enlace previo al aprovisionamiento al crear una plantilla de aprovisionamiento de flotas. Un enlace de preaprovisionamiento es una AWS Lambda función que valida los parámetros de plantilla que proporcionan los dispositivos durante el registro. Por ejemplo, puede crear un enlace previo al aprovisionamiento que compruebe un ID de un dispositivo con una base de datos para comprobar que el dispositivo tiene permiso de aprovisionamiento. Para obtener más información, consulte los [enlaces previos al aprovisionamiento](https://docs.aws.amazon.com/iot/latest/developerguide/pre-provisioning-hook.html) en la *Guía para desarrolladores de AWS IoT Core *.
**Cómo crear un certificado de reclamación de aprovisionamiento y una clave privada**
1. Cree una carpeta en la que pueda descargar el certificado de reclamación y la clave privada.
```
mkdir claim-certs
```
1. Cree y guarde un certificado y una clave privada para usarlos en el aprovisionamiento. AWS IoT proporciona certificados de cliente firmados por la autoridad de certificación (CA) raíz de Amazon.
------
#### [ Linux or Unix ]
```
aws iot create-keys-and-certificate \
--certificate-pem-outfile "claim-certs/claim.pem.crt" \
--public-key-outfile "claim-certs/claim.public.pem.key" \
--private-key-outfile "claim-certs/claim.private.pem.key" \
--set-as-active
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws iot create-keys-and-certificate ^
--certificate-pem-outfile "claim-certs/claim.pem.crt" ^
--public-key-outfile "claim-certs/claim.public.pem.key" ^
--private-key-outfile "claim-certs/claim.private.pem.key" ^
--set-as-active
```
------
#### [ PowerShell ]
```
aws iot create-keys-and-certificate `
--certificate-pem-outfile "claim-certs/claim.pem.crt" `
--public-key-outfile "claim-certs/claim.public.pem.key" `
--private-key-outfile "claim-certs/claim.private.pem.key" `
--set-as-active
```
------
La respuesta contiene información sobre el certificado, si la solicitud se realiza correctamente. Guarde el ARN del certificado para usarlo más adelante.
1. Cree y adjunte una AWS IoT política que permita a los dispositivos usar el certificado para crear certificados de dispositivo únicos y aprovisionarlos con la plantilla de aprovisionamiento de flotas. La siguiente política permite acceder a la API MQTT de aprovisionamiento de dispositivos. Para obtener más información, consulte la [API MQTT de aprovisionamiento de dispositivos](https://docs.aws.amazon.com/iot/latest/developerguide/fleet-provision-api.html) en la *Guía para desarrolladores de AWS IoT Core *.
Haga lo siguiente:
1. Cree un archivo que contenga el documento AWS IoT de política que requieren los dispositivos principales de Greengrass.
Por ejemplo, en un sistema basado en Linux, puede ejecutar el siguiente comando para usar GNU nano a fin de crear el archivo.
```
nano greengrass-provisioning-claim-iot-policy.json
```
Copie el siguiente JSON en el archivo.
+ Sustituya cada instancia por la *region* instancia en la Región de AWS que configuró el aprovisionamiento de la flota.
+ Sustituya cada instancia de *account-id* por su Cuenta de AWS ID.
+ Sustituya cada instancia *GreengrassFleetProvisioningTemplate* de por el nombre de la plantilla de aprovisionamiento de flota que creó en la sección anterior.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iot:Connect",
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"iot:Publish",
"iot:Receive"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/$aws/certificates/create/*",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/provisioning-templates/GreengrassFleetProvisioningTemplate/provision/*"
]
},
{
"Effect": "Allow",
"Action": "iot:Subscribe",
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/certificates/create/*",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/provisioning-templates/GreengrassFleetProvisioningTemplate/provision/*"
]
}
]
}
```
------
1. Cree una AWS IoT política a partir del documento de política.
+ *GreengrassProvisioningClaimPolicy*Sustitúyala por el nombre de la política que se va a crear.
```
aws iot create-policy --policy-name GreengrassProvisioningClaimPolicy --policy-document file://greengrass-provisioning-claim-iot-policy.json
```
Si la solicitud se realiza exitosamente, la respuesta se parece al siguiente ejemplo.
------
#### [ JSON ]
****
```
{
"policyName": "GreengrassProvisioningClaimPolicy",
"policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GreengrassProvisioningClaimPolicy",
"policyDocument": "{
\"Version\": \"2012-10-17\",
\"Statement\": [
{
\"Effect\": \"Allow\",
\"Action\": \"iot:Connect\",
\"Resource\": \"*\"
},
{
\"Effect\": \"Allow\",
\"Action\": [
\"iot:Publish\",
\"iot:Receive\"
],
\"Resource\": [
\"arn:aws:iot:us-east-1:123456789012:topic/$aws/certificates/create/*\",
\"arn:aws:iot:us-east-1:123456789012:topic/$aws/provisioning-templates/GreengrassFleetProvisioningTemplate/provision/*\"
]
},
{
\"Effect\": \"Allow\",
\"Action\": \"iot:Subscribe\",
\"Resource\": [
\"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/certificates/create/*\",
\"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/provisioning-templates/GreengrassFleetProvisioningTemplate/provision/*\"
]
}
]
}",
"policyVersionId": "1"
}
```
------
1. Adjunte la AWS IoT política al certificado de notificación de aprovisionamiento.
+ *GreengrassProvisioningClaimPolicy*Sustitúyala por el nombre de la política que se va a adjuntar.
+ Sustituya el ARN de destino por el ARN del certificado de reclamación de aprovisionamiento.
```
aws iot attach-policy --policy-name GreengrassProvisioningClaimPolicy --target arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
```
El comando no tiene ningún resultado si la solicitud se realiza correctamente.
Ahora tiene un certificado de notificación de aprovisionamiento y una clave privada que los dispositivos pueden usar para registrarse AWS IoT y aprovisionarse como dispositivos principales de Greengrass. Puede incrustar el certificado de reclamación y la clave privada en los dispositivos durante la fabricación, o bien copiar el certificado y la clave en los dispositivos antes de instalar el software AWS IoT Greengrass Core. Para obtener más información, consulte [Instale el software AWS IoT Greengrass principal con aprovisionamiento AWS IoT de flota](fleet-provisioning.md).
# Configurar el complemento de aprovisionamiento de AWS IoT flotas
El complemento de aprovisionamiento de AWS IoT flotas proporciona los siguientes parámetros de configuración que puede personalizar al [instalar el software AWS IoT Greengrass Core con el](fleet-provisioning.md) aprovisionamiento de flotas.
`rootPath`
La ruta a la carpeta que se va a utilizar como raíz del software AWS IoT Greengrass principal.
`awsRegion`
La Región de AWS que utiliza el complemento de aprovisionamiento de flotas para aprovisionar AWS recursos.
`iotDataEndpoint`
El punto final AWS IoT de datos para su. Cuenta de AWS
`iotCredentialEndpoint`
El punto final de AWS IoT credenciales para su Cuenta de AWS.
`iotRoleAlias`
El alias del AWS IoT rol que apunta a un rol de IAM de intercambio de fichas. El proveedor de AWS IoT credenciales asume esta función para permitir que el dispositivo principal de Greengrass interactúe con AWS los servicios. Para obtener más información, consulte [Autorizar a los dispositivos principales a interactuar con AWS los servicios](device-service-role.md).
`provisioningTemplate`
La plantilla de aprovisionamiento de AWS IoT flota que se utilizará para AWS aprovisionar recursos. Esta plantilla debe especificar lo siguiente:
+ Cualquier AWS IoT cosa: un recurso. Puede especificar una lista de grupos de objetos existentes para implementar componentes en cada dispositivo cuando esté en línea.
+ Un recurso AWS IoT político. Este recurso puede definir al menos una de las siguientes propiedades:
+ El nombre de una AWS IoT política existente. Si elige esta opción, los dispositivos principales que cree a partir de esta plantilla utilizarán la misma AWS IoT política y podrá gestionar sus permisos como una flota.
+ Un documento AWS IoT de política. Si elige esta opción, cada dispositivo principal que cree a partir de esta plantilla utilizará una AWS IoT política única y podrá administrar los permisos de cada dispositivo principal individual.
+ Un recurso AWS IoT de certificados. Este recurso de certificado debe usar el parámetro `AWS::IoT::Certificate::Id` para adjuntar el certificado al dispositivo principal. Para obtener más información, consulte el [Just-in-time aprovisionamiento](https://docs.aws.amazon.com/iot/latest/developerguide/jit-provisioning.html) en la *Guía para AWS IoT desarrolladores*.
Para más información, consulte [Plantillas de aprovisionamiento](https://docs.aws.amazon.com/iot/latest/developerguide/provision-template.html) en la *Guía para desarrolladores de AWS IoT Core *.
`claimCertificatePath`
La ruta al certificado de reclamación de aprovisionamiento de la plantilla de aprovisionamiento que especifica en `provisioningTemplate`. Para obtener más información, consulta [CreateProvisioningClaim](https://docs.aws.amazon.com/iot/latest/apireference/API_CreateProvisioningClaim.html) en la *AWS IoT Core Referencia de la API de *.
`claimCertificatePrivateKeyPath`
La ruta a la clave privada del certificado de reclamación de aprovisionamiento de la plantilla de aprovisionamiento que especifica en `provisioningTemplate`. Para obtener más información, consulta [CreateProvisioningClaim](https://docs.aws.amazon.com/iot/latest/apireference/API_CreateProvisioningClaim.html) en la *AWS IoT Core Referencia de la API de *.
Las claves privadas de la notificación de aprovisionamiento deben estar protegidas en todo momento, también en el dispositivo principal de Greengrass. Te recomendamos que utilices CloudWatch las estadísticas y los registros de Amazon para detectar indicios de uso indebido, como el uso no autorizado del certificado de reclamación para aprovisionar dispositivos. Si detecta un uso incorrecto, deshabilite el certificado de notificación de aprovisionamiento para que no se pueda utilizar para el aprovisionamiento de dispositivos. Para obtener más información, consulte [Monitorear AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/monitoring_overview.html) en la *Guía para desarrolladores de AWS IoT Core *.
Para ayudarte a gestionar mejor el número de dispositivos y los dispositivos que se registran automáticamente en el tuyo Cuenta de AWS, puedes especificar un enlace previo al aprovisionamiento al crear una plantilla de aprovisionamiento de flotas. Un enlace de preaprovisionamiento es una AWS Lambda función que valida los parámetros de plantilla que proporcionan los dispositivos durante el registro. Por ejemplo, puede crear un enlace previo al aprovisionamiento que compruebe un ID de un dispositivo con una base de datos para comprobar que el dispositivo tiene permiso de aprovisionamiento. Para obtener más información, consulte los [enlaces previos al aprovisionamiento](https://docs.aws.amazon.com/iot/latest/developerguide/pre-provisioning-hook.html) en la *Guía para desarrolladores de AWS IoT Core *.
`rootCaPath`
La ruta al certificado de la autoridad de certificación (CA) raíz de Amazon.
`templateParameters`
(Opcional) El mapa de parámetros que se debe proporcionar a la plantilla de aprovisionamiento de la flota. Para obtener más información, consulte [la sección de parámetros de las plantillas de aprovisionamiento](https://docs.aws.amazon.com/iot/latest/developerguide/provision-template.html#parameters-section) en la *Guía para desarrolladores de AWS IoT Core *.
`deviceId`
(Opcional) El identificador del dispositivo que se utilizará como ID de cliente cuando el complemento de aprovisionamiento de flotas cree una conexión MQTT a AWS IoT.
Predeterminado: un UUID con asignación al azar.
`mqttPort`
(Opcional) El puerto que se utilizará para las conexiones MQTT.
Valor predeterminado: `8883`
`proxyUrl`
(Opcional) La dirección URL del servidor proxy, en el formato `scheme://userinfo@host:port`. Para utilizar un proxy HTTPS, debe utilizar la versión 1.1.0 o posterior del complemento de aprovisionamiento de flotas.
+ `scheme`: el esquema, que debe ser `http` o `https`.
**importante**
Los dispositivos principales de Greengrass deben ejecutar la versión 2.5.0 o versiones posteriores del [núcleo de Greengrass ](greengrass-nucleus-component.md) para usar proxies HTTPS.
Si configura un proxy HTTPS, debe agregar el certificado de la CA del servidor proxy al certificado de la CA raíz de Amazon del dispositivo principal. Para obtener más información, consulte [Permita que el dispositivo principal confíe en un proxy HTTPS](configure-greengrass-core-v2.md#https-proxy-certificate-trust).
+ `userinfo`: (opcional) la información de nombre de usuario y contraseña. Si especifica esta información en `url`, el dispositivo principal de Greengrass ignora los campos `username` y `password`.
+ `host`: el nombre de host o dirección IP del servidor proxy.
+ `port`: (opcional) el número de puerto. Si no especifica el puerto, el dispositivo principal de Greengrass usará los siguientes valores predeterminados:
+ `http`: 80
+ `https`: 443
`proxyUserName`
(Opcional) El nombre de usuario que autentica el servidor proxy.
`proxyPassword`
(Opcional) El nombre de usuario que autentica el servidor proxy.
csrPath
(Opcional) La ruta al archivo de solicitud de firma de certificado (CSR) que se utilizará para crear el certificado del dispositivo a partir de una CSR. Para obtener más información, consulte [Aprovisionamiento por reclamación](https://docs.aws.amazon.com/iot/latest/developerguide/provision-wo-cert.html#claim-based) en la *Guía para desarrolladores de AWS IoT Core *.
csrPrivateKeyRuta
(Opcional, obligatorio si se declara `csrPath`) La ruta a la clave privada utilizada para generar la CSR. La clave privada debe haberse utilizado para generar la CSR. Para obtener más información, consulte [Aprovisionamiento por reclamación](https://docs.aws.amazon.com/iot/latest/developerguide/provision-wo-cert.html#claim-based) en la *Guía para desarrolladores de AWS IoT Core *.
certificatePath
(Opcional) Ruta que se utilizará para guardar el certificado del dispositivo descargado.
privateKeyPath
(Opcional) Ruta que se utilizará para guardar la clave privada del dispositivo descargado.
# Registro de cambios del complemento de aprovisionamiento de flotas AWS IoT
En la tabla a continuación, se describen los cambios de cada versión del aprovisionamiento de flotas AWS IoT por complemento de reclamación (`aws.greengrass.FleetProvisioningByClaim`).
| Versión | Cambios |
| --- | --- |
| 1.2.2 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/greengrass/v2/developerguide/fleet-provisioning-changelog.html) |
| 1.2.1 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/greengrass/v2/developerguide/fleet-provisioning-changelog.html) |
| 1.2.0 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/greengrass/v2/developerguide/fleet-provisioning-changelog.html) |
| 1.1.0 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/greengrass/v2/developerguide/fleet-provisioning-changelog.html) |
| 1.0.0 | Versión inicial. |
# Instale el software AWS IoT Greengrass principal con aprovisionamiento de recursos personalizado
Esta característica está disponible para la versión 2.4.0 y versiones posteriores del [componente núcleo de Greengrass](greengrass-nucleus-component.md).
El instalador de software AWS IoT Greengrass Core proporciona una interfaz Java que puede implementar en un complemento personalizado que aprovisione AWS los recursos necesarios. Puede desarrollar un complemento de aprovisionamiento para usar certificados de cliente X.509 personalizados o ejecutar pasos de aprovisionamiento complejos que otros procesos de instalación no admiten. Para obtener más información, consulte [Crear sus propios certificados de cliente](https://docs.aws.amazon.com/iot/latest/developerguide/device-certs-your-own.html) en la *Guía para desarrolladores de AWS IoT Core *.
Para ejecutar un complemento de aprovisionamiento personalizado al instalar el software AWS IoT Greengrass Core, debe crear un archivo JAR que se proporciona al instalador. El instalador ejecuta el complemento y el complemento devuelve una configuración de aprovisionamiento que define los AWS recursos del dispositivo principal de Greengrass. El instalador usa esta información para configurar el software AWS IoT Greengrass principal en el dispositivo. Para obtener más información, consulte [Desarrollo de complementos de aprovisionamiento personalizados](develop-custom-provisioning-plugins.md).
**importante**
Antes de descargar el software AWS IoT Greengrass Core, compruebe que su dispositivo principal cumpla los [requisitos](greengrass-nucleus-component.md#greengrass-v2-requirements) para instalar y ejecutar el software AWS IoT Greengrass Core v2.0.
**Topics**
+ [Requisitos previos](#custom-provisioning-prerequisites)
+ [Configuración del entorno del dispositivo](#set-up-device-environment)
+ [Descargue el software AWS IoT Greengrass principal](#download-greengrass-core-v2)
+ [Instale el software principal AWS IoT Greengrass](#run-greengrass-core-v2-installer-custom)
+ [Desarrollo de complementos de aprovisionamiento personalizados](develop-custom-provisioning-plugins.md)
## Requisitos previos
Para instalar el software AWS IoT Greengrass Core con aprovisionamiento personalizado, debe disponer de lo siguiente:
+ Un archivo JAR para un complemento de aprovisionamiento personalizado que implementa la `DeviceIdentityInterface`. El complemento de aprovisionamiento personalizado debe devolver valores para cada parámetro de configuración del núcleo y del sistema. De lo contrario, debe proporcionar esos valores en el archivo de configuración durante la instalación. Para obtener más información, consulte [Desarrollo de complementos de aprovisionamiento personalizados](develop-custom-provisioning-plugins.md).
## Configuración del entorno del dispositivo
Siga los pasos de esta sección para configurar un dispositivo Linux o Windows para usarlo como su dispositivo principal de AWS IoT Greengrass .
### Configuración de un dispositivo Linux
**Para configurar un dispositivo Linux para AWS IoT Greengrass V2**
1. Instale el motor de ejecución de Java, que el software AWS IoT Greengrass principal necesita para ejecutarse. Le recomendamos que utilice las versiones de compatibilidad a largo plazo de [Amazon Corretto](https://aws.amazon.com/corretto/) u [OpenJDK](https://openjdk.java.net/). Se requiere la versión 8 o posterior. Los siguientes comandos muestran cómo instalar OpenJDK en su dispositivo.
+ Para distribuciones basadas en Debian o en Ubuntu:
```
sudo apt install default-jdk
```
+ Para distribuciones basadas en Red Hat:
```
sudo yum install java-11-openjdk-devel
```
+ En Amazon Linux 2:
```
sudo amazon-linux-extras install java-openjdk11
```
+ En Amazon Linux 2023:
```
sudo dnf install java-11-amazon-corretto -y
```
Cuando se complete la instalación, ejecute el siguiente comando para comprobar que Java se ejecuta en su dispositivo Linux.
```
java -version
```
El comando imprime la versión de Java que se ejecuta en el dispositivo. Por ejemplo, en una distribución basada en Debian, el resultado podría ser similar al siguiente ejemplo.
```
openjdk version "11.0.9.1" 2020-11-04
OpenJDK Runtime Environment (build 11.0.9.1+1-post-Debian-1deb10u2)
OpenJDK 64-Bit Server VM (build 11.0.9.1+1-post-Debian-1deb10u2, mixed mode)
```
1. (Opcional) Cree el usuario y el grupo predeterminado del sistema que ejecutan los componentes del dispositivo. También puede optar por permitir que el instalador del software AWS IoT Greengrass principal cree este usuario y grupo durante la instalación con el argumento del `--component-default-user` instalador. Para obtener más información, consulte [Argumentos del instalador](configure-installer.md).
```
sudo useradd --system --create-home ggc_user
sudo groupadd --system ggc_group
```
1. Compruebe que el usuario que ejecuta el software AWS IoT Greengrass principal (normalmente`root`) tiene permiso para ejecutar `sudo` con cualquier usuario y grupo.
1. Ejecute el siguiente comando para abrir el archivo `/etc/sudoers`.
```
sudo visudo
```
1. Compruebe que el permiso del usuario se parezca al siguiente ejemplo.
```
root ALL=(ALL:ALL) ALL
```
1. (Opcional) Para [ejecutar funciones de Lambda en contenedores](run-lambda-functions.md), debe habilitar la versión 1 de [cgroups](https://en.wikipedia.org/wiki/Cgroups), y habilitar y montar los cgroups de *memoria* y de *dispositivos*. Si no tiene previsto ejecutar funciones de Lambda en contenedores, puede omitir este paso.
Para habilitar estas opciones de cgroups, arranque el dispositivo con los siguientes parámetros del kernel de Linux.
```
cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0
```
Para obtener más información acerca de cómo ver y configurar los parámetros del kernel de su dispositivo, consulte la documentación del sistema operativo y del gestor de arranque. Siga las instrucciones para configurar permanentemente los parámetros del kernel.
1. Instale todas las demás dependencias necesarias en su dispositivo tal y como se indica en la lista de requisitos de [Requisitos de los dispositivos](greengrass-nucleus-component.md#greengrass-v2-requirements).
### Configuración de un dispositivo de Windows
**nota**
Esta característica está disponible para la versión 2.5.0 y versiones posteriores del [componente núcleo de Greengrass](greengrass-nucleus-component.md).
**Para configurar un dispositivo Windows para AWS IoT Greengrass V2**
1. Instale el motor de ejecución de Java, que el software AWS IoT Greengrass principal necesita para ejecutarse. Le recomendamos que utilice las versiones de compatibilidad a largo plazo de [Amazon Corretto](https://aws.amazon.com/corretto/) u [OpenJDK](https://openjdk.java.net/). Se requiere la versión 8 o posterior.
1. Compruebe si Java está disponible en la variable del sistema [PATH](https://en.wikipedia.org/wiki/PATH_(variable)) y agréguelo si no lo está. La LocalSystem cuenta ejecuta el software AWS IoT Greengrass principal, por lo que debe agregar Java a la variable de sistema PATH en lugar de a la variable de usuario PATH de su usuario. Haga lo siguiente:
1. Pulse la tecla Windows para abrir el menú de inicio.
1. Escriba **environment variables** para buscar las opciones del sistema en el menú de inicio.
1. En los resultados de la búsqueda del menú de inicio, elija **Editar las variables de entorno del sistema** para abrir la ventana de **Propiedades del sistema**.
1. Elija **Variables de entorno...** para abrir la ventana **Variables de entorno**.
1. En **Variables del sistema**, elija **Ruta** y, luego, **Editar**. En la ventana **Editar variables de entorno**, puede ver cada ruta en una línea independiente.
1. Compruebe si la ruta a la carpeta de la instalación de Java `bin` está presente. La ruta puede tener un aspecto similar al siguiente ejemplo.
```
C:\\Program Files\\Amazon Corretto\\jdk11.0.13_8\\bin
```
1. Si la carpeta de la instalación de Java `bin` no aparece en **Ruta**, elija **Nueva** para agregarla y, a continuación, pulse **Aceptar**.
1. Abra el símbolo del sistema de Windows (`cmd.exe`) como administrador.
1. Cree el usuario predeterminado en la LocalSystem cuenta del dispositivo Windows. *password*Sustitúyalo por una contraseña segura.
```
net user /add ggc_user password
```
**sugerencia**
Según su configuración de Windows, es posible que la contraseña del usuario caduque en una fecha futura. Para garantizar que sus aplicaciones de Greengrass sigan funcionando, controle cuándo caduca la contraseña y actualícela antes de que caduque. También puede configurar la contraseña del usuario para que nunca caduque.
Para comprobar cuándo caducan un usuario y su contraseña, ejecute el siguiente comando.
```
net user ggc_user | findstr /C:expires
```
Para configurar la contraseña de un usuario para que no caduque nunca, ejecute el siguiente comando.
```
wmic UserAccount where "Name='ggc_user'" set PasswordExpires=False
```
Si utilizas Windows 10 o una versión posterior, donde el [`wmic`comando está en desuso](https://learn.microsoft.com/en-us/windows/win32/wmisdk/wmic), ejecuta el siguiente PowerShell comando.
```
Get-CimInstance -Query "SELECT * from Win32_UserAccount WHERE name = 'ggc_user'" | Set-CimInstance -Property @{PasswordExpires="False"}
```
1. Descargue e instale la [PsExecutilidad](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec) de Microsoft en el dispositivo.
1. Utilice la PsExec utilidad para almacenar el nombre de usuario y la contraseña del usuario predeterminado en la instancia de Credential Manager de la LocalSystem cuenta. *password*Sustitúyala por la contraseña de usuario que configuraste anteriormente.
```
psexec -s cmd /c cmdkey /generic:ggc_user /user:ggc_user /pass:password
```
Si **PsExec License Agreement** se abre, elija **Accept** para aceptar la licencia y ejecute el comando.
**nota**
En los dispositivos Windows, la LocalSystem cuenta ejecuta el núcleo de Greengrass y debe usar la PsExec utilidad para almacenar la información de usuario predeterminada en la LocalSystem cuenta. El uso de la aplicación Credential Manager almacena esta información en la cuenta de Windows del usuario que ha iniciado sesión actualmente, en lugar de en la LocalSystem cuenta.
## Descargue el software AWS IoT Greengrass principal
Puede descargar la última versión del software AWS IoT Greengrass Core desde la siguiente ubicación:
+ [https://d2s8p88vqu9w66.cloudfront. net/releases/greengrass](https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip)-nucleus-latest.zip
**nota**
Puede descargar una versión específica del software AWS IoT Greengrass Core desde la siguiente ubicación. *version*Sustitúyala por la versión que se va a descargar.
```
https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-version.zip
```
**Para descargar el software AWS IoT Greengrass principal**
1. En su dispositivo principal, descargue el software AWS IoT Greengrass Core en un archivo denominado`greengrass-nucleus-latest.zip`.
------
#### [ Linux or Unix ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
iwr -Uri https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip -OutFile greengrass-nucleus-latest.zip
```
------
Al descargar este software, acepta el [acuerdo de licencia del software de Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf).
1. (Opcional) Verificación de la firma del software del núcleo de Greengrass
**nota**
Esta característica está disponible en la versión 2.9.5 y versiones posteriores del núcleo de Greengrass.
1. Use el siguiente comando para verificar la firma del artefacto del núcleo de Greengrass:
------
#### [ Linux or Unix ]
```
jarsigner -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
El nombre del archivo puede tener un aspecto diferente según la versión de JDK que instale. Reemplace *`jdk17.0.6_10`* por la versión de JDK que instaló.
```
"C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe" -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
El nombre del archivo puede tener un aspecto diferente según la versión de JDK que instale. Reemplace *`jdk17.0.6_10`* por la versión de JDK que instaló.
```
'C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe' -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
1. La invocación `jarsigner` produce un resultado que indica los resultados de la verificación.
1. Si el archivo zip del núcleo de Greengrass está firmado, el resultado contiene la siguiente declaración:
```
jar verified.
```
1. Si el archivo zip del núcleo de Greengrass no está firmado, el resultado contiene la siguiente declaración:
```
jar is unsigned.
```
1. Si ha proporcionado la opción `-certs` Jarsigner junto con las opciones `-verify` y `-verbose`, el resultado también incluye información detallada del certificado de firmante.
1. Descomprime el software AWS IoT Greengrass Core en una carpeta de tu dispositivo. *GreengrassInstaller*Sustitúyalo por la carpeta que desee usar.
------
#### [ Linux or Unix ]
```
unzip greengrass-nucleus-latest.zip -d GreengrassInstaller && rm greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir GreengrassInstaller && tar -xf greengrass-nucleus-latest.zip -C GreengrassInstaller && del greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
Expand-Archive -Path greengrass-nucleus-latest.zip -DestinationPath .\\GreengrassInstaller
rm greengrass-nucleus-latest.zip
```
------
1. (Opcional) Ejecute el siguiente comando para ver la versión del software AWS IoT Greengrass principal.
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
**importante**
Si instala una versión del núcleo de Greengrass anterior a la v2.4.0, no elimine esta carpeta después de instalar el software Core. AWS IoT Greengrass El software AWS IoT Greengrass Core utiliza los archivos de esta carpeta para ejecutarse.
Si descargó la última versión del software, instale la versión 2.4.0 o posterior y podrá eliminar esta carpeta después de instalar el software AWS IoT Greengrass principal.
## Instale el software principal AWS IoT Greengrass
Ejecute el instalador con argumentos que especifiquen las siguientes acciones:
+ Instálelo desde un archivo de configuración parcial que especifique el uso de su complemento de aprovisionamiento personalizado para aprovisionar AWS recursos. El software AWS IoT Greengrass Core utiliza un archivo de configuración que especifica la configuración de todos los componentes de Greengrass del dispositivo. El instalador crea un archivo de configuración completo a partir del archivo de configuración parcial que usted proporciona y de los AWS recursos que crea el complemento de aprovisionamiento personalizado.
+ Especifique si desea usar el usuario del sistema `ggc_user` para ejecutar los componentes de software en el dispositivo principal. En los dispositivos Linux, este comando también especifica el uso del grupo del sistema `ggc_group` y el instalador crea el usuario y el grupo del sistema por usted.
+ Configure el software AWS IoT Greengrass principal como un servicio del sistema que se ejecute durante el arranque. En los dispositivos Linux, esto requiere el sistema de inicio [Systemd](https://en.wikipedia.org/wiki/Systemd).
**importante**
En los dispositivos principales de Windows, debe configurar el software AWS IoT Greengrass principal como un servicio del sistema.
Para obtener más información acerca de los argumentos que puede especificar, consulte [Argumentos del instalador](configure-installer.md).
**nota**
Si utilizas un AWS IoT Greengrass dispositivo con memoria limitada, puedes controlar la cantidad de memoria que utiliza el software AWS IoT Greengrass Core. Para controlar la asignación de memoria, puede configurar las opciones de tamaño de montón de la JVM en el parámetro de configuración `jvmOptions` del componente núcleo. Para obtener más información, consulte [Control de la asignación de memoria con las opciones de JVM](configure-greengrass-core-v2.md#jvm-tuning).
**Para instalar el software AWS IoT Greengrass Core (Linux)**
1. Compruebe la versión del software AWS IoT Greengrass principal.
+ *GreengrassInstaller*Sustitúyala por la ruta a la carpeta que contiene el software.
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
1. Use un editor de texto para crear un archivo de configuración llamado `config.yaml` para proporcionárselo al instalador.
Por ejemplo, en un sistema basado en Linux, puede ejecutar el siguiente comando para usar GNU nano a fin de crear el archivo.
```
nano GreengrassInstaller/config.yaml
```
Copie el siguiente contenido YAML en el archivo.
```
---
system:
rootpath: "/greengrass/v2"
# The following values are optional. Return them from the provisioning plugin or set them here.
# certificateFilePath: ""
# privateKeyPath: ""
# rootCaPath: ""
# thingName: ""
services:
aws.greengrass.Nucleus:
version: "2.16.1"
configuration:
# The following values are optional. Return them from the provisioning plugin or set them here.
# awsRegion: ""
# iotRoleAlias: ""
# iotDataEndpoint: ""
# iotCredEndpoint: ""
com.example.CustomProvisioning:
configuration:
# You can specify configuration parameters to provide to your plugin.
# pluginParameter: ""
```
A continuación, proceda del modo siguiente:
+ *2.16.1*Sustitúyala por la versión del software AWS IoT Greengrass principal.
+ Reemplace cada instancia de `/greengrass/v2` por la carpeta raíz de Greengrass.
+ (Opcional) Especifique los valores de configuración del sistema y del núcleo. Debe establecer estos valores si su complemento de aprovisionamiento no los proporciona.
+ (Opcional) Especifique los parámetros de configuración para proporcionarlos a su complemento de aprovisionamiento.
**nota**
En este archivo de configuración, puede personalizar otras opciones de configuración, como los puertos y el proxy de red que use, tal como se muestra en el siguiente ejemplo. Para obtener más información, consulte la [Configuración del núcleo de Greengrass](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration).
```
---
system:
rootpath: "/greengrass/v2"
# The following values are optional. Return them from the provisioning plugin or set them here.
# certificateFilePath: ""
# privateKeyPath: ""
# rootCaPath: ""
# thingName: ""
services:
aws.greengrass.Nucleus:
version: "2.16.1"
configuration:
mqtt:
port: 443
greengrassDataPlanePort: 443
networkProxy:
noProxyAddresses: "http://192.168.0.1,www.example.com"
proxy:
url: "http://my-proxy-server:1100"
username: "Mary_Major"
password: "pass@word1357"
# The following values are optional. Return them from the provisioning plugin or set them here.
# awsRegion: ""
# iotRoleAlias: ""
# iotDataEndpoint: ""
# iotCredEndpoint: ""
com.example.CustomProvisioning:
configuration:
# You can specify configuration parameters to provide to your plugin.
# pluginParameter: ""
```
1. Ejecute el instalador. Especifique `--trusted-plugin` para proporcionar su complemento de aprovisionamiento personalizado y especifique `--init-config` para proporcionar el archivo de configuración.
**nota**
Windows tiene una limitación de longitud de ruta de 260 caracteres. Si usa Windows, use una carpeta raíz como `C:\greengrass\v2` o `D:\greengrass\v2` para mantener las rutas de los componentes de Greengrass por debajo del límite de 260 caracteres.
+ Sustituya `/greengrass/v2` o *C:\$1greengrass\$1v2* por la carpeta raíz de Greengrass.
+ Sustituya cada instancia de por *GreengrassInstaller* la carpeta en la que desempaquetó el instalador.
+ Reemplace la ruta al archivo JAR del complemento de aprovisionamiento personalizado por la ruta al archivo JAR del complemento.
------
#### [ Linux or Unix ]
```
sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
-jar ./GreengrassInstaller/lib/Greengrass.jar \
--trusted-plugin /path/to/com.example.CustomProvisioning.jar \
--init-config ./GreengrassInstaller/config.yaml \
--component-default-user ggc_user:ggc_group \
--setup-system-service true
```
------
#### [ Windows Command Prompt (CMD) ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" ^
-jar ./GreengrassInstaller/lib/Greengrass.jar ^
--trusted-plugin /path/to/com.example.CustomProvisioning.jar ^
--init-config ./GreengrassInstaller/config.yaml ^
--component-default-user ggc_user ^
--setup-system-service true
```
------
#### [ PowerShell ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" `
-jar ./GreengrassInstaller/lib/Greengrass.jar `
--trusted-plugin /path/to/com.example.CustomProvisioning.jar `
--init-config ./GreengrassInstaller/config.yaml `
--component-default-user ggc_user `
--setup-system-service true
```
------
**importante**
En los dispositivos principales de Windows, debe especificar si `--setup-system-service true` desea configurar el software AWS IoT Greengrass principal como un servicio del sistema.
Si especifica `--setup-system-service true`, el instalador imprime `Successfully set up Nucleus as a system service` si configuró y ejecutó el software como un servicio del sistema. De lo contrario, el instalador no mostrará ningún mensaje si instala el software correctamente.
**nota**
No puede usar el argumento `deploy-dev-tools` para implementar herramientas de desarrollo locales cuando ejecuta el instalador sin el argumento `--provision true`. Para obtener información sobre cómo implementar la CLI de Greengrass directamente en su dispositivo, consulte [Interfaz de la línea de comandos de Greengrass](gg-cli.md).
1. Verifique la instalación mediante la consulta de los archivos de la carpeta raíz.
------
#### [ Linux or Unix ]
```
ls /greengrass/v2
```
------
#### [ Windows Command Prompt (CMD) ]
```
dir C:\greengrass\v2
```
------
#### [ PowerShell ]
```
ls C:\greengrass\v2
```
------
Si la instalación se realizó correctamente, la carpeta raíz contiene varias carpetas, como `config`, `packages` y `logs`.
Si instaló el software AWS IoT Greengrass Core como un servicio del sistema, el instalador ejecutará el software automáticamente. De no ser así, debe ejecutar el software manualmente. Para obtener más información, consulte [Ejecute el software AWS IoT Greengrass principal](run-greengrass-core-v2.md).
Para obtener más información sobre cómo configurar y utilizar el software AWS IoT Greengrass, consulte lo siguiente:
+ [Configurar el software AWS IoT Greengrass principal](configure-greengrass-core-v2.md)
+ [Desarrollo de componentes de AWS IoT Greengrass](develop-greengrass-components.md)
+ [Implemente AWS IoT Greengrass componentes en los dispositivos](manage-deployments.md)
+ [Interfaz de la línea de comandos de Greengrass](gg-cli.md)
# Desarrollo de complementos de aprovisionamiento personalizados
Para desarrollar un complemento de aprovisionamiento personalizado, cree una clase Java que implemente la interfaz `com.aws.greengrass.provisioning.DeviceIdentityInterface`. Puede incluir el archivo JAR del núcleo de Greengrass en su proyecto para acceder a esta interfaz y a sus clases. Esta interfaz define un método que introduce una configuración de complemento y genera una configuración de aprovisionamiento. La configuración de aprovisionamiento define las configuraciones para el sistema y el [componente núcleo de Greengrass](greengrass-nucleus-component.md). El instalador del software AWS IoT Greengrass principal utiliza esta configuración de aprovisionamiento para configurar el software AWS IoT Greengrass principal en un dispositivo.
Después de desarrollar un complemento de aprovisionamiento personalizado, créelo como un archivo JAR que puede proporcionar al instalador del software AWS IoT Greengrass principal para que ejecute el complemento durante la instalación. El instalador ejecuta el complemento de aprovisionamiento personalizado en la misma JVM que utiliza el instalador, por lo que puede crear un JAR que contenga únicamente el código del complemento.
**nota**
El [complemento de aprovisionamiento de flota de AWS IoT](fleet-provisioning.md) implementa `DeviceIdentityInterface` para utilizar el aprovisionamiento de flota durante la instalación. El complemento de aprovisionamiento de flota es de código abierto, por lo que puede explorar su código de origen para ver un ejemplo de cómo utilizar la interfaz del complemento de aprovisionamiento. Para obtener más información, consulte el [complemento de aprovisionamiento de AWS IoT flotas](https://github.com/aws-greengrass/aws-greengrass-fleet-provisioning-by-claim) en. GitHub
**Topics**
+ [Requisitos](#custom-provisioning-plugin-requirements)
+ [Implemente la interfaz DeviceIdentityInterface](#implement-device-identity-interface)
## Requisitos
Para desarrollar un complemento de aprovisionamiento personalizado, debe crear una clase Java que cumpla con los siguientes requisitos:
+ Usa el paquete `com.aws.greengrass` o un paquete dentro del paquete `com.aws.greengrass`.
+ Tiene un constructor sin argumentos.
+ Implementa la interfaz `DeviceIdentityInterface`. Para obtener más información, consulte [Implemente la interfaz DeviceIdentityInterface](#implement-device-identity-interface).
## Implemente la interfaz DeviceIdentityInterface
Para utilizar la interfaz `com.aws.greengrass.provisioning.DeviceIdentityInterface` en su complemento personalizado, agregue el núcleo de Greengrass como una dependencia a su proyecto.
**Para utilizarla DeviceIdentityInterface en un proyecto de complemento de aprovisionamiento personalizado**
+ Puede agregar el archivo JAR del núcleo de Greengrass como biblioteca o agregar el núcleo de Greengrass como una dependencia de Maven. Realice una de las siguientes acciones:
+ Para añadir el archivo JAR del núcleo de Greengrass como biblioteca, descargue el software AWS IoT Greengrass Core, que contiene el JAR del núcleo de Greengrass. Puede descargar la última versión del software AWS IoT Greengrass Core desde la siguiente ubicación:
+ [https://d2s8p88vqu9w66.cloudfront. net/releases/greengrass](https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip)-nucleus-latest.zip
Puede encontrar el archivo JAR del núcleo de Greengrass (`Greengrass.jar`) en la carpeta `lib` del archivo ZIP. Agregue este archivo JAR a su proyecto.
+ Para utilizar el núcleo de Greengrass en un proyecto de Maven, agregue una dependencia al artefacto `nucleus` del grupo `com.aws.greengrass`. También debe agregar el repositorio `greengrass-common`, ya que el núcleo de Greengrass no está disponible en el repositorio central de Maven.
```
...
greengrass-common
greengrass common
https://d2jrmugq4soldf.cloudfront.net/snapshots
...
com.aws.greengrass
nucleus
2.5.0-SNAPSHOT
provided
```
### La DeviceIdentityInterface interfaz
La interfaz `com.aws.greengrass.provisioning.DeviceIdentityInterface` tiene la siguiente forma.
**nota**
[También puede explorar estas clases en el [paquete com.aws.greengrass.provisioning del](https://github.com/aws-greengrass/aws-greengrass-nucleus/tree/main/src/main/java/com/aws/greengrass/provisioning) código fuente del núcleo de Greengrass en.](https://github.com/aws-greengrass/aws-greengrass-nucleus) GitHub
```
public interface com.aws.greengrass.provisioning.DeviceIdentityInterface {
ProvisionConfiguration updateIdentityConfiguration(ProvisionContext context)
throws RetryableProvisioningException, InterruptedException;
// Return the name of the plugin.
String name();
}
com.aws.greengrass.provisioning.ProvisionConfiguration {
SystemConfiguration systemConfiguration;
NucleusConfiguration nucleusConfiguration
}
com.aws.greengrass.provisioning.ProvisionConfiguration.SystemConfiguration {
String certificateFilePath;
String privateKeyPath;
String rootCAPath;
String thingName;
}
com.aws.greengrass.provisioning.ProvisionConfiguration.NucleusConfiguration {
String awsRegion;
String iotCredentialsEndpoint;
String iotDataEndpoint;
String iotRoleAlias;
}
com.aws.greengrass.provisioning.ProvisioningContext {
Map parameterMap;
String provisioningPolicy; // The policy is always "PROVISION_IF_NOT_PROVISIONED".
}
com.aws.greengrass.provisioning.exceptions.RetryableProvisioningException {}
```
Todos los valores de configuración de `SystemConfiguration` y `NucleusConfiguration` son necesarios para instalar el software Core, pero puede devolverlos AWS IoT Greengrass . `null` Si su complemento de aprovisionamiento personalizado devuelve `null` algún valor de configuración, debe proporcionar ese valor en la configuración del sistema o del núcleo al crear el `config.yaml` archivo que se va a proporcionar al instalador del software AWS IoT Greengrass Core. Si su complemento de aprovisionamiento personalizado devuelve un valor no nulo para una opción que también ha definido en `config.yaml`, el instalador sustituirá el valor en `config.yaml` por el valor devuelto por el complemento.
# Argumentos del instalador
El software AWS IoT Greengrass Core incluye un instalador que configura el software y proporciona los recursos de AWS necesarios para que se ejecute el dispositivo principal de Greengrass. El instalador incluye los siguientes argumentos que puede especificar para configurar la instalación:
`-h`, `--help`
(Opcional) Muestra la información de ayuda del instalador.
`--version`
(Opcional) Muestra la versión del software AWS IoT Greengrass Core.
`-Droot`
(Opcional) La ruta a la carpeta que se va a usar como la raíz del software AWS IoT Greengrass Core.
Este argumento establece una propiedad de JVM, por lo que debe especificarla antes de `-jar` cuando ejecute el instalador. Por ejemplo, especifique `java -Droot="/greengrass/v2" -jar /path/to/Greengrass.jar`.
Predeterminado:
+ Linux: `~/.greengrass`
+ Windows: : `%USERPROFILE%/.greengrass`
`-ar`, `--aws-region`
La Región de AWS que el software AWS IoT Greengrass Core usa para recuperar o crear los recursos de AWS necesarios.
`-p`, `--provision`
(Opcional) Puede registrar este dispositivo como un objeto AWS IoT y aprovisionar los recursos de AWS que necesite el dispositivo principal. Si especifica `true`, el software AWS IoT Greengrass Core aprovisiona un objeto AWS IoT, (opcional) un grupo de objetos AWS IoT, un rol de IAM y un alias de rol AWS IoT.
Predeterminado: `false`
`-tn`, `--thing-name`
(Opcional) El nombre del objeto AWS IoT que registra como este dispositivo principal. Si el objeto con ese nombre no existe en su Cuenta de AWS, será creado por el software AWS IoT Greengrass Core.
El nombre del objeto no puede contener dos puntos (`:`).
Debe especificar `--provision true` si desea aplicar este argumento.
Valor predeterminado: `GreengrassV2IotThing_` más un UUID asignado al azar.
`-tgn`, `--thing-group-name`
(Opcional) El nombre del grupo de objetos AWS IoT al que se agrega el objeto AWS IoT de este dispositivo principal. Si una implementación se dirige a este grupo de objetos, este dispositivo principal recibe esa implementación cuando se conecta a AWS IoT Greengrass. Si el grupo de objetos con este nombre no existe en su Cuenta de AWS, el software AWS IoT Greengrass Core lo crea.
El nombre del grupo de objetos no puede contener dos puntos (`:`).
Debe especificar `--provision true` si desea aplicar este argumento.
`-tpn`, `--thing-policy-name`
Esta característica está disponible para la versión 2.4.0 y versiones posteriores del [componente núcleo de Greengrass](greengrass-nucleus-component.md).
(Opcional) El nombre de la política de AWS IoT que se debe adjuntar al certificado del objeto AWS IoT de este dispositivo principal. Si la política AWS IoT con este nombre no existe en su Cuenta de AWS, el software AWS IoT Greengrass Core la crea.
El software AWS IoT Greengrass Core crea una política de AWS IoT permisiva de forma predeterminada. Puede limitar el alcance de esta política o crear una política personalizada en la que restrinja los permisos según su caso de uso. Para obtener más información, consulte [AWS IoT Política mínima para los dispositivos AWS IoT Greengrass V2 principales](device-auth.md#greengrass-core-minimal-iot-policy).
Debe especificar `--provision true` si desea aplicar este argumento.
Valor predeterminado: `GreengrassV2IoTThingPolicy`
`-trn`, `--tes-role-name`
(Opcional) El nombre del rol de IAM que se va a usar para adquirir las credenciales de AWS que permiten al dispositivo principal interactuar con los servicios de AWS. Si el rol con este nombre no existe en su Cuenta de AWS, el software AWS IoT Greengrass Core lo crea con la política `GreengrassV2TokenExchangeRoleAccess`. Este rol no tiene acceso a los buckets de S3 donde aloja los artefactos de los componentes. Por lo tanto, debe agregar permisos a los buckets y objetos de S3 de sus artefactos al crear un componente. Para obtener más información, consulte [Autorizar a los dispositivos principales a interactuar con AWS los servicios](device-service-role.md).
Debe especificar `--provision true` si desea aplicar este argumento.
Valor predeterminado: `GreengrassV2TokenExchangeRole`
`-tra`, `--tes-role-alias-name`
(Opcional) El nombre del alias del rol AWS IoT que apunta al rol de IAM que proporciona las credenciales de AWS para este dispositivo principal. Si el alias del rol con este nombre no existe en su Cuenta de AWS, el software AWS IoT Greengrass Core lo crea y lo dirige al rol de IAM que especifique.
Debe especificar `--provision true` si desea aplicar este argumento.
Valor predeterminado: `GreengrassV2TokenExchangeRoleAlias`
`-ss`, `--setup-system-service`
(Opcional) Puede configurar el software AWS IoT Greengrass Core como un servicio del sistema que se ejecute cuando arranque el dispositivo. El nombre del servicio del sistema es `greengrass`. 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).
En los sistemas operativos Linux, este argumento requiere que el sistema de inicio systemd esté disponible en el dispositivo.
En los dispositivos principales de Windows, debe configurar el software AWS IoT Greengrass Core como un servicio del sistema.
Predeterminado: `false`
`-u`, `--component-default-user`
El nombre o ID del usuario que el software AWS IoT Greengrass Core usa para ejecutar los componentes. Por ejemplo, puede especificar **ggc\$1user**. Este valor es obligatorio cuando se ejecuta el instalador en sistemas operativos Windows.
En los sistemas operativos Linux, también puede especificar el grupo de forma opcional. Especifique el usuario y el grupo separados por dos puntos. Por ejemplo, **ggc\$1user:ggc\$1group**.
Las siguientes consideraciones adicionales se aplican a los sistemas operativos Linux:
+ Si se ejecuta como raíz, el usuario del componente predeterminado es el usuario definido en el archivo de configuración. Si el archivo de configuración no define un usuario, el valor predeterminado es `ggc_user:ggc_group`. Si no existen `ggc_user` o `ggc_group`, el software los crea.
+ Si se ejecuta como un usuario no raíz, el software AWS IoT Greengrass Core usa ese usuario para ejecutar los componentes.
+ Si no especifica un grupo, el software AWS IoT Greengrass Core usa el grupo principal del usuario del sistema.
Para obtener más información, consulte [Configuración del usuario que ejecuta los componentes](configure-greengrass-core-v2.md#configure-component-user).
`-d`, `--deploy-dev-tools`
(Opcional) Puede descargar e implementar el componente de la [CLI de Greengrass](greengrass-cli-component.md) en este dispositivo principal. Puede usar esta herramienta para desarrollar y depurar los componentes en este dispositivo principal.
Se recomienda usar este componente solo en entornos de desarrollo y no en entornos de producción. Este componente brinda acceso a información y operaciones que, por lo general, no necesitará en un entorno de producción. Siga el principio de privilegio mínimo al implementar este componente solo en los dispositivos principales donde lo necesite.
Debe especificar `--provision true` si desea aplicar este argumento.
Predeterminado: `false`
`-init`, `--init-config`
(Opcional) La ruta al archivo de configuración que se usa para instalar el software AWS IoT Greengrass Core. Puede usar esta opción para configurar nuevos dispositivos principales con una configuración de núcleo específica, por ejemplo.
El archivo de configuración que especifique se fusiona con el archivo de configuración existente en el dispositivo principal. Esto incluye los componentes y las configuraciones de los componentes del dispositivo principal. Se recomienda que el archivo de configuración solo muestre las configuraciones que está intentando cambiar.
`-tp`, `--trusted-plugin`
(Opcional) La ruta a un archivo JAR para cargarlo como un complemento de confianza. Use esta opción para brindar aprovisionamiento a los archivos JAR del complemento, por ejemplo, para instalarlo con el [aprovisionamiento de flota](fleet-provisioning.md) o el [aprovisionamiento personalizado](custom-provisioning.md), o para instalarlo con la clave privada y el certificado en un [módulo de seguridad de hardware](hardware-security.md).
`-s`, `--start`
(Opcional) Puede iniciar el software AWS IoT Greengrass Core después de que se haya instalado y, de forma opcional, aprovisionar recursos.
Valor predeterminado: `true`
# Ejecute el software AWS IoT Greengrass principal
Después de [instalar el software AWS IoT Greengrass Core](install-greengrass-core-v2.md), ejecútelo para conectar el dispositivo a AWS IoT Greengrass.
Al instalar el software AWS IoT Greengrass Core, puede especificar si desea instalarlo como un servicio del sistema con [systemd.](https://en.wikipedia.org/wiki/Systemd) Si elige esta opción, el instalador ejecutará el software automáticamente y lo configurará para que se ejecute al arrancar el dispositivo.
**importante**
En los dispositivos principales de Windows, debe configurar el software AWS IoT Greengrass principal como un servicio del sistema.
**Topics**
+ [Compruebe si el software AWS IoT Greengrass Core se ejecuta como un servicio del sistema](#check-system-service)
+ [Ejecute el software AWS IoT Greengrass Core como un servicio del sistema](#run-greengrass-core-system-service)
+ [Ejecute el software AWS IoT Greengrass Core sin un servicio de sistema](#run-greengrass-core-no-system-service)
## Compruebe si el software AWS IoT Greengrass Core se ejecuta como un servicio del sistema
Al instalar el software AWS IoT Greengrass Core, puede especificar el `--setup-system-service true` argumento para instalar el software AWS IoT Greengrass Core como un servicio del sistema. Los dispositivos Linux requieren que el sistema [systemd](https://en.wikipedia.org/wiki/Systemd) init configure el software AWS IoT Greengrass Core como un servicio del sistema. Si elige esta opción, el instalador ejecutará el software automáticamente y lo configurará para que se ejecute al arrancar el dispositivo. El instalador muestra el siguiente mensaje si instala correctamente el software AWS IoT Greengrass Core como un servicio del sistema.
```
Successfully set up Nucleus as a system service
```
Si ya instaló el software AWS IoT Greengrass Core y no tiene la salida del instalador, puede comprobar si el software está instalado como un servicio del sistema.
**Para comprobar si el software AWS IoT Greengrass principal está instalado como un servicio del sistema**
+ Ejecute el siguiente comando para verificar el estado del servicio del sistema Greengrass.
------
#### [ Linux or Unix (systemd) ]
```
sudo systemctl status greengrass.service
```
La respuesta es similar a la del siguiente ejemplo si el software AWS IoT Greengrass principal está instalado como un servicio del sistema y está activo.
```
● greengrass.service - Greengrass Core
Loaded: loaded (/etc/systemd/system/greengrass.service; enabled; vendor preset: disabled)
Active: active (running) since Thu 2021-02-11 01:33:44 UTC; 4 days ago
Main PID: 16107 (sh)
CGroup: /system.slice/greengrass.service
├─16107 /bin/sh /greengrass/v2/alts/current/distro/bin/loader
└─16111 java -Dlog.store=FILE -Droot=/greengrass/v2 -jar /greengrass/v2/alts/current/distro/lib/Greengrass...
```
Si `systemctl` `greengrass.service` no lo encuentra, significa que el software AWS IoT Greengrass principal no está instalado como un servicio del sistema. Para ejecutar el software, vea [Ejecute el software AWS IoT Greengrass Core sin un servicio de sistema](#run-greengrass-core-no-system-service).
------
#### [ Windows Command Prompt (CMD) ]
```
sc query greengrass
```
La respuesta es similar a la del siguiente ejemplo si el software AWS IoT Greengrass principal está instalado como un servicio de Windows y está activo.
```
SERVICE_NAME: greengrass
TYPE : 10 WIN32_OWN_PROCESS
STATE : 4 RUNNING
(STOPPABLE, NOT_PAUSABLE, ACCEPTS_SHUTDOWN)
WIN32_EXIT_CODE : 0 (0x0)
SERVICE_EXIT_CODE : 0 (0x0)
CHECKPOINT : 0x0
WAIT_HINT : 0x0
```
------
#### [ PowerShell ]
```
Get-Service greengrass
```
La respuesta es similar a la del siguiente ejemplo si el software AWS IoT Greengrass principal está instalado como un servicio de Windows y está activo.
```
Status Name DisplayName
------ ---- -----------
Running greengrass greengrass
```
------
## Ejecute el software AWS IoT Greengrass Core como un servicio del sistema
Si el software AWS IoT Greengrass principal está instalado como un servicio del sistema, puede usar el administrador de servicios del sistema para iniciar, detener y administrar el software. 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).
**Para ejecutar el software AWS IoT Greengrass principal**
+ Ejecute el siguiente comando para iniciar el software AWS IoT Greengrass Core.
------
#### [ Linux or Unix (systemd) ]
```
sudo systemctl start greengrass.service
```
------
#### [ Windows Command Prompt (CMD) ]
```
sc start greengrass
```
------
#### [ PowerShell ]
```
Start-Service greengrass
```
------
## Ejecute el software AWS IoT Greengrass Core sin un servicio de sistema
En los dispositivos Linux Core, si el software AWS IoT Greengrass Core no está instalado como un servicio del sistema, puede ejecutar el script de carga del software para ejecutarlo.
**Para ejecutar el software AWS IoT Greengrass principal sin un servicio del sistema**
+ Ejecute el siguiente comando para iniciar el software AWS IoT Greengrass Core. Si ejecuta este comando en una terminal, debe mantener abierta la sesión de la terminal para que el software AWS IoT Greengrass principal siga funcionando.
+ Sustituya `/greengrass/v2` o *C:\$1greengrass\$1v2* por la carpeta raíz de Greengrass que utilice.
```
sudo /greengrass/v2/alts/current/distro/bin/loader
```
El software imprime el siguiente mensaje si se inicia correctamente.
```
Launched Nucleus successfully.
```
# Ejecute AWS IoT Greengrass el software principal en un contenedor de Docker
AWS IoT Greengrass se puede configurar para que se ejecute en un contenedor de Docker. Docker es una plataforma que le permite crear, ejecutar, probar e implementar aplicaciones basadas en contenedores de Linux. Al ejecutar una imagen de AWS IoT Greengrass Docker, puede elegir si desea proporcionar sus AWS credenciales al contenedor de Docker y permitir que el instalador del software AWS IoT Greengrass Core aprovisione automáticamente los AWS recursos que un dispositivo principal de Greengrass necesita para funcionar. Si no desea proporcionar AWS credenciales, puede aprovisionar AWS recursos manualmente y ejecutar el software AWS IoT Greengrass Core en el contenedor de Docker.
**Topics**
+ [Plataformas compatibles y requisitos](#greengrass-docker-supported-platforms)
+ [Descargas de software](#greengrass-docker-downloads)
+ [Elija cómo aprovisionar los recursos AWS](#greengrass-docker-resource-provisioning)
+ [Cree la AWS IoT Greengrass imagen a partir de un Dockerfile](build-greengrass-dockerfile.md)
+ [Se ejecuta AWS IoT Greengrass en Docker con aprovisionamiento automático](run-greengrass-docker-automatic-provisioning.md)
+ [Se ejecuta AWS IoT Greengrass en Docker con aprovisionamiento manual](run-greengrass-docker-manual-provisioning.md)
+ [Solución de problemas AWS IoT Greengrass en un contenedor Docker](docker-troubleshooting.md)
## Plataformas compatibles y requisitos
Los ordenadores host deben cumplir los siguientes requisitos mínimos para instalar y ejecutar el software AWS IoT Greengrass principal en un contenedor de Docker:
+ Sistema operativo basado en Linux con conexión a Internet.
+ [Docker Engine](https://docs.docker.com/engine/install/), versión 18.09 o posterior.
+ (Opcional) [Docker Compose](https://docs.docker.com/compose/install/) versión 1.22 o posterior. Docker Compose solo es necesario si quiere usar la CLI de Docker Compose para ejecutar sus imágenes de Docker.
Para ejecutar componentes de función de Lambda dentro del contenedor de Docker, debe configurar el contenedor para cumplir con requisitos adicionales. Para obtener más información, consulte [Requisitos de la función de Lambda](setting-up.md#greengrass-v2-lambda-requirements).
### Ejecución de los componentes en modo de proceso
AWS IoT Greengrass no admite la ejecución de funciones de Lambda o componentes AWS proporcionados en un entorno de ejecución aislado dentro del AWS IoT Greengrass contenedor de Docker. Debe ejecutar estos componentes en modo de proceso sin ningún tipo de aislamiento.
Al configurar un componente de la función de Lambda, defina el modo de aislamiento en **Sin contenedor**. Para obtener más información, consulte [Ejecución de funciones de AWS Lambda](run-lambda-functions.md).
Al implementar cualquiera de los siguientes componentes AWS proporcionados, actualice la configuración de cada componente para establecer el parámetro en. `containerMode` `NoContainer` Para obtener más información acerca de las actualizaciones de configuración, consulte [Actualización de las configuraciones de los componentes](update-component-configurations.md).
+ [CloudWatch métricas](cloudwatch-metrics-component.md)
+ [Device Defender](device-defender-component.md)
+ [Firehose](kinesis-firehose-component.md)
+ [Adaptador de protocolo Modbus-RTU](modbus-rtu-protocol-adapter-component.md)
+ [Amazon SNS](sns-component.md)
## AWS IoT Greengrass descargas del software Docker
AWS IoT Greengrass proporciona un Dockerfile para crear una imagen de contenedor que tiene el software AWS IoT Greengrass principal y las dependencias instaladas en una imagen base de Amazon Linux 2 (x86\$164). Puede modificar la imagen base del Dockerfile para que se ejecute en una arquitectura de plataforma diferente. AWS IoT Greengrass
Descargue el paquete Dockerfile desde. [GitHub](https://github.com/aws-greengrass/aws-greengrass-docker)
El Dockerfile usa una versión anterior de Greengrass. Debe actualizar el archivo para usar la versión de Greengrass que desee. Para obtener información sobre cómo crear la imagen del AWS IoT Greengrass contenedor a partir del Dockerfile, consulte. [Cree la imagen del AWS IoT Greengrass contenedor a partir de un Dockerfile](build-greengrass-dockerfile.md)
## Elija cómo aprovisionar los recursos AWS
Al instalar el software AWS IoT Greengrass Core en un contenedor de Docker, puede elegir si desea aprovisionar automáticamente los AWS recursos que un dispositivo principal de Greengrass necesita para funcionar o usar los recursos que aprovisiona manualmente.
+ **Aprovisionamiento automático de recursos**: el instalador proporciona la AWS IoT AWS IoT cosa, el grupo de cosas, la función de IAM y el alias de la AWS IoT función al ejecutar la imagen del AWS IoT Greengrass contenedor por primera vez. El instalador también puede implementar las herramientas de desarrollo locales en el dispositivo principal, de modo que usted pueda usar el dispositivo para desarrollar y probar componentes de software personalizados. Para aprovisionar estos recursos automáticamente, debe proporcionar credenciales de AWS como variables de entorno a la imagen de Docker.
Para utilizar el aprovisionamiento automático, debe configurar la variable de entorno `PROVISION=true` de Docker y montar un archivo de credenciales para proporcionar sus credenciales de AWS al contenedor.
+ **Aprovisionamiento manual de recursos**: si no desea proporcionar AWS credenciales al contenedor, puede aprovisionar los AWS recursos manualmente antes de ejecutar la imagen del contenedor. AWS IoT Greengrass Debe crear un archivo de configuración para proporcionar información sobre estos recursos al instalador del software AWS IoT Greengrass principal dentro del contenedor de Docker.
Para utilizar el aprovisionamiento manual, debe configurar la variable de entorno de Docker `PROVISION=false`. La opción predeterminada es el aprovisionamiento manual.
Para obtener más información, consulte [Cree la imagen del AWS IoT Greengrass contenedor a partir de un Dockerfile](build-greengrass-dockerfile.md).
# Cree la imagen del AWS IoT Greengrass contenedor a partir de un Dockerfile
AWS proporciona un Dockerfile que puede descargar y usar para ejecutar AWS IoT Greengrass el software principal en un contenedor de Docker. Los archivos Docker contienen código fuente para crear imágenes de contenedores. AWS IoT Greengrass
Antes de crear una imagen de AWS IoT Greengrass contenedor, debe configurar su Dockerfile para seleccionar la versión del software AWS IoT Greengrass principal que desea instalar. También puede configurar las variables de entorno para elegir cómo aprovisionar los recursos durante la instalación y personalizar otras opciones de instalación. En esta sección se describe cómo configurar y crear una imagen de Docker a partir de un AWS IoT Greengrass Dockerfile.
## Descarga del paquete Dockerfile
Puede descargar el paquete AWS IoT Greengrass Dockerfile desde: GitHub
[Repositorio Docker de AWS Greengrass](https://github.com/aws-greengrass/aws-greengrass-docker)
Tras descargar el paquete, extraiga el contenido a la carpeta `download-directory/aws-greengrass-docker-nucleus-version` de su computadora. El Dockerfile usa una versión anterior de Greengrass. Debe actualizar el archivo para usar la versión de Greengrass que desee.
## Especifique la versión del AWS IoT Greengrass software principal
Usa el siguiente argumento de compilación en el Dockerfile para especificar la versión del software AWS IoT Greengrass principal que deseas usar en la imagen de AWS IoT Greengrass Docker. De forma predeterminada, el Dockerfile usa la última versión del software Core. AWS IoT Greengrass
`GREENGRASS_RELEASE_VERSION`
La versión del software AWS IoT Greengrass principal. De forma predeterminada, el Dockerfile descarga la última versión disponible del núcleo de Greengrass. Establezca el valor en la versión del núcleo que quiere descargar.
## Configuración de las variables de entorno
Las variables de entorno le permiten personalizar la forma en que se instala el software AWS IoT Greengrass principal en el contenedor de Docker. Puede configurar las variables de entorno para la imagen de AWS IoT Greengrass Docker de varias maneras.
+ Para usar las mismas variables de entorno para crear varias imágenes, configure las variables de entorno directamente en el Dockerfile.
+ Si usa `docker run` para iniciar el contenedor, pase variables de entorno como argumentos en el comando o establezca las variables de entorno en un archivo de variables de entorno y, a continuación, pase el archivo como un argumento. Para obtener más información sobre cómo configurar las variables de entorno en Docker, consulte [las variables de entorno](https://docs.docker.com/engine/reference/commandline/run/#env) en la documentación de Docker.
+ Si usa `docker-compose up` para iniciar su contenedor, configure las variables de entorno en un archivo de variables de entorno y, a continuación, pase el archivo como un argumento. Para obtener más información sobre cómo configurar las variables de entorno en Compose, consulte la [documentación de Docker](https://docs.docker.com/compose/environment-variables/).
Puede configurar las siguientes variables de entorno para la imagen de AWS IoT Greengrass Docker.
**nota**
No modifique la variable `TINI_KILL_PROCESS_GROUP` en el Dockerfile. Esta variable permite reenviarla `SIGTERM` a todos los miembros PIDs del grupo PID para que el software AWS IoT Greengrass principal se pueda cerrar correctamente cuando se detenga el contenedor de Docker.
`GGC_ROOT_PATH`
(Opcional) La ruta a la carpeta dentro del contenedor que se usará como raíz del software AWS IoT Greengrass Core.
Valor predeterminado: `/greengrass/v2`
`PROVISION`
(Opcional) Determina si el AWS IoT Greengrass núcleo AWS aprovisiona recursos.
+ Si lo especificas`true`, el software AWS IoT Greengrass Core registra la imagen del contenedor como una AWS IoT cosa y aprovisiona los AWS recursos que requiere el dispositivo principal de Greengrass. El software AWS IoT Greengrass Core aprovisiona AWS IoT cualquier cosa, (opcional) un grupo de AWS IoT cosas, un rol de IAM y un alias de AWS IoT rol. Para obtener más información, consulte [Se ejecuta AWS IoT Greengrass en un contenedor Docker con aprovisionamiento automático de recursos](run-greengrass-docker-automatic-provisioning.md).
+ Si lo especifica`false`, debe crear un archivo de configuración para proporcionárselo al instalador AWS IoT Greengrass principal que especifique el uso de los AWS recursos y certificados que creó manualmente. Para obtener más información, consulte [Se ejecuta AWS IoT Greengrass en un contenedor Docker con aprovisionamiento manual de recursos](run-greengrass-docker-manual-provisioning.md).
Valor predeterminado: `false`
`AWS_REGION`
(Opcional) El Región de AWS que el software AWS IoT Greengrass principal utiliza para recuperar o crear AWS los recursos necesarios.
Predeterminado: `us-east-1`.
`THING_NAME`
(Opcional) El nombre de AWS IoT lo que se registra como este dispositivo principal. Si el elemento con este nombre no existe en el tuyo Cuenta de AWS, será creado por el software AWS IoT Greengrass Core.
Debe especificar `PROVISION=true` si desea aplicar este argumento.
Valor predeterminado: `GreengrassV2IotThing_` más un UUID asignado al azar.
`THING_GROUP_NAME`
(Opcional) El nombre del grupo de elementos al AWS IoT que se agrega este dispositivo principal. AWS IoT Si una implementación se dirige a este grupo, este y otros dispositivos principales de ese grupo reciben ese despliegue cuando se conectan AWS IoT Greengrass. Si el grupo de cosas con este nombre no existe en su empresa Cuenta de AWS, el software AWS IoT Greengrass Core lo crea.
Debe especificar `PROVISION=true` si desea aplicar este argumento.
`TES_ROLE_NAME`
(Opcional) El nombre de la función de IAM que se utilizará para adquirir AWS las credenciales que permiten al dispositivo principal de Greengrass interactuar con AWS los servicios. Si el rol con este nombre no existe en su cuenta Cuenta de AWS, el software AWS IoT Greengrass principal lo crea con la `GreengrassV2TokenExchangeRoleAccess` política. Este rol no tiene acceso a los buckets de S3 donde aloja los artefactos de los componentes. Por lo tanto, debe agregar permisos a los buckets y objetos de S3 de sus artefactos al crear un componente. Para obtener más información, consulte [Autorizar a los dispositivos principales a interactuar con AWS los servicios](device-service-role.md).
Valor predeterminado: `GreengrassV2TokenExchangeRole`
`TES_ROLE_ALIAS_NAME`
(Opcional) El nombre del alias del AWS IoT rol que apunta al rol de IAM que proporciona AWS las credenciales para el dispositivo principal de Greengrass. Si el alias del rol con este nombre no existe en su cuenta Cuenta de AWS, el software AWS IoT Greengrass principal lo crea y lo dirige al rol de IAM que especifique.
Valor predeterminado: `GreengrassV2TokenExchangeRoleAlias`
`COMPONENT_DEFAULT_USER`
(Opcional) El nombre o ID del usuario y grupo del sistema que el software AWS IoT Greengrass principal utiliza para ejecutar los componentes. Especifique el usuario y el grupo, separados por dos puntos. El grupo es opcional. Por ejemplo, puede especificar **ggc\$1user:ggc\$1group** o **ggc\$1user**.
+ Si se ejecuta como raíz, el usuario y el grupo que defina el archivo de configuración son de forma predeterminada. Si el archivo de configuración no define un usuario ni un grupo, el valor predeterminado es `ggc_user:ggc_group`. Si no existen `ggc_user` o `ggc_group`, el software los crea.
+ Si se ejecuta como un usuario que no es root, el software AWS IoT Greengrass principal utiliza ese usuario para ejecutar los componentes.
+ Si no especifica un grupo, el software AWS IoT Greengrass Core utiliza el grupo principal del usuario del sistema.
Para obtener más información, consulte [Configuración del usuario que ejecuta los componentes](configure-greengrass-core-v2.md#configure-component-user).
`DEPLOY_DEV_TOOLS`
Define si se debe descargar e implementar el [componente de la CLI de Greengrass](greengrass-cli-component.md) en la imagen del contenedor. Puede usar la CLI de Greengrass para desarrollar y depurar componentes localmente.
Se recomienda usar este componente solo en entornos de desarrollo y no en entornos de producción. Este componente brinda acceso a información y operaciones que, por lo general, no necesitará en un entorno de producción. Siga el principio de privilegio mínimo al implementar este componente solo en los dispositivos principales donde lo necesite.
Valor predeterminado: `false`
`INIT_CONFIG`
(Opcional) La ruta al archivo de configuración que se utilizará para instalar el software AWS IoT Greengrass principal. Puede usar esta opción para configurar nuevos dispositivos principales de Greengrass con una configuración de núcleo específica o para especificar recursos aprovisionados manualmente, por ejemplo. Debe montar el archivo de configuración en la ruta que especifique en este argumento.
`TRUSTED_PLUGIN`
Esta característica está disponible para la versión 2.4.0 y versiones posteriores del [componente núcleo de Greengrass](greengrass-nucleus-component.md).
(Opcional) La ruta a un archivo JAR para cargarlo como un complemento de confianza. Use esta opción para aprovisionar archivos JAR, como instalar con el [aprovisionamiento de flota](fleet-provisioning.md) o el [aprovisionamiento personalizado](custom-provisioning.md).
`THING_POLICY_NAME`
Esta característica está disponible para la versión 2.4.0 y versiones posteriores del [componente núcleo de Greengrass](greengrass-nucleus-component.md).
(Opcional) El nombre de la AWS IoT política que se va a adjuntar al certificado AWS IoT Thing de este dispositivo principal. Si la AWS IoT política con este nombre no existe en su software AWS IoT Greengrass Core Cuenta de AWS la crea.
Debe especificar `PROVISION=true` si desea aplicar este argumento.
El software AWS IoT Greengrass Core crea una AWS IoT política permisiva de forma predeterminada. Puede limitar el alcance de esta política o crear una política personalizada en la que restrinja los permisos según su caso de uso. Para obtener más información, consulte [AWS IoT Política mínima para los dispositivos AWS IoT Greengrass V2 principales](device-auth.md#greengrass-core-minimal-iot-policy).
## Especificación de las dependencias que desea instalar
La instrucción RUN del AWS IoT Greengrass Dockerfile prepara el entorno del contenedor para ejecutar el instalador del AWS IoT Greengrass software Core. Puede personalizar las dependencias que se instalan antes de que el instalador del software AWS IoT Greengrass Core se ejecute en el contenedor de Docker.
## Cree la imagen AWS IoT Greengrass
Usa el AWS IoT Greengrass Dockerfile para crear una imagen de AWS IoT Greengrass contenedor. Puede usar la CLI de Docker o la CLI de Docker Compose para crear la imagen e iniciar el contenedor. También puede usar la CLI de Docker para crear la imagen y, a continuación, usar Docker Compose para iniciar el contenedor a partir de esa imagen.
------
#### [ Docker ]
1. En la máquina host, ejecute el siguiente comando para cambiar al directorio que contiene el Dockerfile configurado.
```
cd download-directory/aws-greengrass-docker-nucleus-version
```
1. Ejecute el siguiente comando para crear la imagen del AWS IoT Greengrass contenedor a partir del Dockerfile.
```
sudo docker build -t "platform/aws-iot-greengrass:nucleus-version" ./
```
------
#### [ Docker Compose ]
1. En la máquina host, ejecute el siguiente comando para cambiar al directorio que contiene el Dockerfile y el archivo Compose.
```
cd download-directory/aws-greengrass-docker-nucleus-version
```
1. Ejecuta el siguiente comando para usar el archivo Compose para crear la imagen del AWS IoT Greengrass contenedor.
```
docker-compose -f docker-compose.yml build
```
------
Ha creado correctamente la imagen del AWS IoT Greengrass contenedor. La imagen de Docker tiene instalado el software AWS IoT Greengrass principal. Ahora puede ejecutar el software AWS IoT Greengrass principal en un contenedor de Docker.
# Se ejecuta AWS IoT Greengrass en un contenedor Docker con aprovisionamiento automático de recursos
En este tutorial, se muestra cómo instalar y ejecutar el software AWS IoT Greengrass principal en un contenedor Docker con AWS recursos aprovisionados automáticamente y herramientas de desarrollo local. Puedes usar este entorno de desarrollo para explorar las AWS IoT Greengrass funciones de un contenedor Docker. El software requiere las credenciales de AWS para aprovisionar estos recursos e implementar las herramientas de desarrollo local.
Si no puede proporcionar AWS credenciales al contenedor, puede aprovisionar los AWS recursos que el dispositivo principal necesita para funcionar. También puede implementar las herramientas de desarrollo en un dispositivo principal para usarlas como dispositivo de desarrollo. Esto le permite conceder menos permisos al dispositivo al ejecutar el contenedor. Para obtener más información, consulte [Se ejecuta AWS IoT Greengrass en un contenedor Docker con aprovisionamiento manual de recursos](run-greengrass-docker-manual-provisioning.md).
## Requisitos previos
Necesitará lo siguiente para completar este tutorial.
+ Un Cuenta de AWS. Si no dispone de una, consulte [Configura un Cuenta de AWS](setting-up.md#set-up-aws-account).
+ Un usuario de AWS IAM con permisos para aprovisionar los recursos AWS IoT de IAM para un dispositivo principal de Greengrass. El instalador del software AWS IoT Greengrass principal utiliza sus AWS credenciales para aprovisionar automáticamente estos recursos. Para obtener información sobre la política de IAM mínima para aprovisionar recursos automáticamente, consulte [Política de IAM mínima para que el instalador aprovisione recursos](provision-minimal-iam-policy.md).
+ Una imagen de AWS IoT Greengrass Docker. Puede [crear una imagen a partir del AWS IoT Greengrass Dockerfile](build-greengrass-dockerfile.md).
+ El equipo host en el que ejecute el contenedor de Docker debe cumplir los siguientes requisitos:
+ Sistema operativo basado en Linux con conexión a Internet.
+ [Docker Engine](https://docs.docker.com/engine/install/), versión 18.09 o posterior.
+ (Opcional) [Docker Compose](https://docs.docker.com/compose/install/) versión 1.22 o posterior. Docker Compose solo es necesario si quiere usar la CLI de Docker Compose para ejecutar sus imágenes de Docker.
## Configura tus credenciales AWS
En este paso, crea un archivo de credenciales en la computadora host que contiene sus credenciales de seguridad de AWS . Al ejecutar la imagen de AWS IoT Greengrass Docker, debe montar la carpeta que contiene este archivo de credenciales `/root/.aws/` en el contenedor de Docker. El AWS IoT Greengrass instalador usa estas credenciales para aprovisionar recursos en su. Cuenta de AWS Para obtener información sobre la política de IAM mínima que requiere el instalador para aprovisionar recursos automáticamente, consulte [Política de IAM mínima para que el instalador aprovisione recursos](provision-minimal-iam-policy.md).
1. Recuperación de uno de los siguientes elementos.
+ Credenciales a largo plazo para un usuario de IAM. Para obtener información sobre cómo recuperar credenciales a largo plazo, consulte [Administrar claves de acceso para usuarios de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html) en la * Guía del usuario de IAM*.
+ (Recomendado) Credenciales temporales para un rol de IAM. Para obtener información sobre cómo obtener credenciales temporales, consulte [Uso de credenciales de seguridad temporales con la AWS CLI](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html#using-temp-creds-sdk-cli) en la *Guía del usuario de IAM*.
1. Cree una carpeta en la que coloque el archivo de credenciales.
```
mkdir ./greengrass-v2-credentials
```
1. Utilice un editor de texto para crear un archivo de configuración denominado `credentials` en la carpeta `./greengrass-v2-credentials`.
Por ejemplo, puede ejecutar el comando siguiente para usar GNU nano para crear el archivo `credentials`.
```
nano ./greengrass-v2-credentials/credentials
```
1. Añada sus AWS credenciales al `credentials` archivo en el siguiente formato.
```
[default]
aws_access_key_id = AKIAIOSFODNN7EXAMPLE
aws_secret_access_key = wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
aws_session_token = AQoEXAMPLEH4aoAH0gNCAPy...truncated...zrkuWJOgQs8IZZaIv2BXIa2R4Olgk
```
Incluya `aws_session_token` solo para credenciales temporales.
**importante**
Elimine el archivo de credenciales de la computadora host después de iniciar el AWS IoT Greengrass contenedor. Si no elimina el archivo de credenciales, sus AWS credenciales permanecerán montadas dentro del contenedor. Para obtener más información, consulte [Ejecute el software AWS IoT Greengrass principal en un contenedor](#run-greengrass-image-automatic-provisioning).
## Creación de un archivo de entorno
En este tutorial, se utiliza un archivo de entorno para configurar las variables de entorno que se transferirán al instalador del software AWS IoT Greengrass principal dentro del contenedor de Docker. También puede utilizar [el argumento `-e` o `--env`](https://docs.docker.com/engine/reference/commandline/run/#env) en su comando `docker run` para establecer variables de entorno en el contenedor de Docker o puede establecer las variables en [un bloque `environment`](https://docs.docker.com/compose/compose-file/compose-file-v3/#environment) en el archivo `docker-compose.yml`.
1. Utilice un editor de texto para crear un archivo de política llamado `.env`.
Por ejemplo, en un sistema basado en Linux, puede ejecutar el siguiente comando para usar GNU nano para crearlo en el `.env` en el directorio actual.
```
nano .env
```
1. Copie el contenido siguiente en el archivo.
```
GGC_ROOT_PATH=/greengrass/v2
AWS_REGION=region
PROVISION=true
THING_NAME=MyGreengrassCore
THING_GROUP_NAME=MyGreengrassCoreGroup
TES_ROLE_NAME=GreengrassV2TokenExchangeRole
TES_ROLE_ALIAS_NAME=GreengrassCoreTokenExchangeRoleAlias
COMPONENT_DEFAULT_USER=ggc_user:ggc_group
```
Reemplace los siguientes valores.
+ `/greengrass/v2`. La carpeta raíz de Greengrass que quiera usar para la instalación. Puede establecer este valor mediante la variable de entorno `GGC_ROOT`.
+ *region*. El Región de AWS lugar donde creaste los recursos.
+ *MyGreengrassCore*. El nombre de la AWS IoT cosa. Si el objeto no existe, el instalador la crea. El instalador descarga los certificados para autenticarse como tal AWS IoT .
+ *MyGreengrassCoreGroup*. El nombre del grupo de AWS IoT cosas. Si el grupo de objetos no existe, el instalador lo crea y le agrega un objeto. Si el grupo de objetos existe y tiene una implementación activa, el dispositivo principal descarga y ejecuta el software que especifique la implementación.
+ *GreengrassV2TokenExchangeRole*. Sustitúyalo por el nombre de la función de intercambio de fichas de IAM que permite al dispositivo principal de Greengrass obtener AWS credenciales temporales. Si el rol no existe, el instalador lo crea y crea y adjunta una política denominada Access. *GreengrassV2TokenExchangeRole* Para obtener más información, consulte [Autorizar a los dispositivos principales a interactuar con AWS los servicios](device-service-role.md).
+ *GreengrassCoreTokenExchangeRoleAlias*. El alias del rol de intercambio de fichas. Si el alias del rol no existe, el instalador lo crea y lo dirige al rol de intercambio de token de IAM que especifique. Para obtener más información, consulte
**nota**
Puede configurar la variable de entorno `DEPLOY_DEV_TOOLS` a `true` para implementar el [componente CLI de Greengrass](greengrass-cli-component.md), que le permite desarrollar componentes personalizados dentro del contenedor de Docker. Se recomienda usar este componente solo en entornos de desarrollo y no en entornos de producción. Este componente brinda acceso a información y operaciones que, por lo general, no necesitará en un entorno de producción. Siga el principio de privilegio mínimo al implementar este componente solo en los dispositivos principales donde lo necesite.
## Ejecute el software AWS IoT Greengrass principal en un contenedor
Este tutorial le muestra cómo iniciar la imagen de Docker que creó en un contenedor de Docker. Puede usar la CLI de Docker o la CLI de Docker Compose para ejecutar la imagen del software AWS IoT Greengrass principal en un contenedor de Docker.
------
#### [ Docker ]
1. Ejecute el siguiente comando para iniciar el contenedor de Docker.
```
docker run --rm --init -it --name docker-image \
-v path/to/greengrass-v2-credentials:/root/.aws/:ro \
--env-file .env \
-p 8883 \
your-container-image:version
```
Este comando de ejemplo usa los siguientes argumentos para [ejecutar docker](https://docs.docker.com/engine/reference/commandline/run/):
+ [https://docs.docker.com/engine/reference/run/#clean-up---rm](https://docs.docker.com/engine/reference/run/#clean-up---rm). Limpia el contenedor al salir.
+ [https://docs.docker.com/engine/reference/run/#specify-an-init-process](https://docs.docker.com/engine/reference/run/#specify-an-init-process). Utiliza un proceso de inicio en el contenedor.
**nota**
El `--init` argumento es necesario para cerrar el software AWS IoT Greengrass Core al detener el contenedor de Docker.
+ [https://docs.docker.com/engine/reference/run/#foreground](https://docs.docker.com/engine/reference/run/#foreground). (Opcional) Ejecuta el contenedor de Docker en primer plano como un proceso interactivo. En su lugar, puede sustituirlo por el argumento `-d` para ejecutar el contenedor de Docker en modo separado. Para obtener más información, consulte [Separado frente a Primer plano](https://docs.docker.com/engine/reference/run/#detached-vs-foreground) en la documentación de Docker.
+ [https://docs.docker.com/engine/reference/run/#name---name](https://docs.docker.com/engine/reference/run/#name---name). Ejecuta un contenedor llamado `aws-iot-greengrass`
+ [https://docs.docker.com/storage/volumes/](https://docs.docker.com/storage/volumes/). Monta un volumen en el contenedor de Docker para que el archivo de configuración y los archivos de certificado estén disponibles para su AWS IoT Greengrass ejecución dentro del contenedor.
+ [https://docs.docker.com/engine/reference/commandline/run/#env](https://docs.docker.com/engine/reference/commandline/run/#env). (Opcional) Especifica el archivo de entorno para establecer las variables de entorno que se pasarán al instalador del software AWS IoT Greengrass principal dentro del contenedor de Docker. Este argumento solo es necesario si ha creado un [archivo de entorno](run-greengrass-docker-manual-provisioning.md#create-env-file-manual-provisioning) para establecer variables de entorno. Si no creó un archivo de entorno, puede usar argumentos `--env` para establecer las variables de entorno directamente en el comando run de Docker.
+ [https://docs.docker.com/engine/reference/commandline/run/#publish](https://docs.docker.com/engine/reference/commandline/run/#publish). (Opcional) Publica el puerto contenedor 8883 en la máquina host. Este argumento es obligatorio si desea conectarse y comunicarse a través de MQTT, ya que AWS IoT Greengrass utiliza el puerto 8883 para el tráfico de MQTT. Para abrir otros puertos, utilice argumentos adicionales `-p`.
**nota**
Para ejecutar su contenedor de Docker con mayor seguridad, puede usar los argumentos `--cap-drop` y `--cap-add` para habilitar de forma selectiva las capacidades de Linux para su contenedor. Para obtener más información, consulte [Privilegios en tiempo de ejecución y capacidades de Linux](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) en el sitio web de Docker.
1. Elimine las credenciales del `./greengrass-v2-credentials` en el dispositivo host.
```
rm -rf ./greengrass-v2-credentials
```
**importante**
Va a eliminar estas credenciales porque proporcionan amplios permisos que el dispositivo principal solo necesita durante la configuración. Si no elimina estas credenciales, los componentes de Greengrass y otros procesos que se ejecutan en el contenedor podrán acceder a ellas. Si necesita proporcionar AWS credenciales a un componente de Greengrass, utilice el servicio de intercambio de fichas. Para obtener más información, consulte [Interacción con servicios de AWS](interact-with-aws-services.md).
------
#### [ Docker Compose ]
1. Utilice un editor de texto para crear un archivo Docker Compose llamado `docker-compose.yml`.
Por ejemplo, en un sistema basado en Linux, puede ejecutar el siguiente comando para usar GNU nano para crearlo en el `docker-compose.yml` en el directorio actual.
```
nano docker-compose.yml
```
**nota**
También puede descargar y usar la última versión del archivo Compose AWS proporcionado desde. [GitHub](https://github.com/aws-greengrass/aws-greengrass-docker/releases/)
1. Agregue el siguiente contenido al archivo Compose. El archivo debe ser similar al siguiente ejemplo. *docker-image*Sustitúyelo por el nombre de la imagen de Docker.
```
version: '3.7'
services:
greengrass:
init: true
container_name: aws-iot-greengrass
image: docker-image
volumes:
- ./greengrass-v2-credentials:/root/.aws/:ro
env_file: .env
ports:
- "8883:8883"
```
Los siguientes parámetros del archivo Compose de ejemplo son opcionales:
+ `ports`: (Opcional) Publica el puerto contenedor 8883 en la máquina host. Este parámetro es obligatorio si desea conectarse y comunicarse a través de MQTT, ya que AWS IoT Greengrass utiliza el puerto 8883 para el tráfico de MQTT.
+ `env_file`—Especifica el archivo de entorno para establecer las variables de entorno que se pasarán al instalador del software AWS IoT Greengrass principal dentro del contenedor de Docker. Este parámetro solo es necesario si ha creado un [archivo de entorno](run-greengrass-docker-manual-provisioning.md#create-env-file-manual-provisioning) para establecer variables de entorno. Si no creó un archivo de entorno, puede usar el parámetro de [entorno](https://docs.docker.com/compose/compose-file/compose-file-v3/#environment) para configurar las variables directamente en su archivo Compose.
**nota**
Para ejecutar su contenedor de Docker con mayor seguridad, puede usar `cap_drop` y `cap_add` en su archivo Compose para habilitar de forma selectiva las capacidades de Linux para su contenedor. Para obtener más información, consulte [Privilegios en tiempo de ejecución y capacidades de Linux](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) en el sitio web de Docker.
1. Ejecute el siguiente comando para iniciar el contenedor de Docker.
```
docker-compose -f docker-compose.yml up
```
1. Elimine las credenciales del `./greengrass-v2-credentials` en el dispositivo host.
```
rm -rf ./greengrass-v2-credentials
```
**importante**
Va a eliminar estas credenciales porque proporcionan amplios permisos que el dispositivo principal solo necesita durante la configuración. Si no elimina estas credenciales, los componentes de Greengrass y otros procesos que se ejecutan en el contenedor podrán acceder a ellas. Si necesita proporcionar AWS credenciales a un componente de Greengrass, utilice el servicio de intercambio de fichas. Para obtener más información, consulte [Interacción con servicios de AWS](interact-with-aws-services.md).
------
## Siguientes pasos
AWS IoT Greengrass El software principal se ejecuta ahora en un contenedor de Docker. Ejecute el siguiente comando para recuperar el ID del contenedor en el contenedor de ejecución actual.
```
docker ps
```
A continuación, puede ejecutar el siguiente comando para acceder al contenedor y explorar el software AWS IoT Greengrass principal que se ejecuta dentro del contenedor.
```
docker exec -it container-id /bin/bash
```
Para obtener más información sobre cómo crear un componente simple, consulte [Paso 4: Desarrollo y prueba de un componente en su dispositivo](create-first-component.md) en [Tutorial: Introducción a AWS IoT Greengrass V2](getting-started.md)
**nota**
Cuando utiliza `docker exec` para ejecutar comandos dentro del contenedor de Docker, esos comandos no se capturan en los registros de Docker. Para registrar los comandos en los registros de Docker, asocie un intérprete de comandos interactivo al contenedor de Docker. Para obtener más información, consulte [Asociación de un intérprete de comandos interactivo a un contenedor de Docker](docker-troubleshooting.md#debugging-docker-attach-shell).
El archivo de registro AWS IoT Greengrass Core se llama `greengrass.log` y se encuentra en`/greengrass/v2/logs`. Los archivos de registro de componentes también se encuentran en el mismo directorio. Para copiar los registros de Greengrass en un directorio temporal del host, ejecute el siguiente comando:
```
docker cp container-id:/greengrass/v2/logs /tmp/logs
```
Si desea conservar los registros después de que un contenedor se cierre o se haya eliminado, le recomendamos que monte únicamente el directorio `/greengrass/v2/logs` en el directorio de registros temporales del host, en lugar de montar todo el directorio de Greengrass. Para obtener más información, consulte [Conservación de los registros de Greengrass fuera del contenedor de Docker](docker-troubleshooting.md#debugging-docker-persist-logs).
Para detener un contenedor AWS IoT Greengrass Docker en ejecución, ejecute `docker stop` o`docker-compose -f docker-compose.yml stop`. Esta acción envía `SIGTERM` al proceso de Greengrass y cierra todos los procesos asociados que se iniciaron en el contenedor. El contenedor de Docker se inicializa con el ejecutable `docker-init` como PID 1, lo que ayuda a eliminar los procesos zombis restantes. Para obtener más información, consulte la sección [Especificar un proceso de instalación](https://docs.docker.com/engine/reference/run/#specify-an-init-process) de la documentación de Docker.
Para obtener más información acerca de la solución de problemas relacionados con la ejecución de AWS IoT Greengrass en un contenedor de Docker, consulte [Solución de problemas AWS IoT Greengrass en un contenedor Docker](docker-troubleshooting.md).
# Se ejecuta AWS IoT Greengrass en un contenedor Docker con aprovisionamiento manual de recursos
En este tutorial, se muestra cómo instalar y ejecutar el software AWS IoT Greengrass principal en un contenedor Docker con recursos aprovisionados manualmente. AWS
**Topics**
+ [Requisitos previos](#docker-manual-provisioning-prereqs)
+ [Recupere los puntos finales AWS IoT](#retrieve-iot-endpoints)
+ [Crea cualquier AWS IoT cosa](#create-iot-thing)
+ [Creación del certificado del objeto](#create-thing-certificate-mp)
+ [Creación de un rol de intercambio de token](#create-token-exchange-role)
+ [Descarga de certificados al dispositivo](#download-thing-certificates)
+ [Creación de un archivo de configuración](#create-docker-install-configuration-file)
+ [Creación de un archivo de entorno](#create-env-file-manual-provisioning)
+ [Ejecute el software AWS IoT Greengrass principal en un contenedor](#run-greengrass-image-manual-provisioning)
+ [Siguientes pasos](#run-greengrass-docker-next-steps)
## Requisitos previos
Necesitará lo siguiente para completar este tutorial:
+ Un. Cuenta de AWS Si no dispone de una, consulte [Configura un Cuenta de AWS](setting-up.md#set-up-aws-account).
+ Una imagen de AWS IoT Greengrass Docker. Puede [crear una imagen a partir del AWS IoT Greengrass Dockerfile](build-greengrass-dockerfile.md).
+ El equipo host en el que ejecute el contenedor de Docker debe cumplir los siguientes requisitos:
+ Sistema operativo basado en Linux con conexión a Internet.
+ [Docker Engine](https://docs.docker.com/engine/install/), versión 18.09 o posterior.
+ (Opcional) [Docker Compose](https://docs.docker.com/compose/install/) versión 1.22 o posterior. Docker Compose solo es necesario si quiere usar la CLI de Docker Compose para ejecutar sus imágenes de Docker.
## Recupere los puntos finales AWS IoT
Obtenga los AWS IoT puntos finales que desee y guárdelos para usarlos más adelante. Cuenta de AWS El dispositivo usa estos puntos de conexión para conectarse a AWS IoT. Haga lo siguiente:
1. Obtenga el punto final AWS IoT de datos para su. Cuenta de AWS
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
Si la solicitud se realiza exitosamente, la respuesta se parece al siguiente ejemplo.
```
{
"endpointAddress": "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
}
```
1. Obtenga el punto final de AWS IoT credenciales para su Cuenta de AWS.
```
aws iot describe-endpoint --endpoint-type iot:CredentialProvider
```
Si la solicitud se realiza exitosamente, la respuesta se parece al siguiente ejemplo.
```
{
"endpointAddress": "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
}
```
## Crea cualquier AWS IoT cosa
AWS IoT *las cosas* representan dispositivos y entidades lógicas a las que se conectan AWS IoT. Los dispositivos principales de Greengrass son AWS IoT cosas. Cuando registras un dispositivo como una AWS IoT cosa, ese dispositivo puede usar un certificado digital para autenticarse. AWS
En esta sección, crearás AWS IoT algo que represente tu dispositivo.
**Para crear cualquier AWS IoT cosa**
1. Crea cualquier AWS IoT cosa para tu dispositivo. En su equipo de desarrollo, ejecute el siguiente comando.
+ *MyGreengrassCore*Sustitúyalo por el nombre de la cosa que se va a utilizar. Este nombre también es el nombre de su dispositivo principal de Greengrass.
**nota**
El nombre del objeto no puede contener dos puntos (`:`).
```
aws iot create-thing --thing-name MyGreengrassCore
```
Si la solicitud se realiza exitosamente, la respuesta se parece al siguiente ejemplo.
```
{
"thingName": "MyGreengrassCore",
"thingArn": "arn:aws:iot:us-west-2:123456789012:thing/MyGreengrassCore",
"thingId": "8cb4b6cd-268e-495d-b5b9-1713d71dbf42"
}
```
1. (Opcional) Añada la AWS IoT cosa a un grupo de cosas nuevo o existente. Los grupos de objetos se usan para administrar las flotas de dispositivos principales de Greengrass. Al implementar componentes de software en sus dispositivos, puede dirigirlos a dispositivos individuales o a grupos de dispositivos. Puede agregar un dispositivo a un grupo de objetos con una implementación activa de Greengrass para implementar los componentes de software de ese grupo de objetos en el dispositivo. Haga lo siguiente:
1. (Opcional) Cree un grupo de AWS IoT cosas.
+ *MyGreengrassCoreGroup*Sustitúyalo por el nombre del grupo de cosas que desee crear.
**nota**
El nombre del grupo de objetos no puede contener dos puntos (`:`).
```
aws iot create-thing-group --thing-group-name MyGreengrassCoreGroup
```
Si la solicitud se realiza exitosamente, la respuesta se parece al siguiente ejemplo.
```
{
"thingGroupName": "MyGreengrassCoreGroup",
"thingGroupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/MyGreengrassCoreGroup",
"thingGroupId": "4df721e1-ff9f-4f97-92dd-02db4e3f03aa"
}
```
1. Añada la AWS IoT cosa a un grupo de cosas.
+ *MyGreengrassCore*Sustitúyala por el nombre de la AWS IoT cosa.
+ *MyGreengrassCoreGroup*Sustitúyalo por el nombre del grupo de cosas.
```
aws iot add-thing-to-thing-group --thing-name MyGreengrassCore --thing-group-name MyGreengrassCoreGroup
```
El comando no tiene ningún resultado si la solicitud se realiza correctamente.
## Creación del certificado del objeto
Al registrar un dispositivo como una AWS IoT cosa, ese dispositivo puede utilizar un certificado digital para autenticarse AWS. Este certificado permite que el dispositivo se comunique con AWS IoT y AWS IoT Greengrass.
En esta sección, puede crear y descargar certificados que el dispositivo puede usar para conectarse a AWS.
**Creación del certificado del objeto**
1. Crea una carpeta donde descargues los certificados de la AWS IoT cosa.
```
mkdir greengrass-v2-certs
```
1. Crea y descarga los certificados de la AWS IoT cosa.
```
aws iot create-keys-and-certificate --set-as-active --certificate-pem-outfile greengrass-v2-certs/device.pem.crt --public-key-outfile greengrass-v2-certs/public.pem.key --private-key-outfile greengrass-v2-certs/private.pem.key
```
Si la solicitud se realiza exitosamente, la respuesta se parece al siguiente ejemplo.
```
{
"certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificateId": "aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificatePem": "-----BEGIN CERTIFICATE-----
MIICiTCCAfICCQD6m7oRw0uXOjANBgkqhkiG9w
0BAQUFADCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZ
WF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIw
EAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5
jb20wHhcNMTEwNDI1MjA0NTIxWhcNMTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBh
MCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBb
WF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMx
HzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5jb20wgZ8wDQYJKoZIhvcNAQE
BBQADgY0AMIGJAoGBAMaK0dn+a4GmWIWJ21uUSfwfEvySWtC2XADZ4nB+BLYgVI
k60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9TrDHudUZg3qX4waLG5M43q7Wgc/MbQ
ITxOUSQv7c7ugFFDzQGBzZswY6786m86gpEIbb3OhjZnzcvQAaRHhdlQWIMm2nr
AgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4nUhVVxYUntneD9+h8Mg9q6q+auN
KyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0FkbFFBjvSfpJIlJ00zbhNYS5f6Guo
EDmFJl0ZxBHjJnyp378OD8uTs7fLvjx79LjSTbNYiytVbZPQUQ5Yaxu2jXnimvw
3rrszlaEXAMPLE=
-----END CERTIFICATE-----",
"keyPair": {
"PublicKey": "-----BEGIN PUBLIC KEY-----\
MIIBIjANBgkqhkEXAMPLEQEFAAOCAQ8AMIIBCgKCAQEAEXAMPLE1nnyJwKSMHw4h\
MMEXAMPLEuuN/dMAS3fyce8DW/4+EXAMPLEyjmoF/YVF/gHr99VEEXAMPLE5VF13\
59VK7cEXAMPLE67GK+y+jikqXOgHh/xJTwo+sGpWEXAMPLEDz18xOd2ka4tCzuWEXAMPLEahJbYkCPUBSU8opVkR7qkEXAMPLE1DR6sx2HocliOOLtu6Fkw91swQWEXAMPLE\\GB3ZPrNh0PzQYvjUStZeccyNCx2EXAMPLEvp9mQOUXP6plfgxwKRX2fEXAMPLEDa\
hJLXkX3rHU2xbxJSq7D+XEXAMPLEcw+LyFhI5mgFRl88eGdsAEXAMPLElnI9EesG\
FQIDAQAB\
-----END PUBLIC KEY-----\
",
"PrivateKey": "-----BEGIN RSA PRIVATE KEY-----\
key omitted for security reasons\
-----END RSA PRIVATE KEY-----\
"
}
}
```
Guarde el nombre de recurso de Amazon (ARN) del certificado para usarlo para configurar el certificado más adelante.
A continuación, configure el certificado de la cosa. Para obtener más información, consulte [Configuración del certificado del objeto](manual-installation.md#configure-thing-certificate).
## Creación de un rol de intercambio de token
Los dispositivos principales de Greengrass utilizan una función de servicio de IAM, denominada función de *intercambio de fichas*, para autorizar las llamadas a los servicios. AWS El dispositivo utiliza el proveedor de AWS IoT credenciales para obtener AWS credenciales temporales para esta función, lo que permite al dispositivo interactuar con Amazon Logs AWS IoT, enviar registros a Amazon CloudWatch Logs y descargar artefactos de componentes personalizados de Amazon S3. Para obtener más información, consulte [Autorizar a los dispositivos principales a interactuar con AWS los servicios](device-service-role.md).
Se utiliza un *alias de AWS IoT rol* para configurar el rol de intercambio de fichas para los dispositivos principales de Greengrass. Los alias de rol le permiten cambiar el rol de intercambio de token de un dispositivo, pero mantener la configuración del dispositivo igual. 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 *.
En esta sección, creará un rol de IAM de intercambio de tokens y un alias de AWS IoT rol que apunte al rol. Si ya ha configurado un dispositivo principal de Greengrass, puede usar su rol de intercambio de token y su alias de rol en lugar de crear otros nuevos. A continuación, configure el objeto AWS IoT del dispositivo para que use ese rol y ese alias.
**Creación de un rol de IAM de intercambio de token**
1. Creación de un rol de IAM que su dispositivo puede usar como rol de intercambio de token. Haga lo siguiente:
1. Creación de un archivo que contenga el documento de política de confianza que requiere el rol de intercambio de token.
Por ejemplo, en un sistema basado en Linux, puede ejecutar el siguiente comando para usar GNU nano a fin de crear el archivo.
```
nano device-role-trust-policy.json
```
Copie el siguiente JSON en el archivo.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
1. Creación del rol de intercambio de token con el documento de política de confianza.
+ *GreengrassV2TokenExchangeRole*Sustitúyalo por el nombre del rol de IAM que se va a crear.
```
aws iam create-role --role-name GreengrassV2TokenExchangeRole --assume-role-policy-document file://device-role-trust-policy.json
```
Si la solicitud se realiza exitosamente, la respuesta se parece al siguiente ejemplo.
```
{
"Role": {
"Path": "/",
"RoleName": "GreengrassV2TokenExchangeRole",
"RoleId": "AROAZ2YMUHYHK5OKM77FB",
"Arn": "arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole",
"CreateDate": "2021-02-06T00:13:29+00:00",
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
}
```
1. Creación de un archivo que contenga el documento de política de acceso que requiere el rol de intercambio de token.
Por ejemplo, en un sistema basado en Linux, puede ejecutar el siguiente comando para usar GNU nano a fin de crear el archivo.
```
nano device-role-access-policy.json
```
Copie el siguiente JSON en el archivo.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents",
"logs:DescribeLogStreams",
"s3:GetBucketLocation"
],
"Resource": "*"
}
]
}
```
**nota**
Esta política de acceso no permite el acceso a los artefactos de componentes en los buckets de S3. Para implementar componentes personalizados que definan artefactos en Amazon S3, debe agregar permisos al rol para permitir que su dispositivo principal recupere artefactos de componentes. 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).
Si aún no tiene un bucket de S3 para los artefactos de los componentes, puede agregar estos permisos más adelante, después de crear un bucket.
1. Creación de la política de IAM a partir del documento de política.
+ *GreengrassV2TokenExchangeRoleAccess*Sustitúyalo por el nombre de la política de IAM que se va a crear.
```
aws iam create-policy --policy-name GreengrassV2TokenExchangeRoleAccess --policy-document file://device-role-access-policy.json
```
Si la solicitud se realiza exitosamente, la respuesta se parece al siguiente ejemplo.
```
{
"Policy": {
"PolicyName": "GreengrassV2TokenExchangeRoleAccess",
"PolicyId": "ANPAZ2YMUHYHACI7C5Z66",
"Arn": "arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess",
"Path": "/",
"DefaultVersionId": "v1",
"AttachmentCount": 0,
"PermissionsBoundaryUsageCount": 0,
"IsAttachable": true,
"CreateDate": "2021-02-06T00:37:17+00:00",
"UpdateDate": "2021-02-06T00:37:17+00:00"
}
}
```
1. Adjunte la política de IAM al rol de intercambio de token.
+ Reemplace *GreengrassV2TokenExchangeRole* por el nombre del rol de IAM.
+ Reemplace el ARN de la política por el ARN de la política de IAM que creó en el paso anterior.
```
aws iam attach-role-policy --role-name GreengrassV2TokenExchangeRole --policy-arn arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess
```
El comando no tiene ningún resultado si la solicitud se realiza correctamente.
1. Cree un alias de AWS IoT rol que apunte al rol de intercambio de fichas.
+ *GreengrassCoreTokenExchangeRoleAlias*Sustitúyalo por el nombre del alias del rol que se va a crear.
+ Reemplace el ARN del rol por el ARN del rol de IAM que creó en el paso anterior.
```
aws iot create-role-alias --role-alias GreengrassCoreTokenExchangeRoleAlias --role-arn arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole
```
Si la solicitud se realiza exitosamente, la respuesta se parece al siguiente ejemplo.
```
{
"roleAlias": "GreengrassCoreTokenExchangeRoleAlias",
"roleAliasArn": "arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
```
**nota**
Para crear un alias de rol, debe tener el permiso para transferir el rol de IAM de intercambio de token a AWS IoT. Si recibe un mensaje de error al intentar crear un alias de rol, compruebe que el AWS usuario tiene este permiso. Para obtener más información, consulte [Conceder permisos a un usuario para transferir un rol a un AWS servicio](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_passrole.html) en la *Guía del AWS Identity and Access Management usuario*.
1. Cree y adjunte una AWS IoT política que permita a su dispositivo principal de Greengrass utilizar el alias del rol para asumir el rol de intercambio de fichas. Si ya ha configurado un dispositivo principal de Greengrass, puede adjuntar su AWS IoT política de alias de rol en lugar de crear una nueva. Haga lo siguiente:
1. (Opcional) Cree un archivo que contenga el documento AWS IoT de política que requiere el alias del rol.
Por ejemplo, en un sistema basado en Linux, puede ejecutar el siguiente comando para usar GNU nano a fin de crear el archivo.
```
nano greengrass-v2-iot-role-alias-policy.json
```
Copie el siguiente JSON en el archivo.
+ Reemplace el ARN del recurso por el ARN del alias de rol.
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iot:AssumeRoleWithCertificate",
"Resource": "arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
]
}
```
1. Cree una AWS IoT política a partir del documento de política.
+ *GreengrassCoreTokenExchangeRoleAliasPolicy*Sustitúyala por el nombre de la AWS IoT política que se va a crear.
```
aws iot create-policy --policy-name GreengrassCoreTokenExchangeRoleAliasPolicy --policy-document file://greengrass-v2-iot-role-alias-policy.json
```
Si la solicitud se realiza exitosamente, la respuesta se parece al siguiente ejemplo.
```
{
"policyName": "GreengrassCoreTokenExchangeRoleAliasPolicy",
"policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GreengrassCoreTokenExchangeRoleAliasPolicy",
"policyDocument": "{
\\"Version\\":\\"2012-10-17 \\",
\\"Statement\\": [
{
\\"Effect\\": \\"Allow\\",
\\"Action\\": \\"iot:AssumeRoleWithCertificate\\",
\\"Resource\\": \\"arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias\\"
}
]
}",
"policyVersionId": "1"
}
```
1. Adjunta la AWS IoT política al certificado de la AWS IoT cosa.
+ *GreengrassCoreTokenExchangeRoleAliasPolicy*Sustitúyala por el nombre de la AWS IoT política de alias del rol.
+ Reemplace el ARN de destino por el ARN del certificado de su objeto AWS IoT .
```
aws iot attach-policy --policy-name GreengrassCoreTokenExchangeRoleAliasPolicy --target arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
```
El comando no tiene ningún resultado si la solicitud se realiza correctamente.
## Descarga de certificados al dispositivo
Anteriormente, descargó el certificado de su dispositivo en su computadora de desarrollo. En esta sección, puede descargar el certificado de autoridad de certificación (CA) raíz de Amazon. A continuación, si planea ejecutar el software AWS IoT Greengrass principal de Docker en un equipo diferente al de desarrollo, debe copiar los certificados en ese equipo host. El software AWS IoT Greengrass Core usa estos certificados para conectarse al servicio AWS IoT en la nube.
**Descarga de certificados al dispositivo**
1. En tu ordenador de desarrollo, descarga el certificado de la autoridad de certificación raíz (CA) de Amazon. AWS IoT los certificados están asociados al certificado de CA raíz de Amazon de forma predeterminada.
------
#### [ Linux or Unix ]
```
sudo curl -o ./greengrass-v2-certs/AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -o .\greengrass-v2-certs\AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ PowerShell ]
```
iwr -Uri https://www.amazontrust.com/repository/AmazonRootCA1.pem -OutFile .\greengrass-v2-certs\AmazonRootCA1.pem
```
------
1. Si planea ejecutar el software AWS IoT Greengrass principal de Docker en un dispositivo diferente al de su ordenador de desarrollo, copie los certificados en el ordenador host. Si SSH y SCP están habilitados en la computadora de desarrollo y en la computadora host, puede utilizar el comando `scp` de la computadora de desarrollo para transferir el certificado. *device-ip-address*Sustitúyalos por la dirección IP de la computadora host.
```
scp -r greengrass-v2-certs/ device-ip-address:~
```
## Creación de un archivo de configuración
1. En la computadora host, cree una carpeta en la que coloque el archivo de configuración.
```
mkdir ./greengrass-v2-config
```
1. Utilice un editor de texto para crear un archivo de configuración denominado `config.yaml` en la carpeta `./greengrass-v2-config`.
Por ejemplo, puede ejecutar el comando siguiente para usar GNU nano para crear el `config.yaml`.
```
nano ./greengrass-v2-config/config.yaml
```
1. Copie el siguiente contenido YAML en el archivo. Este archivo de configuración parcial especifica los parámetros del sistema y los parámetros del núcleo de Greengrass.
```
---
system:
certificateFilePath: "/tmp/certs/device.pem.crt"
privateKeyPath: "/tmp/certs/private.pem.key"
rootCaPath: "/tmp/certs/AmazonRootCA1.pem"
rootpath: "/greengrass/v2"
thingName: "MyGreengrassCore"
services:
aws.greengrass.Nucleus:
componentType: "NUCLEUS"
version: "nucleus-version"
configuration:
awsRegion: "region"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
iotDataEndpoint: "device-data-prefix-ats.iot.region.amazonaws.com"
iotCredEndpoint: "device-credentials-prefix.credentials.region.amazonaws.com"
```
Reemplace los siguientes valores:
+ */tmp/certs*. El directorio del contenedor de Docker en el que se montan los certificados descargados al iniciar el contenedor.
+ `/greengrass/v2`. La carpeta raíz de Greengrass que quiera usar para la instalación. Puede establecer este valor mediante la variable de entorno `GGC_ROOT`.
+ *MyGreengrassCore*. El nombre de la AWS IoT cosa.
+ *nucleus-version*. La versión del software AWS IoT Greengrass principal que se va a instalar. Este valor debe coincidir con la versión de la imagen de Docker o del Dockerfile que ha descargado. Si ha descargado la imagen de Docker de Greengrass con la etiqueta `latest`, use ****docker inspect *image-id***** para ver la versión de la imagen.
+ *region*. El Región de AWS lugar donde creaste tus AWS IoT recursos. También debe especificar el mismo valor para la variable de entorno `AWS_REGION` en el [archivo de entorno](#create-env-file-manual-provisioning).
+ *GreengrassCoreTokenExchangeRoleAlias*. El alias del rol de intercambio de fichas.
+ *device-data-prefix*. El prefijo del punto final AWS IoT de datos.
+ *device-credentials-prefix*. El prefijo del punto final de tus AWS IoT credenciales.
## Creación de un archivo de entorno
En este tutorial, se utiliza un archivo de entorno para configurar las variables de entorno que se transferirán al instalador del software AWS IoT Greengrass principal dentro del contenedor de Docker. También puede utilizar [el argumento `-e` o `--env`](https://docs.docker.com/engine/reference/commandline/run/#env) en su comando `docker run` para establecer variables de entorno en el contenedor de Docker o puede establecer las variables en [un bloque `environment`](https://docs.docker.com/compose/compose-file/compose-file-v3/#environment) en el archivo `docker-compose.yml`.
1. Utilice un editor de texto para crear un archivo de política llamado `.env`.
Por ejemplo, en un sistema basado en Linux, puede ejecutar el siguiente comando para usar GNU nano para crearlo en el `.env` en el directorio actual.
```
nano .env
```
1. Copie el contenido siguiente en el archivo.
```
GGC_ROOT_PATH=/greengrass/v2
AWS_REGION=region
PROVISION=false
COMPONENT_DEFAULT_USER=ggc_user:ggc_group
INIT_CONFIG=/tmp/config/config.yaml
```
Reemplace los siguientes valores.
+ `/greengrass/v2`. La ruta a la carpeta raíz que se va a utilizar para instalar el software AWS IoT Greengrass principal.
+ *region*. El Región de AWS lugar donde creaste tus AWS IoT recursos. Debe especificar el mismo valor para el parámetro `awsRegion` de configuración en el [archivo de configuración](#create-docker-install-configuration-file).
+ */tmp/config/*. La carpeta en la que se monta el archivo de configuración al iniciar el contenedor de Docker.
**nota**
Puede configurar la variable de entorno `DEPLOY_DEV_TOOLS` a `true` para implementar el [componente CLI de Greengrass](greengrass-cli-component.md), que le permite desarrollar componentes personalizados dentro del contenedor de Docker. Se recomienda usar este componente solo en entornos de desarrollo y no en entornos de producción. Este componente brinda acceso a información y operaciones que, por lo general, no necesitará en un entorno de producción. Siga el principio de privilegio mínimo al implementar este componente solo en los dispositivos principales donde lo necesite.
## Ejecute el software AWS IoT Greengrass principal en un contenedor
Este tutorial le muestra cómo iniciar la imagen de Docker que creó en un contenedor de Docker. Puede usar la CLI de Docker o la CLI de Docker Compose para ejecutar la imagen del software AWS IoT Greengrass principal en un contenedor de Docker.
------
#### [ Docker ]
+ Este tutorial le muestra cómo iniciar la imagen de Docker que creó en un contenedor de Docker.
```
docker run --rm --init -it --name docker-image \
-v path/to/greengrass-v2-config:/tmp/config/:ro \
-v path/to/greengrass-v2-certs:/tmp/certs:ro \
--env-file .env \
-p 8883 \
your-container-image:version
```
Este comando de ejemplo usa los siguientes argumentos para [ejecutar docker](https://docs.docker.com/engine/reference/commandline/run/):
+ [https://docs.docker.com/engine/reference/run/#clean-up---rm](https://docs.docker.com/engine/reference/run/#clean-up---rm). Limpia el contenedor al salir.
+ [https://docs.docker.com/engine/reference/run/#specify-an-init-process](https://docs.docker.com/engine/reference/run/#specify-an-init-process). Utiliza un proceso de inicio en el contenedor.
**nota**
El `--init` argumento es necesario para cerrar el software AWS IoT Greengrass Core al detener el contenedor de Docker.
+ [https://docs.docker.com/engine/reference/run/#foreground](https://docs.docker.com/engine/reference/run/#foreground). (Opcional) Ejecuta el contenedor de Docker en primer plano como un proceso interactivo. En su lugar, puede sustituirlo por el argumento `-d` para ejecutar el contenedor de Docker en modo separado. Para obtener más información, consulte [Separado frente a Primer plano](https://docs.docker.com/engine/reference/run/#detached-vs-foreground) en la documentación de Docker.
+ [https://docs.docker.com/engine/reference/run/#name---name](https://docs.docker.com/engine/reference/run/#name---name). Ejecuta un contenedor llamado `aws-iot-greengrass`
+ [https://docs.docker.com/storage/volumes/](https://docs.docker.com/storage/volumes/). Monta un volumen en el contenedor de Docker para que el archivo de configuración y los archivos de certificado estén disponibles para su AWS IoT Greengrass ejecución dentro del contenedor.
+ [https://docs.docker.com/engine/reference/commandline/run/#env](https://docs.docker.com/engine/reference/commandline/run/#env). (Opcional) Especifica el archivo de entorno para establecer las variables de entorno que se pasarán al instalador del software AWS IoT Greengrass principal dentro del contenedor de Docker. Este argumento solo es necesario si ha creado un [archivo de entorno](#create-env-file-manual-provisioning) para establecer variables de entorno. Si no creó un archivo de entorno, puede usar argumentos `--env` para establecer las variables de entorno directamente en el comando run de Docker.
+ [https://docs.docker.com/engine/reference/commandline/run/#publish](https://docs.docker.com/engine/reference/commandline/run/#publish). (Opcional) Publica el puerto contenedor 8883 en la máquina host. Este argumento es obligatorio si desea conectarse y comunicarse a través de MQTT, ya que AWS IoT Greengrass utiliza el puerto 8883 para el tráfico de MQTT. Para abrir otros puertos, utilice argumentos adicionales `-p`.
**nota**
Para ejecutar su contenedor de Docker con mayor seguridad, puede usar los argumentos `--cap-drop` y `--cap-add` para habilitar de forma selectiva las capacidades de Linux para su contenedor. Para obtener más información, consulte [Privilegios en tiempo de ejecución y capacidades de Linux](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) en el sitio web de Docker.
------
#### [ Docker Compose ]
1. Utilice un editor de texto para crear un archivo Docker Compose llamado `docker-compose.yml`.
Por ejemplo, en un sistema basado en Linux, puede ejecutar el siguiente comando para usar GNU nano para crearlo en el `docker-compose.yml` en el directorio actual.
```
nano docker-compose.yml
```
**nota**
También puedes descargar y usar la última versión del archivo Compose AWS proporcionado desde. [GitHub](https://github.com/aws-greengrass/aws-greengrass-docker/releases/)
1. Agregue el siguiente contenido al archivo Compose. El archivo debe ser similar al siguiente ejemplo. *your-container-name:version*Sustitúyelo por el nombre de la imagen de Docker.
```
version: '3.7'
services:
greengrass:
init: true
build:
context: .
container_name: aws-iot-greengrass
image: your-container-name:version
volumes:
- /path/to/greengrass-v2-config:/tmp/config/:ro
- /path/to/greengrass-v2-certs:/tmp/certs:ro
env_file: .env
ports:
- "8883:8883"
```
Los siguientes parámetros del archivo Compose de ejemplo son opcionales:
+ `ports`: (Opcional) Publica el puerto contenedor 8883 en la máquina host. Este parámetro es obligatorio si desea conectarse y comunicarse a través de MQTT, ya que AWS IoT Greengrass utiliza el puerto 8883 para el tráfico de MQTT.
+ `env_file`—Especifica el archivo de entorno para establecer las variables de entorno que se pasarán al instalador del software AWS IoT Greengrass principal dentro del contenedor de Docker. Este parámetro solo es necesario si ha creado un [archivo de entorno](#create-env-file-manual-provisioning) para establecer variables de entorno. Si no creó un archivo de entorno, puede usar el parámetro de [entorno](https://docs.docker.com/compose/compose-file/compose-file-v3/#environment) para configurar las variables directamente en su archivo Compose.
**nota**
Para ejecutar su contenedor de Docker con mayor seguridad, puede usar `cap_drop` y `cap_add` en su archivo Compose para habilitar de forma selectiva las capacidades de Linux para su contenedor. Para obtener más información, consulte [Privilegios en tiempo de ejecución y capacidades de Linux](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) en el sitio web de Docker.
1. Para iniciar el contenedor, ejecute el siguiente comando.
```
docker-compose -f docker-compose.yml up
```
------
## Siguientes pasos
AWS IoT Greengrass El software principal se ejecuta ahora en un contenedor de Docker. Ejecute el siguiente comando para recuperar el ID del contenedor en el contenedor de ejecución actual.
```
docker ps
```
A continuación, puede ejecutar el siguiente comando para acceder al contenedor y explorar el software AWS IoT Greengrass principal que se ejecuta dentro del contenedor.
```
docker exec -it container-id /bin/bash
```
Para obtener más información sobre cómo crear un componente simple, consulte [Paso 4: Desarrollo y prueba de un componente en su dispositivo](create-first-component.md) en [Tutorial: Introducción a AWS IoT Greengrass V2](getting-started.md)
**nota**
Cuando utiliza `docker exec` para ejecutar comandos dentro del contenedor de Docker, esos comandos no se capturan en los registros de Docker. Para registrar los comandos en los registros de Docker, asocie un intérprete de comandos interactivo al contenedor de Docker. Para obtener más información, consulte [Asociación de un intérprete de comandos interactivo a un contenedor de Docker](docker-troubleshooting.md#debugging-docker-attach-shell).
El archivo de registro AWS IoT Greengrass Core se llama `greengrass.log` y se encuentra en`/greengrass/v2/logs`. Los archivos de registro de componentes también se encuentran en el mismo directorio. Para copiar los registros de Greengrass en un directorio temporal del host, ejecute el siguiente comando:
```
docker cp container-id:/greengrass/v2/logs /tmp/logs
```
Si desea conservar los registros después de que un contenedor se cierre o se haya eliminado, le recomendamos que monte únicamente el directorio `/greengrass/v2/logs` en el directorio de registros temporales del host, en lugar de montar todo el directorio de Greengrass. Para obtener más información, consulte [Conservación de los registros de Greengrass fuera del contenedor de Docker](docker-troubleshooting.md#debugging-docker-persist-logs).
Para detener un contenedor AWS IoT Greengrass Docker en ejecución, ejecute `docker stop` o`docker-compose -f docker-compose.yml stop`. Esta acción envía `SIGTERM` al proceso de Greengrass y cierra todos los procesos asociados que se iniciaron en el contenedor. El contenedor de Docker se inicializa con el ejecutable `docker-init` como PID 1, lo que ayuda a eliminar los procesos zombis restantes. Para obtener más información, consulte la sección [Especificar un proceso de instalación](https://docs.docker.com/engine/reference/run/#specify-an-init-process) de la documentación de Docker.
Para obtener más información acerca de la solución de problemas relacionados con la ejecución de AWS IoT Greengrass en un contenedor de Docker, consulte [Solución de problemas AWS IoT Greengrass en un contenedor Docker](docker-troubleshooting.md).
# Solución de problemas AWS IoT Greengrass en un contenedor Docker
Usa la siguiente información como ayuda para solucionar problemas relacionados con la ejecución AWS IoT Greengrass en un contenedor de Docker y para depurar los problemas AWS IoT Greengrass en el contenedor de Docker.
**Topics**
+ [Solución de problemas al ejecutar el contenedor de Docker](#troubleshooting-container-errors)
+ [Depuración en un contenedor de Docker AWS IoT Greengrass](#debugging-greengrass-in-docker)
## Solución de problemas al ejecutar el contenedor de Docker
Usa la siguiente información para solucionar problemas relacionados con la ejecución AWS IoT Greengrass en un contenedor de Docker.
**Topics**
+ [Error: No se puede realizar un inicio de sesión interactivo desde un dispositivo que no sea TTY](#docker-troubleshootin-ecr-get-login-password)
+ [Error: opciones desconocidas: - no-include-email](#docker-troubleshooting-cli-version)
+ [Error: A firewall is blocking file Sharing between windows and the containers.](#docker-troubleshooting-firewall)
+ [Error: se produjo un error (AccessDeniedException) al llamar a la GetAuthorizationToken operación: el usuario: arn:aws:iam: ::user/ no *account-id* está autorizado a realizar: ecr: on resource: \$1 GetAuthorizationToken](#docker-troubleshooting-ecr-perms)
+ [Error: Ha alcanzado su límite de tasa de cambios](#docker-troubleshooting-too-many-requests)
### Error: No se puede realizar un inicio de sesión interactivo desde un dispositivo que no sea TTY
Este error puede producirse al ejecutar el comando `aws ecr get-login-password`. Asegúrese de haber instalado la AWS CLI versión 2 o 1 más reciente. Le recomendamos que utilice la AWS CLI versión 2. Para obtener más información, consulte [Installing the AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) en la *Guía del usuario de AWS Command Line Interface *.
### Error: opciones desconocidas: - no-include-email
Este error puede producirse al ejecutar el comando `aws ecr get-login`. Asegúrese de tener instalada la última AWS CLI versión (por ejemplo, Run:`pip install awscli --upgrade --user`). Para obtener más información, consulte [Instalación de AWS Command Line Interface en Microsoft Windows](https://docs.aws.amazon.com/cli/latest/userguide/awscli-install-windows.html) en la *Guía del AWS Command Line Interface usuario*.
### Error: A firewall is blocking file Sharing between windows and the containers.
Puede que reciba este error o un mensaje `Firewall Detected` al ejecutar Docker en un equipo Windows. Esto también puede ocurrir si ha iniciado sesión en una red privada virtual (VPN) y su configuración de red impide el montaje de la unidad compartida. En esta situación, desactive la VPN y vuelva a ejecutar el contenedor Docker.
### Error: se produjo un error (AccessDeniedException) al llamar a la GetAuthorizationToken operación: el usuario: arn:aws:iam: ::user/ no *account-id* está autorizado a realizar: ecr: on resource: \$1 GetAuthorizationToken
Puede recibir este error al ejecutar el comando `aws ecr get-login-password` si no tiene los permisos suficientes para acceder a un repositorio de Amazon ECR. Para obtener más información, consulte los [Ejemplos de políticas de repositorios de Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-policy-examples.html) y el [Acceso a un repositorio de Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/security_iam_id-based-policy-examples.html) en la *Guía del usuario de Amazon ECR*.
### Error: Ha alcanzado su límite de tasa de cambios
Docker Hub limita la cantidad de solicitudes de cambio que pueden realizar los usuarios anónimos y gratuitos de Docker Hub. Si supera los límites de tasa de solicitudes de cambio de usuarios anónimos o gratuitos, entonces recibe uno de los siguientes errores:
```
ERROR: toomanyrequests: Too Many Requests.
```
```
You have reached your pull rate limit.
```
Para resolver estos errores, puede esperar unas horas antes de intentar realizar otra solicitud de cambio. Si planea enviar una gran cantidad de solicitudes de cambio de forma constante, visite el [sitio web de Docker Hub](https://www.docker.com/increase-rate-limits) para obtener información sobre los límites de tasa y las opciones para autenticar y actualizar su cuenta de Docker.
## Depuración en un contenedor de Docker AWS IoT Greengrass
Para depurar problemas con un contenedor de Docker, puede conservar los registros del tiempo de ejecución de Greengrass o asociar un intérprete de comandos interactivo al contenedor de Docker.
### Conservación de los registros de Greengrass fuera del contenedor de Docker
Tras detener un AWS IoT Greengrass contenedor, puede usar el siguiente `docker cp ` comando para copiar los registros de Greengrass del contenedor de Docker a un directorio de registros temporal.
```
docker cp container-id:/greengrass/v2/logs /tmp/logs
```
Para conservar los registros incluso después de que un contenedor salga o se elimine, debe ejecutar el contenedor AWS IoT Greengrass Docker después de montar el directorio en un enlace. `/greengrass/v2/logs`
Para montar el `/greengrass/v2/logs` directorio de forma binaria, realiza una de las siguientes acciones cuando ejecutes un nuevo contenedor de Docker. AWS IoT Greengrass
+ Incluya `-v /tmp/logs:/greengrass/v2/logs:ro` en su comando `docker run`.
Modifique el bloque `volumes` en el archivo de Compose para incluir la siguiente línea antes de ejecutar el comando `docker-compose up`.
```
volumes:
- /tmp/logs:/greengrass/v2/logs:ro
```
A continuación, puede comprobar sus registros `/tmp/logs` en su host para ver los registros de Greengrass mientras AWS IoT Greengrass se ejecuta dentro del contenedor de Docker.
Para obtener información sobre cómo ejecutar contenedores de Docker de Greengrass, consulte [Se ejecuta AWS IoT Greengrass en Docker con aprovisionamiento manual](run-greengrass-docker-manual-provisioning.md) y [Se ejecuta AWS IoT Greengrass en Docker con aprovisionamiento automático](run-greengrass-docker-automatic-provisioning.md).
### Asociación de un intérprete de comandos interactivo a un contenedor de Docker
Cuando utiliza `docker exec` para ejecutar comandos dentro del contenedor de Docker, esos comandos no se capturan en los registros de Docker. Registrar los comandos en los registros de Docker puede ayudarlo a investigar el estado del contenedor de Docker de Greengrass. Realice una de las siguientes acciones:
+ Ejecute el siguiente comando en un terminal independiente para adjuntar la entrada, la salida y el error estándar del terminal al contenedor en ejecución. Esto le permite ver y controlar el contenedor de Docker desde su terminal actual.
```
docker attach container-id
```
+ Ejecute el siguiente comando en un terminal independiente. Esto le permite ejecutar sus comandos en modo interactivo, incluso si el contenedor no está conectado.
```
docker exec -it container-id sh -c "command > /proc/1/fd/1"
```
Para obtener información general sobre la AWS IoT Greengrass solución de problemas, consulte. [Solución de problemas AWS IoT Greengrass V2](troubleshooting.md)
# Configurar el software AWS IoT Greengrass principal
El software AWS IoT Greengrass Core ofrece opciones que puede utilizar para configurar el software. Puede crear implementaciones para configurar el software AWS IoT Greengrass principal en cada dispositivo principal.
**Topics**
+ [Implementación del componente núcleo de Greengrass](#configure-nucleus-component)
+ [Configuración del núcleo de Greengrass como un servicio del sistema](#configure-system-service)
+ [Control de la asignación de memoria con las opciones de JVM](#jvm-tuning)
+ [Configuración del usuario que ejecuta los componentes](#configure-component-user)
+ [Configuración de los límites de recursos del sistema para los componentes](#configure-component-system-resource-limits)
+ [Realizar la conexión en el puerto 443 o a través de un proxy de red](#configure-alpn-network-proxy)
+ [Use un certificado de dispositivo firmado por una CA privada](#configure-nucleus-private-ca)
+ [Configuración de los tiempos de espera y los ajustes de caché de MQTT](#configure-mqtt)
+ [Configurar Greengrass Nucleus en la red IPv6](#configure-ipv6)
## Implementación del componente núcleo de Greengrass
AWS IoT Greengrass proporciona el software AWS IoT Greengrass Core como un componente que puede implementar en sus dispositivos principales de Greengrass. Puede crear una implementación para aplicar la misma configuración a varios dispositivos principales de Greengrass. Para obtener más información, consulte [Núcleo de Greengrass](greengrass-nucleus-component.md) y [Actualización del software AWS IoT Greengrass Core (OTA)](update-greengrass-core-v2.md).
## Configuración del núcleo de Greengrass como un servicio del sistema
Debe configurar el software AWS IoT Greengrass Core como un servicio del sistema en el sistema de inicio de su dispositivo para hacer lo siguiente:
+ Inicie el software AWS IoT Greengrass Core cuando se inicie el dispositivo. Esta es una buena práctica si administra grandes flotas de dispositivos.
+ Instale y ejecute los componentes del complemento. Varios AWS de los componentes proporcionados son componentes de complementos, lo que les permite interactuar directamente con el núcleo de Greengrass. Para obtener más información acerca de los tipos de componentes, consulte [Tipos de componentes](develop-greengrass-components.md#component-types).
+ Aplique las actualizaciones over-the-air (OTA) al software principal del dispositivo AWS IoT Greengrass principal. Para obtener más información, consulte [Actualización del software AWS IoT Greengrass Core (OTA)](update-greengrass-core-v2.md).
+ Permita que los componentes reinicien el software AWS IoT Greengrass principal o el dispositivo principal cuando una implementación actualice el componente a una nueva versión o actualice ciertos parámetros de configuración. Para obtener más información, consulte el [paso del ciclo de vida de arranque](component-recipe-reference.md#bootstrap-lifecycle-definition).
**importante**
En los dispositivos principales de Windows, debe configurar el software AWS IoT Greengrass principal como un servicio del sistema.
**Topics**
+ [Configuración del núcleo como un servicio del sistema (Linux)](#configure-system-service-linux)
+ [Configuración del núcleo como un servicio del sistema (Windows)](#configure-system-service-windows)
### Configuración del núcleo como un servicio del sistema (Linux)
Los dispositivos Linux admiten diferentes sistemas de inicio, como initd, systemd y SystemV. El `--setup-system-service true` argumento se utiliza al instalar el software AWS IoT Greengrass Core para iniciar el núcleo como un servicio del sistema y configurarlo para que se inicie cuando se inicie el dispositivo. El instalador configura el software AWS IoT Greengrass Core como un servicio del sistema con systemd.
También puede configurar manualmente el núcleo para que se ejecute como un servicio del sistema. En el siguiente ejemplo se muestra un archivo de servicio para systemd.
```
[Unit]
Description=Greengrass Core
[Service]
Type=simple
PIDFile=/greengrass/v2/alts/loader.pid
RemainAfterExit=no
Restart=on-failure
RestartSec=10
ExecStart=/bin/sh /greengrass/v2/alts/current/distro/bin/loader
[Install]
WantedBy=multi-user.target
```
Tras configurar el servicio del sistema, puede ejecutar los siguientes comandos para configurar el inicio del dispositivo al arrancar y para iniciar o detener el software AWS IoT Greengrass principal.
+ Comprobar el estado del servicio (systemd)
```
sudo systemctl status greengrass.service
```
+ Permitir que el núcleo se inicie al arrancar el dispositivo.
```
sudo systemctl enable greengrass.service
```
+ Impedir que el núcleo se inicie al arrancar el dispositivo.
```
sudo systemctl disable greengrass.service
```
+ Para iniciar el software AWS IoT Greengrass principal.
```
sudo systemctl start greengrass.service
```
+ Para detener el software AWS IoT Greengrass Core.
```
sudo systemctl stop greengrass.service
```
### Configuración del núcleo como un servicio del sistema (Windows)
El `--setup-system-service true` argumento se utiliza al instalar el software AWS IoT Greengrass Core para iniciar el núcleo como un servicio de Windows y configurarlo para que se inicie al arrancar el dispositivo.
Tras configurar el servicio, puede ejecutar los siguientes comandos para configurar el inicio del dispositivo durante el arranque y para iniciar o detener el software AWS IoT Greengrass Core. Debe ejecutar la línea de comandos o PowerShell como administrador para ejecutar estos comandos.
------
#### [ Windows Command Prompt (CMD) ]
+ Comprobar el estado del servicio
```
sc query "greengrass"
```
+ Permitir que el núcleo se inicie al arrancar el dispositivo.
```
sc config "greengrass" start=auto
```
+ Impedir que el núcleo se inicie al arrancar el dispositivo.
```
sc config "greengrass" start=disabled
```
+ Para iniciar el software AWS IoT Greengrass principal.
```
sc start "greengrass"
```
+ Para detener el software AWS IoT Greengrass Core.
```
sc stop "greengrass"
```
**nota**
En los dispositivos Windows, el software AWS IoT Greengrass Core ignora esta señal de apagado mientras cierra los procesos de los componentes de Greengrass. Si el software AWS IoT Greengrass Core ignora la señal de apagado al ejecutar este comando, espere unos segundos e inténtelo de nuevo.
------
#### [ PowerShell ]
+ Comprobar el estado del servicio
```
Get-Service -Name "greengrass"
```
+ Permitir que el núcleo se inicie al arrancar el dispositivo.
```
Set-Service -Name "greengrass" -Status stopped -StartupType automatic
```
+ Impedir que el núcleo se inicie al arrancar el dispositivo.
```
Set-Service -Name "greengrass" -Status stopped -StartupType disabled
```
+ Para iniciar el software AWS IoT Greengrass Core.
```
Start-Service -Name "greengrass"
```
+ Para detener el software AWS IoT Greengrass Core.
```
Stop-Service -Name "greengrass"
```
**nota**
En los dispositivos Windows, el software AWS IoT Greengrass Core ignora esta señal de apagado mientras cierra los procesos de los componentes de Greengrass. Si el software AWS IoT Greengrass Core ignora la señal de apagado al ejecutar este comando, espere unos segundos e inténtelo de nuevo.
------
## Control de la asignación de memoria con las opciones de JVM
Si utilizas un dispositivo con memoria limitada, puedes usar las opciones de la máquina virtual Java (JVM) para controlar el tamaño máximo del montón, los modos de recolección de basura y las opciones del compilador, que controlan la cantidad de memoria que AWS IoT Greengrass utiliza el software Core. AWS IoT Greengrass El tamaño del montón de la JVM determina la cantidad de memoria que puede usar una aplicación antes de que se produzca la [recopilación de elementos no utilizados](https://docs.oracle.com/javase/8/docs/technotes/guides/vm/gctuning/introduction.html) o antes de que la aplicación se quede sin memoria. El tamaño de montón máximo especifica la cantidad máxima de memoria que la JVM puede asignar al ampliar el montón durante un periodo de actividad intensa.
Para controlar la asignación de memoria, cree una nueva implementación o revise una implementación existente que incluya el componente núcleo y especifique las opciones de JVM en el parámetro de configuración `jvmOptions` de la [configuración del componente núcleo](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration-jvm-options).
En función de sus necesidades, puede ejecutar el software AWS IoT Greengrass Core con una asignación de memoria reducida o con una asignación de memoria mínima.
**Asignación de memoria reducida**
Para ejecutar el software AWS IoT Greengrass Core con una asignación de memoria reducida, le recomendamos que utilice el siguiente ejemplo de actualización de combinación de configuraciones para configurar las opciones de JVM en su configuración de núcleo:
```
{
"jvmOptions": "-XX:+UseSerialGC -XX:TieredStopAtLevel=1"
}
```
**Asignación de memoria mínima**
Para ejecutar el software AWS IoT Greengrass Core con una asignación de memoria mínima, le recomendamos que utilice el siguiente ejemplo de actualización de combinación de configuraciones para configurar las opciones de JVM en su configuración de núcleo:
```
{
"jvmOptions": "-Xmx32m -XX:+UseSerialGC -Xint"
}
```
**importante**
La ejecución AWS IoT Greengrass del software Core con una asignación de memoria mínima puede tener un impacto significativo en el rendimiento en sistemas de baja especificación, ya que la JVM procesará más cuando utilice menos memoria. Recomendamos ajustar las opciones para equilibrar las necesidades de memoria y rendimiento.
Estos ejemplos de actualizaciones de combinación de configuraciones usan las siguientes opciones de JVM:
`-XX:+UseSerialGC`
Especifica el uso de la recopilación de elementos no utilizados en serie para el espacio del montón de JVM. La recopilación de elementos no utilizados en serie es más lenta, pero usa menos memoria que otras implementaciones de recopilación de elementos no utilizados de JVM.
`-XX:TieredStopAtLevel=1`
Indica a la JVM que utilice el compilador de Java just-in-time (JIT) una vez. Como el código compilado JIT ocupa espacio en la memoria del dispositivo, usar el compilador JIT más de una vez consume más memoria que una sola compilación.
`-XmxNNm`
Establece el tamaño máximo de los montones de JVM.
Si el tamaño máximo del montón es demasiado bajo, se pueden producir errores o ralentizar el rendimiento. out-of-memory Recomendamos medir el uso actual del montón antes de establecer un tamaño máximo con la opción `-XmxNNm`. Configure su JVM con la opción de JVM `-XX:NativeMemoryTracking=detail`. A continuación, mida el uso actual del montón mediante la solicitud de comando `VM.native_memory` dentro de la [utilidad jcmd](https://docs.oracle.com/javase/8/docs/technotes/guides/troubleshoot/tooldescr006.html).
Si la medición del montón no es una opción, use `-Xmx64m` como valor inicial para limitar el tamaño del montón a 64 MB. A partir de ahí, puede reducir gradualmente el tamaño máximo del montón. Para una asignación de memoria mínima, use `-Xmx32m` como valor inicial para limitar el tamaño del montón a 32 MB.
Puede aumentar o disminuir el valor `-Xmx` en función de sus necesidades reales; sin embargo, le recomendamos encarecidamente que no establezca el tamaño máximo del montón por debajo de 16 MB. La cantidad de tamaño de montón de JVM necesaria también puede variar con el tiempo en función de los componentes del complemento implementados en el dispositivo principal. Si el tamaño máximo del montón es demasiado bajo para su entorno, es posible que el software AWS IoT Greengrass Core detecte errores inesperados debido a la falta de memoria. Si el rendimiento es más lento o se producen errores debido a una memoria insuficiente, vuelva a una configuración que se sepa que es correcta. Por ejemplo, si el tamaño normal del montón asignado es `41428KB`, use `-Xmx40m` para limitar ligeramente el uso del montón.
`-Xint`
Indica a la JVM que no utilice el compilador just-in-time (JIT). En su lugar, la JVM se ejecuta en modo de solo interpretación. Este modo es más lento (potencialmente 20 veces más lento para las implementaciones en sistemas de gama baja) que ejecutar código compilado por JIT; sin embargo, el código compilado no ocupa espacio en la memoria.
Para obtener información sobre la creación de actualizaciones de combinación de configuraciones, consulte [Actualización de las configuraciones de los componentes](update-component-configurations.md).
## Configuración del usuario que ejecuta los componentes
El software AWS IoT Greengrass Core puede ejecutar procesos componentes como usuario y grupo del sistema distintos del que ejecuta el software. Esto aumenta la seguridad, ya que puede ejecutar el software AWS IoT Greengrass principal como usuario root o como usuario administrador, sin conceder esos permisos a los componentes que se ejecutan en el dispositivo principal.
En la siguiente tabla se indican los tipos de componentes que el software AWS IoT Greengrass principal puede ejecutar como usuario que especifique. Para obtener más información, consulte [Tipos de componentes](develop-greengrass-components.md#component-types).
| Tipo de componente | Configuración del usuario del componente |
| --- | --- |
| Núcleo | ![\[No\]](http://docs.aws.amazon.com/es_es/greengrass/v2/developerguide/images/icon-no.png) No |
| Complemento | ![\[No\]](http://docs.aws.amazon.com/es_es/greengrass/v2/developerguide/images/icon-no.png) No |
| Genérico | ![\[Yes\]](http://docs.aws.amazon.com/es_es/greengrass/v2/developerguide/images/icon-yes.png) Sí |
| Lambda (no contenerizado) | ![\[Yes\]](http://docs.aws.amazon.com/es_es/greengrass/v2/developerguide/images/icon-yes.png) Sí |
| Lambda (en contenedor) | ![\[Yes\]](http://docs.aws.amazon.com/es_es/greengrass/v2/developerguide/images/icon-yes.png) Sí |
Debe crear el usuario del componente antes de poder especificarlo en una configuración de implementación. En los dispositivos basados en Windows, también debe almacenar el nombre de usuario y la contraseña del usuario en la instancia del administrador de credenciales de la LocalSystem cuenta. Para obtener más información, consulte [Configuración de un usuario del componente en dispositivos Windows](#create-component-user-windows).
Al configurar el usuario del componente en un dispositivo basado en Linux, también puede especificar un grupo si lo desea. Especifique el usuario y el grupo separados por dos puntos (`:`) con el siguiente formato: `user:group`. Si no especifica ningún grupo, el software AWS IoT Greengrass principal utilizará de forma predeterminada el grupo principal del usuario. Puede usar el nombre o el ID para identificar al usuario y al grupo.
En los dispositivos basados en Linux, también puede ejecutar componentes como un usuario del sistema que no existe (también denominado usuario desconocido) para aumentar la seguridad. Un proceso de Linux puede indicar cualquier otro proceso que ejecute el mismo usuario. Un usuario desconocido no ejecuta otros procesos, por lo que puede ejecutar componentes como un usuario desconocido para evitar que los componentes señalen otros componentes del dispositivo principal. Para ejecutar los componentes como un usuario desconocido, especifique un ID de usuario que no exista en el dispositivo principal. También puede especificar un ID de grupo que no existe para que se ejecute como un grupo desconocido.
Puede configurar el usuario para cada componente y para cada dispositivo principal.
+ **Configuración para un componente**
Puede configurar cada componente para que se ejecute con un usuario específico de ese componente. Al crear una implementación, puede especificar el usuario para cada componente de la configuración `runWith` de ese componente. El software AWS IoT Greengrass principal ejecuta los componentes como el usuario especificado si los configura. De lo contrario, se ejecutarán los componentes de forma predeterminada como el usuario predeterminado que configure para el dispositivo principal. Para obtener más información sobre cómo especificar el usuario del componente en la configuración de implementación, consulte el parámetro de configuración [`runWith`](create-deployments.md#component-run-with-config) en [Crear implementaciones](create-deployments.md).
+ **Configuración del usuario predeterminado para un dispositivo principal**
Puede configurar un usuario predeterminado que el software AWS IoT Greengrass Core utilice para ejecutar los componentes. Cuando el software AWS IoT Greengrass principal ejecuta un componente, comprueba si ha especificado un usuario para ese componente y lo utiliza para ejecutar el componente. Si el componente no especifica un usuario, el software AWS IoT Greengrass principal ejecuta el componente como el usuario predeterminado que configuró para el dispositivo principal. Para obtener más información, consulte [Configuración del usuario del componente predeterminado](#configure-default-component-user).
**nota**
En los dispositivos basados en Windows, debe especificar al menos un usuario predeterminado para ejecutar los componentes.
En los dispositivos basados en Linux, se deben tener en cuenta las siguientes consideraciones si no se configura un usuario para que ejecute componentes:
Si ejecuta el software AWS IoT Greengrass principal como root, el software no ejecutará los componentes. Debe especificar un usuario predeterminado para ejecutar los componentes si ejecuta los componentes como raíz.
Si ejecuta el software AWS IoT Greengrass Core como un usuario que no es root, el software ejecuta los componentes como ese usuario.
**Topics**
+ [Configuración de un usuario del componente en dispositivos Windows](#create-component-user-windows)
+ [Configuración del usuario del componente predeterminado](#configure-default-component-user)
### Configuración de un usuario del componente en dispositivos Windows
**Cómo configurar un usuario del componente en un dispositivo basado en Windows**
1. Cree el usuario del componente en la LocalSystem cuenta del dispositivo.
```
net user /add component-user password
```
1. Utilice [la PsExec utilidad de Microsoft](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec) para almacenar el nombre de usuario y la contraseña del usuario del componente en la instancia de Credential Manager de la LocalSystem cuenta.
```
psexec -s cmd /c cmdkey /generic:component-user /user:component-user /pass:password
```
**nota**
En los dispositivos basados en Windows, la LocalSystem cuenta ejecuta el núcleo de Greengrass y debe utilizar PsExec la utilidad para almacenar la información del usuario del componente en LocalSystem la cuenta. El uso de la aplicación Credential Manager almacena esta información en la cuenta de Windows del usuario que ha iniciado sesión actualmente, en lugar de en la cuenta. LocalSystem
### Configuración del usuario del componente predeterminado
Puede usar una implementación para configurar el usuario predeterminado en un dispositivo principal. En esta implementación, se actualiza la configuración de los [componentes del núcleo](greengrass-nucleus-component.md).
**nota**
También puede configurar el usuario predeterminado al instalar el software AWS IoT Greengrass principal con la `--component-default-user` opción. Para obtener más información, consulte [Instalación del software AWS IoT Greengrass Core](install-greengrass-core-v2.md).
[Cree una implementación](create-deployments.md) que especifique la siguiente actualización de configuración para el componente `aws.greengrass.Nucleus`.
------
#### [ Linux ]
```
{
"runWithDefault": {
"posixUser": "ggc_user:ggc_group"
}
}
```
------
#### [ Windows ]
```
{
"runWithDefault": {
"windowsUser": "ggc_user"
}
}
```
**nota**
El usuario que especifique debe existir y el nombre de usuario y la contraseña de este usuario deben estar almacenados en la instancia del administrador de credenciales de la LocalSystem cuenta de su dispositivo Windows. Para obtener más información, consulte [Configuración de un usuario del componente en dispositivos Windows](#create-component-user-windows).
------
En el siguiente ejemplo, se define una implementación para un dispositivo basado en Linux que configura `ggc_user` como usuario predeterminado y `ggc_group` como grupo predeterminado. La actualización de configuración `merge` requiere un objeto JSON serializado.
```
{
"components": {
"aws.greengrass.Nucleus": {
"version": "2.16.1",
"configurationUpdate": {
"merge": "{\"runWithDefault\":{\"posixUser\":\"ggc_user:ggc_group\"}}"
}
}
}
}
```
## Configuración de los límites de recursos del sistema para los componentes
**nota**
Esta función está disponible para la versión 2.4.0 y versiones posteriores del componente núcleo de [Greengrass](greengrass-nucleus-component.md). AWS IoT Greengrass actualmente no admite esta función en los dispositivos principales de Windows.
Puede configurar la cantidad máxima de uso de CPU y RAM que cada proceso de un componente pueden usar en el dispositivo principal.
En la siguiente tabla, se muestran los tipos de componentes que admiten los límites de recursos del sistema. Para obtener más información, consulte [Tipos de componentes](develop-greengrass-components.md#component-types).
| Tipo de componente | Configuración de los límites de recursos del sistema |
| --- | --- |
| Núcleo | ![\[No\]](http://docs.aws.amazon.com/es_es/greengrass/v2/developerguide/images/icon-no.png) No |
| Complemento | ![\[No\]](http://docs.aws.amazon.com/es_es/greengrass/v2/developerguide/images/icon-no.png) No |
| Genérico | ![\[Yes\]](http://docs.aws.amazon.com/es_es/greengrass/v2/developerguide/images/icon-yes.png) Sí |
| Lambda (no contenerizado) | ![\[Yes\]](http://docs.aws.amazon.com/es_es/greengrass/v2/developerguide/images/icon-yes.png) Sí |
| Lambda (en contenedor) | ![\[No\]](http://docs.aws.amazon.com/es_es/greengrass/v2/developerguide/images/icon-no.png) No |
**importante**
Los límites de recursos del sistema no se admiten cuando se [ejecuta el software AWS IoT Greengrass principal en un contenedor de Docker](run-greengrass-docker.md).
Puede configurar los límites de recursos del sistema para cada componente y para cada dispositivo principal.
+ **Configuración para un componente**
Puede configurar cada componente con los límites de recursos del sistema específicos para ese componente. Al crear una implementación, puede especificar los límites de recursos del sistema para cada componente de la implementación. Si el componente admite los límites de recursos del sistema, el software AWS IoT Greengrass Core aplica los límites a los procesos del componente. Si no especificas los límites de recursos del sistema para un componente, el software AWS IoT Greengrass principal utilizará los valores predeterminados que hayas configurado para el dispositivo principal. Para obtener más información, consulte [Crear implementaciones](create-deployments.md).
+ **Configuración de los valores predeterminados para un dispositivo principal**
Puede configurar los límites de recursos del sistema predeterminados que el software AWS IoT Greengrass Core aplica a los componentes que admiten estos límites. Cuando el software AWS IoT Greengrass principal ejecuta un componente, aplica los límites de recursos del sistema que especifique para ese componente. Si ese componente no especifica los límites de recursos del sistema, el software AWS IoT Greengrass Core aplica los límites de recursos del sistema predeterminados que usted configure para el dispositivo principal. Si no especificas los límites de recursos del sistema predeterminados, el software AWS IoT Greengrass Core no aplicará ningún límite de recursos del sistema de forma predeterminada. Para obtener más información, consulte [Configuración de los límites de recursos del sistema predeterminados](#configure-default-component-system-resource-limits).
### Configuración de los límites de recursos del sistema predeterminados
Puede implementar el [componente núcleo de Greengrass](greengrass-nucleus-component.md) para configurar los límites de recursos del sistema predeterminados para un dispositivo principal. Para configurar los límites de recursos del sistema predeterminados, [cree una implementación](create-deployments.md) que especifique la siguiente actualización de configuración para el componente `aws.greengrass.Nucleus`.
```
{
"runWithDefault": {
"systemResourceLimits": {
"cpu": cpuTimeLimit,
"memory": memoryLimitInKb
}
}
}
```
En el siguiente ejemplo, se define una implementación que configura el límite de tiempo de la CPU en `2`, lo que equivale al 50 % de uso en un dispositivo con 4 núcleos de CPU. Este ejemplo también configura el uso de memoria en 100 MB.
```
{
"components": {
"aws.greengrass.Nucleus": {
"version": "2.16.1",
"configurationUpdate": {
"merge": "{\"runWithDefault\":{\"systemResourceLimits\":\"cpus\":2,\"memory\":102400}}}"
}
}
}
}
```
## Realizar la conexión en el puerto 443 o a través de un proxy de red
AWS IoT Greengrass los dispositivos principales se comunican AWS IoT Core mediante el protocolo de mensajería MQTT con autenticación de cliente TLS. Convencionalmente, MQTT sobre TLS utiliza el puerto 8883. Sin embargo, como medida de seguridad, los entornos restrictivos podrían limitar el tráfico de entrada y salida a un pequeño rango de puertos TCP. Por ejemplo, el firewall de una compañía podría abrir el puerto 443 para el tráfico HTTPS, pero cerrar otros puertos que se utilizan para protocolos menos frecuentes, como, por ejemplo, el puerto 8883 para tráfico MQTT. Otros entornos restrictivos podrían requerir que todo el tráfico pase a través de un proxy antes de conectarse a Internet.
**nota**
Los dispositivos principales de Greengrass que ejecutan el [componente núcleo de Greengrass](greengrass-nucleus-component.md) v2.0.3 y versiones anteriores utilizan el puerto 8443 para conectarse al punto final del plano de datos. AWS IoT Greengrass Estos dispositivos deben poder conectarse a este punto de conexión en el puerto 8443. Para obtener más información, consulte [Cómo permitir el tráfico del dispositivo a través de un proxy o firewall](allow-device-traffic.md).
Para habilitar la comunicación en estos escenarios, AWS IoT Greengrass proporciona las siguientes opciones de configuración:
+ **Comunicación MQTT a través del puerto 443**. Si su red permite realizar conexiones al puerto 443, puede configurar el dispositivo principal de Greengrass para usar el puerto 443 para tráfico MQTT en lugar del puerto predeterminado 8883. Esto puede ser una conexión directa al puerto 443 o una conexión a través de un servidor proxy de red. A diferencia de la configuración predeterminada, que usa la autenticación de cliente basada en certificados, el MQTT del puerto 443 usa la función de [rol de servicio del dispositivo](device-service-role.md) para la autenticación.
Para obtener más información, consulte [Configuración de MQTT a través del puerto 443](#configure-mqtt-port-443).
+ **Comunicación HTTPS a través del puerto 443**. El software AWS IoT Greengrass principal envía el tráfico HTTPS a través del puerto 8443 de forma predeterminada, pero puede configurarlo para que utilice el puerto 443. AWS IoT Greengrass utiliza la extensión TLS de [Application Layer Protocol Network](https://tools.ietf.org/html/rfc7301) (ALPN) para habilitar esta conexión. Como en el caso de la configuración predeterminada, HTTPS en el puerto 443 usa la autenticación de cliente basada en certificados.
**importante**
Para usar ALPN y habilitar la comunicación HTTPS a través del puerto 443, el dispositivo principal debe ejecutar la actualización 252 o posterior de Java 8. Todas las actualizaciones de la versión 9 y posteriores de Java también son compatibles con ALPN.
Para obtener más información, consulte [Configuración de HTTPS a través del puerto 443](#configure-https-port-443).
+ **Conexión a través de un proxy de red**. Puede configurar un servidor proxy de red para que actúe como intermediario para conectarse al dispositivo principal de Greengrass. AWS IoT Greengrass admite la autenticación básica para los proxy de HTTP y HTTPS.
Los dispositivos principales de Greengrass deben ejecutar la versión 2.5.0 o versiones posteriores del [núcleo de Greengrass ](greengrass-nucleus-component.md) para usar proxies HTTPS.
El software AWS IoT Greengrass principal transfiere la configuración del proxy a los componentes a través de las `ALL_PROXY` variables de `NO_PROXY` entorno `HTTP_PROXY``HTTPS_PROXY`,, y. Los componentes deben utilizar estos ajustes para conectarse a través del proxy. Los componentes usan bibliotecas (como boto3 o cURL y los paquetes `requests` de Python) que suelen usar estas variables de entorno de forma predeterminada para hacer conexiones. Si un componente también especifica estas variables de entorno, AWS IoT Greengrass no las invalida.
Para obtener más información, consulte [Configuración de un proxy de red](#configure-network-proxy).
### Configuración de MQTT a través del puerto 443
Puede configurar MQTT a través del puerto 443 en los dispositivos principales existentes o al instalar el software AWS IoT Greengrass Core en un dispositivo principal nuevo.
**Topics**
+ [Configuración de MQTT a través del puerto 443 en los dispositivos principales existentes](#configure-mqtt-port-443-deployment)
+ [Configuración de MQTT a través del puerto 443 durante la instalación](#configure-mqtt-port-443-installer)
#### Configuración de MQTT a través del puerto 443 en los dispositivos principales existentes
Puede usar una implementación para configurar MQTT a través del puerto 443 en un único dispositivo principal o en un grupo de dispositivos principales. En esta implementación, se actualiza la configuración de los [componentes del núcleo](greengrass-nucleus-component.md). El núcleo se reinicia al actualizar su configuración `mqtt`.
Para configurar MQTT a través del puerto 443, [cree una implementación](create-deployments.md) que especifique la siguiente actualización de configuración para el componente `aws.greengrass.Nucleus`.
```
{
"mqtt": {
"port": 443
}
}
```
En el siguiente ejemplo, se define una implementación que configura MQTT a través del puerto 443. La actualización de configuración `merge` requiere un objeto JSON serializado.
```
{
"components": {
"aws.greengrass.Nucleus": {
"version": "2.16.1",
"configurationUpdate": {
"merge": "{\"mqtt\":{\"port\":443}}"
}
}
}
}
```
#### Configuración de MQTT a través del puerto 443 durante la instalación
Puede configurar MQTT a través del puerto 443 al instalar el software AWS IoT Greengrass Core en un dispositivo principal. Use el argumento del instalador `--init-config` para configurar MQTT a través del puerto 443. Puede especificar este argumento al realizar la instalación con [aprovisionamiento manual](manual-installation.md), [aprovisionamiento de flota](fleet-provisioning.md) o [aprovisionamiento personalizado](custom-provisioning.md).
### Configuración de HTTPS a través del puerto 443
Esta característica requiere la versión 2.0.4 o posterior de [Núcleo de Greengrass](greengrass-nucleus-component.md).
Puede configurar HTTPS a través del puerto 443 en los dispositivos principales existentes o al instalar el software AWS IoT Greengrass Core en un dispositivo principal nuevo.
**Topics**
+ [Configuración de HTTPS a través del puerto 443 en los dispositivos principales existentes](#configure-https-port-443-deployment)
+ [Configuración de HTTPS a través del puerto 443 durante la instalación](#configure-https-port-443-installer)
#### Configuración de HTTPS a través del puerto 443 en los dispositivos principales existentes
Puede usar una implementación para configurar HTTPS a través del puerto 443 en un único dispositivo principal o en un grupo de dispositivos principales. En esta implementación, se actualiza la configuración de los [componentes del núcleo](greengrass-nucleus-component.md).
Para configurar HTTPS a través del puerto 443, [cree una implementación](create-deployments.md) que especifique la siguiente actualización de configuración para el componente `aws.greengrass.Nucleus`.
```
{
"greengrassDataPlanePort": 443
}
```
En el ejemplo siguiente, se define una implementación que configura HTTPS a través del puerto 443. La actualización de configuración `merge` requiere un objeto JSON serializado.
```
{
"components": {
"aws.greengrass.Nucleus": {
"version": "2.16.1",
"configurationUpdate": {
"merge": "{\"greengrassDataPlanePort\":443}"
}
}
}
}
```
#### Configuración de HTTPS a través del puerto 443 durante la instalación
Puede configurar HTTPS a través del puerto 443 al instalar el software AWS IoT Greengrass Core en un dispositivo principal. Use el argumento del instalador `--init-config` para configurar HTTPS a través del puerto 443. Puede especificar este argumento al realizar la instalación con [aprovisionamiento manual](manual-installation.md), [aprovisionamiento de flota](fleet-provisioning.md) o [aprovisionamiento personalizado](custom-provisioning.md).
### Configuración de un proxy de red
Siga el procedimiento de esta sección para configurar los dispositivos principales de Greengrass para que se conecten a Internet a través de un proxy de red HTTP o HTTPS. Para obtener más información acerca de los puntos de conexión y los puertos que usan los dispositivos principales, consulte [Cómo permitir el tráfico del dispositivo a través de un proxy o firewall](allow-device-traffic.md).
**importante**
Si su dispositivo principal ejecuta una versión del [núcleo de Greengrass](greengrass-nucleus-component.md) anterior a la 2.4.0, la función de su dispositivo debe permitir los siguientes permisos para usar un proxy de red:
`iot:Connect`
`iot:Publish`
`iot:Receive`
`iot:Subscribe`
Esto es necesario porque el dispositivo utiliza AWS las credenciales del servicio de intercambio de fichas para autenticar las conexiones MQTT. AWS IoT El dispositivo utiliza MQTT para recibir e instalar las implementaciones desde allí Nube de AWS, por lo que el dispositivo no funcionará a menos que defina estos permisos en función de su función. Los dispositivos suelen usar certificados X.509 para autenticar las conexiones MQTT, pero los dispositivos no pueden hacerlo para autenticarse cuando usan un proxy.
Para obtener más información acerca de cómo configurar el rol de dispositivo, consulte [Autorizar a los dispositivos principales a interactuar con AWS los servicios](device-service-role.md).
**Topics**
+ [Configuración de un proxy de red en dispositivos principales existentes](#configure-network-proxy-deployment)
+ [Configuración de un proxy de red durante la instalación](#configure-network-proxy-installer)
+ [Permita que el dispositivo principal confíe en un proxy HTTPS](#https-proxy-certificate-trust)
+ [El objeto networkProxy](#network-proxy-object)
#### Configuración de un proxy de red en dispositivos principales existentes
Puede usar una implementación para configurar un proxy de red en un único dispositivo principal o en un grupo de dispositivos principales. En esta implementación, se actualiza la configuración de los [componentes del núcleo](greengrass-nucleus-component.md). El núcleo se reinicia al actualizar su configuración `networkProxy`.
Para configurar un proxy de red, [cree una implementación](create-deployments.md) para el componente `aws.greengrass.Nucleus` que combine la siguiente actualización de configuración. Esta actualización de configuración contiene el [objeto networkProxy](#network-proxy-object).
```
{
"networkProxy": {
"noProxyAddresses": "http://192.168.0.1,www.example.com",
"proxy": {
"url": "https://my-proxy-server:1100"
}
}
}
```
En el ejemplo siguiente, se define una implementación que configura un proxy de red. La actualización de configuración `merge` requiere un objeto JSON serializado.
```
{
"components": {
"aws.greengrass.Nucleus": {
"version": "2.16.1",
"configurationUpdate": {
"merge": "{\"networkProxy\":{\"noProxyAddresses\":\"http://192.168.0.1,www.example.com\",\"proxy\":{\"url\":\"https://my-proxy-server:1100\",\"username\":\"Mary_Major\",\"password\":\"pass@word1357\"}}}"
}
}
}
}
```
#### Configuración de un proxy de red durante la instalación
Puede configurar un proxy de red al instalar el software AWS IoT Greengrass Core en un dispositivo principal. Use el argumento del instalador `--init-config` para configurar el proxy de red. Puede especificar este argumento al realizar la instalación con [aprovisionamiento manual](manual-installation.md), [aprovisionamiento de flota](fleet-provisioning.md) o [aprovisionamiento personalizado](custom-provisioning.md).
#### Permita que el dispositivo principal confíe en un proxy HTTPS
Al configurar un dispositivo principal para que use un proxy HTTPS, debe agregar la cadena de certificados del servidor proxy a la del dispositivo principal para que pueda confiar en el proxy HTTPS. De lo contrario, el dispositivo principal podría encontrar errores al intentar enrutar el tráfico a través del proxy. Agregue el certificado de CA del servidor proxy al archivo de certificado de la CA raíz de Amazon en el dispositivo principal.
**Habilitación del dispositivo principal para que confíe en el proxy HTTPS**
1. Encuentre el archivo de certificado de la CA raíz de Amazon en el dispositivo principal.
+ Si instaló el software AWS IoT Greengrass Core con [aprovisionamiento automático](quick-installation.md), el archivo de certificado de CA raíz de Amazon existe en`/greengrass/v2/rootCA.pem`.
+ Si instaló el software AWS IoT Greengrass Core con [aprovisionamiento [manual](manual-installation.md) o de flota](fleet-provisioning.md), es posible que el archivo de certificado CA raíz de Amazon esté en`/greengrass/v2/AmazonRootCA1.pem`.
Si el certificado de la CA raíz de Amazon no existe en estas ubicaciones, registre la propiedad `system.rootCaPath` en `/greengrass/v2/config/effectiveConfig.yaml` para encontrar su ubicación.
1. Agregue el contenido del archivo de certificado de la CA del servidor proxy al archivo de certificado de la CA raíz de Amazon.
En el ejemplo siguiente, se muestra un certificado de la CA del servidor proxy agregado al archivo de certificado de la CA raíz de Amazon.
```
-----BEGIN CERTIFICATE-----
MIIEFTCCAv2gAwIQWgIVAMHSAzWG/5YVRYtRQOxXUTEpHuEmApzGCSqGSIb3DQEK
\nCwUAhuL9MQswCQwJVUzEPMAVUzEYMBYGA1UECgwP1hem9uLmNvbSBJbmMuMRww
... content of proxy CA certificate ...
+vHIRlt0e5JAm5\noTIZGoFbK82A0/nO7f/t5PSIDAim9V3Gc3pSXxCCAQoFYnui
GaPUlGk1gCE84a0X\n7Rp/lND/PuMZ/s8YjlkY2NmYmNjMCAXDTE5MTEyN2cM216
gJMIADggEPADf2/m45hzEXAMPLE=
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
MIIDQTCCAimgF6AwIBAgITBmyfz/5mjAo54vB4ikPmljZKyjANJmApzyMZFo6qBg
ADA5MQswCQYDVQQGEwJVUzEPMA0tMVT8QtPHRh8jrdkGA1UEChMGDV3QQDExBBKW
... content of root CA certificate ...
o/ufQJQWUCyziar1hem9uMRkwFwYVPSHCb2XV4cdFyQzR1KldZwgJcIQ6XUDgHaa
5MsI+yMRQ+hDaXJiobldXgjUka642M4UwtBV8oK2xJNDd2ZhwLnoQdeXeGADKkpy
rqXRfKoQnoZsG4q5WTP46EXAMPLE
-----END CERTIFICATE-----
```
#### El objeto networkProxy
Utilice el objeto `networkProxy` para especificar información sobre el proxy de red. Este objeto contiene la siguiente información:
`noProxyAddresses`
(Opcional) Una lista separada por comas de direcciones IP o nombres de host que están exentos del proxy.
`proxy`
El proxy al que conectar. Este objeto contiene la siguiente información:
`url`
La dirección URL del servidor proxy, en el formato `scheme://userinfo@host:port`.
+ `scheme`: el esquema, que debe ser `http` o `https`.
**importante**
Los dispositivos principales de Greengrass deben ejecutar la versión 2.5.0 o versiones posteriores del [núcleo de Greengrass ](greengrass-nucleus-component.md) para usar proxies HTTPS.
Si configura un proxy HTTPS, debe agregar el certificado de la CA del servidor proxy al certificado de la CA raíz de Amazon del dispositivo principal. Para obtener más información, consulte [Permita que el dispositivo principal confíe en un proxy HTTPS](#https-proxy-certificate-trust).
+ `userinfo`: (opcional) la información de nombre de usuario y contraseña. Si especifica esta información en `url`, el dispositivo principal de Greengrass ignora los campos `username` y `password`.
+ `host`: el nombre de host o dirección IP del servidor proxy.
+ `port`: (opcional) el número de puerto. Si no especifica el puerto, el dispositivo principal de Greengrass usará los siguientes valores predeterminados:
+ `http`: 80
+ `https`: 443
`username`
(Opcional) El nombre de usuario que autentica el servidor proxy.
`password`
(Opcional) La contraseña para autenticarse en el servidor proxy.
## Use un certificado de dispositivo firmado por una CA privada
Si usa una autoridad de certificación (CA) privada personalizada, deberá establecer el **greengrassDataPlaneEndpoint** del núcleo de Greengrass en **iotdata**. Puede configurar esta opción durante la implementación o la instalación mediante el [argumento del instalador **--init-config**](configure-installer.md).
Puede personalizar el punto de conexión del plano de datos de Greengrass al que se conecta el dispositivo. Puede establecer esta opción de configuración en **iotdata** para que el punto de conexión del plano de datos de Greengrass esté en el mismo punto de conexión que el punto de conexión de datos de IoT, que puede especificar con **iotDataEndpoint**.
## Configuración de los tiempos de espera y los ajustes de caché de MQTT
En el AWS IoT Greengrass entorno, los componentes pueden utilizar MQTT para comunicarse con ellos. AWS IoT Core El software AWS IoT Greengrass Core gestiona los mensajes MQTT de los componentes. Cuando el dispositivo principal pierde la conexión con la Nube de AWS, el software almacena en caché los mensajes MQTT para volver a intentarlo más adelante cuando se restablezca la conexión. Puede configurar ajustes como los tiempos de espera de los mensajes y el tamaño de la memoria caché. Para obtener más información, consulte `mqtt` y los parámetros de configuración `mqtt.spooler` del [componente núcleo de Greengrass](greengrass-nucleus-component.md).
AWS IoT Core impone cuotas de servicio a su agente de mensajes MQTT. Estas cuotas pueden aplicarse a los mensajes que envíe entre los dispositivos principales y AWS IoT Core. Para obtener más información, consulte [Service Quotas al agente de mensajes de AWS IoT Core](https://docs.aws.amazon.com/general/latest/gr/iot-core.html#message-broker-limits) en *Referencia general de AWS*.
## Configurar Greengrass Nucleus en la red IPv6
[Greengrass Nucleus habla a través de AWS IoT Core Greengrass. APIs](https://docs.aws.amazon.com/general/latest/gr/greengrassv2.html) APIs Compatibilidad con Greengrass en un entorno de IPv6 doble pila.
Para habilitar los puntos finales de doble pila para: IPv6
+ Agregue las propiedades del sistema `aws.useDualstackEndpoint=true` y `java.net.preferIPv6Addresses=true` a `jvmOptions`
+ Establezca `s3EndpointType` en `DUALSTACK`
Establezca esta opción durante la [implementación](https://docs.aws.amazon.com/greengrass/v2/developerguide/create-deployments.html) o aprovisiónela de forma manual con el [argumento de instalador](https://docs.aws.amazon.com/greengrass/v2/developerguide/configure-installer.html) `--init-config`. Consulte [Using Amazon S3 dual-stack endpoints](https://docs.aws.amazon.com/AmazonS3/latest/API/dual-stack-endpoints.html).
**Example código de implementación:**
```
{
"jvmOptions": "-Daws.useDualstackEndpoint=true",
"s3EndpointType":"DUALSTACK"
}
```
**Example `config.yaml` mediante aprovisionamiento manual:**
```
---
system:
...
services:
aws.greengrass.Nucleus:
...
configuration:
...
jvmOptions: "-Daws.useDualstackEndpoint=true -Djava.net.preferIPv6Addresses=true"
s3EndpointType: "DUALSTACK"
```
# Actualización del software AWS IoT Greengrass Core (OTA)
El software AWS IoT Greengrass Core incluye el [componente de núcleo de Greengrass](greengrass-nucleus-component.md) y otros componentes opcionales que puede implementar en sus dispositivos para realizar actualizaciones vía inalámbrica (OTA) del software. Esta característica está integrada en el software AWS IoT Greengrass Core.
Las actualizaciones OTA hacen que sea más eficiente:
+ Corrige vulnerabilidades de seguridad.
+ Solucionar problemas de estabilidad del software.
+ Implementar características nuevas o mejoradas.
**Topics**
+ [Requisitos](#ota-update-requirements)
+ [Consideraciones para los dispositivos principales](#ota-update-considerations)
+ [Comportamiento de actualización del núcleo de Greengrass](#ota-update-behavior-nucleus)
+ [Cómo realizar actualizaciones OTA](#create-ota-update)
## Requisitos
Los siguientes requisitos se aplican para la implementación de las actualizaciones OTA del software AWS IoT Greengrass Core:
+ El dispositivo principal de Greengrass debe tener una conexión con la Nube de AWS para recibir la implementación.
+ El dispositivo principal de Greengrass debe configurarse y aprovisionarse correctamente con certificados y claves para la autenticación con AWS IoT Core y AWS IoT Greengrass.
+ El software AWS IoT Greengrass Core debe configurarse y ejecutarse como un servicio del sistema. Las actualizaciones OTA no funcionan si se ejecuta el núcleo desde el archivo JAR, `Greengrass.jar`. 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).
## Consideraciones para los dispositivos principales
Antes de realizar una actualización OTA, tenga en cuenta el impacto en los dispositivos principales que actualice y en los dispositivos de cliente conectados:
+ El núcleo de Greengrass se apaga.
+ Todos los componentes que se ejecutan en el dispositivo principal también se apagan. Si estos componentes escriben en recursos locales, es posible que dejen esos recursos en un estado incorrecto, salvo que se apaguen correctamente. Los componentes pueden utilizar la [comunicación entre procesos](interprocess-communication.md) para indicar al componente del núcleo que aplace la actualización hasta que borren los recursos que utilizan.
+ Mientras el componente del núcleo está apagado, el dispositivo principal pierde sus conexiones con Nube de AWS y con los dispositivos locales. El dispositivo principal no enrutará los mensajes de los dispositivos de cliente mientras esté apagado.
+ Las funciones de Lambda de larga duración que se ejecutan como componentes perderán la información de estado dinámico y eliminarán todos los trabajos pendientes.
## Comportamiento de actualización del núcleo de Greengrass
Cuando implementa un componente, AWS IoT Greengrass instala las últimas versiones compatibles de todas las dependencias de ese componente. Por este motivo, es posible que las nuevas versiones con parches de los componentes públicos proporcionados por AWS se implementen de forma automática en sus dispositivos principales si agrega nuevos dispositivos a un grupo de elementos o si actualiza la implementación destinada a esos dispositivos. Algunas actualizaciones automáticas, como las actualizaciones de núcleo, pueden provocar que los dispositivos se reinicien de forma inesperada.
Cuando la versión del [componente de núcleo de Greengrass](greengrass-nucleus-component.md) cambia, el software AWS IoT Greengrass Core, que incluye el núcleo y todos los demás componentes del dispositivo, se reinicia para aplicar los cambios. Debido a que la actualización del componente núcleo [afecta a los dispositivos principales](#ota-update-considerations), es posible que desee controlar cuándo se implementará una nueva versión del parche de núcleo en sus dispositivos. Para ello, debe incluir directamente el componente de núcleo de Greengrass en su implementación. Incluir directamente un componente significa incluir una versión específica de ese componente en la configuración de implementación y no depender de las dependencias de los componentes para implementar ese componente en sus dispositivos. Para obtener más información sobre cómo definir dependencias en sus recetas de componentes, consulte [Formato de receta](component-recipe-reference.md#recipe-format).
Consulte la siguiente tabla para comprender el comportamiento de actualización del componente de núcleo de Greengrass en función de sus acciones y configuraciones de implementación.
| Acción | Configuración de implementación | Comportamiento de actualización de núcleo |
| --- | --- | --- |
| Agregue nuevos dispositivos a un grupo de objetos al que apunta una implementación existente sin revisar la implementación. | La implementación no incluye directamente el núcleo de Greengrass.La implementación incluye directamente al menos un componente proporcionado por AWS o incluye un componente personalizado que depende de un componente proporcionado por AWS o del núcleo de Greengrass. | En los dispositivos nuevos, instala la última versión de parche de núcleo que cumple con todos los requisitos de dependencia de los componentes.En los dispositivos existentes, no actualiza la versión instalada del núcleo. |
| Agregue nuevos dispositivos a un grupo de objetos al que apunta una implementación existente sin revisar la implementación. | La implementación incluye directamente una versión específica del núcleo de Greengrass. | En los dispositivos nuevos, instala la versión del núcleo especificada.En los dispositivos existentes, no actualiza la versión instalada del núcleo. |
| Cree una nueva implementación o revise una implementación existente. | La implementación no incluye directamente el núcleo de Greengrass.La implementación incluye directamente al menos un componente proporcionado por AWS o incluye un componente personalizado que depende de un componente proporcionado por AWS o del núcleo de Greengrass. | En todos los dispositivos de destino, instala la última versión del parche del núcleo que cumpla con todos los requisitos de dependencia de los componentes, incluso en los dispositivos nuevos que agregue al grupo de objetos de destino. |
| Cree una nueva implementación o revise una implementación existente. | La implementación incluye directamente una versión específica del núcleo de Greengrass. | En todos los dispositivos de destino, instala la versión de núcleo especificada, incluidos los dispositivos nuevos que agregue al grupo de objetos de destino. |
## Cómo realizar actualizaciones OTA
Para realizar una actualización OTA, [cree una implementación](create-deployments.md) que incluya el [componente de núcleo](greengrass-nucleus-component.md) y la versión que desee instalar.
# Desinstalación del software AWS IoT Greengrass Core
Puede desinstalar el software AWS IoT Greengrass Core para eliminarlo de un dispositivo que no desee utilizar como dispositivo principal de Greengrass. También puede seguir estos pasos para limpiar una instalación que no funcione.
**Cómo desinstalar el software AWS IoT Greengrass Core**
1. Si ejecuta el software como un servicio del sistema, debe detener, deshabilitar y eliminar el servicio. Ejecute los comandos apropiados para su sistema operativo.
------
#### [ Linux ]
1. Detenga el servicio .
```
sudo systemctl stop greengrass.service
```
1. Deshabilite el servicio.
```
sudo systemctl disable greengrass.service
```
1. Elimine el servicio.
```
sudo rm /etc/systemd/system/greengrass.service
```
1. Compruebe que el servicio se eliminó.
```
sudo systemctl daemon-reload && sudo systemctl reset-failed
```
------
#### [ Windows (Command Prompt) ]
**nota**
Debe ejecutar Command Prompt o PowerShell como administrador para ejecutar estos comandos.
1. Detenga el servicio .
```
sc stop "greengrass"
```
1. Deshabilite el servicio.
```
sc config "greengrass" start=disabled
```
1. Elimine el servicio.
```
sc delete "greengrass"
```
1. Reinicie el dispositivo.
------
#### [ Windows (PowerShell) ]
**nota**
Debe ejecutar PowerShell como administrador para ejecutar estos comandos.
1. Detenga el servicio .
```
Stop-Service -Name "greengrass"
```
1. Deshabilite el servicio.
```
Set-Service -Name "greengrass" -Status stopped -StartupType disabled
```
1. Elimine el servicio.
+ Para PowerShell 6.0 o posterior:
```
Remove-Service -Name "greengrass" -Confirm:$false -Verbose
```
+ Para las versiones de PowerShell anteriores a la 6.0:
```
Get-Item HKLM:\SYSTEM\CurrentControlSet\Services\greengrass | Remove-Item -Force -Verbose
```
1. Reinicie el dispositivo.
------
1. Elimine la carpeta raíz del dispositivo. Sustituya `/greengrass/v2` o *C:\$1greengrass\$1v2* por la ruta de acceso a la carpeta raíz.
------
#### [ Linux ]
```
sudo rm -rf /greengrass/v2
```
------
#### [ Windows (Command Prompt) ]
```
rmdir /s /q C:\greengrass\v2
```
------
#### [ Windows (PowerShell) ]
```
cmd.exe /c "rmdir /s /q C:\greengrass\v2"
```
------
1. Elimine el dispositivo principal del servicio de AWS IoT Greengrass. Este paso elimina la información de estado del dispositivo principal de la Nube de AWS. Asegúrese de completar este paso si planea volver a instalar el software AWS IoT Greengrass Core en un dispositivo principal con el mismo nombre.
+ Para eliminar un dispositivo principal de la consola de AWS IoT Greengrass, haga lo siguiente:
1. Vaya a la [consola de AWS IoT Greengrass](https://console.aws.amazon.com/greengrass).
1. Elija **Dispositivos principales**.
1. Elija el dispositivo principal que desee eliminar.
1. Elija **Eliminar**.
1. En el cuadro de confirmación, elija **Eliminar**.
+ Para eliminar un dispositivo principal con la AWS Command Line Interface, utilice la operación [DeleteCoreDevice](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_DeleteCoreDevice.html). Ejecute el siguiente comando y reemplace *MyGreengrassCore* por el nombre del dispositivo principal.
```
aws greengrassv2 delete-core-device --core-device-thing-name MyGreengrassCore
```