Implementazione di un'applicazione

Per distribuire un'applicazione, devi utilizzare l'interfaccia a riga di comando dell'applicazione AWS Panorama, importarla nel tuo account, creare il contenitore, caricare e registrare risorse e creare un'istanza dell'applicazione. In questo argomento vengono descritti in dettaglio ciascuno di questi passaggi e viene descritto ciò che accade in background.

Se non hai ancora distribuito un'applicazione, consulta Nozioni di base su AWS Panorama la procedura dettagliata.

Per ulteriori informazioni sulla personalizzazione e l'estensione dell'applicazione di esempio, vedere. In fase di creazioneAWS Panoramaapplicazioni

Installa l'interfaccia a riga di comando dell'applicazione AWS Panorama

Per installare l'interfaccia a riga di comando dell'applicazione AWS PanoramaAWS CLI, usa pip.

$ pip3 install --upgrade awscli panoramacli

Per creare immagini di applicazioni con l'interfaccia a riga di comando dell'applicazione AWS Panorama, hai bisogno di Docker. Su Linux sono necessarie anche le librerie di sistema correlate. qemu Per ulteriori informazioni sull'installazione e la configurazione dell'interfaccia a riga di comando dell'applicazione AWS Panorama, consulta il file README nel repository del progetto. GitHub

• github.com/aws/ aws-panorama-cli

Per istruzioni sulla configurazione di un ambiente di compilazione in Windows con WSL2, vedere. Configurazione di un ambiente di sviluppo in Windows

Importazione di un'applicazione

Se lavori con un'applicazione di esempio o un'applicazione fornita da una terza parte, utilizza l'interfaccia a riga di comando dell'applicazione AWS Panorama per importare l'applicazione.

my-app$ panorama-cli import-application

Questo comando rinomina i pacchetti delle applicazioni con l'ID del tuo account. I nomi dei pacchetti iniziano con l'ID dell'account su cui sono distribuiti. Quando distribuisci un'applicazione su più account, devi importare e impacchettare l'applicazione separatamente per ogni account.

Ad esempio, l'applicazione di esempio di questa guida, un pacchetto di codice e un pacchetto modello, ciascuno denominato con un ID account segnaposto. Il import-application comando li rinomina per utilizzare l'ID account che la CLI deduce dalle credenziali del tuo spazio di lavoro. AWS

/aws-panorama-sample
├── assets
├── graphs
│   └── my-app
│       └── graph.json
└── packages
    ├── 123456789012-SAMPLE_CODE-1.0
    │   ├── Dockerfile
    │   ├── application.py
    │   ├── descriptor.json
    │   ├── package.json
    │   ├── requirements.txt
    │   └── squeezenet_classes.json
    └── 123456789012-SQUEEZENET_PYTORCH-1.0
        ├── descriptor.json
        └── package.json

123456789012viene sostituito dall'ID dell'account nei nomi delle directory dei pacchetti e nell'applicazione manifest (graph.json), che fa riferimento ad essi. Puoi confermare l'ID del tuo account chiamando aws sts get-caller-identity con ilAWS CLI.

$ aws sts get-caller-identity
{
    "UserId": "AIDAXMPL7W66UC3GFXMPL",
    "Account": "210987654321",
    "Arn": "arn:aws:iam::210987654321:user/devenv"
}

Crea un'immagine del contenitore

Il codice dell'applicazione è contenuto in un'immagine contenitore Docker, che include il codice dell'applicazione e le librerie che installi nel tuo Dockerfile. Usa il build-container comando AWS Panorama Application CLI per creare un'immagine Docker ed esportare un'immagine del file system.

my-app$ panorama-cli build-container --container-asset-name code_asset --package-path packages/210987654321-SAMPLE_CODE-1.0
{
    "name": "code_asset",
    "implementations": [
        {
            "type": "container",
            "assetUri": "5fa5xmplbc8c16bf8182a5cb97d626767868d3f4d9958a4e49830e1551d227c5.tar.gz",
            "descriptorUri": "1872xmpl129481ed053c52e66d6af8b030f9eb69b1168a29012f01c7034d7a8f.json"
        }
    ]
}
Container asset for the package has been succesfully built at assets/5fa5xmplbc8c16bf8182a5cb97d626767868d3f4d9958a4e49830e1551d227c5.tar.gz

