Pemberitahuan akhir dukungan: Pada 31 Mei 2026, AWS akan mengakhiri dukungan untuk AWS Panorama. Setelah 31 Mei 2026, Anda tidak akan lagi dapat mengakses AWS Panorama konsol atau AWS Panorama sumber daya. Untuk informasi lebih lanjut, lihat [AWS Panorama akhir dukungan](https://docs.aws.amazon.com/panorama/latest/dev/panorama-end-of-support.html).
Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Membangun AWS Panorama aplikasi
Aplikasi berjalan di AWS Panorama Appliance untuk melakukan tugas visi komputer pada aliran video. Anda dapat membangun aplikasi visi komputer dengan menggabungkan kode Python dan model pembelajaran mesin, dan menerapkannya ke AWS Panorama Appliance melalui internet. Aplikasi dapat mengirim video ke layar, atau menggunakan AWS SDK untuk mengirim hasil ke layanan AWS.
Sebuah [model](applications-models.md) menganalisis gambar untuk mendeteksi orang, kendaraan, dan objek lainnya. Berdasarkan gambar yang telah dilihatnya selama pelatihan, model memberi tahu Anda apa yang dipikirkannya, dan seberapa yakin itu dalam tebakannya. Anda dapat melatih model dengan data gambar Anda sendiri atau memulai dengan sampel.
Proses [kode](gettingstarted-sample.md) aplikasi masih gambar dari aliran kamera, mengirimkannya ke model, dan memproses hasilnya. Sebuah model dapat mendeteksi beberapa objek dan mengembalikan bentuk dan lokasinya. Kode dapat menggunakan informasi ini untuk menambahkan teks atau grafik ke video, atau untuk mengirim hasil ke AWS layanan untuk penyimpanan atau pemrosesan lebih lanjut.
Untuk mendapatkan gambar dari aliran, berinteraksi dengan model, dan video keluaran, kode aplikasi menggunakan [SDK AWS Panorama Aplikasi](applications-panoramasdk.md). Aplikasi SDK adalah pustaka Python yang mendukung model yang dihasilkan PyTorch dengan, MXNet Apache, dan. TensorFlow
**Topics**
+ [Model visi komputer](applications-models.md)
+ [Membangun gambar aplikasi](applications-image.md)
+ [Memanggil layanan AWS dari kode aplikasi Anda](applications-awssdk.md)
+ [SDK Aplikasi AWS Panorama](applications-panoramasdk.md)
+ [Menjalankan beberapa utas](applications-threading.md)
+ [Melayani lalu lintas masuk](applications-ports.md)
+ [Menggunakan GPU](applications-gpuaccess.md)
+ [Menyiapkan lingkungan pengembangan di Windows](applications-devenvwindows.md)
# Model visi komputer
*Model visi komputer* adalah program perangkat lunak yang dilatih untuk mendeteksi objek dalam gambar. Sebuah model belajar mengenali satu set objek dengan terlebih dahulu menganalisis gambar objek tersebut melalui pelatihan. Model visi komputer mengambil gambar sebagai input dan output informasi tentang objek yang dideteksi, seperti jenis objek dan lokasinya. AWS Panorama mendukung model visi komputer yang dibangun dengan PyTorch, Apache MXNet, dan. TensorFlow
**catatan**
Untuk daftar model pra-bangun yang telah diuji dengan AWS Panorama, [lihat](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/resources/model-compatibility.md) Kompatibilitas model.
**Topics**
+ [Menggunakan model dalam kode](#applications-models-using)
+ [Membangun model khusus](#applications-models-custom)
+ [Mengemas model](#applications-models-package)
+ [Model pelatihan](#applications-models-training)
## Menggunakan model dalam kode
Sebuah model mengembalikan satu atau lebih hasil, yang dapat mencakup probabilitas untuk kelas terdeteksi, informasi lokasi, dan data lainnya.Contoh berikut menunjukkan bagaimana menjalankan inferensi pada gambar dari aliran video dan mengirim output model ke fungsi pemrosesan.
**Example [application.py](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/packages/123456789012-SAMPLE_CODE-1.0/application.py) - Inferensi**
```
def process_media(self, stream):
"""Runs inference on a frame of video."""
image_data = preprocess(stream.image,self.MODEL_DIM)
logger.debug('Image data: {}'.format(image_data))
# Run inference
inference_start = time.time()
inference_results = self.call({"data":image_data}, self.MODEL_NODE)
# Log metrics
inference_time = (time.time() - inference_start) * 1000
if inference_time > self.inference_time_max:
self.inference_time_max = inference_time
self.inference_time_ms += inference_time
# Process results (classification)
self.process_results(inference_results, stream)
```
Contoh berikut menunjukkan fungsi yang memproses hasil dari model klasifikasi dasar. Model sampel mengembalikan array probabilitas, yang merupakan nilai pertama dan satu-satunya dalam array hasil.
**Example [application.py](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/packages/123456789012-SAMPLE_CODE-1.0/application.py) - Hasil pengolahan**
```
def process_results(self, inference_results, stream):
"""Processes output tensors from a computer vision model and annotates a video frame."""
if inference_results is None:
logger.warning("Inference results are None.")
return
max_results = 5
logger.debug('Inference results: {}'.format(inference_results))
class_tuple = inference_results[0]
enum_vals = [(i, val) for i, val in enumerate(class_tuple[0])]
sorted_vals = sorted(enum_vals, key=lambda tup: tup[1])
top_k = sorted_vals[::-1][:max_results]
indexes = [tup[0] for tup in top_k]
for j in range(max_results):
label = 'Class [%s], with probability %.3f.'% (self.classes[indexes[j]], class_tuple[0][indexes[j]])
stream.add_label(label, 0.1, 0.1 + 0.1*j)
```
Kode aplikasi menemukan nilai dengan probabilitas tertinggi dan memetakannya ke label dalam file sumber daya yang dimuat selama inisialisasi.
## Membangun model khusus
Anda dapat menggunakan model yang Anda buat PyTorch, Apache MXNet, dan TensorFlow dalam aplikasi AWS Panorama. Sebagai alternatif untuk membangun dan melatih model dalam SageMaker AI, Anda dapat menggunakan model terlatih atau membangun dan melatih model Anda sendiri dengan kerangka kerja yang didukung dan mengekspornya di lingkungan lokal atau di Amazon EC2.
**catatan**
Untuk detail tentang versi framework dan format file yang didukung oleh SageMaker AI Neo, lihat [Kerangka Kerja yang Didukung](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-supported-devices-edge-frameworks.html) di Panduan Pengembang Amazon SageMaker AI.
Repositori untuk panduan ini menyediakan contoh aplikasi yang menunjukkan alur kerja ini untuk model Keras dalam format. TensorFlow `SavedModel` Ini menggunakan TensorFlow 2 dan dapat berjalan secara lokal di lingkungan virtual atau dalam wadah Docker. Aplikasi sampel juga menyertakan templat dan skrip untuk membuat model pada EC2 instance Amazon.
****
+ [Aplikasi sampel model kustom](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/custom-model)
![\[\]](http://docs.aws.amazon.com/id_id/panorama/latest/dev/images/sample-custom-model.png)
AWS Panorama menggunakan SageMaker AI Neo untuk mengkompilasi model untuk digunakan pada AWS Panorama Appliance. Untuk setiap kerangka kerja, gunakan [format yang didukung oleh SageMaker AI Neo](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-compilation-preparing-model.html), dan paket model dalam `.tar.gz` arsip.
Untuk informasi selengkapnya, lihat [Mengompilasi dan menerapkan model dengan Neo](https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html) di Panduan Pengembang Amazon SageMaker AI.
## Mengemas model
Paket model terdiri dari deskriptor, konfigurasi paket, dan arsip model. Seperti dalam [paket gambar aplikasi, konfigurasi paket](applications-image.md) memberi tahu layanan AWS Panorama tempat model dan deskriptor disimpan di Amazon S3.
**Example [Paket/123456789012-Squeezenet\$1Pytorch-1.0/Descriptor.json](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/packages/123456789012-SQUEEZENET_PYTORCH-1.0/descriptor.json)**
```
{
"mlModelDescriptor": {
"envelopeVersion": "2021-01-01",
"framework": "PYTORCH",
"frameworkVersion": "1.8",
"precisionMode": "FP16",
"inputs": [
{
"name": "data",
"shape": [
1,
3,
224,
224
]
}
]
}
}
```
**catatan**
Tentukan versi mayor dan minor versi kerangka kerja saja. Untuk daftar versi yang didukung PyTorch, Apache MXNet, dan TensorFlow versi, lihat [Kerangka kerja yang didukung](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-supported-devices-edge-frameworks.html).
Untuk mengimpor model, gunakan perintah AWS Panorama Application CLI. `import-raw-model` Jika Anda membuat perubahan pada model atau deskriptornya, Anda harus menjalankan kembali perintah ini untuk memperbarui aset aplikasi. Untuk informasi selengkapnya, lihat [Mengubah model visi komputer](gettingstarted-sample.md#gettingstarted-sample-model).
[Untuk skema JSON file deskriptor, lihat AssetDescriptor.schema.json.](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/resources/manifest-schema/ver_2021-01-01/assetDescriptor.schema.json)
## Model pelatihan
Saat Anda melatih model, gunakan gambar dari lingkungan target, atau dari lingkungan pengujian yang sangat mirip dengan lingkungan target. Pertimbangkan faktor-faktor berikut yang dapat mempengaruhi kinerja model:
****
+ **Pencahayaan** — Jumlah cahaya yang dipantulkan oleh subjek menentukan seberapa banyak detail yang harus dianalisis model. Model yang dilatih dengan gambar subjek yang cukup terang mungkin tidak berfungsi dengan baik di lingkungan dengan cahaya rendah atau cahaya latar.
+ **Resolusi** — Ukuran input model biasanya ditetapkan pada resolusi antara 224 dan 512 piksel lebar dalam rasio aspek persegi. Sebelum Anda meneruskan bingkai video ke model, Anda dapat menurunkan atau memotongnya agar sesuai dengan ukuran yang diperlukan.
+ **Distorsi gambar** — Panjang fokus kamera dan bentuk lensa dapat menyebabkan gambar menunjukkan distorsi jauh dari pusat bingkai. Posisi kamera juga menentukan fitur subjek mana yang terlihat. Misalnya, kamera overhead dengan lensa sudut lebar akan menunjukkan bagian atas subjek saat berada di tengah bingkai, dan tampilan miring dari sisi subjek saat bergerak lebih jauh dari tengah.
Untuk mengatasi masalah ini, Anda dapat memproses gambar sebelum mengirimnya ke model, dan melatih model pada variasi gambar yang lebih luas yang mencerminkan varians di lingkungan dunia nyata. Jika model perlu beroperasi dalam situasi pencahayaan dan dengan berbagai kamera, Anda memerlukan lebih banyak data untuk pelatihan. Selain mengumpulkan lebih banyak gambar, Anda bisa mendapatkan lebih banyak data pelatihan dengan membuat variasi gambar yang ada yang miring atau memiliki pencahayaan berbeda.
# Membangun gambar aplikasi
AWS Panorama Appliance menjalankan aplikasi sebagai sistem file kontainer yang diekspor dari gambar yang Anda buat. Anda menentukan dependensi dan resource aplikasi Anda di Dockerfile yang menggunakan image dasar aplikasi AWS Panorama sebagai titik awal.
Untuk membuat image aplikasi, Anda menggunakan Docker dan AWS Panorama Application CLI. Contoh berikut dari contoh aplikasi panduan ini menunjukkan kasus penggunaan ini.
**Example [Paket/123456789012-sample\$1code-1.0/dockerfile](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/packages/123456789012-SAMPLE_CODE-1.0/Dockerfile)**
```
FROM public.ecr.aws/panorama/panorama-application
WORKDIR /panorama
COPY . .
RUN pip install --no-cache-dir --upgrade pip && \
pip install --no-cache-dir -r requirements.txt
```
Instruksi Dockerfile berikut digunakan.
****
+ `FROM`— Memuat gambar dasar aplikasi (`public.ecr.aws/panorama/panorama-application`).
+ `WORKDIR`— Atur direktori kerja pada gambar. `/panorama`digunakan untuk kode aplikasi dan file terkait. Pengaturan ini hanya bertahan selama pembuatan dan tidak memengaruhi direktori kerja untuk aplikasi Anda saat runtime ()`/`.
+ `COPY`— Menyalin file dari jalur lokal ke jalur pada gambar. `COPY . .`menyalin file di direktori saat ini (direktori paket) ke direktori kerja pada gambar. Misalnya, kode aplikasi disalin dari `packages/123456789012-SAMPLE_CODE-1.0/application.py` ke`/panorama/application.py`.
+ `RUN`— Menjalankan perintah shell pada gambar selama pembuatan. Sebuah `RUN` operasi tunggal dapat menjalankan beberapa perintah secara berurutan dengan menggunakan `&&` antara perintah. Contoh ini memperbarui manajer `pip` paket dan kemudian menginstal pustaka yang tercantum di dalamnya. `requirements.txt`
Anda dapat menggunakan instruksi lain, seperti `ADD` dan`ARG`, yang berguna pada waktu pembuatan. Petunjuk yang menambahkan informasi runtime ke container, seperti`ENV`, tidak berfungsi dengan AWS Panorama. AWS Panorama tidak menjalankan wadah dari gambar. Ini hanya menggunakan gambar untuk mengekspor sistem file, yang ditransfer ke alat.
## Menentukan dependensi
`requirements.txt`adalah file persyaratan Python yang menentukan pustaka yang digunakan oleh aplikasi. Contoh aplikasi menggunakan Open CV dan AWS SDK untuk Python (Boto3).
**Example [Paket/123456789012-sample\$1code-1.0/requirements.txt](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/packages/123456789012-SAMPLE_CODE-1.0/requirements.txt)**
```
boto3==1.24.*
opencv-python==4.6.*
```
`pip install`Perintah di Dockerfile menginstal pustaka ini ke `dist-packages` direktori Python di bawah`/usr/local/lib`, sehingga mereka dapat diimpor oleh kode aplikasi Anda.
## Penyimpanan lokal
AWS Panorama menyimpan `/opt/aws/panorama/storage` direktori untuk penyimpanan aplikasi. Aplikasi Anda dapat membuat dan memodifikasi file di jalur ini. File yang dibuat di direktori penyimpanan tetap ada di reboot. Lokasi file sementara lainnya dihapus saat boot.
## Membangun aset citra
Saat Anda membuat gambar untuk paket aplikasi Anda dengan AWS Panorama Application CLI, CLI berjalan di direktori paket. `docker build` Ini membangun gambar aplikasi yang berisi kode aplikasi Anda. CLI kemudian membuat wadah, mengekspor sistem file-nya, mengompresnya, dan menyimpannya di folder. `assets`
```
$ panorama-cli build-container --container-asset-name code_asset --package-path packages/123456789012-SAMPLE_CODE-1.0
docker build -t code_asset packages/123456789012-SAMPLE_CODE-1.0 --pull
docker export --output=code_asset.tar $(docker create code_asset:latest)
gzip -1 code_asset.tar
{
"name": "code_asset",
"implementations": [
{
"type": "container",
"assetUri": "6f67xmpl32743ed0e60c151a02f2f0da1bf70a4ab9d83fe236fa32a6f9b9f808.tar.gz",
"descriptorUri": "1872xmpl129481ed053c52e66d6af8b030f9eb69b1168a29012f01c7034d7a8f.json"
}
]
}
Container asset for the package has been succesfully built at /home/user/aws-panorama-developer-guide/sample-apps/aws-panorama-sample/assets/6f67xmpl32743ed0e60c151a02f2f0da1bf70a4ab9d83fe236fa32a6f9b9f808.tar.gz
```
Blok JSON dalam output adalah definisi aset yang ditambahkan CLI ke konfigurasi paket `package.json` () dan mendaftar dengan layanan AWS Panorama. CLI juga menyalin file deskriptor, yang menentukan jalur ke skrip aplikasi (titik masuk aplikasi).
**Example [Paket/123456789012-sample\$1code-1.0/descriptor.json](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/packages/123456789012-SAMPLE_CODE-1.0/descriptor.json)**
```
{
"runtimeDescriptor":
{
"envelopeVersion": "2021-01-01",
"entry":
{
"path": "python3",
"name": "/panorama/application.py"
}
}
}
```
Dalam folder aset, deskriptor dan gambar aplikasi diberi nama untuk checksum SHA-256 mereka. Nama ini digunakan sebagai pengidentifikasi unik untuk aset saat disimpan adalah Amazon S3.
# Memanggil layanan AWS dari kode aplikasi Anda
Anda dapat menggunakan layanan AWS SDK for Python (Boto) untuk memanggil AWS dari kode aplikasi Anda. Misalnya, jika model Anda mendeteksi sesuatu yang tidak biasa, Anda dapat memposting metrik ke Amazon CloudWatch, mengirim pemberitahuan dengan Amazon SNS, menyimpan gambar ke Amazon S3, atau menjalankan fungsi Lambda untuk diproses lebih lanjut. Sebagian besar layanan AWS memiliki API publik yang dapat Anda gunakan dengan AWS SDK.
Alat tidak memiliki izin untuk mengakses layanan AWS apa pun secara default. Untuk memberikan izin, [buat peran untuk aplikasi](permissions-application.md), dan tetapkan ke instance aplikasi selama penerapan.
**Topics**
+ [Menggunakan Amazon S3](#applications-awssdk-s3)
+ [Menggunakan topik AWS IoT MQTT](#monitoring-messagestream)
## Menggunakan Amazon S3
Anda dapat menggunakan Amazon S3 untuk menyimpan hasil pemrosesan dan data aplikasi lainnya.
```
import boto3
s3_client=boto3.client("s3")
s3_clients3.upload_file(data_file,
s3_bucket_name,
os.path.basename(data_file))
```
## Menggunakan topik AWS IoT MQTT
[Anda dapat menggunakan SDK for Python (Boto3) untuk mengirim pesan ke topik MQTT di.](https://docs.aws.amazon.com/iot/latest/developerguide/topics.html) AWS IoT Dalam contoh berikut, aplikasi memposting ke topik yang dinamai sesuai *nama benda* alat, yang dapat Anda temukan di [AWS IoT konsol](https://console.aws.amazon.com/iot/home#/thinghub).
```
import boto3
iot_client=boto3.client('iot-data')
topic = "panorama/panorama_my-appliance_Thing_a01e373b"
iot_client.publish(topic=topic, payload="my message")
```
Pilih nama yang menunjukkan ID perangkat atau pengenal lain pilihan Anda. Untuk mempublikasikan pesan, aplikasi memerlukan izin untuk menelepon`iot:Publish`.
**Untuk memantau antrian MQTT**
1. Buka [halaman Uji AWS IoT konsol](https://console.aws.amazon.com/iot/home?region=us-east-1#/test).
1. Untuk **topik Langganan**, masukkan nama topik. Misalnya, `panorama/panorama_my-appliance_Thing_a01e373b`.
1. Pilih **Berlangganan topik**.
# SDK Aplikasi AWS Panorama
AWS Panorama Application SDK adalah pustaka Python untuk mengembangkan aplikasi AWS Panorama. Dalam [kode aplikasi](gettingstarted-sample.md), Anda menggunakan AWS Panorama Application SDK untuk memuat model visi komputer, menjalankan inferensi, dan mengeluarkan video ke monitor.
**catatan**
Untuk memastikan bahwa Anda memiliki akses ke fungsionalitas terbaru SDK Aplikasi AWS Panorama, [tingkatkan](appliance-manage.md#appliance-manage-software) perangkat lunak alat.
Untuk detail tentang kelas yang didefinisikan SDK aplikasi dan metodenya, lihat Referensi [SDK aplikasi](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/resources/applicationsdk-reference.md).
**Topics**
+ [Menambahkan teks dan kotak untuk output video](#applications-panoramasdk-overlays)
## Menambahkan teks dan kotak untuk output video
Dengan AWS Panorama SDK, Anda dapat menampilkan aliran video ke layar. Video dapat menyertakan teks dan kotak yang menampilkan output dari model, keadaan aplikasi saat ini, atau data lainnya.
Setiap objek dalam `video_in` array adalah gambar dari aliran kamera yang terhubung ke alat. Jenis objek ini adalah`panoramasdk.media`. Ini memiliki metode untuk menambahkan teks dan kotak persegi panjang ke gambar, yang kemudian dapat Anda tetapkan ke `video_out` array.
Dalam contoh berikut, aplikasi sampel menambahkan label untuk setiap hasil. Setiap hasil diposisikan pada posisi kiri yang sama, tetapi pada ketinggian yang berbeda.
```
for j in range(max_results):
label = 'Class [%s], with probability %.3f.'% (self.classes[indexes[j]], class_tuple[0][indexes[j]])
stream.add_label(label, 0.1, 0.1 + 0.1*j)
```
Untuk menambahkan kotak ke gambar output, gunakan`add_rect`. Metode ini mengambil 4 nilai antara 0 dan 1, menunjukkan posisi sudut kiri atas dan kanan bawah kotak.
```
w,h,c = stream.image.shape
stream.add_rect(x1/w, y1/h, x2/w, y2/h)
```
# Menjalankan beberapa utas
Anda dapat menjalankan logika aplikasi Anda pada thread pemrosesan dan menggunakan utas lain untuk proses latar belakang lainnya. Misalnya, Anda dapat membuat thread yang [melayani lalu lintas HTTP](applications-ports.md) untuk debugging, atau thread yang memantau hasil inferensi dan mengirimkan data ke. AWS
Untuk menjalankan beberapa thread, Anda menggunakan [modul threading](https://docs.python.org/3/library/threading.html) dari pustaka standar Python untuk membuat thread untuk setiap proses. Contoh berikut menunjukkan loop utama dari aplikasi sampel server debug, yang menciptakan objek aplikasi dan menggunakannya untuk menjalankan tiga thread.
**Example [Paket/123456789012-DEBUG\$1SERVER-1.0/Application.py](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/debug-server/packages/123456789012-DEBUG_SERVER-1.0/application.py) — Loop utama**
```
def main():
panorama = panoramasdk.node()
while True:
try:
# Instantiate application
logger.info('INITIALIZING APPLICATION')
app = Application(panorama)
# Create threads for stream processing, debugger, and client
app.run_thread = threading.Thread(target=app.run_cv)
app.server_thread = threading.Thread(target=app.run_debugger)
app.client_thread = threading.Thread(target=app.run_client)
# Start threads
logger.info('RUNNING APPLICATION')
app.run_thread.start()
logger.info('RUNNING SERVER')
app.server_thread.start()
logger.info('RUNNING CLIENT')
app.client_thread.start()
# Wait for threads to exit
app.run_thread.join()
app.server_thread.join()
app.client_thread.join()
logger.info('RESTARTING APPLICATION')
except:
logger.exception('Exception during processing loop.')
```
Ketika semua thread keluar, aplikasi restart sendiri. `run_cv`Loop memproses gambar dari aliran kamera. Jika menerima sinyal untuk berhenti, itu mematikan proses debugger, yang menjalankan server HTTP dan tidak dapat mematikan dirinya sendiri. Setiap thread harus menangani kesalahannya sendiri. Jika kesalahan tidak tertangkap dan dicatat, utas keluar diam-diam.
**Example [Paket/123456789012-DEBUG\$1SERVER-1.0/Application.py](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/debug-server/packages/123456789012-DEBUG_SERVER-1.0/application.py) — Loop pemrosesan**
```
# Processing loop
def run_cv(self):
"""Run computer vision workflow in a loop."""
logger.info("PROCESSING STREAMS")
while not self.terminate:
try:
self.process_streams()
# turn off debug logging after 15 loops
if logger.getEffectiveLevel() == logging.DEBUG and self.frame_num == 15:
logger.setLevel(logging.INFO)
except:
logger.exception('Exception on processing thread.')
# Stop signal received
logger.info("SHUTTING DOWN SERVER")
self.server.shutdown()
self.server.server_close()
logger.info("EXITING RUN THREAD")
```
Thread berkomunikasi melalui `self` objek aplikasi. Untuk memulai ulang loop pemrosesan aplikasi, utas debugger memanggil metode. `stop` Metode ini menetapkan `terminate` atribut, yang memberi sinyal thread lain untuk dimatikan.
**Example [Paket/123456789012-debug\$1server-1.0/application.py](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/debug-server/packages/123456789012-DEBUG_SERVER-1.0/application.py) - Metode berhenti**
```
# Interrupt processing loop
def stop(self):
"""Signal application to stop processing."""
logger.info("STOPPING APPLICATION")
# Signal processes to stop
self.terminate = True
# HTTP debug server
def run_debugger(self):
"""Process debug commands from local network."""
class ServerHandler(SimpleHTTPRequestHandler):
# Store reference to application
application = self
# Get status
def do_GET(self):
"""Process GET requests."""
logger.info('Get request to {}'.format(self.path))
if self.path == "/status":
self.send_200('OK')
else:
self.send_error(400)
# Restart application
def do_POST(self):
"""Process POST requests."""
logger.info('Post request to {}'.format(self.path))
if self.path == '/restart':
self.send_200('OK')
ServerHandler.application.stop()
else:
self.send_error(400)
```
# Melayani lalu lintas masuk
Anda dapat memantau atau men-debug aplikasi secara lokal dengan menjalankan server HTTP di samping kode aplikasi Anda. Untuk melayani lalu lintas eksternal, Anda memetakan port di AWS Panorama Appliance ke port pada wadah aplikasi Anda.
**penting**
Secara default, AWS Panorama Appliance tidak menerima lalu lintas masuk pada port apa pun. Membuka port pada alat memiliki risiko keamanan implisit. Saat Anda menggunakan fitur ini, Anda harus mengambil langkah tambahan untuk [mengamankan alat Anda dari lalu lintas eksternal](appliance-network.md) dan mengamankan komunikasi antara klien resmi dan alat.
Kode contoh yang disertakan dengan panduan ini adalah untuk tujuan demonstrasi dan tidak menerapkan otentikasi, otorisasi, atau enkripsi.
Anda dapat membuka port dalam kisaran 8000—9000 pada alat. Port ini, ketika dibuka, dapat menerima lalu lintas dari klien yang dapat dirutekan. Saat menerapkan aplikasi, Anda menentukan port mana yang akan dibuka, dan memetakan port pada alat ke port pada wadah aplikasi Anda. Perangkat lunak alat meneruskan lalu lintas ke wadah, dan mengirimkan tanggapan kembali ke pemohon. Permintaan diterima di port alat yang Anda tentukan dan respons keluar pada port singkat acak.
## Mengkonfigurasi port masuk
Anda menentukan pemetaan port di tiga tempat dalam konfigurasi aplikasi Anda. Paket kode`package.json`, Anda menentukan port yang simpul kode mendengarkan di dalam `network` blok. Contoh berikut menyatakan bahwa node mendengarkan pada port 80.
**Example [Paket/123456789012-DEBUG\$1SERVER-1.0/package.json](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/debug-server/packages/123456789012-DEBUG_SERVER-1.0/package.json)**
```
"outputs": [
{
"description": "Video stream output",
"name": "video_out",
"type": "media"
}
],
"network": {
"inboundPorts": [
{
"port": 80,
"description": "http"
}
]
}
```
Dalam manifes aplikasi, Anda mendeklarasikan aturan perutean yang memetakan port pada alat ke port pada wadah kode aplikasi. Contoh berikut menambahkan aturan yang memetakan port 8080 pada perangkat ke port 80 pada `code_node` wadah.
**Example [graphs/my-app/graph.json](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/debug-server/graphs/my-app/graph.json)**
```
{
"producer": "model_input_width",
"consumer": "code_node.model_input_width"
},
{
"producer": "model_input_order",
"consumer": "code_node.model_input_order"
}
],
"networkRoutingRules": [
{
"node": "code_node",
"containerPort": 80,
"hostPort": 8080,
"decorator": {
"title": "Listener port 8080",
"description": "Container monitoring and debug."
}
}
]
```
Saat menerapkan aplikasi, Anda menentukan aturan yang sama di konsol AWS Panorama, atau dengan dokumen penggantian yang diteruskan ke API. [CreateApplicationInstance](https://docs.aws.amazon.com/panorama/latest/api/API_CreateApplicationInstance.html) Anda harus menyediakan konfigurasi ini pada waktu penerapan untuk mengonfirmasi bahwa Anda ingin membuka port pada alat.
**Example [graphs/my-app/override.json](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/debug-server/graphs/my-app/override.json)**
```
{
"replace": "camera_node",
"with": [
{
"name": "exterior-north"
}
]
}
],
"networkRoutingRules":[
{
"node": "code_node",
"containerPort": 80,
"hostPort": 8080
}
],
"envelopeVersion": "2021-01-01"
}
}
```
Jika port perangkat yang ditentukan dalam manifes aplikasi digunakan oleh aplikasi lain, Anda dapat menggunakan dokumen override untuk memilih port yang berbeda.
## Melayani lalu lintas
Dengan port terbuka pada wadah, Anda dapat membuka soket atau menjalankan server untuk menangani permintaan yang masuk. `debug-server`Sampel menunjukkan implementasi dasar dari server HTTP yang berjalan bersama kode aplikasi visi komputer.
**penting**
Implementasi sampel tidak aman untuk penggunaan produksi. Untuk menghindari membuat alat Anda rentan terhadap serangan, Anda harus menerapkan kontrol keamanan yang sesuai dalam kode dan konfigurasi jaringan Anda.
**Example [Paket/123456789012-DEBUG\$1SERVER-1.0/Application.py](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/debug-server/packages/123456789012-DEBUG_SERVER-1.0/application.py) — Server HTTP**
```
# HTTP debug server
def run_debugger(self):
"""Process debug commands from local network."""
class ServerHandler(SimpleHTTPRequestHandler):
# Store reference to application
application = self
# Get status
def do_GET(self):
"""Process GET requests."""
logger.info('Get request to {}'.format(self.path))
if self.path == '/status':
self.send_200('OK')
else:
self.send_error(400)
# Restart application
def do_POST(self):
"""Process POST requests."""
logger.info('Post request to {}'.format(self.path))
if self.path == '/restart':
self.send_200('OK')
ServerHandler.application.stop()
else:
self.send_error(400)
# Send response
def send_200(self, msg):
"""Send 200 (success) response with message."""
self.send_response(200)
self.send_header('Content-Type', 'text/plain')
self.end_headers()
self.wfile.write(msg.encode('utf-8'))
try:
# Run HTTP server
self.server = HTTPServer(("", self.CONTAINER_PORT), ServerHandler)
self.server.serve_forever(1)
# Server shut down by run_cv loop
logger.info("EXITING SERVER THREAD")
except:
logger.exception('Exception on server thread.')
```
Server menerima permintaan GET di `/status` jalur untuk mengambil beberapa informasi tentang aplikasi. Ini juga menerima permintaan POST `/restart` untuk me-restart aplikasi.
Untuk mendemonstrasikan fungsionalitas ini, aplikasi sampel menjalankan klien HTTP pada utas terpisah. Klien memanggil `/status` jalur melalui jaringan lokal segera setelah startup, dan memulai ulang aplikasi beberapa menit kemudian.
**Example [Paket/123456789012-DEBUG\$1SERVER-1.0/Application.py](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/debug-server/packages/123456789012-DEBUG_SERVER-1.0/application.py) - klien HTTP**
```
# HTTP test client
def run_client(self):
"""Send HTTP requests to device port to demnostrate debug server functions."""
def client_get():
"""Get container status"""
r = requests.get('http://{}:{}/status'.format(self.device_ip, self.DEVICE_PORT))
logger.info('Response: {}'.format(r.text))
return
def client_post():
"""Restart application"""
r = requests.post('http://{}:{}/restart'.format(self.device_ip, self.DEVICE_PORT))
logger.info('Response: {}'.format(r.text))
return
# Call debug server
while not self.terminate:
try:
time.sleep(30)
client_get()
time.sleep(300)
client_post()
except:
logger.exception('Exception on client thread.')
# stop signal received
logger.info("EXITING CLIENT THREAD")
```
Loop utama mengelola thread dan memulai ulang aplikasi ketika mereka keluar.
**Example [Paket/123456789012-DEBUG\$1SERVER-1.0/Application.py](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/debug-server/packages/123456789012-DEBUG_SERVER-1.0/application.py) — Loop utama**
```
def main():
panorama = panoramasdk.node()
while True:
try:
# Instantiate application
logger.info('INITIALIZING APPLICATION')
app = Application(panorama)
# Create threads for stream processing, debugger, and client
app.run_thread = threading.Thread(target=app.run_cv)
app.server_thread = threading.Thread(target=app.run_debugger)
app.client_thread = threading.Thread(target=app.run_client)
# Start threads
logger.info('RUNNING APPLICATION')
app.run_thread.start()
logger.info('RUNNING SERVER')
app.server_thread.start()
logger.info('RUNNING CLIENT')
app.client_thread.start()
# Wait for threads to exit
app.run_thread.join()
app.server_thread.join()
app.client_thread.join()
logger.info('RESTARTING APPLICATION')
except:
logger.exception('Exception during processing loop.')
```
Untuk menyebarkan aplikasi sampel, lihat [instruksi di GitHub repositori panduan ini](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/debug-server/README.md).
# Menggunakan GPU
Anda dapat mengakses prosesor grafis (GPU) di AWS Panorama Appliance untuk menggunakan pustaka yang dipercepat GPU, atau menjalankan model pembelajaran mesin dalam kode aplikasi Anda. Untuk mengaktifkan akses GPU, Anda menambahkan akses GPU sebagai persyaratan ke konfigurasi paket setelah membangun wadah kode aplikasi Anda.
**penting**
Jika Anda mengaktifkan akses GPU, Anda tidak dapat menjalankan node model di aplikasi apa pun di alat. Untuk tujuan keamanan, akses GPU dibatasi saat alat menjalankan model yang dikompilasi dengan SageMaker AI Neo. Dengan akses GPU, Anda harus menjalankan model Anda di node kode aplikasi, dan semua aplikasi di perangkat berbagi akses ke GPU.
Untuk mengaktifkan akses GPU untuk aplikasi Anda, perbarui [konfigurasi paket setelah Anda membuat paket](applications-packages.md) dengan AWS Panorama Application CLI. Contoh berikut menunjukkan `requirements` blok yang menambahkan akses GPU ke node kode aplikasi.
**Example package.json dengan blok persyaratan**
```
{
"nodePackage": {
"envelopeVersion": "2021-01-01",
"name": "SAMPLE_CODE",
"version": "1.0",
"description": "Computer vision application code.",
"assets": [
{
"name": "code_asset",
"implementations": [
{
"type": "container",
"assetUri": "eba3xmpl71aa387e8f89be9a8c396416cdb80a717bb32103c957a8bf41440b12.tar.gz",
"descriptorUri": "4abdxmpl5a6f047d2b3047adde44704759d13f0126c00ed9b4309726f6bb43400ba9.json",
"requirements": [
{
"type": "hardware_access",
"inferenceAccelerators": [
{
"deviceType": "nvhost_gpu",
"sharedResourcePolicy": {
"policy" : "allow_all"
}
}
]
}
]
}
]
}
],
"interfaces": [
...
```
Perbarui konfigurasi paket antara langkah pembuatan dan pengemasan dalam alur kerja pengembangan Anda.
**Untuk menyebarkan aplikasi dengan akses GPU**
1. Untuk membangun wadah aplikasi, gunakan `build-container` perintah.
```
$ panorama-cli build-container --container-asset-name code_asset --package-path packages/123456789012-SAMPLE_CODE-1.0
```
1. Tambahkan `requirements` blok ke konfigurasi paket.
1. Untuk mengunggah aset kontainer dan konfigurasi paket, gunakan `package-application` perintah.
```
$ panorama-cli package-application
```
1. Men-deploy aplikasi.
Untuk contoh aplikasi yang menggunakan akses GPU, kunjungi [aws-panorama-samples](https://github.com/aws-samples/aws-panorama-samples) GitHub repositori.
# Menyiapkan lingkungan pengembangan di Windows
Untuk membangun aplikasi AWS Panorama, Anda menggunakan Docker, alat baris perintah, dan Python. Di Windows, Anda dapat mengatur lingkungan pengembangan dengan menggunakan Docker Desktop dengan Windows Subsystem untuk Linux dan Ubuntu. Tutorial ini memandu Anda melalui proses penyiapan untuk lingkungan pengembangan yang telah diuji dengan alat AWS Panorama dan contoh aplikasi.
**Topics**
+ [Prasyarat](#applications-devenvwindows-prerequisites)
+ [Instal WSL 2 dan Ubuntu](#applications-devenvwindows-wsl2)
+ [Instal Docker](#applications-devenvwindows-docker)
+ [Konfigurasikan Ubuntu](#applications-devenvwindows-ubuntu)
+ [Langkah selanjutnya](#applications-devenvwindows-nextsteps)
## Prasyarat
Untuk mengikuti tutorial ini, Anda memerlukan versi Windows yang mendukung Windows Subsystem untuk Linux 2 (WSL 2).
****
+ Windows 10 versi 1903 dan lebih tinggi (Build 18362 dan lebih tinggi) atau Windows 11
+ Fitur Windows
+ Subsistem Windows untuk Linux
+ Hyper-V
+ Platform mesin virtual
Tutorial ini dikembangkan dengan versi perangkat lunak berikut.
****
+ Ubuntu 20.04
+ Python 3.8.5
+ Docker 20.10.8
## Instal WSL 2 dan Ubuntu
Jika Anda memiliki Windows 10 versi 2004 dan lebih tinggi (Build 19041 dan lebih tinggi), Anda dapat menginstal WSL 2 dan Ubuntu 20.04 dengan perintah berikut. PowerShell
```
> wsl --install -d Ubuntu-20.04
```
Untuk versi Windows yang lebih lama, ikuti petunjuk dalam dokumentasi WSL 2: [Langkah-langkah instalasi manual untuk](https://docs.microsoft.com/en-us/windows/wsl/install-manual) versi yang lebih lama
## Instal Docker
[Untuk menginstal Docker Desktop, download dan jalankan paket installer dari hub.docker.com.](https://hub.docker.com/editions/community/docker-ce-desktop-windows/) Jika Anda mengalami masalah, ikuti petunjuk di situs web Docker: backend [Docker Desktop WSL](https://docs.docker.com/desktop/windows/wsl/) 2.
Jalankan Docker Desktop dan ikuti tutorial pertama untuk membangun wadah contoh.
**catatan**
Docker Desktop hanya mengaktifkan Docker dalam distribusi default. **Jika Anda memiliki distribusi Linux lain yang diinstal sebelum menjalankan tutorial ini, aktifkan Docker di distribusi Ubuntu yang baru diinstal di menu pengaturan Docker Desktop di bawah **Sumber Daya**, integrasi WSL.**
## Konfigurasikan Ubuntu
Anda sekarang dapat menjalankan perintah Docker di mesin virtual Ubuntu Anda. Untuk membuka terminal baris perintah, jalankan distribusi dari menu mulai. Pertama kali Anda menjalankannya, Anda mengonfigurasi nama pengguna dan kata sandi yang dapat Anda gunakan untuk menjalankan perintah administrator.
Untuk menyelesaikan konfigurasi lingkungan pengembangan Anda, perbarui perangkat lunak mesin virtual dan instal alat.
**Untuk mengkonfigurasi mesin virtual**
1. Perbarui perangkat lunak yang disertakan dengan Ubuntu.
```
$ sudo apt update && sudo apt upgrade -y && sudo apt autoremove
```
1. Instal alat pengembangan dengan apt.
```
$ sudo apt install unzip python3-pip
```
1. Instal pustaka Python dengan pip.
```
$ pip3 install awscli panoramacli
```
1. Buka terminal baru, lalu jalankan `aws configure` untuk mengkonfigurasi AWS CLI.
```
$ aws configure
```
Jika Anda tidak memiliki kunci akses, Anda dapat membuatnya di [konsol IAM](https://console.aws.amazon.com/iamv2/home?#/users).
Terakhir, unduh dan impor aplikasi sampel.
**Untuk mendapatkan aplikasi sampel**
1. Unduh dan ekstrak aplikasi sampel.
```
$ wget https://github.com/awsdocs/aws-panorama-developer-guide/releases/download/v1.0-ga/aws-panorama-sample.zip
$ unzip aws-panorama-sample.zip
$ cd aws-panorama-sample
```
1. Jalankan skrip yang disertakan untuk menguji kompilasi, membangun wadah aplikasi, dan mengunggah paket ke AWS Panorama.
```
aws-panorama-sample$ ./0-test-compile.sh
aws-panorama-sample$ ./1-create-role.sh
aws-panorama-sample$ ./2-import-app.sh
aws-panorama-sample$ ./3-build-container.sh
aws-panorama-sample$ ./4-package-app.sh
```
CLI Aplikasi AWS Panorama mengunggah paket dan mendaftarkannya dengan layanan AWS Panorama. Anda sekarang dapat [menerapkan aplikasi sampel](gettingstarted-deploy.md#gettingstarted-deploy-deploy) dengan konsol AWS Panorama.
## Langkah selanjutnya
Untuk menjelajahi dan mengedit file proyek, Anda dapat menggunakan File Explorer atau lingkungan pengembangan terintegrasi (IDE) yang mendukung WSL.
Untuk mengakses sistem file mesin virtual, buka File explorer dan masukkan `\\wsl$` di bilah navigasi. Direktori ini berisi link ke sistem file mesin virtual (`Ubuntu-20.04`) dan sistem file untuk data Docker. Di bawah`Ubuntu-20.04`, direktori pengguna Anda berada di`home\username`.
**catatan**
Untuk mengakses file dalam instalasi Windows Anda dari dalam Ubuntu, navigasikan ke `/mnt/c` direktori. Misalnya, Anda dapat membuat daftar file di direktori unduhan dengan menjalankan`ls /mnt/c/Users/windows-username/Downloads`.
Dengan Visual Studio Code, Anda dapat mengedit kode aplikasi di lingkungan pengembangan Anda dan menjalankan perintah dengan terminal terintegrasi. Untuk menginstal Visual Studio Code, kunjungi [code.visualstudio.com](https://code.visualstudio.com/). Setelah instalasi, tambahkan ekstensi [Remote WSL](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-wsl).
Terminal Windows adalah alternatif dari terminal Ubuntu standar tempat Anda menjalankan perintah. Ini mendukung banyak tab dan dapat menjalankan PowerShell, Command Prompt, dan terminal untuk berbagai Linux lainnya yang Anda instal. Ini mendukung salin dan tempel dengan Ctrl C dan Ctrl V , dapat diklik URLs, dan peningkatan bermanfaat lainnya. Untuk menginstal Terminal Windows, kunjungi [microsoft.com](https://www.microsoft.com/en-us/p/windows-terminal/9n0dx20hk701).