Créer et enregistrer des flottes, et authentifier des dispositifs

Dans cette section, vous allez créer votre objet AWS IoT, créer une flotte de dispositifs, enregistrer votre flotte de dispositifs pour qu'elle puisse interagir avec le cloud, créer des certificats X.509 pour authentifier vos dispositifs sur AWS IoT Core, associer l'alias du rôle à AWS IoT qui a été généré lorsque vous avez créé votre flotte, obtenir votre point de terminaison spécifique au compte AWS pour le fournisseur d'informations d'identification, obtenir un fichier officiel d'autorité de certification Amazon Root et télécharger le fichier d'autorité de certification Amazon sur Amazon S3.

Créez des objets AWS IoT.

SageMaker Edge Manager tire parti des AWS IoT Core services pour faciliter la connexion entre les appareils de périphérie et les points de terminaison dans le AWS cloud. Vous pouvez tirer parti de la fonctionnalité AWS IoT existante après avoir configuré vos dispositifs pour qu'ils fonctionnent avec Edge Manager.

Pour connecter votre dispositif à AWS IoT, vous devez créer des objets AWS IoT, créer et enregistrer un certificat client avec AWS IoT, et créer et configurer le rôle IAM pour vos dispositifs.

Tout d'abord, créez des objets AWS IoT avec le client AWS IoT (iot_client) que vous avez créé précédemment avec Boto3. L'exemple suivant montre comment créer deux objets IoT :
```
iot_thing_name = 'sample-device'
iot_thing_type = 'getting-started-demo'

iot_client.create_thing_type(
    thingTypeName=iot_thing_type
)

# Create an AWS IoT thing objects
iot_client.create_thing(
    thingName=iot_thing_name,
    thingTypeName=iot_thing_type
)
```
Créez votre flotte de dispositifs.

Créez un parc d'appareils avec l'objet SageMaker client défini à l'étape précédente. Vous pouvez également utiliser la SageMaker console pour créer un parc d'appareils.
```
import time
device_fleet_name="demo-device-fleet" + str(time.time()).split('.')[0]
device_name="sagemaker-edge-demo-device" + str(time.time()).split('.')[0]
```
Spécifiez votre ARN de rôle IoT. Cela permet à AWS IoT d'octroyer des informations d'identification temporaires aux dispositifs.
```
device_model_directory='device_output'
s3_device_fleet_output = 's3://{}/{}'.format(bucket, device_model_directory)

sagemaker_client.create_device_fleet(
    DeviceFleetName=device_fleet_name,
    RoleArn=iot_role_arn, # IoT Role ARN specified in previous step
    OutputConfig={
        'S3OutputLocation': s3_device_fleet_output
    }
)
```
Un alias de rôle AWS IoT est créé lorsque vous créez une flotte de dispositifs. Cet alias de rôle est associé à l'utilisation par AWS IoT de l'objet iot_client à une étape ultérieure.
Enregistrez votre flotte de dispositifs.

Pour interagir avec le cloud, vous devez enregistrer votre appareil auprès d' SageMaker Edge Manager. Dans cet exemple, vous enregistrez un seul dispositif dans la flotte que vous avez créée. Pour enregistrer le dispositif, vous devez fournir un nom de dispositif et le nom AWS IoT, comme illustré dans l'exemple suivant :
```
# Device name should be 36 characters
device_name = "sagemaker-edge-demo-device" + str(time.time()).split('.')[0]

sagemaker_client.register_devices(
    DeviceFleetName=device_fleet_name,
    Devices=[
        {
            "DeviceName": device_name,
            "IotThingName": iot_thing_name
        }
    ]
)
```

Créez des certificats X.509.

Après avoir créé l'objet AWS IoT, vous devez créer un certificat de périphérique X.509 pour votre objet. Ce certificat authentifie votre dispositif auprès de AWS IoT Core.

Utilisez les instructions suivantes pour créer une clé privée, une clé publique et un fichier de certificat X.509 à l'aide de l'AWS IoT précédemment défini par le client (iot_client).


# Creates a 2048-bit RSA key pair and issues an X.509 # certificate 
# using the issued public key.
create_cert = iot_client.create_keys_and_certificate(
    setAsActive=True 
)

# Get certificate from dictionary object and save in its own
with open('./device.pem.crt', 'w') as f:
    for line in create_cert['certificatePem'].split('\n'):
        f.write(line)
        f.write('\n')
# Get private key from dictionary object and save in its own 
with open('./private.pem.key', 'w') as f:
    for line in create_cert['keyPair']['PrivateKey'].split('\n'):
        f.write(line)
        f.write('\n')
