Pemberitahuan akhir dukungan: Pada 7 Oktober 2026, AWS akan menghentikan dukungan untuk. AWS IoT Greengrass Version 1 Setelah 7 Oktober 2026, Anda tidak akan lagi dapat mengakses sumber daya. AWS IoT Greengrass V1 Untuk informasi lebih lanjut, silakan kunjungi [Migrasi dari AWS IoT Greengrass Version 1](https://docs.aws.amazon.com/greengrass/v2/developerguide/migrate-from-v1.html).
Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Ekspor aliran data ke AWS Cloud (CLI)
Tutorial ini menunjukkan cara menggunakan AWS CLI untuk mengkonfigurasi dan menyebarkan AWS IoT Greengrass grup dengan manajer aliran diaktifkan. Grup ini berisi fungsi Lambda yang ditetapkan pengguna yang menulis ke pengaliran di pengelola pengaliran, yang kemudian diekspor secara otomatis ke AWS Cloud.
Pengelola pengaliran membuat penyerapan, pemrosesan, dan ekspor pengaliran data volume tinggi menjadi lebih efisien dan andal. Dalam tutorial ini, Anda membuat `TransferStream` fungsi Lambda yang mengonsumsi data IoT. Fungsi Lambda menggunakan AWS IoT Greengrass Core SDK untuk membuat aliran di stream manager dan kemudian membaca dan menulis ke sana. Pengelola pengaliran kemudian mengekspor pengaliran ke Kinesis Data Streams. Diagram berikut menunjukkan alur kerja ini.
![\[Diagram alur kerja manajemen pengaliran.\]](http://docs.aws.amazon.com/id_id/greengrass/v1/developerguide/images/stream-manager-scenario.png)
Fokus tutorial ini adalah untuk menunjukkan bagaimana fungsi Lambda yang ditentukan pengguna menggunakan `StreamManagerClient` objek di AWS IoT Greengrass Core SDK untuk berinteraksi dengan manajer aliran. Untuk mempermudah, fungsi Lambda Python yang Anda buat untuk tutorial ini menghasilkan data perangkat simulasi.
Saat Anda menggunakan AWS IoT Greengrass API, yang menyertakan perintah Greengrass di, untuk membuat grup, AWS CLI pengelola aliran dinonaktifkan secara default. Untuk mengaktifkan pengelola pengaliran di core, Anda [membuat versi definisi fungsi](#stream-manager-cli-create-function-definition) yang mencakup sistem `GGStreamManager` fungsi Lambda dan versi grup yang referensi versi definisi fungsi baru. Kemudian Anda men-deploy grup.
## Prasyarat
Untuk menyelesaikan tutorial ini, Anda membutuhkan:
+ Sebuah grup Greengrass dan core Greengrass (v1.10 atau yang lebih baru). Untuk informasi tentang cara membuat grup Greengrass dan core, lihat [Memulai dengan AWS IoT Greengrass](gg-gs.md). Tutorial Memulai juga mencakup langkah-langkah untuk menginstal perangkat lunak AWS IoT Greengrass Core.
**catatan**
Manajer aliran tidak didukung pada OpenWrt distribusi.
+ Waktu aktif Java 8 (JDK 8) dipasang pada perangkat core.
+ Untuk distribusi berbasis Debian (termasuk Raspbian) atau distribusi berbasis Ubuntu, jalankan perintah berikut:
```
sudo apt install openjdk-8-jdk
```
+ Untuk distribusi berbasis Red Hat (termasuk Amazon Linux), jalankan perintah berikut:
```
sudo yum install java-1.8.0-openjdk
```
Untuk informasi lebih lanjut, lihat [ Cara mengunduh dan menginstal paket OpenJDK prebuilt](https://openjdk.java.net/install/) dalam dokumentasi OpenJDK.
+ AWS IoT Greengrass Core SDK untuk Python v1.5.0 atau yang lebih baru. Untuk menggunakan `StreamManagerClient` dalam AWS IoT Greengrass Core SDK for Python, Anda harus:
+ Instal Python 3.7 atau yang lebih baru pada perangkat core.
+ Sertakan SDK dan dependensinya dalam paket deployment fungsi Lambda Anda. Instruksi disediakan pada tutorial ini.
**Tip**
Anda dapat menggunakan `StreamManagerClient` dengan Java atau NodeJS. Misalnya kode, lihat [AWS IoT Greengrass Core SDK for](https://github.com/aws/aws-greengrass-core-sdk-java/blob/master/samples/StreamManagerKinesis/src/main/java/com/amazonaws/greengrass/examples/StreamManagerKinesis.java) Java [AWS IoT Greengrass dan Core SDK untuk](https://github.com/aws/aws-greengrass-core-sdk-js/blob/master/greengrassExamples/StreamManagerKinesis/index.js) Node.js aktif. GitHub
+ Aliran tujuan bernama **MyKinesisStream** dibuat di Amazon Kinesis Data Streams sama dengan grup Wilayah AWS Greengrass Anda. Untuk informasi lebih lanjut, lihat [Buat aliran](https://docs.aws.amazon.com/streams/latest/dev/fundamental-stream.html#create-stream) dalam *Panduan Developer Amazon Kinesis*.
**catatan**
Dalam tutorial ini, pengelola pengaliran mengekspor data ke Kinesis Data Streams, yang mengakibatkan biaya ke Akun AWS. Untuk informasi lebih lanjut tentang harga, lihat [Harga Kinesis Data Streams](https://aws.amazon.com/kinesis/data-streams/pricing/).
Untuk menghindari timbulnya biaya, Anda dapat menjalankan tutorial ini tanpa membuat Kinesis data stream. Dalam kasus ini, Anda memeriksa catatan untuk melihat pengelola pengaliran tersebut berusaha mengekspor pengaliran ke Kinesis Data Streams.
+ Kebijakan IAM ditambahkan ke [Peran grup Greengrass](group-role.md) yang mengizinkan tindakan `kinesis:PutRecords` pada aliran data target, seperti yang ditunjukkan dalam contoh berikut:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"kinesis:PutRecords"
],
"Resource": [
"arn:aws:kinesis:us-east-1:123456789012:stream/MyKinesisStream"
]
}
]
}
```
------
+ Yang AWS CLI diinstal dan dikonfigurasi di komputer Anda. Untuk informasi lebih lanjut, lihat [ Menginstal AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) dan [Mengonfigurasi AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) di *AWS Command Line Interface Panduan Pengguna*.
Contoh perintah dalam tutorial ini ditulis untuk Linux dan sistem berbasis UNIX lainnya. Jika Anda menggunakan Windows, lihat [Menentukan nilai parameter untuk antarmuka baris AWS perintah untuk](https://docs.aws.amazon.com/cli/latest/userguide/cli-using-param.html) informasi selengkapnya tentang perbedaan sintaks.
Jika perintah berisi string JSON, tutorial memberikan contoh yang memiliki JSON pada satu baris. Pada beberapa sistem, mungkin lebih efisien untuk mengedit dan menjalankan perintah menggunakan format ini.
Tutorial berisi langkah-langkah tingkat tinggi berikut:
1. [Buat paket deployment fungsi Lambda](#stream-manager-cli-create-deployment-package)
1. [Buat fungsi Lambda](#stream-manager-cli-create-function)
1. [Buat definisi fungsi dan versi](#stream-manager-cli-create-function-definition)
1. [Buat definisi pencatat dan versi](#stream-manager-cli-create-logger-definition)
1. [Dapatkan ARN versi definisi core Anda](#stream-manager-cli-get-core-definition-version-arn)
1. [Buat versi grup](#stream-manager-cli-create-group-version)
1. [Buat deployment](#stream-manager-cli-create-deployment)
1. [Uji aplikasi](#stream-manager-cli-test-application)
Tutorial harus memakan waktu sekitar 30 menit untuk menyelesaikannya.
## Langkah 1: Buat paket deployment fungsi Lambda
Dalam langkah ini, Anda membuat paket deployment fungsi Lambda yang berisi kode fungsi Python dan dependensi. Anda mengunggah paket ini nanti saat Anda membuat fungsi Lambda di. AWS Lambda Fungsi Lambda menggunakan AWS IoT Greengrass Core SDK untuk membuat dan berinteraksi dengan aliran lokal.
**catatan**
Fungsi Lambda yang ditetapkan pengguna milik Anda harus menggunakan [AWS IoT Greengrass Core SDK](lambda-functions.md#lambda-sdks-core) untuk berinteraksi dengan pengelola pengaliran. Untuk informasi lebih lanjut tentang persyaratan untuk Greengrass pengelola pengaliran, lihat [Persyaratan pengelola pengaliran Greengrass](stream-manager.md#stream-manager-requirements).
1. Unduh [AWS IoT Greengrass Core SDK for Python](lambda-functions.md#lambda-sdks-core) v1.5.0 atau yang lebih baru.
1. Unzip paket unduhan untuk mendapatkan SDK. SDK adalah folder `greengrasssdk` ini.
1. Instal paket dependensi untuk menyertakan dengan SDK dalam paket deployment fungsi Lambda Anda.
1. Arahkan ke direktori SDK yang berisi file `requirements.txt` ini. File ini berisi daftar dependensi.
1. Instal dependensi SDK. Sebagai contoh, jalankan perintah `pip` berikut untuk menginstalnya di direktori saat ini:
```
pip install --target . -r requirements.txt
```
1. Simpan fungsi kode Python berikut dalam sebuah file lokal bernama `transfer_stream.py`.
**Tip**
Misalnya kode yang menggunakan Java dan NodeJS, lihat AWS IoT Greengrass Core SDK [for [AWS IoT Greengrass Java dan](https://github.com/aws/aws-greengrass-core-sdk-js/blob/master/greengrassExamples/StreamManagerKinesis/index.js) Core SDK for Node.js on](https://github.com/aws/aws-greengrass-core-sdk-java/blob/master/samples/StreamManagerKinesis/src/main/java/com/amazonaws/greengrass/examples/StreamManagerKinesis.java). GitHub
```
import asyncio
import logging
import random
import time
from greengrasssdk.stream_manager import (
ExportDefinition,
KinesisConfig,
MessageStreamDefinition,
ReadMessagesOptions,
ResourceNotFoundException,
StrategyOnFull,
StreamManagerClient,
)
# This example creates a local stream named "SomeStream".
# It starts writing data into that stream and then stream manager automatically exports
# the data to a customer-created Kinesis data stream named "MyKinesisStream".
# This example runs forever until the program is stopped.
# The size of the local stream on disk will not exceed the default (which is 256 MB).
# Any data appended after the stream reaches the size limit continues to be appended, and
# stream manager deletes the oldest data until the total stream size is back under 256 MB.
# The Kinesis data stream in the cloud has no such bound, so all the data from this script is
# uploaded to Kinesis and you will be charged for that usage.
def main(logger):
try:
stream_name = "SomeStream"
kinesis_stream_name = "MyKinesisStream"
# Create a client for the StreamManager
client = StreamManagerClient()
# Try deleting the stream (if it exists) so that we have a fresh start
try:
client.delete_message_stream(stream_name=stream_name)
except ResourceNotFoundException:
pass
exports = ExportDefinition(
kinesis=[KinesisConfig(identifier="KinesisExport" + stream_name, kinesis_stream_name=kinesis_stream_name)]
)
client.create_message_stream(
MessageStreamDefinition(
name=stream_name, strategy_on_full=StrategyOnFull.OverwriteOldestData, export_definition=exports
)
)
# Append two messages and print their sequence numbers
logger.info(
"Successfully appended message to stream with sequence number %d",
client.append_message(stream_name, "ABCDEFGHIJKLMNO".encode("utf-8")),
)
logger.info(
"Successfully appended message to stream with sequence number %d",
client.append_message(stream_name, "PQRSTUVWXYZ".encode("utf-8")),
)
# Try reading the two messages we just appended and print them out
logger.info(
"Successfully read 2 messages: %s",
client.read_messages(stream_name, ReadMessagesOptions(min_message_count=2, read_timeout_millis=1000)),
)
logger.info("Now going to start writing random integers between 0 and 1000 to the stream")
# Now start putting in random data between 0 and 1000 to emulate device sensor input
while True:
logger.debug("Appending new random integer to stream")
client.append_message(stream_name, random.randint(0, 1000).to_bytes(length=4, signed=True, byteorder="big"))
time.sleep(1)
except asyncio.TimeoutError:
logger.exception("Timed out while executing")
except Exception:
logger.exception("Exception while running")
def function_handler(event, context):
return
logging.basicConfig(level=logging.INFO)
# Start up this sample code
main(logger=logging.getLogger())
```
1. Zip item berikut ke dalam file bernama `transfer_stream_python.zip`. Ini adalah paket deployment fungsi Lambda Anda.
+ **transfer\$1stream.py**. Logika aplikasi.
+ **greengrasssdk**. Diperlukan perpustakaan untuk fungsi Python Greengrass Lambda yang menerbitkan pesan MQTT.
[Operasi manajer aliran](work-with-streams.md) tersedia dalam versi 1.5.0 atau yang lebih baru dari AWS IoT Greengrass Core SDK untuk Python.
+ Dependensi yang Anda instal untuk AWS IoT Greengrass Core SDK untuk Python (misalnya, direktori). `cbor2`
Ketika Anda membuat file `zip` ini, termasuk hanya item ini, bukan folder yang berisi.
## Langkah 2: Buat fungsi Lambda
1. Buat IAM role sehingga Anda dapat lulus di dalam peran ARN ketika Anda membuat fungsi.
------
#### [ JSON Expanded ]
```
aws iam create-role --role-name Lambda_empty --assume-role-policy '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}'
```
------
#### [ JSON Single-line ]
```
aws iam create-role --role-name Lambda_empty --assume-role-policy '{"Version": "2012-10-17", "Statement": [{"Effect": "Allow", "Principal": {"Service": "lambda.amazonaws.com"},"Action": "sts:AssumeRole"}]}'
```
------
**catatan**
AWS IoT Greengrass tidak menggunakan peran ini karena izin untuk fungsi Lambda Greengrass Anda ditentukan dalam peran grup Greengrass. Untuk tutorial ini, Anda membuat peran kosong.
1. Salin `Arn` dari output.
1. Gunakan AWS Lambda API untuk membuat `TransferStream` fungsi. Perintah berikut mengasumsikan bahwa file zip dalam direktori saat ini.
+ Ganti *role-arn* dengan `Arn` yang Anda salin.
```
aws lambda create-function \
--function-name TransferStream \
--zip-file fileb://transfer_stream_python.zip \
--role role-arn \
--handler transfer_stream.function_handler \
--runtime python3.7
```
1. Mempublikasikan versi fungsi.
```
aws lambda publish-version --function-name TransferStream --description 'First version'
```
1. Buat alias untuk versi yang dipublikasikan.
Grup Greengrass dapat mereferensi fungsi Lambda dengan alias (direkomendasikan) atau dengan versi. Menggunakan alias membuatnya lebih mudah untuk mengelola pembaruan kode karena Anda tidak perlu mengubah tabel langganan atau definisi grup ketika kode fungsi diperbarui. Sebaliknya, Anda hanya mengarahkan alias ke versi fungsi baru.
```
aws lambda create-alias --function-name TransferStream --name GG_TransferStream --function-version 1
```
**catatan**
AWS IoT Greengrass **tidak mendukung alias Lambda untuk versi \$1LATEST.**
1. Salin `AliasArn` dari output. Anda menggunakan nilai ini ketika Anda mengkonfigurasi fungsi untuk AWS IoT Greengrass.
Sekarang Anda siap untuk mengkonfigurasi fungsi untuk AWS IoT Greengrass.
## Langkah 3: Buat definisi fungsi dan versi
Langkah ini menciptakan versi definisi fungsi yang mereferensi fungsi Lambda `GGStreamManager` sistem dan fungsi Lambda `TransferStream` yang ditetapkan pengguna Anda. Untuk mengaktifkan pengelola aliran saat Anda menggunakan AWS IoT Greengrass API, versi definisi fungsi Anda harus menyertakan `GGStreamManager` fungsi tersebut.
1. Buat definisi fungsi dengan versi awal yang berisi sistem dan fungsi Lambda yang ditetapkan pengguna.
Versi definisi berikut mengizinkan pengelola pengaliran dengan default [pengaturan parameter](configure-stream-manager.md). Untuk mengonfigurasi pengaturan kustom, Anda harus menentukan variabel lingkungan untuk parameter pengelola pengaliran yang sesuai. Sebagai contoh, lihat[Untuk mengaktifkan, menonaktifkan, atau mengonfigurasi pengelola pengaliran (CLI)](configure-stream-manager.md#enable-stream-manager-cli). AWS IoT Greengrass menggunakan pengaturan default untuk parameter yang dihilangkan. `MemorySize`Setidaknya harus`128000`. `Pinned`harus diatur ke`true`.
**catatan**
Fungsi Lambda yang *berumur panjang* (atau *disematkan*) dimulai secara otomatis setelah AWS IoT Greengrass dimulai dan terus berjalan di wadahnya sendiri. Hal ini berbeda dengan fungsi Lambda *sesuai permintaan* ini, yang dimulai ketika diaktifkan dan berhenti ketika tidak ada tugas yang tersisa untuk dijalankan. Untuk informasi selengkapnya, lihat [Konfigurasi siklus hidup untuk fungsi Greengrass Lambda](lambda-functions.md#lambda-lifecycle).
+ Ganti *arbitrary-function-id* dengan nama untuk fungsi tersebut, seperti**stream-manager**.
+ Ganti *alias-arn* dengan `AliasArn` yang Anda salin saat Anda membuat alias untuk fungsi Lambda`TransferStream`.
------
#### [ JSON expanded ]
```
aws greengrass create-function-definition --name MyGreengrassFunctions --initial-version '{
"Functions": [
{
"Id": "arbitrary-function-id",
"FunctionArn": "arn:aws:lambda:::function:GGStreamManager:1",
"FunctionConfiguration": {
"MemorySize": 128000,
"Pinned": true,
"Timeout": 3
}
},
{
"Id": "TransferStreamFunction",
"FunctionArn": "alias-arn",
"FunctionConfiguration": {
"Executable": "transfer_stream.function_handler",
"MemorySize": 16000,
"Pinned": true,
"Timeout": 5
}
}
]
}'
```
------
#### [ JSON single ]
```
aws greengrass create-function-definition \
--name MyGreengrassFunctions \
--initial-version '{"Functions": [{"Id": "arbitrary-function-id","FunctionArn": "arn:aws:lambda:::function:GGStreamManager:1", "FunctionConfiguration": {"Environment": {"Variables":{"STREAM_MANAGER_STORE_ROOT_DIR": "/data","STREAM_MANAGER_SERVER_PORT": "1234","STREAM_MANAGER_EXPORTER_MAX_BANDWIDTH": "20000"}},"MemorySize": 128000,"Pinned": true,"Timeout": 3}},{"Id": "TransferStreamFunction", "FunctionArn": "alias-arn", "FunctionConfiguration": {"Executable": "transfer_stream.function_handler", "MemorySize": 16000,"Pinned": true,"Timeout": 5}}]}'
```
------
**catatan**
`Timeout` diperlukan oleh versi definisi fungsi, tetapi `GGStreamManager` tidak menggunakannya. Untuk informasi lebih lanjut tentang `Timeout` dan pengaturan tingkat grup lainnya, lihat [Mengontrol eksekusi fungsi Greengrass Lambda dengan menggunakan konfigurasi grup khusus](lambda-group-config.md).
1. Salin `LatestVersionArn` dari output. Anda menggunakan nilai ini untuk menambahkan versi definisi fungsi untuk versi grup yang Anda men-deploy ke core.
## Langkah 4: Buat definisi pencatat dan versi
Konfigurasi pengaturan pencatatan grup. Untuk tutorial ini, Anda mengkonfigurasi komponen AWS IoT Greengrass sistem, fungsi Lambda yang ditentukan pengguna, dan konektor untuk menulis log ke sistem file perangkat inti. Anda dapat menggunakan catatan untuk memecahkan masalah yang mungkin Anda alami. Untuk informasi selengkapnya, lihat [Pemantauan dengan AWS IoT Greengrass log](greengrass-logs-overview.md).
1. Membuat definisi pencatat yang mencakup versi awal.
------
#### [ JSON Expanded ]
```
aws greengrass create-logger-definition --name "LoggingConfigs" --initial-version '{
"Loggers": [
{
"Id": "1",
"Component": "GreengrassSystem",
"Level": "INFO",
"Space": 10240,
"Type": "FileSystem"
},
{
"Id": "2",
"Component": "Lambda",
"Level": "INFO",
"Space": 10240,
"Type": "FileSystem"
}
]
}'
```
------
#### [ JSON Single-line ]
```
aws greengrass create-logger-definition \
--name "LoggingConfigs" \
--initial-version '{"Loggers":[{"Id":"1","Component":"GreengrassSystem","Level":"INFO","Space":10240,"Type":"FileSystem"},{"Id":"2","Component":"Lambda","Level":"INFO","Space":10240,"Type":"FileSystem"}]}'
```
------
1. Salin `LatestVersionArn` dari definisi pencatat dari output. Anda menggunakan nilai ini untuk menambahkan versi definisi pencatat ke versi grup yang Anda men-deploy ke core.
## Langkah 5: Dapatkan ARN versi definisi core Anda
Dapatkan ARN versi definisi core untuk ditambahkan ke versi grup baru Anda. Untuk men-deploy versi grup, hal itu harus mereferensi versi definisi core yang berisi tepat satu core.
1. Dapatkan IDs versi grup dan grup Greengrass target. Prosedur ini mengasumsikan bahwa ini adalah versi grup dan grup terbaru. Query berikut mengembalikan grup yang paling baru dibuat.
```
aws greengrass list-groups --query "reverse(sort_by(Groups, &CreationTimestamp))[0]"
```
Atau, Anda dapat melakukan query berdasarkan nama. Nama grup tidak perlu unik, sehingga beberapa grup mungkin ditampilkan.
```
aws greengrass list-groups --query "Groups[?Name=='MyGroup']"
```
**catatan**
Anda juga dapat menemukan nilai-nilai ini di AWS IoT konsol. ID grup ditampilkan pada halaman **Pengaturan** grup. Versi grup IDs ditampilkan di tab **Deployment** grup.
1. Salin `Id` dari grup target dari output. Anda menggunakan ini untuk mendapatkan versi definisi core dan ketika Anda men-deploy grup.
1. Salin `LatestVersion` dari output, yang merupakan ID dari versi terakhir ditambahkan ke grup. Anda menggunakan ini untuk mendapatkan versi definisi core.
1. Dapatkan ARN dari versi definisi core:
1. Dapatkan versi grup.
+ Ganti *group-id* dengan `Id` yang Anda salin untuk grup.
+ Ganti *group-version-id* dengan `LatestVersion` yang Anda salin untuk grup.
```
aws greengrass get-group-version \
--group-id group-id \
--group-version-id group-version-id
```
1. Salin `CoreDefinitionVersionArn` dari output. Anda menggunakan nilai ini untuk menambahkan versi definisi core untuk versi grup yang Anda men-deploy ke core.
## Langkah 6: Buat versi grup
Sekarang, Anda siap untuk membuat versi grup yang berisi entitas yang ingin Anda gunakan. Anda melakukannya dengan membuat versi grup yang mereferensi versi target dari setiap tipe komponen. Untuk tutorial ini, Anda menyertakan versi definisi core, versi definisi fungsi, dan versi definisi logger.
1. Buat versi grup.
+ Ganti *group-id* dengan `Id` yang Anda salin untuk grup.
+ Ganti *core-definition-version-arn* dengan `CoreDefinitionVersionArn` yang Anda salin untuk versi definisi inti.
+ Ganti *function-definition-version-arn* dengan `LatestVersionArn` yang Anda salin untuk versi definisi fungsi baru Anda.
+ Ganti *logger-definition-version-arn* dengan `LatestVersionArn` yang Anda salin untuk versi definisi logger baru Anda.
```
aws greengrass create-group-version \
--group-id group-id \
--core-definition-version-arn core-definition-version-arn \
--function-definition-version-arn function-definition-version-arn \
--logger-definition-version-arn logger-definition-version-arn
```
1. Salin `Version` dari output. Ini adalah ID dari versi grup baru.
## Langkah 7: Buat deployment
Terapkan grup ke perangkat core.
1. Pastikan AWS IoT Greengrass inti sedang berjalan. Jalankan perintah berikut di terminal Raspberry Pi Anda, sesuai kebutuhan.
1. Untuk memeriksa apakah daemon sedang berjalan:
```
ps aux | grep -E 'greengrass.*daemon'
```
Jika outputnya berisi entri `root` untuk `/greengrass/ggc/packages/ggc-version/bin/daemon`, maka daemon sedang berjalan.
**catatan**
Versi di jalur tergantung pada versi perangkat lunak AWS IoT Greengrass Core yang diinstal pada perangkat inti Anda.
1. Mulai daemon:
```
cd /greengrass/ggc/core/
sudo ./greengrassd start
```
1. Buat deployment.
+ Ganti *group-id* dengan `Id` yang Anda salin untuk grup.
+ Ganti *group-version-id* dengan `Version` yang Anda salin untuk versi grup baru.
```
aws greengrass create-deployment \
--deployment-type NewDeployment \
--group-id group-id \
--group-version-id group-version-id
```
1. Salin `DeploymentId` dari output.
1. Dapatkan status deployment.
+ Ganti *group-id* dengan `Id` yang Anda salin untuk grup.
+ Ganti *deployment-id* dengan `DeploymentId` yang Anda salin untuk penerapan.
```
aws greengrass get-deployment-status \
--group-id group-id \
--deployment-id deployment-id
```
Jika statusnya `Success`, deployment berhasil. Untuk bantuan pemecahan masalah, lihat [Pemecahan masalah AWS IoT Greengrass](gg-troubleshooting.md).
## Langkah 8: Uji aplikasi
Fungsi Lambda `TransferStream` menghasilkan data perangkat yang disimulasikan. Ini menulis data ke pengaliran yang diekspor oleh pengelola pengaliran ke Kinesis data stream target.
1. Di konsol Amazon Kinesis, di bawah aliran **data Kinesis**, pilih. **MyKinesisStream**
**catatan**
Jika Anda menjalankan tutorial tanpa Kinesis data streams target, [periksa berkas log](#stream-manager-cli-logs) untuk pengelola pengaliran (`GGStreamManager`). Jika itu berisi `export stream MyKinesisStream doesn't exist` dalam pesan kesalahan, maka uji ini berhasil. Kesalahan ini berarti bahwa layanan mencoba untuk mengekspor ke pengaliran tetapi pengaliran tidak ada.
1. Pada **MyKinesisStream**halaman, pilih **Monitoring**. Jika uji berhasil, Anda akan melihat data di bagan **Pasang Catatan** ini. Tergantung pada koneksi Anda, mungkin diperlukan waktu satu menit sebelum data ditampilkan.
**penting**
Setelah selesai melakukan pengujian, hapus Kinesis data stream agar tidak menimbulkan biaya tambahan.
Atau, jalankan perintah berikut untuk menghentikan daemon Greengrass. Hal ini mencegah core mengirim pesan hingga Anda siap untuk melanjutkan pengujian.
```
cd /greengrass/ggc/core/
sudo ./greengrassd stop
```
1. Hapus fungsi **TransferStream**Lambda dari inti.
1. Ikuti [Langkah 6: Buat versi grup](#stream-manager-cli-create-group-version) untuk membuat versi grup baru. tetapi menghapus `--function-definition-version-arn` di dalam opsi perintah `create-group-version` ini. Atau, buat versi definisi fungsi yang tidak menyertakan fungsi **TransferStream**Lambda.
**catatan**
Dengan menghilangkan fungsi Lambda `GGStreamManager` sistem dari versi grup yang di-deploy, Anda menonaktifkan pengelolaan pengaliran pada core.
1. Ikuti [Langkah 7: Buat deployment](#stream-manager-cli-create-deployment) untuk men-deploy versi grup baru.
Untuk melihat pencatatan informasi atau pemecahan masalah dengan aliran, periksa log untuk fungsi `TransferStream` dan `GGStreamManager` tersebut. Anda harus memiliki `root` izin untuk membaca AWS IoT Greengrass log pada sistem file.
+ `TransferStream` menulis entri log ke `greengrass-root/ggc/var/log/user/region/account-id/TransferStream.log`.
+ `GGStreamManager` menulis entri log ke `greengrass-root/ggc/var/log/system/GGStreamManager.log`.
Jika Anda memerlukan informasi pemecahan masalah lainnya, Anda dapat mengatur tingkat pencatatan `Lambda` ke `DEBUG` lalu membuat dan men-deploy versi grup baru.
## Lihat juga
+ [Mengelola aliran data pada inti AWS IoT Greengrass](stream-manager.md)
+ [Gunakan StreamManagerClient untuk bekerja dengan aliran](work-with-streams.md)
+ [Ekspor konfigurasi untuk tujuan yang didukung AWS Cloud](stream-export-configurations.md)
+ [Konfigurasikan pengelola AWS IoT Greengrass aliran](configure-stream-manager.md)
+ [Ekspor aliran data ke AWS Cloud (konsol)](stream-manager-console.md)
+ [AWS Identity and Access Management (IAM) perintah di *AWS CLI Command*](https://docs.aws.amazon.com/cli/latest/reference/iam) Reference
+ [AWS Lambda perintah](https://docs.aws.amazon.com/cli/latest/reference/lambda) dalam *Referensi AWS CLI Perintah*
+ [AWS IoT Greengrass perintah](https://docs.aws.amazon.com/cli/latest/reference/greengrass/index.html) dalam *Referensi AWS CLI Perintah*