Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Installation AWS IoT Greengrass du logiciel Core avec provisionnement manuel des ressources
Le logiciel AWS IoT Greengrass Core inclut un programme d'installation qui configure votre appareil en tant qu'appareil principal Greengrass. Pour configurer un appareil manuellement, vous pouvez créer les ressources requises AWS IoT et les ressources IAM que l'appareil doit utiliser. Si vous créez ces ressources manuellement, il n'est pas nécessaire de fournir des AWS informations d'identification au programme d'installation.
Lorsque vous installez manuellement le logiciel AWS IoT Greengrass Core, vous pouvez également configurer le périphérique pour qu'il utilise un proxy réseau ou qu'il se connecte AWS au port 443. Vous devrez peut-être spécifier ces options de configuration si votre appareil fonctionne derrière un pare-feu ou un proxy réseau, par exemple. Pour de plus amples informations, veuillez consulter [Connexion au port 443 ou via un proxy réseau](configure-greengrass-core-v2.md#configure-alpn-network-proxy).
Vous pouvez également configurer le logiciel AWS IoT Greengrass Core pour utiliser un module de sécurité matériel (HSM) via l'interface [PKCS \$111](https://en.wikipedia.org/wiki/PKCS_11). Cette fonctionnalité vous permet de stocker en toute sécurité les fichiers de clés privées et de certificats afin qu'ils ne soient pas exposés ou dupliqués dans le logiciel. Vous pouvez stocker des clés privées et des certificats sur un module matériel tel qu'un HSM, un module TPM (Trusted Platform Module) ou un autre élément cryptographique. Cette fonctionnalité n'est disponible que sur les appareils Linux. Pour plus d'informations sur la sécurité matérielle et les conditions requises pour l'utiliser, consultez[Intégration de sécurité matérielle](hardware-security.md).
**Important**
Avant de télécharger le logiciel AWS IoT Greengrass Core, vérifiez que votre appareil principal répond à la [configuration requise](greengrass-nucleus-component.md#greengrass-v2-requirements) pour installer et exécuter le logiciel AWS IoT Greengrass Core v2.0.
**Topics**
+ [Récupérer des points de AWS IoT terminaison](#retrieve-iot-endpoints)
+ [Créez n'importe AWS IoT quoi](#create-iot-thing)
+ [Créez le certificat d'objet](#create-thing-certificate)
+ [Configurer le certificat d'objet](#configure-thing-certificate)
+ [Création d'un rôle d'échange de jetons](#create-token-exchange-role)
+ [Télécharger les certificats sur l'appareil](#download-thing-certificates)
+ [Configuration de l'environnement de l'appareil](#set-up-device-environment)
+ [Téléchargez le logiciel AWS IoT Greengrass de base](#download-greengrass-core-v2)
+ [Installation du logiciel AWS IoT Greengrass Core](#run-greengrass-core-v2-installer-manual)
## Récupérer des points de AWS IoT terminaison
Obtenez les AWS IoT points de terminaison qui vous Compte AWS conviennent et enregistrez-les pour les utiliser ultérieurement. Votre appareil utilise ces points de terminaison pour se connecter à AWS IoT. Procédez comme suit :
1. Obtenez le point de terminaison de AWS IoT données pour votre Compte AWS.
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
La réponse ressemble à l'exemple suivant, si la demande aboutit.
```
{
"endpointAddress": "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
}
```
1. Obtenez le point de terminaison des informations d' AWS IoT identification pour votre Compte AWS.
```
aws iot describe-endpoint --endpoint-type iot:CredentialProvider
```
La réponse ressemble à l'exemple suivant, si la demande aboutit.
```
{
"endpointAddress": "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
}
```
## Créez n'importe AWS IoT quoi
AWS IoT *les objets* représentent les appareils et les entités logiques auxquels ils se connectent AWS IoT. Les appareils Greengrass Core sont AWS IoT des objets. Lorsque vous enregistrez un appareil en tant qu' AWS IoT objet, celui-ci peut utiliser un certificat numérique pour s'authentifier. AWS
Dans cette section, vous allez créer un AWS IoT objet qui représente votre appareil.
**Pour créer AWS IoT quelque chose**
1. Créez n'importe AWS IoT quel objet pour votre appareil. Sur votre ordinateur de développement, exécutez la commande suivante.
+ Remplacez *MyGreengrassCore* par le nom de l'objet à utiliser. Ce nom est également le nom de votre appareil principal Greengrass.
**Note**
Le nom de l'objet ne peut pas contenir de caractères deux-points (`:`).
```
aws iot create-thing --thing-name MyGreengrassCore
```
La réponse ressemble à l'exemple suivant, si la demande aboutit.
```
{
"thingName": "MyGreengrassCore",
"thingArn": "arn:aws:iot:us-west-2:123456789012:thing/MyGreengrassCore",
"thingId": "8cb4b6cd-268e-495d-b5b9-1713d71dbf42"
}
```
1. (Facultatif) Ajoutez l' AWS IoT objet à un nouveau groupe d'objets ou à un groupe d'objets existant. Vous utilisez des groupes d'objets pour gérer des flottes d'appareils principaux de Greengrass. Lorsque vous déployez des composants logiciels sur vos appareils, vous pouvez cibler des appareils individuels ou des groupes d'appareils. Vous pouvez ajouter un appareil à un groupe d'objets avec un déploiement Greengrass actif pour déployer les composants logiciels de ce groupe d'objets sur l'appareil. Procédez comme suit :
1. (Facultatif) Créez un AWS IoT groupe d'objets.
+ Remplacez *MyGreengrassCoreGroup* par le nom du groupe d'objets à créer.
**Note**
Le nom du groupe d'objets ne peut pas contenir de deux-points (`:`).
```
aws iot create-thing-group --thing-group-name MyGreengrassCoreGroup
```
La réponse ressemble à l'exemple suivant, si la demande aboutit.
```
{
"thingGroupName": "MyGreengrassCoreGroup",
"thingGroupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/MyGreengrassCoreGroup",
"thingGroupId": "4df721e1-ff9f-4f97-92dd-02db4e3f03aa"
}
```
1. Ajoutez l' AWS IoT objet à un groupe d'objets.
+ Remplacez *MyGreengrassCore* par le nom de votre AWS IoT objet.
+ Remplacez *MyGreengrassCoreGroup* par le nom du groupe d'objets.
```
aws iot add-thing-to-thing-group --thing-name MyGreengrassCore --thing-group-name MyGreengrassCoreGroup
```
La commande n'a aucune sortie si la demande aboutit.
## Créez le certificat d'objet
Lorsque vous enregistrez un appareil en tant qu' AWS IoT objet, celui-ci peut utiliser un certificat numérique pour s'authentifier. AWS Ce certificat permet à l'appareil de communiquer avec AWS IoT et AWS IoT Greengrass.
Dans cette section, vous allez créer et télécharger des certificats que votre appareil peut utiliser pour se connecter AWS.
Si vous souhaitez configurer le logiciel AWS IoT Greengrass Core pour utiliser un module de sécurité matériel (HSM) pour stocker en toute sécurité la clé privée et le certificat, suivez les étapes pour créer le certificat à partir d'une clé privée dans un HSM. Sinon, suivez les étapes pour créer le certificat et la clé privée dans le AWS IoT service. La fonctionnalité de sécurité matérielle n'est disponible que sur les appareils Linux. Pour plus d'informations sur la sécurité matérielle et les conditions requises pour l'utiliser, consultez[Intégration de sécurité matérielle](hardware-security.md).
### Créez le certificat et la clé privée dans le AWS IoT service
**Pour créer le certificat d'objet**
1. Créez un dossier dans lequel vous téléchargerez les certificats de l' AWS IoT objet.
```
mkdir greengrass-v2-certs
```
1. Créez et téléchargez les certificats AWS IoT correspondants.
```
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
```
La réponse ressemble à l'exemple suivant, si la demande aboutit.
```
{
"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-----\
"
}
}
```
Enregistrez le nom de ressource Amazon (ARN) du certificat afin de l'utiliser pour configurer le certificat ultérieurement.
### Créez le certificat à partir d'une clé privée dans un HSM
**Note**
Cette fonctionnalité est disponible pour les versions 2.5.3 et ultérieures du composant [Greengrass](greengrass-nucleus-component.md) nucleus. AWS IoT Greengrass ne prend actuellement pas en charge cette fonctionnalité sur les appareils Windows principaux.
**Pour créer le certificat d'objet**
1. Sur le périphérique principal, initialisez un jeton PKCS \$111 dans le HSM et générez une clé privée. La clé privée doit être une clé RSA de taille RSA-2048 (ou supérieure) ou une clé ECC.
**Note**
Pour utiliser un module de sécurité matériel avec des clés ECC, vous devez utiliser [Greengrass](greengrass-nucleus-component.md) nucleus v2.5.6 ou version ultérieure.
Pour utiliser un module de sécurité matériel et un [gestionnaire de secrets](secret-manager-component.md), vous devez utiliser un module de sécurité matériel avec des clés RSA.
Consultez la documentation de votre HSM pour savoir comment initialiser le jeton et générer la clé privée. Si votre HSM prend en charge l'objet IDs, spécifiez un ID d'objet lorsque vous générez la clé privée. Enregistrez l'ID d'emplacement, le code PIN utilisateur, le libellé de l'objet, l'ID d'objet (si votre HSM en utilise un) que vous spécifiez lorsque vous initialisez le jeton et générez la clé privée. Vous utiliserez ces valeurs ultérieurement lorsque vous importez le certificat d'objet dans le HSM et que vous configurez le logiciel AWS IoT Greengrass principal.
1. Créez une demande de signature de certificat (CSR) à partir de la clé privée. AWS IoT utilise ce CSR pour créer un certificat d'objet pour la clé privée que vous avez générée dans le HSM. Pour plus d'informations sur la création d'un CSR à partir de la clé privée, consultez la documentation de votre HSM. Le CSR est un fichier, tel que`iotdevicekey.csr`.
1. Copiez le CSR de l'appareil vers votre ordinateur de développement. Si SSH et SCP sont activés sur l'ordinateur de développement et le périphérique, vous pouvez utiliser la `scp` commande de votre ordinateur de développement pour transférer le CSR. Remplacez *device-ip-address* par l'adresse IP de votre appareil, puis *\$1/iotdevicekey.csr* par le chemin d'accès au fichier CSR sur l'appareil.
```
scp device-ip-address:~/iotdevicekey.csr iotdevicekey.csr
```
1. Sur votre ordinateur de développement, créez un dossier dans lequel vous téléchargerez le certificat AWS IoT correspondant.
```
mkdir greengrass-v2-certs
```
1. Utilisez le fichier CSR pour créer et télécharger le certificat correspondant à l' AWS IoT objet sur votre ordinateur de développement.
```
aws iot create-certificate-from-csr --set-as-active --certificate-signing-request=file://iotdevicekey.csr --certificate-pem-outfile greengrass-v2-certs/device.pem.crt
```
La réponse ressemble à l'exemple suivant, si la demande aboutit.
```
{
"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-----"
}
```
Enregistrez l'ARN du certificat afin de l'utiliser pour le configurer ultérieurement.
## Configurer le certificat d'objet
Attachez le certificat d' AWS IoT objet à l'objet que vous avez créé précédemment et ajoutez une AWS IoT politique au certificat afin de définir les AWS IoT autorisations pour le périphérique principal.
**Pour configurer le certificat de l'objet**
1. Joignez le certificat à l' AWS IoT objet.
+ Remplacez *MyGreengrassCore* par le nom de votre AWS IoT objet.
+ Remplacez le certificat Amazon Resource Name (ARN) par l'ARN du certificat que vous avez créé à l'étape précédente.
```
aws iot attach-thing-principal --thing-name MyGreengrassCore --principal arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
```
La commande n'a aucune sortie si la demande aboutit.
1. Créez et joignez une AWS IoT politique qui définit les AWS IoT autorisations pour votre appareil principal Greengrass. La politique suivante permet d'accéder à tous les sujets MQTT et aux opérations Greengrass, afin que votre appareil fonctionne avec les applications personnalisées et les modifications futures qui nécessitent de nouvelles opérations Greengrass. Vous pouvez restreindre cette politique en fonction de votre cas d'utilisation. Pour de plus amples informations, veuillez consulter [AWS IoT Politique minimale pour les appareils AWS IoT Greengrass V2 principaux](device-auth.md#greengrass-core-minimal-iot-policy).
Si vous avez déjà configuré un appareil principal Greengrass, vous pouvez joindre sa AWS IoT politique au lieu d'en créer une nouvelle.
Procédez comme suit :
1. Créez un fichier contenant le document de AWS IoT politique dont les appareils principaux de Greengrass ont besoin.
Par exemple, sur un système basé sur Linux, vous pouvez exécuter la commande suivante pour utiliser GNU nano pour créer le fichier.
```
nano greengrass-v2-iot-policy.json
```
Copiez le code JSON suivant dans le fichier.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Publish",
"iot:Subscribe",
"iot:Receive",
"iot:Connect",
"greengrass:*"
],
"Resource": [
"*"
]
}
]
}
```
1. Créez une AWS IoT politique à partir du document de stratégie.
+ Remplacez *GreengrassV2IoTThingPolicy* par le nom de la politique à créer.
```
aws iot create-policy --policy-name GreengrassV2IoTThingPolicy --policy-document file://greengrass-v2-iot-policy.json
```
La réponse ressemble à l'exemple suivant, si la demande aboutit.
```
{
"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. Joignez la AWS IoT politique au certificat de l' AWS IoT objet.
+ Remplacez *GreengrassV2IoTThingPolicy* par le nom de la politique à joindre.
+ Remplacez l'ARN cible par l'ARN du certificat associé à votre AWS IoT objet.
```
aws iot attach-policy --policy-name GreengrassV2IoTThingPolicy --target arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
```
La commande n'a aucune sortie si la demande aboutit.
## Création d'un rôle d'échange de jetons
Les appareils principaux de Greengrass utilisent un rôle de service IAM, appelé rôle d'*échange de jetons*, pour autoriser les appels aux services. AWS L'appareil utilise le fournisseur AWS IoT d'informations d'identification pour obtenir des AWS informations d'identification temporaires pour ce rôle, ce qui lui permet d'interagir avec Amazon Logs AWS IoT, d'envoyer des journaux à Amazon CloudWatch Logs et de télécharger des artefacts de composants personnalisés depuis Amazon S3. Pour de plus amples informations, veuillez consulter [Autoriser les appareils principaux à interagir avec les AWS services](device-service-role.md).
Vous utilisez un *alias de AWS IoT rôle* pour configurer le rôle d'échange de jetons pour les appareils principaux de Greengrass. Les alias de rôle vous permettent de modifier le rôle d'échange de jetons d'un appareil tout en conservant la même configuration de l'appareil. Pour plus d'informations, consultez la section [Autorisation des appels directs vers AWS des services](https://docs.aws.amazon.com/iot/latest/developerguide/authorizing-direct-aws.html) dans le *Guide du AWS IoT Core développeur*.
Dans cette section, vous allez créer un rôle IAM d'échange de jetons et un alias de AWS IoT rôle pointant vers le rôle. Si vous avez déjà configuré un appareil principal Greengrass, vous pouvez utiliser son rôle d'échange de jetons et son alias de rôle au lieu d'en créer de nouveaux. Ensuite, vous configurez l'appareil pour AWS IoT qu'il utilise ce rôle et cet alias.
**Pour créer un rôle IAM d'échange de jetons**
1. Créez un rôle IAM que votre appareil peut utiliser comme rôle d'échange de jetons. Procédez comme suit :
1. Créez un fichier contenant le document de politique de confiance requis par le rôle d'échange de jetons.
Par exemple, sur un système basé sur Linux, vous pouvez exécuter la commande suivante pour utiliser GNU nano pour créer le fichier.
```
nano device-role-trust-policy.json
```
Copiez le code JSON suivant dans le fichier.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
1. Créez le rôle d'échange de jetons avec le document de politique de confiance.
+ Remplacez *GreengrassV2TokenExchangeRole* par le nom du rôle IAM à créer.
```
aws iam create-role --role-name GreengrassV2TokenExchangeRole --assume-role-policy-document file://device-role-trust-policy.json
```
La réponse ressemble à l'exemple suivant, si la demande aboutit.
```
{
"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. Créez un fichier contenant le document de politique d'accès requis par le rôle d'échange de jetons.
Par exemple, sur un système basé sur Linux, vous pouvez exécuter la commande suivante pour utiliser GNU nano pour créer le fichier.
```
nano device-role-access-policy.json
```
Copiez le code JSON suivant dans le fichier.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents",
"logs:DescribeLogStreams",
"s3:GetBucketLocation"
],
"Resource": "*"
}
]
}
```
**Note**
Cette politique d'accès n'autorise pas l'accès aux artefacts des composants dans les compartiments S3. Pour déployer des composants personnalisés qui définissent des artefacts dans Amazon S3, vous devez ajouter des autorisations au rôle afin de permettre à votre appareil principal de récupérer les artefacts des composants. Pour de plus amples informations, veuillez consulter [Autoriser l'accès aux compartiments S3 pour les artefacts des composants](device-service-role.md#device-service-role-access-s3-bucket).
Si vous ne possédez pas encore de compartiment S3 pour les artefacts des composants, vous pouvez ajouter ces autorisations ultérieurement après avoir créé un compartiment.
1. Créez la politique IAM à partir du document de stratégie.
+ Remplacez *GreengrassV2TokenExchangeRoleAccess* par le nom de la politique IAM à créer.
```
aws iam create-policy --policy-name GreengrassV2TokenExchangeRoleAccess --policy-document file://device-role-access-policy.json
```
La réponse ressemble à l'exemple suivant, si la demande aboutit.
```
{
"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. Associez la politique IAM au rôle d'échange de jetons.
+ Remplacez *GreengrassV2TokenExchangeRole* par le nom du rôle IAM.
+ Remplacez l'ARN de la stratégie par l'ARN de la stratégie IAM que vous avez créée à l'étape précédente.
```
aws iam attach-role-policy --role-name GreengrassV2TokenExchangeRole --policy-arn arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess
```
La commande n'a aucune sortie si la demande aboutit.
1. Créez un alias de AWS IoT rôle qui pointe vers le rôle d'échange de jetons.
+ Remplacez *GreengrassCoreTokenExchangeRoleAlias* par le nom de l'alias de rôle à créer.
+ Remplacez l'ARN du rôle par l'ARN du rôle IAM que vous avez créé à l'étape précédente.
```
aws iot create-role-alias --role-alias GreengrassCoreTokenExchangeRoleAlias --role-arn arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole
```
La réponse ressemble à l'exemple suivant, si la demande aboutit.
```
{
"roleAlias": "GreengrassCoreTokenExchangeRoleAlias",
"roleAliasArn": "arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
```
**Note**
Pour créer un alias de rôle, vous devez être autorisé à transmettre le rôle IAM d'échange de jetons à AWS IoT. Si vous recevez un message d'erreur lorsque vous essayez de créer un alias de rôle, vérifiez que votre AWS utilisateur dispose de cette autorisation. Pour plus d'informations, consultez la section [Octroi à un utilisateur des autorisations lui permettant de transférer un rôle à un AWS service](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_passrole.html) dans le *Guide de Gestion des identités et des accès AWS l'utilisateur*.
1. Créez et attachez une AWS IoT politique qui permet à votre appareil principal Greengrass d'utiliser l'alias de rôle pour assumer le rôle d'échange de jetons. Si vous avez déjà configuré un appareil principal Greengrass, vous pouvez associer sa AWS IoT politique d'alias de rôle au lieu d'en créer une nouvelle. Procédez comme suit :
1. (Facultatif) Créez un fichier contenant le document AWS IoT de politique requis par l'alias de rôle.
Par exemple, sur un système basé sur Linux, vous pouvez exécuter la commande suivante pour utiliser GNU nano pour créer le fichier.
```
nano greengrass-v2-iot-role-alias-policy.json
```
Copiez le code JSON suivant dans le fichier.
+ Remplacez l'ARN de la ressource par l'ARN de votre alias de rôle.
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iot:AssumeRoleWithCertificate",
"Resource": "arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
]
}
```
1. Créez une AWS IoT politique à partir du document de stratégie.
+ Remplacez *GreengrassCoreTokenExchangeRoleAliasPolicy* par le nom de la AWS IoT politique à créer.
```
aws iot create-policy --policy-name GreengrassCoreTokenExchangeRoleAliasPolicy --policy-document file://greengrass-v2-iot-role-alias-policy.json
```
La réponse ressemble à l'exemple suivant, si la demande aboutit.
```
{
"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. Joignez la AWS IoT politique au certificat de l' AWS IoT objet.
+ Remplacez *GreengrassCoreTokenExchangeRoleAliasPolicy* par le nom de la AWS IoT politique d'alias de rôle.
+ Remplacez l'ARN cible par l'ARN du certificat associé à votre AWS IoT objet.
```
aws iot attach-policy --policy-name GreengrassCoreTokenExchangeRoleAliasPolicy --target arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
```
La commande n'a aucune sortie si la demande aboutit.
## Télécharger les certificats sur l'appareil
Auparavant, vous avez téléchargé le certificat de votre appareil sur votre ordinateur de développement. Dans cette section, vous allez copier le certificat sur votre appareil principal pour configurer celui-ci avec les certificats auxquels il se connecte AWS IoT. Vous téléchargez également le certificat de l'autorité de certification racine (CA) Amazon. Si vous utilisez un HSM, vous importez également le fichier de certificat dans le HSM dans cette section.
+ Si vous avez créé le certificat d'objet et la clé privée dans le AWS IoT service précédemment, suivez les étapes pour télécharger les certificats avec la clé privée et les fichiers de certificat.
+ Si vous avez créé le certificat d'objet à partir d'une clé privée dans un module de sécurité matériel (HSM) plus tôt, suivez les étapes pour télécharger les certificats avec la clé privée et le certificat dans un HSM.
### Télécharger des certificats avec clé privée et fichiers de certificats
**Pour télécharger des certificats sur l'appareil**
1. Copiez le certificat d' AWS IoT objet de votre ordinateur de développement sur l'appareil. Si SSH et SCP sont activés sur l'ordinateur de développement et le périphérique, vous pouvez utiliser la `scp` commande de votre ordinateur de développement pour transférer le certificat. Remplacez *device-ip-address* par l'adresse IP de votre appareil.
```
scp -r greengrass-v2-certs/ device-ip-address:~
```
1. Créez le dossier racine Greengrass sur l'appareil. Vous installerez ultérieurement le logiciel AWS IoT Greengrass Core dans ce dossier.
**Note**
Pour Windows, la limitation de la longueur du chemin est de 260 caractères. Si vous utilisez Windows, utilisez un dossier racine tel que `C:\greengrass\v2` ou `D:\greengrass\v2` pour conserver les chemins des composants Greengrass en dessous de la limite de 260 caractères.
------
#### [ Linux or Unix ]
+ `/greengrass/v2`Remplacez-le par le dossier à utiliser.
```
sudo mkdir -p /greengrass/v2
```
------
#### [ Windows Command Prompt ]
+ *C:\$1greengrass\$1v2*Remplacez-le par le dossier à utiliser.
```
mkdir C:\greengrass\v2
```
------
#### [ PowerShell ]
+ *C:\$1greengrass\$1v2*Remplacez-le par le dossier à utiliser.
```
mkdir C:\greengrass\v2
```
------
1. (Linux uniquement) Définissez les autorisations du parent du dossier racine de Greengrass.
+ Remplacez */greengrass* par le parent du dossier racine.
```
sudo chmod 755 /greengrass
```
1. Copiez les AWS IoT certificats d'objets dans le dossier racine de Greengrass.
------
#### [ Linux or Unix ]
+ `/greengrass/v2`Remplacez-le par le dossier racine de Greengrass.
```
sudo cp -R ~/greengrass-v2-certs/* /greengrass/v2
```
------
#### [ Windows Command Prompt ]
+ *C:\$1greengrass\$1v2*Remplacez-le par le dossier à utiliser.
```
robocopy %USERPROFILE%\greengrass-v2-certs C:\greengrass\v2 /E
```
------
#### [ PowerShell ]
+ *C:\$1greengrass\$1v2*Remplacez-le par le dossier à utiliser.
```
cp -Path ~\greengrass-v2-certs\* -Destination C:\greengrass\v2
```
------
1. Téléchargez le certificat de l'autorité de certification racine (CA) Amazon. AWS IoT les certificats sont associés par défaut au certificat de l'autorité de certification racine d'Amazon.
------
#### [ 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
```
------
### Téléchargez les certificats avec la clé privée et le certificat dans un HSM
**Note**
Cette fonctionnalité est disponible pour les versions 2.5.3 et ultérieures du composant [Greengrass](greengrass-nucleus-component.md) nucleus. AWS IoT Greengrass ne prend actuellement pas en charge cette fonctionnalité sur les appareils Windows principaux.
**Pour télécharger des certificats sur l'appareil**
1. Copiez le certificat d' AWS IoT objet de votre ordinateur de développement sur l'appareil. Si SSH et SCP sont activés sur l'ordinateur de développement et le périphérique, vous pouvez utiliser la `scp` commande de votre ordinateur de développement pour transférer le certificat. Remplacez *device-ip-address* par l'adresse IP de votre appareil.
```
scp -r greengrass-v2-certs/ device-ip-address:~
```
1. Créez le dossier racine Greengrass sur l'appareil. Vous installerez ultérieurement le logiciel AWS IoT Greengrass Core dans ce dossier.
**Note**
Pour Windows, la limitation de la longueur du chemin est de 260 caractères. Si vous utilisez Windows, utilisez un dossier racine tel que `C:\greengrass\v2` ou `D:\greengrass\v2` pour conserver les chemins des composants Greengrass en dessous de la limite de 260 caractères.
------
#### [ Linux or Unix ]
+ `/greengrass/v2`Remplacez-le par le dossier à utiliser.
```
sudo mkdir -p /greengrass/v2
```
------
#### [ Windows Command Prompt ]
+ *C:\$1greengrass\$1v2*Remplacez-le par le dossier à utiliser.
```
mkdir C:\greengrass\v2
```
------
#### [ PowerShell ]
+ *C:\$1greengrass\$1v2*Remplacez-le par le dossier à utiliser.
```
mkdir C:\greengrass\v2
```
------
1. (Linux uniquement) Définissez les autorisations du parent du dossier racine de Greengrass.
+ Remplacez */greengrass* par le parent du dossier racine.
```
sudo chmod 755 /greengrass
```
1. Importez le fichier de certificat d'`~/greengrass-v2-certs/device.pem.crt`objet dans le HSM. Consultez la documentation de votre HSM pour savoir comment y importer des certificats. Importez le certificat en utilisant le jeton, l'ID de slot, le code PIN utilisateur, le même libellé d'objet et le même ID d'objet (si votre HSM en utilise un) où vous avez généré la clé privée dans le HSM précédemment.
**Note**
Si vous avez généré la clé privée plus tôt sans ID d'objet et que le certificat possède un ID d'objet, définissez l'ID d'objet de la clé privée sur la même valeur que le certificat. Consultez la documentation de votre HSM pour savoir comment définir l'ID d'objet pour l'objet clé privée.
1. (Facultatif) Supprimez le fichier de certificat d'objet afin qu'il n'existe que dans le HSM.
```
rm ~/greengrass-v2-certs/device.pem.crt
```
1. Téléchargez le certificat de l'autorité de certification racine (CA) Amazon. AWS IoT les certificats sont associés par défaut au certificat de l'autorité de certification racine d'Amazon.
------
#### [ 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
```
------
## Configuration de l'environnement de l'appareil
Suivez les étapes décrites dans cette section pour configurer un appareil Linux ou Windows à utiliser comme périphérique AWS IoT Greengrass principal.
### Configuration d'un appareil Linux
**Pour configurer un appareil Linux pour AWS IoT Greengrass V2**
1. Installez le moteur d'exécution Java, dont le logiciel AWS IoT Greengrass Core a besoin pour fonctionner. Nous vous recommandons d'utiliser les versions de support à long terme d'[Amazon Corretto](https://aws.amazon.com/corretto/) [ou](https://openjdk.java.net/) d'OpenJDK. La version 8 ou supérieure est requise. Les commandes suivantes vous montrent comment installer OpenJDK sur votre appareil.
+ Pour les distributions basées sur Debian ou Ubuntu :
```
sudo apt install default-jdk
```
+ Pour les distributions basées sur Red Hat :
```
sudo yum install java-11-openjdk-devel
```
+ Dans Amazon Linux 2 :
```
sudo amazon-linux-extras install java-openjdk11
```
+ Pour Amazon Linux 2023 :
```
sudo dnf install java-11-amazon-corretto -y
```
Lorsque l'installation est terminée, exécutez la commande suivante pour vérifier que Java s'exécute sur votre appareil Linux.
```
java -version
```
La commande affiche la version de Java exécutée sur le périphérique. Par exemple, sur une distribution basée sur Debian, le résultat peut ressembler à celui de l'exemple suivant.
```
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. (Facultatif) Créez l'utilisateur système et le groupe par défaut qui exécutent les composants sur le périphérique. Vous pouvez également choisir de laisser le programme d'installation du logiciel AWS IoT Greengrass Core créer cet utilisateur et ce groupe lors de l'installation avec l'argument `--component-default-user` installer. Pour de plus amples informations, veuillez consulter [Arguments d'installation](configure-installer.md).
```
sudo useradd --system --create-home ggc_user
sudo groupadd --system ggc_group
```
1. Vérifiez que l'utilisateur qui exécute le logiciel AWS IoT Greengrass Core (généralement`root`) est autorisé à exécuter `sudo` avec n'importe quel utilisateur et n'importe quel groupe.
1. Exécutez la commande suivante pour ouvrir le `/etc/sudoers` fichier.
```
sudo visudo
```
1. Vérifiez que l'autorisation accordée à l'utilisateur ressemble à l'exemple suivant.
```
root ALL=(ALL:ALL) ALL
```
1. **(Facultatif) Pour [exécuter des fonctions Lambda conteneurisées](run-lambda-functions.md), vous devez activer [cgroups](https://en.wikipedia.org/wiki/Cgroups) v1, et vous devez activer et monter les cgroups de mémoire et de périphériques.** Si vous ne prévoyez pas d'exécuter des fonctions Lambda conteneurisées, vous pouvez ignorer cette étape.
Pour activer ces options cgroups, démarrez le périphérique avec les paramètres du noyau Linux suivants.
```
cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0
```
Pour plus d'informations sur l'affichage et la définition des paramètres du noyau de votre appareil, consultez la documentation de votre système d'exploitation et de votre chargeur de démarrage. Suivez les instructions pour définir définitivement les paramètres du noyau.
1. Installez toutes les autres dépendances requises sur votre appareil, comme indiqué dans la liste des exigences figurant dans[Exigences relatives aux dispositifs](greengrass-nucleus-component.md#greengrass-v2-requirements).
### Configuration d'un appareil Windows
**Note**
Cette fonctionnalité est disponible pour les versions 2.5.0 et ultérieures du composant [Greengrass](greengrass-nucleus-component.md) nucleus.
**Pour configurer un appareil Windows pour AWS IoT Greengrass V2**
1. Installez le moteur d'exécution Java, dont le logiciel AWS IoT Greengrass Core a besoin pour fonctionner. Nous vous recommandons d'utiliser les versions de support à long terme d'[Amazon Corretto](https://aws.amazon.com/corretto/) [ou](https://openjdk.java.net/) d'OpenJDK. La version 8 ou supérieure est requise.
1. Vérifiez si Java est disponible sur la variable système [PATH](https://en.wikipedia.org/wiki/PATH_(variable)), et ajoutez-le dans le cas contraire. Le LocalSystem compte exécute le logiciel AWS IoT Greengrass Core. Vous devez donc ajouter Java à la variable système PATH au lieu de la variable utilisateur PATH pour votre utilisateur. Procédez comme suit :
1. Appuyez sur la touche Windows pour ouvrir le menu de démarrage.
1. Tapez **environment variables** pour rechercher les options du système dans le menu Démarrer.
1. Dans les résultats de recherche du menu Démarrer, choisissez **Modifier les variables d'environnement du système** pour ouvrir la fenêtre **des propriétés du système**.
1. Choisissez les **variables d'environnement...** pour ouvrir la fenêtre **des variables d'environnement**.
1. Sous **Variables système**, sélectionnez **Chemin**, puis **Modifier**. Dans la fenêtre **Modifier la variable d'environnement**, vous pouvez afficher chaque chemin sur une ligne distincte.
1. Vérifiez si le chemin d'accès au `bin` dossier d'installation de Java est présent. Le chemin peut ressembler à celui de l'exemple suivant.
```
C:\\Program Files\\Amazon Corretto\\jdk11.0.13_8\\bin
```
1. Si le `bin` dossier de l'installation Java est absent de **Path**, choisissez **Nouveau** pour l'ajouter, puis **OK**.
1. Ouvrez l'invite de commande Windows (`cmd.exe`) en tant qu'administrateur.
1. Créez l'utilisateur par défaut dans le LocalSystem compte sur l'appareil Windows. *password*Remplacez-le par un mot de passe sécurisé.
```
net user /add ggc_user password
```
**Astuce**
En fonction de votre configuration Windows, le mot de passe de l'utilisateur peut être configuré pour expirer à une date ultérieure. Pour vous assurer que vos applications Greengrass continuent de fonctionner, suivez la date d'expiration du mot de passe et mettez-le à jour avant son expiration. Vous pouvez également définir le mot de passe de l'utilisateur pour qu'il n'expire jamais.
Pour vérifier la date d'expiration d'un utilisateur et de son mot de passe, exécutez la commande suivante.
```
net user ggc_user | findstr /C:expires
```
Pour définir le mot de passe d'un utilisateur afin qu'il n'expire jamais, exécutez la commande suivante.
```
wmic UserAccount where "Name='ggc_user'" set PasswordExpires=False
```
Si vous utilisez Windows 10 ou une version ultérieure où la [`wmic`commande est obsolète](https://learn.microsoft.com/en-us/windows/win32/wmisdk/wmic), exécutez la commande suivante PowerShell .
```
Get-CimInstance -Query "SELECT * from Win32_UserAccount WHERE name = 'ggc_user'" | Set-CimInstance -Property @{PasswordExpires="False"}
```
1. Téléchargez et installez l'[PsExecutilitaire](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec) de Microsoft sur l'appareil.
1. Utilisez l' PsExec utilitaire pour stocker le nom d'utilisateur et le mot de passe de l'utilisateur par défaut dans l'instance Credential Manager du LocalSystem compte. *password*Remplacez-le par le mot de passe utilisateur que vous avez défini précédemment.
```
psexec -s cmd /c cmdkey /generic:ggc_user /user:ggc_user /pass:password
```
S'il **PsExec License Agreement**s'ouvre, choisissez **Accept**d'accepter la licence et exécutez la commande.
**Note**
Sur les appareils Windows, le LocalSystem compte exécute le noyau Greengrass, et vous devez utiliser l' PsExec utilitaire pour stocker les informations utilisateur par défaut dans le LocalSystem compte. L'application Credential Manager stocke ces informations dans le compte Windows de l'utilisateur actuellement connecté, plutôt que dans le LocalSystem compte.
## Téléchargez le logiciel AWS IoT Greengrass de base
Vous pouvez télécharger la dernière version du logiciel AWS IoT Greengrass Core à l'adresse suivante :
+ [https://d2s8p88vqu9w66.cloudfront. net/releases/greengrass](https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip)-nucleus-latest.zip
**Note**
Vous pouvez télécharger une version spécifique du logiciel AWS IoT Greengrass Core à l'emplacement suivant. Remplacez *version* par la version à télécharger.
```
https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-version.zip
```
**Pour télécharger le logiciel AWS IoT Greengrass Core**
1. Sur votre appareil principal, téléchargez le logiciel AWS IoT Greengrass Core dans un fichier nommé`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
```
------
Si vous téléchargez ce logiciel, vous acceptez le [contrat de licence du logiciel Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf).
1. (Facultatif) Pour vérifier la signature du logiciel Greengrass Nucleus
**Note**
Cette fonctionnalité est disponible avec Greengrass nucleus version 2.9.5 et versions ultérieures.
1. Utilisez la commande suivante pour vérifier la signature de votre artefact Greengrass nucleus :
------
#### [ Linux or Unix ]
```
jarsigner -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
Le nom du fichier peut être différent selon la version du JDK que vous installez. *`jdk17.0.6_10`*Remplacez-le par la version du JDK que vous avez installée.
```
"C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe" -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
Le nom du fichier peut être différent selon la version du JDK que vous installez. *`jdk17.0.6_10`*Remplacez-le par la version du JDK que vous avez installée.
```
'C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe' -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
1. L'`jarsigner`invocation produit une sortie qui indique les résultats de la vérification.
1. Si le fichier zip Greengrass nucleus est signé, le résultat contient l'instruction suivante :
```
jar verified.
```
1. Si le fichier zip Greengrass nucleus n'est pas signé, le résultat contient l'instruction suivante :
```
jar is unsigned.
```
1. Si vous avez fourni l'`-certs`option Jarsigner en même temps que les `-verbose` options `-verify` et, le résultat inclut également des informations détaillées sur le certificat du signataire.
1. Décompressez le logiciel AWS IoT Greengrass Core dans un dossier de votre appareil. *GreengrassInstaller*Remplacez-le par le dossier que vous souhaitez utiliser.
------
#### [ 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. (Facultatif) Exécutez la commande suivante pour voir la version du logiciel AWS IoT Greengrass Core.
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
**Important**
Si vous installez une version du noyau Greengrass antérieure à la version 2.4.0, ne supprimez pas ce dossier après avoir installé le logiciel Core. AWS IoT Greengrass Le logiciel AWS IoT Greengrass Core utilise les fichiers de ce dossier pour s'exécuter.
Si vous avez téléchargé la dernière version du logiciel, vous devez installer la version 2.4.0 ou ultérieure, et vous pouvez supprimer ce dossier après avoir installé le logiciel AWS IoT Greengrass Core.
## Installation du logiciel AWS IoT Greengrass Core
Exécutez le programme d'installation avec des arguments qui spécifient les actions suivantes :
+ Effectuez l'installation à partir d'un fichier de configuration partiel qui indique d'utiliser les AWS ressources et les certificats que vous avez créés précédemment. Le logiciel AWS IoT Greengrass Core utilise un fichier de configuration qui spécifie la configuration de chaque composant Greengrass de l'appareil. Le programme d'installation crée un fichier de configuration complet à partir du fichier de configuration partiel que vous fournissez.
+ Spécifiez d'utiliser l'utilisateur `ggc_user` du système pour exécuter les composants logiciels sur le périphérique principal. Sur les appareils Linux, cette commande indique également d'utiliser le groupe `ggc_group` système, et le programme d'installation crée l'utilisateur et le groupe système pour vous.
+ Configurez le logiciel AWS IoT Greengrass Core en tant que service système qui s'exécute au démarrage. Sur les appareils Linux, cela nécessite le [système d'initialisation Systemd](https://en.wikipedia.org/wiki/Systemd).
**Important**
Sur les appareils Windows Core, vous devez configurer le logiciel AWS IoT Greengrass Core en tant que service système.
Pour plus d'informations sur les arguments que vous pouvez spécifier, consultez[Arguments d'installation](configure-installer.md).
**Note**
Si vous utilisez AWS IoT Greengrass un appareil dont la mémoire est limitée, vous pouvez contrôler la quantité de mémoire utilisée par le logiciel AWS IoT Greengrass Core. Pour contrôler l'allocation de mémoire, vous pouvez définir les options de taille de segment de mémoire JVM dans le paramètre de `jvmOptions` configuration de votre composant Nucleus. Pour de plus amples informations, veuillez consulter [Contrôlez l'allocation de mémoire grâce aux options JVM](configure-greengrass-core-v2.md#jvm-tuning).
+ Si vous avez créé le certificat d'objet et la clé privée dans le AWS IoT service précédemment, suivez les étapes pour installer le logiciel AWS IoT Greengrass Core avec les fichiers de clé privée et de certificat.
+ Si vous avez créé le certificat d'objet à partir d'une clé privée dans un module de sécurité matériel (HSM) plus tôt, suivez les étapes pour installer le logiciel AWS IoT Greengrass Core avec la clé privée et le certificat dans un HSM.
### Installez le logiciel AWS IoT Greengrass Core avec les fichiers de clé privée et de certificat
**Pour installer le logiciel AWS IoT Greengrass Core**
1. Vérifiez la version du logiciel AWS IoT Greengrass Core.
+ Remplacez *GreengrassInstaller* par le chemin d'accès au dossier contenant le logiciel.
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
1. Utilisez un éditeur de texte pour créer un fichier de configuration nommé `config.yaml` à fournir au programme d'installation.
Par exemple, sur un système basé sur Linux, vous pouvez exécuter la commande suivante pour utiliser GNU nano pour créer le fichier.
```
nano GreengrassInstaller/config.yaml
```
Copiez le contenu YAML suivant dans le fichier. Ce fichier de configuration partiel spécifie les paramètres du système et les paramètres du noyau 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.17.0"
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"
```
Ensuite, procédez comme suit :
+ Remplacez chaque instance de `/greengrass/v2` par le dossier racine de Greengrass.
+ Remplacez *MyGreengrassCore* par le nom de l' AWS IoT objet.
+ *2.17.0*Remplacez-le par la version du logiciel AWS IoT Greengrass Core.
+ Remplacez *us-west-2* par l' Région AWS endroit où vous avez créé les ressources.
+ Remplacez *GreengrassCoreTokenExchangeRoleAlias* par le nom de l'alias du rôle d'échange de jetons.
+ Remplacez le `iotDataEndpoint` par votre point de terminaison de AWS IoT données.
+ Remplacez le point de terminaison `iotCredEndpoint` par vos AWS IoT informations d'identification.
**Note**
Dans ce fichier de configuration, vous pouvez personnaliser d'autres options de configuration du noyau, telles que les ports et le proxy réseau à utiliser, comme indiqué dans l'exemple suivant. Pour plus d'informations, consultez la section Configuration du [noyau 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.17.0"
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. Exécutez le programme d'installation et spécifiez `--init-config` de fournir le fichier de configuration.
+ Remplacez `/greengrass/v2` ou *C:\$1greengrass\$1v2* par le dossier racine de Greengrass.
+ Remplacez chaque instance de *GreengrassInstaller* par le dossier dans lequel vous avez décompressé le programme d'installation.
------
#### [ 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
```
------
**Important**
Sur les appareils Windows Core, vous `--setup-system-service true` devez spécifier de configurer le logiciel AWS IoT Greengrass Core en tant que service système.
Si vous le spécifiez`--setup-system-service true`, le programme d'installation affiche `Successfully set up Nucleus as a system service` s'il a configuré et exécuté le logiciel en tant que service système. Dans le cas contraire, le programme d'installation n'affiche aucun message s'il installe le logiciel avec succès.
**Note**
Vous ne pouvez pas utiliser l'`deploy-dev-tools`argument pour déployer des outils de développement locaux lorsque vous exécutez le programme d'installation sans l'`--provision true`argument. Pour plus d'informations sur le déploiement de la CLI Greengrass directement sur votre appareil, consultez. [Interface de ligne de commande Greengrass](gg-cli.md)
1. Vérifiez l'installation en consultant les fichiers du dossier racine.
------
#### [ Linux or Unix ]
```
ls /greengrass/v2
```
------
#### [ Windows Command Prompt (CMD) ]
```
dir C:\greengrass\v2
```
------
#### [ PowerShell ]
```
ls C:\greengrass\v2
```
------
Si l'installation a réussi, le dossier racine contient plusieurs dossiers, tels que `config``packages`, et`logs`.
### Installez le logiciel AWS IoT Greengrass principal avec la clé privée et le certificat dans un HSM
**Note**
Cette fonctionnalité est disponible pour les versions 2.5.3 et ultérieures du composant [Greengrass](greengrass-nucleus-component.md) nucleus. AWS IoT Greengrass ne prend actuellement pas en charge cette fonctionnalité sur les appareils Windows principaux.
**Pour installer le logiciel AWS IoT Greengrass Core**
1. Vérifiez la version du logiciel AWS IoT Greengrass Core.
+ Remplacez *GreengrassInstaller* par le chemin d'accès au dossier contenant le logiciel.
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
1. Pour permettre au logiciel AWS IoT Greengrass Core d'utiliser la clé privée et le certificat du HSM, installez le [composant fournisseur PKCS \$111](pkcs11-provider-component.md) lors de l'installation du logiciel AWS IoT Greengrass Core. Le composant fournisseur PKCS \$111 est un plugin que vous pouvez configurer lors de l'installation. Vous pouvez télécharger la dernière version du composant fournisseur PKCS \$111 depuis l'emplacement suivant :
+ [https://d2s8p88vqu9w66.cloudfront. net/releases/Pkcs11Provider/aws.greengrass.crypto.pkcs11Provider-Latest.jar](https://d2s8p88vqu9w66.cloudfront.net/releases/Pkcs11Provider/aws.greengrass.crypto.Pkcs11Provider-latest.jar)
Téléchargez le plugin du fournisseur PKCS \$111 dans un fichier nommé`aws.greengrass.crypto.Pkcs11Provider.jar`. *GreengrassInstaller*Remplacez-le par le dossier que vous souhaitez utiliser.
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/Pkcs11Provider/aws.greengrass.crypto.Pkcs11Provider-latest.jar > GreengrassInstaller/aws.greengrass.crypto.Pkcs11Provider.jar
```
Si vous téléchargez ce logiciel, vous acceptez le [contrat de licence du logiciel Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf).
1. Utilisez un éditeur de texte pour créer un fichier de configuration nommé `config.yaml` à fournir au programme d'installation.
Par exemple, sur un système basé sur Linux, vous pouvez exécuter la commande suivante pour utiliser GNU nano pour créer le fichier.
```
nano GreengrassInstaller/config.yaml
```
Copiez le contenu YAML suivant dans le fichier. Ce fichier de configuration partiel spécifie les paramètres système, les paramètres du noyau Greengrass et les paramètres du fournisseur 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.17.0"
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"
```
Ensuite, procédez comme suit :
+ Remplacez chaque instance du PKCS \$111 par le libellé URIs de l'objet *iotdevicekey* dans lequel vous avez créé la clé privée et importé le certificat.
+ Remplacez chaque instance de `/greengrass/v2` par le dossier racine de Greengrass.
+ Remplacez *MyGreengrassCore* par le nom de l' AWS IoT objet.
+ *2.17.0*Remplacez-le par la version du logiciel AWS IoT Greengrass Core.
+ Remplacez *us-west-2* par l' Région AWS endroit où vous avez créé les ressources.
+ Remplacez *GreengrassCoreTokenExchangeRoleAlias* par le nom de l'alias du rôle d'échange de jetons.
+ Remplacez le `iotDataEndpoint` par votre point de terminaison de AWS IoT données.
+ Remplacez le point de terminaison `iotCredEndpoint` par vos AWS IoT informations d'identification.
+ Remplacez les paramètres de configuration du `aws.greengrass.crypto.Pkcs11Provider` composant par les valeurs de la configuration HSM sur le périphérique principal.
**Note**
Dans ce fichier de configuration, vous pouvez personnaliser d'autres options de configuration du noyau, telles que les ports et le proxy réseau à utiliser, comme indiqué dans l'exemple suivant. Pour plus d'informations, consultez la section Configuration du [noyau 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.17.0"
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. Exécutez le programme d'installation et spécifiez `--init-config` de fournir le fichier de configuration.
+ `/greengrass/v2`Remplacez-le par le dossier racine de Greengrass.
+ Remplacez chaque instance de *GreengrassInstaller* par le dossier dans lequel vous avez décompressé le programme d'installation.
```
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
```
**Important**
Sur les appareils Windows Core, vous `--setup-system-service true` devez spécifier de configurer le logiciel AWS IoT Greengrass Core en tant que service système.
Si vous le spécifiez`--setup-system-service true`, le programme d'installation affiche `Successfully set up Nucleus as a system service` s'il a configuré et exécuté le logiciel en tant que service système. Dans le cas contraire, le programme d'installation n'affiche aucun message s'il installe le logiciel avec succès.
**Note**
Vous ne pouvez pas utiliser l'`deploy-dev-tools`argument pour déployer des outils de développement locaux lorsque vous exécutez le programme d'installation sans l'`--provision true`argument. Pour plus d'informations sur le déploiement de la CLI Greengrass directement sur votre appareil, consultez. [Interface de ligne de commande Greengrass](gg-cli.md)
1. Vérifiez l'installation en consultant les fichiers du dossier racine.
------
#### [ Linux or Unix ]
```
ls /greengrass/v2
```
------
#### [ Windows Command Prompt (CMD) ]
```
dir C:\greengrass\v2
```
------
#### [ PowerShell ]
```
ls C:\greengrass\v2
```
------
Si l'installation a réussi, le dossier racine contient plusieurs dossiers, tels que `config``packages`, et`logs`.
Si vous avez installé le logiciel AWS IoT Greengrass Core en tant que service système, le programme d'installation exécute le logiciel pour vous. Dans le cas contraire, vous devez exécuter le logiciel manuellement. Pour de plus amples informations, veuillez consulter [Exécutez le logiciel AWS IoT Greengrass Core](run-greengrass-core-v2.md).
**Note**
Lorsque le logiciel AWS IoT Greengrass Core se connecte au cloud, votre appareil est reconnu comme un appareil Core.
Pour plus d'informations sur la configuration et l'utilisation du logiciel AWS IoT Greengrass, consultez les rubriques suivantes :
+ [Configuration du logiciel AWS IoT Greengrass de base](configure-greengrass-core-v2.md)
+ [Développer des AWS IoT Greengrass composants](develop-greengrass-components.md)
+ [Déployer AWS IoT Greengrass des composants sur des appareils](manage-deployments.md)
+ [Interface de ligne de commande Greengrass](gg-cli.md)