# Get a private key from dictionary object and save in its own 
with open('./public.pem.key', 'w') as f:
    for line in create_cert['keyPair']['PublicKey'].split('\n'):
        f.write(line)
        f.write('\n')

Associez l'alias du rôle à AWS IoT.

Lorsque vous créez un parc d'appareils avec SageMaker (sagemaker_client.create_device_fleet()), un alias de rôle est généré pour vous. L'alias du rôle AWS IoT fournit un mécanisme permettant aux dispositifs connectés de s'authentifier auprès de AWS IoT à l'aide de certificats X.509, puis d'obtenir des informations d'identification AWS de durée limitée à partir d'un rôle IAM associé à un alias de rôle AWS IoT. L'alias de rôle vous permet de modifier le rôle du dispositif sans mettre à jour le dispositif. Utilisez DescribeDeviceFleet pour obtenir le nom de l'alias du rôle et l'ARN.
```
# Print Amazon Resource Name (ARN) and alias that has access 
# to AWS Internet of Things (IoT).
sagemaker_client.describe_device_fleet(DeviceFleetName=device_fleet_name)

# Store iot role alias string in a variable
# Grabs role ARN
full_role_alias_name = sagemaker_client.describe_device_fleet(DeviceFleetName=device_fleet_name)['IotRoleAlias']
start_index = full_role_alias_name.find('SageMaker') # Find beginning of role name  
role_alias_name = full_role_alias_name[start_index:] 
```
Utilisez l'iot_client pour permettre l'association de l'alias de rôle généré à partir de la création de la flotte de dispositifs avec AWS IoT :
```
role_alias = iot_client.describe_role_alias(
                    roleAlias=role_alias_name)
```
Pour de plus amples informations sur l'alias de rôle IAM, veuillez consulter Role alias allows access to unused services (L'alias de rôle permet d'accéder aux services inutilisés).

Précédemment, vous avez créé et enregistré un certificat auprès de AWS IoT pour permettre l'authentification réussie de votre dispositif. Maintenant, vous devez créer et attacher une politique au certificat afin d'autoriser la demande pour le jeton de sécurité.
```
alias_policy = {
  "Version": "2012-10-17",
  "Statement": {
    "Effect": "Allow",
    "Action": "iot:AssumeRoleWithCertificate",
    "Resource": role_alias['roleAliasDescription']['roleAliasArn']
  }
}

policy_name = 'aliaspolicy-'+ str(time.time()).split('.')[0]
aliaspolicy = iot_client.create_policy(policyName=policy_name,
                                       policyDocument=json.dumps(alias_policy))

# Attach policy
iot_client.attach_policy(policyName=policy_name,
                            target=create_cert['certificateArn'])
```
Obtenez votre point de terminaison spécifique au compte AWS pour le fournisseur d'informations d'identification.

Les dispositifs périphériques ont besoin d'un point de terminaison pour prendre en charge les informations d'identification. Obtenez votre point de terminaison spécifique au compte AWS pour le fournisseur d'informations d'identification.
```
# Get the unique endpoint specific to your AWS account that is making the call.
iot_endpoint = iot_client.describe_endpoint(
    endpointType='iot:CredentialProvider'
)

endpoint="https://{}/role-aliases/{}/credentials".format(iot_endpoint['endpointAddress'],role_alias_name)
```
Obtenez le fichier officiel de l'autorité de certification Amazon Root et téléchargez-le dans le compartiment Amazon S3.

Utilisez ce qui suit dans votre bloc-notes Jupyter ou AWS CLI (si vous utilisez votre terminal, supprimez la fonction magique ‘!') :
```
!wget https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
Utilisez le point de terminaison pour adresser une demande HTTPS au fournisseur d'informations d'identification pour qu'il renvoie un jeton de sécurité. L'exemple de commande suivant utilise curl, mais vous pouvez utiliser n'importe quel client HTTP.
```
!curl --cert device.pem.crt --key private.pem.key --cacert AmazonRootCA1.pem $endpoint
```
Si le certificat est vérifié, téléchargez les clés et le certificat dans votre URI du compartiment Amazon S3 :
```
!aws s3 cp private.pem.key s3://{bucket}/authorization-files/
!aws s3 cp device.pem.crt s3://{bucket}/authorization-files/
!aws s3 cp AmazonRootCA1.pem s3://{bucket}/authorization-files/
```
Nettoyez votre répertoire de travail en déplaçant vos clés et votre certificat vers un autre répertoire :
```
# Optional - Clean up working directory
!mkdir authorization-files
!mv private.pem.key device.pem.crt AmazonRootCA1.pem authorization-files/
```

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Entraîner, compiler et empaqueter votre modèle

Télécharger et configurer Edge Manager