Usando um contêiner personalizado para análise

Esta seção inclui informações sobre como criar um contêiner do Docker usando um caderno Jupyter. Há um risco de segurança se você usar blocos de anotações criados por terceiros: os contêineres incluídos poderão executar código arbitrário com as permissões de usuário. Além disso, o HTML gerado pelo notebook pode ser exibido no AWS IoT Analytics console, fornecendo um potencial vetor de ataque no computador que exibe o HTML. Certifique-se de confiar no autor de qualquer bloco de anotações de terceiros antes de usá-lo.

Você pode criar seu próprio contêiner personalizado e executá-lo com o AWS IoT Analytics serviço. Para fazer isso, você configura e faz upload de uma imagem do Docker no Amazon ECR e, em seguida, configura um conjunto de dados para executar uma ação de contêiner. Esta seção fornece um exemplo do processo usando o Octave.

Este tutorial também pressupõe que você tem:

o Octave instalado no computador local
Uma conta de docker configurada no computador local
Uma AWS conta com Amazon ECR ou acesso AWS IoT Analytics

Etapa 1: Configurar uma imagem de docker

Há três arquivos principais dos quais você precisa para este tutorial. Seus nomes e conteúdo são:

Dockerfile: a configuração inicial do processo de conteinerização do Docker.


FROM ubuntu:16.04

# Get required set of software
RUN apt-get update
RUN apt-get install -y software-properties-common
RUN apt-get install -y octave
RUN apt-get install -y python3-pip

# Get boto3 for S3 and other libraries
RUN pip3 install --upgrade pip
RUN pip3 install boto3
RUN pip3 install urllib3

# Move scripts over
ADD moment moment
ADD run-octave.py run-octave.py

# Start python script
ENTRYPOINT ["python3", "run-octave.py"]

run-octave.py— Analisa o JSON AWS IoT Analytics, executa o script Octave e carrega artefatos para o Amazon S3.


import boto3
import json
import os
import sys
from urllib.parse import urlparse

# Parse the JSON from IoT Analytics
with open('/opt/ml/input/data/iotanalytics/params') as params_file:
    params = json.load(params_file)

variables = params['Variables']

order = variables['order']
input_s3_bucket = variables['inputDataS3BucketName']
input_s3_key = variables['inputDataS3Key']
output_s3_uri = variables['octaveResultS3URI']

local_input_filename = "input.txt"
local_output_filename = "output.mat"

# Pull input data from S3...
s3 = boto3.resource('s3')
s3.Bucket(input_s3_bucket).download_file(input_s3_key, local_input_filename)

# Run Octave Script
os.system("octave moment {} {} {}".format(local_input_filename, local_output_filename, order))

# # Upload the artifacts to S3
output_s3_url = urlparse(output_s3_uri)
output_s3_bucket = output_s3_url.netloc
output_s3_key = output_s3_url.path[1:]

s3.Object(output_s3_bucket, output_s3_key).put(Body=open(local_output_filename, 'rb'), ACL='bucket-owner-full-control')

moment: um script do Octave simples que calcula o momento com base em um arquivo de entrada ou saída e uma ordem especificada.


#!/usr/bin/octave -qf

arg_list = argv ();
input_filename = arg_list{1};
output_filename = arg_list{2};
order = str2num(arg_list{3});

[D,delimiterOut]=importdata(input_filename)
M = moment(D, order)

save(output_filename,'M')

Faça download do conteúdo de cada arquivo. Crie um novo diretório e coloque todos os arquivos nele. Em seguida, cd para aquele diretório.
Execute o seguinte comando:
```
docker build -t octave-moment .
```
Você deve ver uma nova imagem no repositório de docker. Instale-o executando o seguinte comando.
```
docker image ls | grep octave-moment
```

Etapa 2: Fazer upload da imagem do Docker em um repositório do Amazon ECR

Crie um repositório do Amazon ECR.


aws ecr create-repository --repository-name octave-moment

Obtenha o login para o ambiente do Docker.
```
aws ecr get-login
```

Copie a saída e execute-a. A saída deve parecer com algo semelhante ao seguinte:


docker login -u AWS -p password -e none https://your-aws-account-id.dkr.ecr..amazonaws.com

Marque a imagem criada com a tag do repositório do Amazon ECR.


docker tag your-image-id  your-aws-account-id.dkr.ecr.region.amazonaws.com/octave-moment

Envie a imagem para o Amazon ECR.


docker push your-aws-account-id.dkr.ecr.region.amazonaws.com/octave-moment

Etapa 3: Fazer upload dos dados de exemplo em um bucket do Amazon S3

Fazer download do seguinte no arquivo input.txt.


0.857549  -0.987565  -0.467288  -0.252233  -2.298007
 0.030077  -1.243324  -0.692745   0.563276   0.772901
-0.508862  -0.404303  -1.363477  -1.812281  -0.296744
-0.203897   0.746533   0.048276   0.075284   0.125395
 0.829358   1.246402  -1.310275  -2.737117   0.024629
 1.206120   0.895101   1.075549   1.897416   1.383577

