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

# Automatizza la distribuzione delle applicazioni
<a name="api-deploy"></a>

Per distribuire un'applicazione, usi sia la AWS Command Line Interface CLI dell'applicazione AWS Panorama che. Dopo aver creato il contenitore dell'applicazione, lo carichi insieme ad altre risorse su un punto di accesso Amazon S3. Quindi distribuisci l'applicazione con l'[CreateApplicationInstance](https://docs.aws.amazon.com/panorama/latest/api/API_CreateApplicationInstance.html)API.

Per ulteriori informazioni e istruzioni sull'uso degli script mostrati, segui le istruzioni nell'[applicazione di esempio README](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/README.md).

**Topics**
+ [Costruisci il contenitore](#api-deploy-build)
+ [Caricate il contenitore e registrate i nodi](#api-deploy-upload)
+ [Distribuzione dell’applicazione](#api-deploy-deploy)
+ [Monitora la distribuzione](#api-deploy-monitor)

## Costruisci il contenitore
<a name="api-deploy-build"></a>

Per creare il contenitore dell'applicazione, usa il `build-container` comando. Questo comando crea un contenitore Docker e lo salva come file system compresso nella cartella. `assets`

**Example [3-build-container.sh](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/3-build-container.sh)**  

```
CODE_PACKAGE=SAMPLE_CODE
ACCOUNT_ID=$(aws sts get-caller-identity --output text --query 'Account')
panorama-cli build-container --container-asset-name code_asset --package-path packages/${ACCOUNT_ID}-${CODE_PACKAGE}-1.0
```

È inoltre possibile utilizzare il completamento dalla riga di comando per inserire l'argomento del percorso digitando una parte del percorso e quindi premendo. TAB

```
$ panorama-cli build-container --package-path packages/TAB
```

## Caricate il contenitore e registrate i nodi
<a name="api-deploy-upload"></a>

Per caricare l'applicazione, usa il `package-application` comando. Questo comando carica le risorse dalla `assets` cartella su un punto di accesso Amazon S3 gestito da AWS Panorama.

**Example [4-package-app.sh](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/4-package-app.sh)**  

```
panorama-cli package-application
```

 L'interfaccia a riga di comando dell'applicazione AWS Panorama carica gli asset container e descrittori a cui fa riferimento la configurazione del pacchetto (`package.json`) in ogni pacchetto e registra i pacchetti come nodi in AWS Panorama. Fai quindi riferimento a questi nodi nel manifesto dell'applicazione (`graph.json`) per distribuire l'applicazione.

## Distribuzione dell’applicazione
<a name="api-deploy-deploy"></a>

Per distribuire l'applicazione, si utilizza l'[CreateApplicationInstance](https://docs.aws.amazon.com/panorama/latest/api/API_CreateApplicationInstance.html)API. Questa azione richiede, tra gli altri, i seguenti parametri.

****
+ `ManifestPayload`— Il manifesto dell'applicazione (`graph.json`) che definisce i nodi, i pacchetti, i bordi e i parametri dell'applicazione.
+ `ManifestOverridesPayload`— Un secondo manifest che sovrascrive i parametri del primo. Il manifesto dell'applicazione può essere considerato una risorsa statica nell'origine dell'applicazione, dove il manifesto di sostituzione fornisce impostazioni relative alla fase di distribuzione che personalizzano la distribuzione.
+ `DefaultRuntimeContextDevice`— Il dispositivo di destinazione.
+ `RuntimeRoleArn`— L'ARN di un ruolo IAM utilizzato dall'applicazione per accedere ai servizi e alle risorse AWS.
+ `ApplicationInstanceIdToReplace`— L'ID di un'istanza di applicazione esistente da rimuovere dal dispositivo.

I payload manifest e override sono documenti JSON che devono essere forniti come valore di stringa annidato all'interno di un altro documento. A tale scopo, lo script carica i manifest da un file come stringa e utilizza [lo strumento jq per costruire il documento annidato](https://stedolan.github.io/jq/).

**Example [5-deploy.sh — compone i manifesti](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/5-deploy.sh)**  

```
GRAPH_PATH="graphs/my-app/graph.json"
OVERRIDE_PATH="graphs/my-app/override.json"
# application manifest
GRAPH=$(cat ${GRAPH_PATH} | tr -d '\n' | tr -d '[:blank:]')
MANIFEST="$(jq --arg value "${GRAPH}" '.PayloadData="\($value)"' <<< {})"
# manifest override
OVERRIDE=$(cat ${OVERRIDE_PATH} | tr -d '\n' | tr -d '[:blank:]')
MANIFEST_OVERRIDE="$(jq --arg value "${OVERRIDE}" '.PayloadData="\($value)"' <<< {})"
```

Lo script di distribuzione utilizza l'[ListDevices](https://docs.aws.amazon.com/panorama/latest/api/API_ListDevices.html)API per ottenere un elenco di dispositivi registrati nella regione corrente e salva la scelta dell'utente in un file locale per le distribuzioni successive.

**Example [5-deploy.sh: trova](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/5-deploy.sh) un dispositivo**  

```
    echo "Getting devices..."
    DEVICES=$(aws panorama list-devices)
    DEVICE_NAMES=($((echo ${DEVICES} | jq -r '.Devices |=sort_by(.LastUpdatedTime) | [.Devices[].Name] | @sh') | tr -d \'\"))
    DEVICE_IDS=($((echo ${DEVICES} | jq -r '.Devices |=sort_by(.LastUpdatedTime) | [.Devices[].DeviceId] | @sh') | tr -d \'\"))
    for (( c=0; c<${#DEVICE_NAMES[@]}; c++ ))
    do
        echo "${c}: ${DEVICE_IDS[${c}]}     ${DEVICE_NAMES[${c}]}"
    done
    echo "Choose a device"
    read D_INDEX
    echo "Deploying to device ${DEVICE_IDS[${D_INDEX}]}"
    echo -n ${DEVICE_IDS[${D_INDEX}]} > device-id.txt
    DEVICE_ID=$(cat device-id.txt)
```

Il ruolo dell'applicazione viene creato da un altro script ([1-create-role.sh](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/1-create-role.sh)). Lo script di distribuzione ottiene l'ARN di questo ruolo da. AWS CloudFormation Se l'applicazione è già distribuita sul dispositivo, lo script ottiene l'ID di quell'istanza dell'applicazione da un file locale.

**Example [5-deploy.sh](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/5-deploy.sh) — ARN del ruolo e argomenti di sostituzione**  

```
# application role
STACK_NAME=panorama-${NAME}
ROLE_ARN=$(aws cloudformation describe-stacks --stack-name panorama-${PWD##*/} --query 'Stacks[0].Outputs[?OutputKey==`roleArn`].OutputValue' --output text)
ROLE_ARG="--runtime-role-arn=${ROLE_ARN}"

# existing application instance id
if [ -f "application-id.txt" ]; then
    EXISTING_APPLICATION=$(cat application-id.txt)
    REPLACE_ARG="--application-instance-id-to-replace=${EXISTING_APPLICATION}"
    echo "Replacing application instance ${EXISTING_APPLICATION}"
fi
```

Infine, lo script mette insieme tutti i pezzi per creare un'istanza dell'applicazione e distribuire l'applicazione sul dispositivo. Il servizio risponde con un ID di istanza che lo script memorizza per un uso successivo.

**Example [5-deploy.sh](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/5-deploy.sh): distribuisce l'applicazione**  

```
APPLICATION_ID=$(aws panorama create-application-instance ${REPLACE_ARG} --manifest-payload="${MANIFEST}" --default-runtime-context-device=${DEVICE_ID} --name=${NAME} --description="command-line deploy" --tags client=sample --manifest-overrides-payload="${MANIFEST_OVERRIDE}" ${ROLE_ARG} --output text)
echo "New application instance ${APPLICATION_ID}"
echo -n $APPLICATION_ID > application-id.txt
```

## Monitora la distribuzione
<a name="api-deploy-monitor"></a>

Per monitorare una distribuzione, utilizza l'[ListApplicationInstances](https://docs.aws.amazon.com/panorama/latest/api/API_ListApplicationInstances.html)API. Lo script di monitoraggio ottiene l'ID del dispositivo e l'ID dell'istanza dell'applicazione dai file nella directory dell'applicazione e li utilizza per creare un comando CLI. Quindi chiama in loop.

**Example [6-monitor-deployment.sh](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/6-monitor-deployment.sh)**  

```
APPLICATION_ID=$(cat application-id.txt)
DEVICE_ID=$(cat device-id.txt)
QUERY="ApplicationInstances[?ApplicationInstanceId==\`APPLICATION_ID\`]"
QUERY=${QUERY/APPLICATION_ID/$APPLICATION_ID}
MONITOR_CMD="aws panorama list-application-instances --device-id ${DEVICE_ID} --query ${QUERY}"
MONITOR_CMD=${MONITOR_CMD/QUERY/$QUERY}
while true; do
    $MONITOR_CMD
    sleep 60
done
```

Una volta completata la distribuzione, puoi visualizzare i log chiamando l'API Amazon CloudWatch Logs. Lo script di visualizzazione dei log utilizza l'API Logs. CloudWatch `GetLogEvents`

**Example [view-logs.sh](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/util-scripts/view-logs.sh)**  

```
GROUP="/aws/panorama/devices/MY_DEVICE_ID/applications/MY_APPLICATION_ID"
GROUP=${GROUP/MY_DEVICE_ID/$DEVICE_ID}
GROUP=${GROUP/MY_APPLICATION_ID/$APPLICATION_ID}
echo "Getting logs for group ${GROUP}."
#set -x
while true
do
    LOGS=$(aws logs get-log-events --log-group-name ${GROUP} --log-stream-name code_node --limit 150)
    readarray -t ENTRIES < <(echo $LOGS | jq -c '.events[].message')
    for ENTRY in "${ENTRIES[@]}"; do
        echo "$ENTRY" | tr -d \"
    done
    sleep 20
done
```