Creare e registrare il parco e autenticare i dispositivi - Amazon SageMaker

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Creare e registrare il parco e autenticare i dispositivi

In questa sezione creerai il tuo AWS IoT oggetto, creerai un parco dispositivi, registrerai il tuo parco dispositivi in modo che possa interagire con il cloud, creerai certificati X.509 per autenticare i tuoi dispositivi AWS IoT Core, assocerai l'alias di ruolo a AWS IoT quello generato al momento della creazione del parco dispositivi, otterrai un endpoint AWS specifico dell'account per il fornitore di credenziali, otterrai un file Amazon Root CA ufficiale e caricherai il file Amazon CA su Amazon S3.

  1. Crea cose. AWS IoT

    SageMaker Edge Manager sfrutta i AWS IoT Core servizi per facilitare la connessione tra i dispositivi perimetrali e gli endpoint nel AWS cloud. È possibile sfruttare le AWS IoT funzionalità esistenti dopo aver configurato i dispositivi per l'utilizzo con Edge Manager.

    Per connettere il tuo dispositivo a AWS IoT, devi creare AWS IoT oggetti, creare e registrare un certificato client con AWS IoT e creare e configurare il ruolo IAM per i tuoi dispositivi.

    Innanzitutto, crea AWS IoT oggetti con il AWS IoT client (iot_client) che hai creato in precedenza con Boto3. L'esempio seguente mostra come creare due oggetti .

    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
)

  2. Creare il proprio parco dispositivi.

    Crea una flotta di dispositivi con l'oggetto SageMaker client definito in un passaggio precedente. Puoi anche utilizzare la SageMaker console per creare un parco dispositivi.

    import time
device_fleet_name="demo-device-fleet" + str(time.time()).split('.')[0]
device_name="sagemaker-edge-demo-device" + str(time.time()).split('.')[0]

    Specifica l'ARN del ruolo IoT. Ciò consente di AWS IoT concedere credenziali temporanee ai dispositivi.

    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 di AWS IoT ruolo viene creato quando si crea un parco dispositivi. Questo alias di ruolo è associato all' AWS IoT utilizzo dell'iot_clientoggetto in una fase successiva.

  3. Registrare il proprio parco dispositivi.

    Per interagire con il cloud, è necessario registrare il dispositivo con SageMaker Edge Manager. In questo esempio, registri un singolo dispositivo con il parco che hai creato. Per registrare il dispositivo, è necessario fornire il nome del dispositivo e il nome dell'oggetto AWS IoT , come illustrato nell'esempio seguente:

    # 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
        }
    ]
)

  4. Creare certificati X.509.

    Dopo aver creato l' AWS IoT oggetto oggetto, è necessario creare un certificato di dispositivo X.509 per l'oggetto oggetto. Questo certificato autentica il proprio dispositivo a AWS IoT Core.

    Utilizzate quanto segue per creare una chiave privata, una chiave pubblica e un file di certificato X.509 utilizzando il AWS IoT client defined () in precedenza. 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')

  5. Associa l'alias del ruolo a. AWS IoT

    Quando crei un parco dispositivi con SageMaker (sagemaker_client.create_device_fleet()), viene generato automaticamente un alias di ruolo. Un alias di AWS IoT ruolo fornisce un meccanismo che consente ai dispositivi connessi di autenticarsi AWS IoT utilizzando certificati X.509 e quindi ottenere AWS credenziali di breve durata da un ruolo IAM associato a un alias di ruolo. AWS IoT L'alias del ruolo ti consente di modificare il ruolo del dispositivo senza doverlo aggiornare. Utilizza DescribeDeviceFleet per ottenere il nome alias del ruolo e 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:]

    Utilizza il iot_client per facilitare l'associazione dell'alias di ruolo generato dalla creazione del parco dispositivi con: AWS IoT

    role_alias = iot_client.describe_role_alias(
                    roleAlias=role_alias_name)

    Per ulteriori informazioni sull'alias del ruolo IAM, consulta L'alias del ruolo consente l'accesso a servizi inutilizzati.

    Hai creato e registrato un certificato con Previous AWS IoT per l'autenticazione corretta del tuo dispositivo. Ora devi creare e collegare una policy al certificato per autorizzare la richiesta del token di sicurezza.

    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'])

  6. Richiedi l'endpoint AWS specifico dell'account per il fornitore delle credenziali.

    I dispositivi Edge necessitano di un endpoint per assumere le credenziali. Ottieni l'endpoint AWS specifico dell'account per il fornitore delle credenziali.

    # 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)

  7. Ottieni il file CA root ufficiale di Amazon e caricalo sul bucket Amazon S3.

    Usa quanto segue nel tuo Jupyter Notebook oppure AWS CLI (se usi il tuo terminale), rimuovi il simbolo «!» funzione magica):

    !wget https://www.amazontrust.com/repository/AmazonRootCA1.pem

    Utilizza l'endpoint per effettuare una richiesta HTTPS al fornitore di credenziali per restituire un token di sicurezza. Il comando di esempio seguente utilizza curl, ma è possibile utilizzare qualsiasi client HTTP.

    !curl --cert device.pem.crt --key private.pem.key --cacert AmazonRootCA1.pem $endpoint

    Se il certificato è verificato, carica le chiavi e il certificato nell'URI del tuo bucket 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/

    Pulisci la directory di lavoro spostando le chiavi e il certificato in un'altra directory:

    # Optional - Clean up working directory
!mkdir authorization-files
!mv private.pem.key device.pem.crt AmazonRootCA1.pem authorization-files/