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à.
# 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.