Crie um bucket do Amazon S3 chamado octave-sample-data-your-aws-account-id.
Faça upload do arquivo input.txt no bucket do Amazon S3 recém-criado. Agora você deve ter um bucket chamado octave-sample-data-your-aws-account-id que contém o arquivo input.txt.

Etapa 4: Criar uma função de execução de contêiner

Copie o seguinte para um arquivo denominado role1.json. your-aws-account-idSubstitua pelo ID da sua AWS conta e aws-region pela AWS região dos seus AWS recursos.

nota

Este exemplo inclui uma chave de contexto de condição global para proteger contra o problema de segurança substituto confuso. Para obter mais informações, consulte Prevenção contra o ataque do “substituto confuso” em todos os serviços.


{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Service": [
                    "sagemaker.amazonaws.com",
                    "iotanalytics.amazonaws.com"
                ]
            },
            "Action": "sts:AssumeRole",
            "Condition": {
              "StringEquals": {
                "aws:SourceAccount": "your-aws-account-id"
              },
              "ArnLike": {
                "aws:SourceArn": "arn:aws:iotanalytics:aws-region:your-aws-account-id:dataset/DOC-EXAMPLE-DATASET"
              }
            }
    ]
}

Crie uma função que dê permissões de acesso à SageMaker IA e AWS IoT Analytics, usando o arquivo role1.json que você baixou.
```
aws iam create-role --role-name container-execution-role --assume-role-policy-document file://role1.json
```

Faça o download do seguinte em um arquivo chamado policy1.json e substitua your-account-id pelo ID da sua conta (veja o segundo ARN abaixo Statement:Resource).


{
 "Version": "2012-10-17",
 "Statement": [
   {
     "Effect": "Allow",
     "Action": [
       "s3:GetBucketLocation",
       "s3:PutObject",
       "s3:GetObject",
       "s3:PutObjectAcl"
     ],
     "Resource": [
       "arn:aws:s3:::*-dataset-*/*",
       "arn:aws:s3:::octave-sample-data-your-account-id/*"
   },
   {
     "Effect": "Allow",
     "Action": [
       "iotanalytics:*"
     ],
     "Resource": "*"
   },
   {
     "Effect": "Allow",
     "Action": [
       "ecr:GetAuthorizationToken",
       "ecr:GetDownloadUrlForLayer",
       "ecr:BatchGetImage",
       "ecr:BatchCheckLayerAvailability",
       "logs:CreateLogGroup",
       "logs:CreateLogStream",
       "logs:DescribeLogStreams",
       "logs:GetLogEvents",
       "logs:PutLogEvents"
     ],
     "Resource": "*"
   },
   {
     "Effect": "Allow",
     "Action": [
       "s3:GetBucketLocation",
       "s3:ListBucket",
       "s3:ListAllMyBuckets"
     ],
     "Resource" : "*"
   }
 ]
}

Crie uma política do IAM, usando o arquivo policy.json obtido por download.


aws iam create-policy --policy-name ContainerExecutionPolicy --policy-document file://policy1.json

Anexe a política ao perfil.


aws iam attach-role-policy --role-name container-execution-role --policy-arn arn:aws:iam::your-account-id:policy/ContainerExecutionPolicy

Etapa 5: Criar um conjunto de dados com uma ação de contêiner

Faça o download do seguinte em um arquivo chamado cli-input.json e substitua todas as instâncias de your-account-id e region pelos valores apropriados.


{
    "datasetName": "octave_dataset",
    "actions": [
        {
            "actionName": "octave",
            "containerAction": {
                "image": "your-account-id.dkr.ecr.region.amazonaws.com/octave-moment",
                "executionRoleArn": "arn:aws:iam::your-account-id:role/container-execution-role",
                "resourceConfiguration": {
                    "computeType": "ACU_1",
                    "volumeSizeInGB": 1
                },
                "variables": [
                    {
                        "name": "octaveResultS3URI",
                        "outputFileUriValue": {
                            "fileName": "output.mat"
                        }
                    },
                    {
                        "name": "inputDataS3BucketName",
                        "stringValue": "octave-sample-data-your-account-id"
                    },
                    {
                        "name": "inputDataS3Key",
                        "stringValue": "input.txt"
                    },
                    {
                        "name": "order",
                        "stringValue": "3"
                    }
                ]
            } 
        }
    ]
}

Crie um conjunto de dados usando o arquivo cli-input.json obtido por download e editado.
```
aws iotanalytics create-dataset —cli-input-json file://cli-input.json
```

Etapa 6: Invocar a geração do conteúdo do conjunto de dados

Execute o seguinte comando:


aws iotanalytics create-dataset-content --dataset-name octave-dataset

Etapa 7: Obter o conteúdo do conjunto de dados

Execute o seguinte comando:


aws iotanalytics get-dataset-content --dataset-name octave-dataset --version-id \$LATEST

É necessário esperar alguns minutos até que o DatasetContentState seja SUCCEEDED.

Etapa 8: Imprimir a saída no Octave

Use o shell do Octave para imprimir a saída do contêiner executando o seguinte comando:


bash> octave
octave> load output.mat
octave> disp(M)
-0.016393 -0.098061 0.380311 -0.564377 -1.318744

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Conteinerização de caderno

Visualizando dados