Questo comando crea un'immagine Docker denominata code_asset ed esporta un file system in un .tar.gz archivio nella cartella. assets L'interfaccia a riga di comando estrae l'immagine di base dell'applicazione da Amazon Elastic Container Registry (Amazon ECR), come specificato nel Dockerfile dell'applicazione.

Oltre all'archivio del contenitore, la CLI crea una risorsa per il descrittore del pacchetto ()descriptor.json. Entrambi i file vengono rinominati con un identificatore univoco che riflette un hash del file originale. L'interfaccia a riga di comando dell'applicazione AWS Panorama aggiunge anche un blocco alla configurazione del pacchetto che registra i nomi delle due risorse. Questi nomi vengono utilizzati dall'appliance durante il processo di installazione.

Esempio packages/123456789012-sample_code-1.0/package.json — con blocco di risorse

{
    "nodePackage": {
        "envelopeVersion": "2021-01-01",
        "name": "SAMPLE_CODE",
        "version": "1.0",
        "description": "Computer vision application code.",
        "assets": [
            {
                "name": "code_asset",
                "implementations": [
                    {
                        "type": "container",
                        "assetUri": "5fa5xmplbc8c16bf8182a5cb97d626767868d3f4d9958a4e49830e1551d227c5.tar.gz",
                        "descriptorUri": "1872xmpl129481ed053c52e66d6af8b030f9eb69b1168a29012f01c7034d7a8f.json"
                    }
                ]
            }
        ],
        "interfaces": [
            {
                "name": "interface",
                "category": "business_logic",
                "asset": "code_asset",
                "inputs": [
                    {
                        "name": "video_in",
                        "type": "media"
                    },

Il nome della risorsa di codice, specificato nel build-container comando, deve corrispondere al valore del asset campo nella configurazione del pacchetto. Nell'esempio precedente, entrambi i valori sonocode_asset.

Importa un modello

L'applicazione potrebbe avere un archivio modello nella cartella delle risorse o che si scarica separatamente. Se hai un nuovo modello, un modello aggiornato o un file descrittore del modello aggiornato, usa il add-raw-model comando per importarlo.

my-app$ panorama-cli add-raw-model --model-asset-name model_asset \
      --model-local-path my-model.tar.gz \
      --descriptor-path packages/210987654321-SQUEEZENET_PYTORCH-1.0/descriptor.json \
      --packages-path packages/210987654321-SQUEEZENET_PYTORCH-1.0

Se hai solo bisogno di aggiornare il file descrittore, puoi riutilizzare il modello esistente nella directory assets. Potrebbe essere necessario aggiornare il file descrittore per configurare funzionalità come la modalità di precisione a virgola mobile. Ad esempio, il seguente script mostra come eseguire questa operazione con l'app di esempio.

Esempio util-script/ .sh update-model-config

#!/bin/bash
set -eo pipefail
MODEL_ASSET=fd1axmplacc3350a5c2673adacffab06af54c3f14da6fe4a8be24cac687a386e
MODEL_PACKAGE=SQUEEZENET_PYTORCH
ACCOUNT_ID=$(ls packages | grep -Eo '[0-9]{12}' | head -1)
panorama-cli add-raw-model --model-asset-name model_asset --model-local-path assets/${MODEL_ASSET}.tar.gz --descriptor-path packages/${ACCOUNT_ID}-${MODEL_PACKAGE}-1.0/descriptor.json --packages-path packages/${ACCOUNT_ID}-${MODEL_PACKAGE}-1.0
cp packages/${ACCOUNT_ID}-${MODEL_PACKAGE}-1.0/package.json packages/${ACCOUNT_ID}-${MODEL_PACKAGE}-1.0/package.json.bup

Le modifiche al file descrittore nella directory del pacchetto del modello non vengono applicate finché non lo si reimporta con la CLI. La CLI aggiorna la configurazione del pacchetto modello con i nuovi nomi delle risorse, in modo simile a come aggiorna la configurazione del pacchetto di codice dell'applicazione quando si ricostruisce un contenitore.

Caricare le risorse dell'applicazione

Per caricare e registrare le risorse dell'applicazione, che includono l'archivio del modello, l'archivio del file system contenitore e i relativi file descrittori, utilizzate il comando. package-application

my-app$ panorama-cli package-application
Uploading package SQUEEZENET_PYTORCH
Patch version for the package 5d3cxmplb7113faa1d130f97f619655d8ca12787c751851a0e155e50eb5e3e96
Deregistering previous patch version e845xmpl8ea0361eb345c313a8dded30294b3a46b486dc8e7c174ee7aab29362
Asset fd1axmplacc3350a5c2673adacffab06af54c3f14da6fe4a8be24cac687a386e.tar.gz already exists, ignoring upload
upload: assets/87fbxmpl6f18aeae4d1e3ff8bbc6147390feaf47d85b5da34f8374974ecc4aaf.json to s3://arn:aws:s3:us-east-2:212345678901:accesspoint/panorama-210987654321-6k75xmpl2jypelgzst7uux62ye/210987654321/nodePackages/SQUEEZENET_PYTORCH/binaries/87fbxmpl6f18aeae4d1e3ff8bbc6147390feaf47d85b5da34f8374974ecc4aaf.json
Called register package version for SQUEEZENET_PYTORCH with patch version 5d3cxmplb7113faa1d130f97f619655d8ca12787c751851a0e155e50eb5e3e96
...

Se non ci sono modifiche a un file di risorse o alla configurazione del pacchetto, la CLI lo ignora.

Uploading package SAMPLE_CODE
Patch Version ca91xmplca526fe3f07821fb0c514f70ed0c444f34cb9bd3a20e153730b35d70 already registered, ignoring upload
Register patch version complete for SQUEEZENET_PYTORCH with patch version 5d3cxmplb7113faa1d130f97f619655d8ca12787c751851a0e155e50eb5e3e96
Register patch version complete for SAMPLE_CODE with patch version ca91xmplca526fe3f07821fb0c514f70ed0c444f34cb9bd3a20e153730b35d70
All packages uploaded and registered successfully

L'interfaccia a riga di comando carica le risorse per ogni pacchetto su un punto di accesso Amazon S3 specifico per il tuo account. AWS Panorama gestisce il punto di accesso per te e fornisce informazioni su di esso tramite l'DescribePackageAPI. L'interfaccia a riga di comando carica le risorse per ogni pacchetto nella posizione fornita per quel pacchetto e le registra con il servizio AWS Panorama con le impostazioni descritte dalla configurazione del pacchetto.

Implementa un'applicazione con la console AWS Panorama

Puoi distribuire un'applicazione con la console AWS Panorama. Durante il processo di distribuzione, scegli quali stream di videocamere passare al codice dell'applicazione e configuri le opzioni fornite dallo sviluppatore dell'applicazione.

Per distribuire un'applicazione

1. Apri la pagina Applicazioni distribuite sulla console AWS Panorama.

2. Scegli Deploy application.

3. Incolla il contenuto del manifesto dell'applicazionegraph.json, nell'editor di testo. Seleziona Successivo.

4. Inserisci un nome e una descrizione.

5. Scegli Procedi alla distribuzione.

6. Scegli Inizia la distribuzione.

7. Se la tua applicazione utilizza un ruolo, sceglilo dal menu a discesa. Seleziona Successivo.

8. Scegli Seleziona dispositivo, quindi scegli il tuo elettrodomestico. Seleziona Successivo.

9. Nella fase Seleziona fonti di dati, scegli Visualizza input e aggiungi lo stream della videocamera come fonte di dati. Seleziona Successivo.

10. Nella fase Configurazione, configura tutte le impostazioni specifiche dell'applicazione definite dallo sviluppatore. Seleziona Successivo.

11. Scegli Distribuisci, quindi scegli Fine.

12. Nell'elenco delle applicazioni distribuite, scegli l'applicazione per monitorarne lo stato.

Il processo di installazione richiede 15-20 minuti. L'uscita dell'appliance può rimanere vuota per un periodo prolungato durante l'avvio dell'applicazione. Se riscontri un errore, consultaRisoluzione dei problemi.

Automatizza la distribuzione delle applicazioni

Puoi automatizzare il processo di distribuzione delle applicazioni con l'CreateApplicationInstanceAPI. L'API accetta due file di configurazione come input. Il manifesto dell'applicazione specifica i pacchetti utilizzati e le relative relazioni. Il secondo file è un file di sostituzioni che specifica le sostituzioni dei valori nel manifesto dell'applicazione in fase di distribuzione. L'utilizzo di un file di sostituzione consente di utilizzare lo stesso manifesto dell'applicazione per distribuire l'applicazione con diversi flussi di telecamere e configurare altre impostazioni specifiche dell'applicazione.

Per ulteriori informazioni e script di esempio per ciascuno dei passaggi di questo argomento, vedereAutomatizza la distribuzione delle applicazioni.