

Pemberitahuan akhir dukungan: Pada 15 Desember 2025, AWS akan mengakhiri dukungan untuk AWS IoT Analytics. Setelah 15 Desember 2025, Anda tidak akan lagi dapat mengakses AWS IoT Analytics konsol, atau AWS IoT Analytics sumber daya. Untuk informasi selengkapnya, lihat [AWS IoT Analytics akhir dukungan](https://docs.aws.amazon.com/iotanalytics/latest/userguide/iotanalytics-end-of-support.html).

Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Menggunakan wadah khusus untuk analisis
<a name="automate-custom-container"></a>

Bagian ini mencakup informasi tentang cara membuat wadah Docker menggunakan notebook Jupyter. Ada risiko keamanan jika Anda menggunakan kembali notebook yang dibuat oleh pihak ketiga: kontainer yang disertakan dapat mengeksekusi kode arbitrer dengan izin pengguna Anda. Selain itu, HTML yang dihasilkan oleh notebook dapat ditampilkan di AWS IoT Analytics konsol, memberikan vektor serangan potensial pada komputer yang menampilkan HTML. Pastikan Anda mempercayai penulis buku catatan pihak ketiga mana pun sebelum menggunakannya.

Anda dapat membuat wadah khusus Anda sendiri dan menjalankannya dengan AWS IoT Analytics layanan. Untuk melakukannya, Anda menyiapkan image Docker dan mengunggahnya ke Amazon ECR, lalu menyiapkan kumpulan data untuk menjalankan tindakan penampung. Bagian ini memberikan contoh proses menggunakan Oktaf. 

Tutorial ini mengasumsikan bahwa Anda memiliki:
+ Oktaf diinstal pada komputer lokal Anda
+ Akun Docker yang disiapkan di komputer lokal Anda
+  AWS Akun dengan Amazon ECR atau akses AWS IoT Analytics 

**Langkah 1: Siapkan gambar Docker**

Ada tiga file utama yang Anda butuhkan untuk tutorial ini. Nama dan isinya ada di sini:
+ `Dockerfile`— Pengaturan awal untuk proses kontainerisasi 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`— Mem-parsing JSON dari AWS IoT Analytics, menjalankan skrip Octave, dan mengunggah artefak ke 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`— Skrip Oktaf sederhana yang menghitung momen berdasarkan file input atau output dan urutan tertentu.

  ```
  #!/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')
  ```

1. Unduh isi dari setiap file. Buat direktori baru dan tempatkan semua file di dalamnya dan kemudian `cd` ke direktori itu.

1. Jalankan perintah berikut.

   ```
   docker build -t octave-moment .
   ```

1. Anda akan melihat gambar baru di repositori Docker Anda. Verifikasi dengan menjalankan perintah berikut.

   ```
   docker image ls | grep octave-moment
   ```

**Langkah 2: Unggah gambar Docker ke repositori Amazon ECR**

1. Buat repositori di Amazon ECR.

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

1. Dapatkan login ke lingkungan Docker Anda.

   ```
   aws ecr get-login
   ```

1. Salin output dan jalankan. Outputnya akan terlihat seperti berikut ini.

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

1. Tandai gambar yang Anda buat dengan tag repositori Amazon ECR.

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

1. Dorong gambar ke Amazon ECR.

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

**Langkah 3: Unggah data sampel Anda ke bucket Amazon S3**

1. Unduh yang berikut ini ke file`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
   ```

1. Buat bucket Amazon S3 yang disebut. `octave-sample-data-{{your-aws-account-id}}`

1. Unggah file `input.txt` ke bucket Amazon S3 yang baru saja Anda buat. Anda sekarang harus memiliki ember bernama `octave-sample-data-{{your-aws-account-id}}` yang berisi `input.txt` file.

**Langkah 4: Buat peran eksekusi kontainer**

1. Salin berikut ini ke file bernama`role1.json`. Ganti {{your-aws-account-id}} dengan ID AWS akun Anda dan {{aws-region}} dengan AWS wilayah sumber AWS daya Anda.
**catatan**  
Contoh ini mencakup kunci konteks kondisi global untuk melindungi dari masalah keamanan wakil yang membingungkan. Untuk informasi selengkapnya, lihat [Pencegahan "confused deputy" lintas layanan](cross-service-confused-deputy-prevention.md).

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Principal": {
                   "Service": [
                       "sagemaker.amazonaws.com",
                       "iotanalytics.amazonaws.com"
                   ]
               },
               "Action": "sts:AssumeRole",
               "Condition": {
                   "StringEquals": {
                       "aws:SourceAccount": "{{123456789012}}"
                   },
                   "ArnLike": {
                       "aws:SourceArn": "arn:aws:iotanalytics:{{us-east-1}}:{{123456789012}}:dataset/{{your-dataset}}"
                   }
               }
           }
       ]
   }
   ```

------

1. Buat peran yang memberikan izin akses ke SageMaker AI dan AWS IoT Analytics, menggunakan file `role1.json` yang Anda unduh.

   ```
   aws iam create-role --role-name container-execution-role --assume-role-policy-document file://role1.json
   ```

1. Unduh yang berikut ini ke file bernama `policy1.json` dan ganti {{`your-account-id`}} dengan ID akun Anda (lihat ARN kedua di bawah`Statement:Resource`).

------
#### [ JSON ]

****  

   ```
   {
       "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-{{123456789012}}/*"
               ]
           },
           {
               "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": "*"
           }
       ]
   }
   ```

------

1. Buat kebijakan IAM, menggunakan `policy.json` file yang baru saja Anda unduh.

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

1. Lampirkan kebijakan pada peran tersebut.

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

**Langkah 5: Buat kumpulan data dengan aksi kontainer**

1. Unduh yang berikut ini ke fie bernama `cli-input.json` dan ganti semua contoh {{`your-account-id`}} dan {{`region`}} dengan nilai yang sesuai.

   ```
   {
       "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"
                       }
                   ]
               } 
           }
       ]
   }
   ```

1. Buat kumpulan data menggunakan file yang baru saja `cli-input.json` Anda unduh dan edit.

   ```
   aws iotanalytics create-dataset —cli-input-json file://cli-input.json
   ```

**Langkah 6: Memanggil pembuatan konten dataset**

1. Jalankan perintah berikut.

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

**Langkah 7: Dapatkan konten dataset**

1. Jalankan perintah berikut.

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

1. Anda mungkin perlu menunggu beberapa menit sampai `DatasetContentState` habis`SUCCEEDED`.

**Langkah 8: Cetak output pada Oktaf**

1. Gunakan shell Octave untuk mencetak output dari wadah dengan menjalankan perintah berikut.

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