Avviso di fine del supporto: il 31 maggio 2026, AWS terminerà il supporto per AWS Panorama. Dopo il 31 maggio 2026, non potrai più accedere alla AWS Panorama console o AWS Panorama alle risorse. Per ulteriori informazioni, consulta [AWS Panorama Fine del supporto](https://docs.aws.amazon.com/panorama/latest/dev/panorama-end-of-support.html).
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à.
# AWS Panorama Applicazioni edili
Le applicazioni vengono eseguite sull' AWS Panorama appliance per eseguire attività di visione artificiale su flussi video. È possibile creare applicazioni di visione artificiale combinando codice Python e modelli di machine learning e distribuirle nell' AWS Panorama Appliance tramite Internet. Le applicazioni possono inviare video a un display o utilizzare l'SDK AWS per inviare risultati ai servizi AWS.
Un [modello](applications-models.md) analizza le immagini per rilevare persone, veicoli e altri oggetti. Sulla base delle immagini che ha visto durante l'allenamento, il modello ti dice cosa pensa che sia qualcosa e quanto è sicuro di indovinare. Puoi addestrare i modelli con i tuoi dati di immagine o iniziare con un campione.
Il [codice](gettingstarted-sample.md) dell'applicazione elabora le immagini fisse provenienti dallo stream di una telecamera, le invia a un modello ed elabora il risultato. Un modello può rilevare più oggetti e restituirne le forme e la posizione. Il codice può utilizzare queste informazioni per aggiungere testo o grafica al video o per inviare i risultati a un AWS servizio per l'archiviazione o l'ulteriore elaborazione.
Per ottenere immagini da uno stream, interagire con un modello e generare video, il codice dell'applicazione utilizza [l' AWS Panorama Application SDK](applications-panoramasdk.md). L'SDK dell'applicazione è una libreria Python che supporta modelli generati PyTorch con, MXNet Apache e. TensorFlow
**Topics**
+ [Modelli di visione artificiale](applications-models.md)
+ [Creazione di un'immagine dell'applicazione](applications-image.md)
+ [Chiamare i servizi AWS dal codice dell'applicazione](applications-awssdk.md)
+ [L'SDK per applicazioni AWS Panorama](applications-panoramasdk.md)
+ [Esecuzione di più thread](applications-threading.md)
+ [Servire il traffico in entrata](applications-ports.md)
+ [Utilizzo della GPU](applications-gpuaccess.md)
+ [Configurazione di un ambiente di sviluppo in Windows](applications-devenvwindows.md)
# Modelli di visione artificiale
Un *modello di visione artificiale* è un programma software addestrato a rilevare oggetti nelle immagini. Un modello impara a riconoscere un insieme di oggetti analizzando prima le immagini di tali oggetti attraverso l'addestramento. Un modello di visione artificiale utilizza un'immagine come input e restituisce informazioni sugli oggetti rilevati, ad esempio il tipo di oggetto e la sua posizione. AWS Panorama supporta modelli di visione artificiale creati con PyTorch, Apache MXNet e TensorFlow.
**Nota**
Per un elenco di modelli predefiniti che sono stati testati con AWS Panorama, consulta [Compatibilità dei modelli](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/resources/model-compatibility.md).
**Topics**
+ [Utilizzo di modelli nel codice](#applications-models-using)
+ [Creazione di un modello personalizzato](#applications-models-custom)
+ [Imballaggio di un modello](#applications-models-package)
+ [Addestramento dei modelli](#applications-models-training)
## Utilizzo di modelli nel codice
Un modello restituisce uno o più risultati, che possono includere probabilità per le classi rilevate, informazioni sulla posizione e altri dati. L'esempio seguente mostra come eseguire l'inferenza su un'immagine da un flusso video e inviare l'output del modello a una funzione di elaborazione.
**Example [application.py — Inferenza](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/packages/123456789012-SAMPLE_CODE-1.0/application.py)**
```
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)
```
L'esempio seguente mostra una funzione che elabora i risultati del modello di classificazione di base. Il modello di esempio restituisce una matrice di probabilità, che è il primo e unico valore nell'array dei risultati.
**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) — Elaborazione dei risultati**
```
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)
```
Il codice dell'applicazione trova i valori con le probabilità più elevate e li associa alle etichette in un file di risorse che viene caricato durante l'inizializzazione.
## Creazione di un modello personalizzato
Puoi usare modelli che crei in PyTorch MXNet Apache e TensorFlow nelle applicazioni AWS Panorama. In alternativa alla creazione e alla formazione di modelli nell' SageMaker intelligenza artificiale, puoi utilizzare un modello addestrato o creare e addestrare il tuo modello con un framework supportato ed esportarlo in un ambiente locale o in Amazon EC2.
**Nota**
Per informazioni dettagliate sulle versioni del framework e sui formati di file supportati da SageMaker AI Neo, consulta [Supported Frameworks](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-supported-devices-edge-frameworks.html) nella Amazon SageMaker AI Developer Guide.
L'archivio di questa guida fornisce un'applicazione di esempio che illustra questo flusso di lavoro per un modello Keras in formato. TensorFlow `SavedModel` Utilizza TensorFlow 2 e può essere eseguito localmente in un ambiente virtuale o in un contenitore Docker. L'app di esempio include anche modelli e script per creare il modello su un' EC2istanza Amazon.
****
+ [Modello di applicazione di esempio personalizzato](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/custom-model)
![\[\]](http://docs.aws.amazon.com/it_it/panorama/latest/dev/images/sample-custom-model.png)
AWS Panorama utilizza SageMaker AI Neo per compilare modelli da utilizzare su AWS Panorama Appliance. Per ogni framework, usa il [formato supportato da SageMaker AI Neo](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-compilation-preparing-model.html) e raccogli il modello in un `.tar.gz` archivio.
Per ulteriori informazioni, consulta [Compilare e distribuire modelli con Neo](https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html) nella Amazon SageMaker AI Developer Guide.
## Imballaggio di un modello
Un pacchetto modello comprende un descrittore, una configurazione del pacchetto e un archivio del modello. Come in un [pacchetto di immagini applicative](applications-image.md), la configurazione del pacchetto indica al servizio AWS Panorama dove il modello e il descrittore sono archiviati in Amazon S3.
**Example [Pacchetti/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
]
}
]
}
}
```
**Nota**
Specificate solo la versione principale e secondaria della versione del framework. Per un elenco delle versioni supportate PyTorch, di Apache MXNet e delle TensorFlow versioni, consulta [Framework supportati](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-supported-devices-edge-frameworks.html).
Per importare un modello, usa il comando CLI `import-raw-model` dell'applicazione AWS Panorama. Se apporti modifiche al modello o al suo descrittore, devi eseguire nuovamente questo comando per aggiornare gli asset dell'applicazione. Per ulteriori informazioni, consulta [Modifica del modello di visione artificiale](gettingstarted-sample.md#gettingstarted-sample-model).
[Per lo schema JSON del file descrittore, vedete AssetDescriptor.schema.json.](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/resources/manifest-schema/ver_2021-01-01/assetDescriptor.schema.json)
## Addestramento dei modelli
Quando addestrate un modello, utilizzate immagini provenienti dall'ambiente di destinazione o da un ambiente di test molto simile a quello di destinazione. Considerate i seguenti fattori che possono influire sulle prestazioni del modello:
****
+ **Illuminazione**: la quantità di luce riflessa da un soggetto determina la quantità di dettagli che il modello deve analizzare. Un modello addestrato con immagini di soggetti ben illuminati potrebbe non funzionare bene in un ambiente con scarsa illuminazione o retroilluminazione.
+ **Risoluzione**: la dimensione di input di un modello è in genere fissata a una risoluzione compresa tra 224 e 512 pixel di larghezza in un rapporto di aspetto quadrato. Prima di passare un fotogramma di video al modello, potete ridimensionarlo o ritagliarlo per adattarlo alle dimensioni richieste.
+ **Distorsione dell'immagine: la** lunghezza focale e la forma dell'obiettivo di una fotocamera possono causare una distorsione delle immagini lontano dal centro dell'inquadratura. La posizione di una fotocamera determina anche quali caratteristiche di un soggetto sono visibili. Ad esempio, una fotocamera a soffitto con obiettivo grandangolare mostrerà la parte superiore di un soggetto quando è al centro dell'inquadratura e una visione distorta del lato del soggetto man mano che si allontana dal centro.
Per risolvere questi problemi, è possibile preelaborare le immagini prima di inviarle al modello e addestrare il modello su una più ampia varietà di immagini che riflettono le variazioni negli ambienti del mondo reale. Se un modello deve funzionare in situazioni di illuminazione e con una varietà di telecamere, sono necessari più dati per l'addestramento. Oltre a raccogliere più immagini, è possibile ottenere più dati di addestramento creando varianti delle immagini esistenti che sono distorte o hanno un'illuminazione diversa.
# Creazione di un'immagine dell'applicazione
L'AWS Panorama Appliance esegue le applicazioni come file system container esportati da un'immagine creata da te. Specifichi le dipendenze e le risorse dell'applicazione in un Dockerfile che utilizza l'immagine di base dell'applicazione AWS Panorama come punto di partenza.
Per creare un'immagine dell'applicazione, usi Docker e la CLI dell'applicazione AWS Panorama. Il seguente esempio tratto dall'applicazione di esempio di questa guida illustra questi casi d'uso.
**Example [Pacchetti/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
```
Vengono utilizzate le seguenti istruzioni del Dockerfile.
****
+ `FROM`— Carica l'immagine di base dell'applicazione ()`public.ecr.aws/panorama/panorama-application`.
+ `WORKDIR`— Imposta la directory di lavoro sull'immagine. `/panorama`viene utilizzato per il codice dell'applicazione e i file correlati. Questa impostazione persiste solo durante la compilazione e non influisce sulla directory di lavoro dell'applicazione in fase di esecuzione (`/`).
+ `COPY`— Copia i file da un percorso locale a un percorso sull'immagine. `COPY . .`copia i file nella directory corrente (la directory del pacchetto) nella directory di lavoro dell'immagine. Ad esempio, il codice dell'applicazione viene copiato da `packages/123456789012-SAMPLE_CODE-1.0/application.py` a`/panorama/application.py`.
+ `RUN`— Esegue i comandi della shell sull'immagine durante la compilazione. Una singola `RUN` operazione può eseguire più comandi in sequenza utilizzando `&&` tra i comandi. Questo esempio aggiorna il gestore di `pip` pacchetti e quindi installa le librerie elencate in`requirements.txt`.
È possibile utilizzare altre istruzioni, come `ADD` e`ARG`, utili in fase di compilazione. Le istruzioni che aggiungono informazioni di runtime al contenitore, ad esempio`ENV`, non funzionano con AWS Panorama. AWS Panorama non esegue un contenitore dall'immagine. Utilizza l'immagine solo per esportare un filesystem, che viene trasferito all'appliance.
## Specifica delle dipendenze
`requirements.txt`è un file di requisiti Python che specifica le librerie utilizzate dall'applicazione. L'applicazione di esempio utilizza Open CV e. AWS SDK per Python (Boto3)
**Example [Pacchetti/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.*
```
Il `pip install` comando nel Dockerfile installa queste librerie nella `dist-packages` directory Python in`/usr/local/lib`, in modo che possano essere importate dal codice dell'applicazione.
## Storage locale
AWS Panorama riserva la `/opt/aws/panorama/storage` directory per lo storage delle applicazioni. L'applicazione può creare e modificare file su questo percorso. I file creati nella directory di archiviazione persistono anche dopo i riavvii. Le altre posizioni dei file temporanei vengono cancellate all'avvio.
## Creazione di risorse di immagini
Quando crei un'immagine per il pacchetto dell'applicazione con l'interfaccia a riga di comando dell'applicazione AWS Panorama, la CLI viene eseguita `docker build` nella directory del pacchetto. Questo crea un'immagine dell'applicazione che contiene il codice dell'applicazione. La CLI crea quindi un contenitore, esporta il relativo filesystem, lo comprime e lo archivia nella cartella. `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
```
Il blocco JSON nell'output è una definizione di asset che la CLI aggiunge alla configurazione del pacchetto `package.json` () e registra con il servizio AWS Panorama. La CLI copia anche il file descrittore, che specifica il percorso dello script dell'applicazione (il punto di ingresso dell'applicazione).
**Example [Pacchetti/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"
}
}
}
```
Nella cartella assets, il descrittore e l'immagine dell'applicazione sono denominati in base al relativo checksum SHA-256. Questo nome viene utilizzato come identificatore univoco per l'asset quando è archiviato in Amazon S3.
# Chiamare i servizi AWS dal codice dell'applicazione
Puoi utilizzarli AWS SDK per Python (Boto) per richiamare i servizi AWS dal codice dell'applicazione. Ad esempio, se il tuo modello rileva qualcosa di insolito, puoi pubblicare parametri su Amazon, inviare una notifica con Amazon SNS CloudWatch, salvare un'immagine su Amazon S3 o richiamare una funzione Lambda per un'ulteriore elaborazione. La maggior parte dei servizi AWS dispone di un'API pubblica che puoi utilizzare con l'SDK AWS.
Per impostazione predefinita, l'appliance non dispone dell'autorizzazione per accedere a nessun servizio AWS. Per concederle l'autorizzazione, [crea un ruolo per l'applicazione](permissions-application.md) e assegnalo all'istanza dell'applicazione durante la distribuzione.
**Topics**
+ [Uso di Amazon S3](#applications-awssdk-s3)
+ [Utilizzo dell'argomento AWS IoT MQTT](#monitoring-messagestream)
## Uso di Amazon S3
Puoi usare Amazon S3 per archiviare i risultati di elaborazione e altri dati dell'applicazione.
```
import boto3
s3_client=boto3.client("s3")
s3_clients3.upload_file(data_file,
s3_bucket_name,
os.path.basename(data_file))
```
## Utilizzo dell'argomento AWS IoT MQTT
[È possibile utilizzare l'SDK for Python (Boto3) per inviare messaggi a un argomento MQTT in.](https://docs.aws.amazon.com/iot/latest/developerguide/topics.html) AWS IoT[Nell'esempio seguente, l'applicazione invia un messaggio a un argomento che prende il nome dal nome dell'oggetto dell'appliance, che è *possibile trovare* nella console.AWS IoT](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")
```
Scegliete un nome che indichi l'ID del dispositivo o un altro identificatore a vostra scelta. Per pubblicare messaggi, l'applicazione necessita dell'autorizzazione per effettuare chiamate`iot:Publish`.
**Per monitorare una coda MQTT**
1. Apri la pagina di [test AWS IoT della console](https://console.aws.amazon.com/iot/home?region=us-east-1#/test).
1. Per **l'argomento Abbonamento**, inserisci il nome dell'argomento. Ad esempio `panorama/panorama_my-appliance_Thing_a01e373b`.
1. Scegli **Subscribe to topic (Effettua sottoscrizione all'argomento)**.
# L'SDK per applicazioni AWS Panorama
L'SDK per applicazioni AWS Panorama è una libreria Python per lo sviluppo di applicazioni AWS Panorama. Nel [codice dell'applicazione](gettingstarted-sample.md), usi l'SDK dell'applicazione AWS Panorama per caricare un modello di visione artificiale, eseguire inferenze e inviare video a un monitor.
**Nota**
Per assicurarti di avere accesso alle funzionalità più recenti dell'SDK per applicazioni AWS Panorama, [aggiorna il software dell'appliance.](appliance-manage.md#appliance-manage-software)
Per i dettagli sulle classi definite dall'SDK dell'applicazione e sui relativi metodi, consulta [Application](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/resources/applicationsdk-reference.md) SDK reference.
**Topics**
+ [Aggiungere testo e riquadri al video in uscita](#applications-panoramasdk-overlays)
## Aggiungere testo e riquadri al video in uscita
Con l'SDK AWS Panorama, puoi inviare un flusso video a un display. Il video può includere testo e riquadri che mostrano l'output del modello, lo stato corrente dell'applicazione o altri dati.
Ogni oggetto dell'`video_in`array è un'immagine proveniente da un flusso di telecamere collegato all'appliance. Il tipo di oggetto è`panoramasdk.media`. Dispone di metodi per aggiungere testo e riquadri rettangolari all'immagine, che è quindi possibile assegnare all'`video_out`array.
Nell'esempio seguente, l'applicazione di esempio aggiunge un'etichetta per ciascuno dei risultati. Ogni risultato viene posizionato nella stessa posizione sinistra, ma ad altezze diverse.
```
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)
```
Per aggiungere un riquadro all'immagine di output, usa`add_rect`. Questo metodo richiede 4 valori compresi tra 0 e 1, che indicano la posizione degli angoli superiore sinistro e inferiore destro del riquadro.
```
w,h,c = stream.image.shape
stream.add_rect(x1/w, y1/h, x2/w, y2/h)
```
# Esecuzione di più thread
È possibile eseguire la logica dell'applicazione su un thread di elaborazione e utilizzare altri thread per altri processi in background. Ad esempio, è possibile creare un thread che [serva il traffico HTTP per il](applications-ports.md) debug o un thread che monitora i risultati dell'inferenza e invia i dati a. AWS
Per eseguire più thread, si utilizza il [modulo threading](https://docs.python.org/3/library/threading.html) della libreria standard Python per creare un thread per ogni processo. L'esempio seguente mostra il ciclo principale dell'applicazione di esempio del server di debug, che crea un oggetto applicativo e lo utilizza per eseguire tre thread.
**Example [Packages/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) — Ciclo principale**
```
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.')
```
Quando tutti i thread vengono chiusi, l'applicazione si riavvia automaticamente. Il `run_cv` loop elabora le immagini provenienti dai flussi della telecamera. Se riceve un segnale di arresto, interrompe il processo di debugger, che esegue un server HTTP e non può spegnersi da solo. Ogni thread deve gestire i propri errori. Se un errore non viene rilevato e registrato, il thread si chiude silenziosamente.
**Example [Packages/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) — Ciclo di elaborazione**
```
# 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")
```
I thread comunicano tramite l'oggetto dell'applicazione. `self` Per riavviare il ciclo di elaborazione dell'applicazione, il thread del debugger chiama il metodo. `stop` Questo metodo imposta un `terminate` attributo che segnala agli altri thread di chiudersi.
**Example [Packages/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) — Metodo Stop**
```
# 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)
```
# Servire il traffico in entrata
Puoi monitorare o eseguire il debug delle applicazioni localmente eseguendo un server HTTP insieme al codice dell'applicazione. Per servire il traffico esterno, mappi le porte di AWS Panorama Appliance alle porte del contenitore dell'applicazione.
**Importante**
Per impostazione predefinita, AWS Panorama Appliance non accetta traffico in entrata su nessuna porta. L'apertura delle porte sull'appliance comporta un rischio implicito per la sicurezza. Quando si utilizza questa funzionalità, è necessario adottare misure aggiuntive per [proteggere l'appliance dal traffico esterno](appliance-network.md) e proteggere le comunicazioni tra i client autorizzati e l'appliance.
Il codice di esempio incluso in questa guida è a scopo dimostrativo e non implementa l'autenticazione, l'autorizzazione o la crittografia.
È possibile aprire porte nell'intervallo 8000-9000 sull'appliance. Queste porte, una volta aperte, possono ricevere traffico da qualsiasi client routabile. Quando si distribuisce l'applicazione, si specificano le porte da aprire e si associano le porte dell'appliance alle porte del contenitore dell'applicazione. Il software dell'appliance inoltra il traffico al contenitore e invia le risposte al richiedente. Le richieste vengono ricevute sulla porta dell'appliance specificata e le risposte vengono inviate su una porta temporanea casuale.
## Configurazione delle porte in entrata
Le mappature delle porte vengono specificate in tre punti della configurazione dell'applicazione. Per quanto riguarda il pacchetto di codice`package.json`, si specifica la porta su cui il nodo di codice ascolta in un blocco. `network` L'esempio seguente dichiara che il nodo è in ascolto sulla porta 80.
**Example [Pacchetti/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"
}
]
}
```
Nel manifesto dell'applicazione, si dichiara una regola di routing che associa una porta dell'appliance a una porta del contenitore di codice dell'applicazione. L'esempio seguente aggiunge una regola che mappa la porta 8080 sul dispositivo alla porta 80 del contenitore. `code_node`
**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."
}
}
]
```
Quando distribuisci l'applicazione, specifichi le stesse regole nella console AWS Panorama o con un documento di override passato all'[CreateApplicationInstance](https://docs.aws.amazon.com/panorama/latest/api/API_CreateApplicationInstance.html)API. È necessario fornire questa configurazione al momento della distribuzione per confermare che si desidera aprire le porte sull'appliance.
**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"
}
}
```
Se la porta del dispositivo specificata nel manifesto dell'applicazione è utilizzata da un'altra applicazione, è possibile utilizzare il documento di sostituzione per scegliere una porta diversa.
## Servire il traffico
Con le porte aperte sul contenitore, puoi aprire un socket o eseguire un server per gestire le richieste in arrivo. L'`debug-server`esempio mostra un'implementazione di base di un server HTTP in esecuzione insieme al codice di un'applicazione di visione artificiale.
**Importante**
L'implementazione di esempio non è sicura per l'uso in produzione. Per evitare di rendere il dispositivo vulnerabile agli attacchi, è necessario implementare controlli di sicurezza appropriati nel codice e nella configurazione di rete.
**Example [Packages/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.')
```
Il server accetta le richieste GET lungo il percorso per recuperare alcune informazioni sull'applicazione. `/status` Accetta anche una richiesta POST per `/restart` riavviare l'applicazione.
Per dimostrare questa funzionalità, l'applicazione di esempio esegue un client HTTP su un thread separato. Il client richiama il `/status` percorso sulla rete locale poco dopo l'avvio e riavvia l'applicazione pochi minuti dopo.
**Example [Packages/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) — client 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")
```
Il ciclo principale gestisce i thread e riavvia l'applicazione quando escono.
**Example [Packages/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) — Ciclo principale**
```
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.')
```
[Per distribuire l'applicazione di esempio, consulta le istruzioni nell'archivio di questa guida. GitHub ](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/debug-server/README.md)
# Utilizzo della GPU
Puoi accedere al processore grafico (GPU) su AWS Panorama Appliance per utilizzare librerie accelerate da GPU o eseguire modelli di machine learning nel codice dell'applicazione. Per attivare l'accesso tramite GPU, aggiungi l'accesso tramite GPU come requisito alla configurazione del pacchetto dopo aver creato il contenitore di codice dell'applicazione.
**Importante**
Se abiliti l'accesso tramite GPU, non puoi eseguire nodi modello in nessuna applicazione sull'appliance. Per motivi di sicurezza, l'accesso alla GPU è limitato quando l'appliance esegue un modello compilato con AI Neo. SageMaker Con l'accesso tramite GPU, è necessario eseguire i modelli in nodi di codice applicativo e tutte le applicazioni sul dispositivo condividono l'accesso alla GPU.
Per attivare l'accesso tramite GPU per la tua applicazione, aggiorna la [configurazione del pacchetto](applications-packages.md) dopo averlo creato con la CLI dell'applicazione AWS Panorama. L'esempio seguente mostra il `requirements` blocco che aggiunge l'accesso tramite GPU al nodo del codice dell'applicazione.
**Example package.json con blocco requirements**
```
{
"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": [
...
```
Aggiorna la configurazione del pacchetto tra le fasi di compilazione e pacchettizzazione nel flusso di lavoro di sviluppo.
**Per distribuire un'applicazione con accesso tramite GPU**
1. Per creare il contenitore dell'applicazione, usa il `build-container` comando.
```
$ panorama-cli build-container --container-asset-name code_asset --package-path packages/123456789012-SAMPLE_CODE-1.0
```
1. Aggiungi il `requirements` blocco alla configurazione del pacchetto.
1. Per caricare la configurazione della risorsa del contenitore e del pacchetto, usa il `package-application` comando.
```
$ panorama-cli package-application
```
1. Distribuire l'applicazione.
Per esempi di applicazioni che utilizzano l'accesso tramite GPU, visita il [aws-panorama-samples](https://github.com/aws-samples/aws-panorama-samples) GitHub repository.
# Configurazione di un ambiente di sviluppo in Windows
Per creare un'applicazione AWS Panorama, usi Docker, strumenti da riga di comando e Python. In Windows, puoi configurare un ambiente di sviluppo utilizzando Docker Desktop con Windows Subsystem per Linux e Ubuntu. Questo tutorial illustra il processo di configurazione di un ambiente di sviluppo che è stato testato con strumenti AWS Panorama e applicazioni di esempio.
**Topics**
+ [Prerequisiti](#applications-devenvwindows-prerequisites)
+ [Installa WSL 2 e Ubuntu](#applications-devenvwindows-wsl2)
+ [Installa Docker](#applications-devenvwindows-docker)
+ [Configura Ubuntu](#applications-devenvwindows-ubuntu)
+ [Passaggi successivi](#applications-devenvwindows-nextsteps)
## Prerequisiti
Per seguire questo tutorial, è necessaria una versione di Windows che supporti Windows Subsystem for Linux 2 (WSL 2).
****
+ Windows 10 versione 1903 e successive (build 18362 e successive) o Windows 11
+ Funzionalità di Windows
+ Sottosistema Windows per Linux
+ Hyper-V
+ Piattaforma di macchina virtuale
Questo tutorial è stato sviluppato con le seguenti versioni del software.
****
+ Ubuntu 20.04
+ Python 3.8.5
+ Docker 20.10.8
## Installa WSL 2 e Ubuntu
Se disponi di Windows 10 versione 2004 e successive (build 19041 e successive), puoi installare WSL 2 e Ubuntu 20.04 con il seguente comando. PowerShell
```
> wsl --install -d Ubuntu-20.04
```
Per le versioni precedenti di Windows, segui le istruzioni nella documentazione di WSL 2: Procedura di [installazione manuale per](https://docs.microsoft.com/en-us/windows/wsl/install-manual) versioni precedenti
## Installa Docker
[Per installare Docker Desktop, scarica ed esegui il pacchetto di installazione da hub.docker.com.](https://hub.docker.com/editions/community/docker-ce-desktop-windows/) [Se riscontri problemi, segui le istruzioni sul sito Web di Docker: Docker Desktop WSL 2 backend.](https://docs.docker.com/desktop/windows/wsl/)
Esegui Docker Desktop e segui il tutorial di prima esecuzione per creare un contenitore di esempio.
**Nota**
Docker Desktop abilita Docker solo nella distribuzione predefinita. ****Se hai installato altre distribuzioni Linux prima di eseguire questo tutorial, abilita Docker nella distribuzione Ubuntu appena installata nel menu delle impostazioni di Docker Desktop in Risorse, integrazione WSL.****
## Configura Ubuntu
Ora puoi eseguire i comandi Docker nella tua macchina virtuale Ubuntu. Per aprire un terminale a riga di comando, esegui la distribuzione dal menu di avvio. La prima volta che lo esegui, configuri un nome utente e una password che puoi usare per eseguire i comandi dell'amministratore.
Per completare la configurazione dell'ambiente di sviluppo, aggiorna il software della macchina virtuale e installa gli strumenti.
**Per configurare la macchina virtuale**
1. Aggiorna il software fornito con Ubuntu.
```
$ sudo apt update && sudo apt upgrade -y && sudo apt autoremove
```
1. Installa gli strumenti di sviluppo con apt.
```
$ sudo apt install unzip python3-pip
```
1. Installa le librerie Python con pip.
```
$ pip3 install awscli panoramacli
```
1. Apri un nuovo terminale, quindi esegui `aws configure` per configurare. AWS CLI
```
$ aws configure
```
Se non disponi delle chiavi di accesso, puoi generarle nella [console IAM](https://console.aws.amazon.com/iamv2/home?#/users).
Infine, scarica e importa l'applicazione di esempio.
**Per scaricare l'applicazione di esempio**
1. Scaricate ed estraete l'applicazione di esempio.
```
$ 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. Esegui gli script inclusi per testare la compilazione, creare il contenitore di applicazioni e caricare pacchetti su 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
```
L'interfaccia a riga di comando dell'applicazione AWS Panorama carica i pacchetti e li registra con il servizio AWS Panorama. Ora puoi [distribuire l'app di esempio con la](gettingstarted-deploy.md#gettingstarted-deploy-deploy) console AWS Panorama.
## Passaggi successivi
Per esplorare e modificare i file di progetto, puoi utilizzare File Explorer o un ambiente di sviluppo integrato (IDE) che supporti WSL.
Per accedere al file system della macchina virtuale, apri File explorer ed entra `\\wsl$` nella barra di navigazione. Questa directory contiene un collegamento al file system (`Ubuntu-20.04`) e ai file system della macchina virtuale per i dati di Docker. Sotto`Ubuntu-20.04`, la tua directory utente si trova in`home\username`.
**Nota**
Per accedere ai file dell'installazione di Windows da Ubuntu, accedi alla `/mnt/c` directory. Ad esempio, puoi elencare i file nella directory dei download eseguendo`ls /mnt/c/Users/windows-username/Downloads`.
Con Visual Studio Code, puoi modificare il codice dell'applicazione nell'ambiente di sviluppo ed eseguire comandi con un terminale integrato. Per installare Visual Studio Code, visita [code.visualstudio.com](https://code.visualstudio.com/). [Dopo l'installazione, aggiungi l'estensione Remote WSL.](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-wsl)
Il terminale Windows è un'alternativa al terminale Ubuntu standard in cui hai eseguito i comandi. Supporta più schede e può essere eseguito PowerShell, Command Prompt e terminali per qualsiasi altra varietà di Linux installata. Supporta il copia e incolla Ctrl V , la Ctrl C funzionalità cliccabile URLs e altri miglioramenti utili. [Per installare Windows Terminal, visita microsoft.com.](https://www.microsoft.com/en-us/p/windows-terminal/9n0dx20hk701)