Aviso de fim do suporte: em 31 de maio de 2026, AWS encerrará o suporte para AWS Panorama. Depois de 31 de maio de 2026, você não poderá mais acessar o AWS Panorama console ou os AWS Panorama recursos. Para obter mais informações, consulte [AWS Panorama Fim do suporte](https://docs.aws.amazon.com/panorama/latest/dev/panorama-end-of-support.html). 

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Automatização da implantação da aplicação
<a name="api-deploy"></a>

Para implantar um aplicativo, você usa o AWS Panorama Application CLI e. AWS Command Line Interface Depois de criar o contêiner da aplicação, faça o upload dele e de outros ativos para um ponto de acesso Amazon S3. Em seguida, você implanta o aplicativo com a [CreateApplicationInstance](https://docs.aws.amazon.com/panorama/latest/api/API_CreateApplicationInstance.html)API.

Para obter mais contexto e instruções sobre como usar os scripts mostrados, siga as instruções no [README da aplicação de exemplo](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/README.md).

**Topics**
+ [Crie o contêiner](#api-deploy-build)
+ [Upload do contêiner e registro dos nós](#api-deploy-upload)
+ [Implantar a aplicação](#api-deploy-deploy)
+ [Monitore a implantação](#api-deploy-monitor)

## Crie o contêiner
<a name="api-deploy-build"></a>

Para criar o contêiner da aplicação, use o comando `build-container`. Esse comando cria um contêiner do Docker e o salva como um sistema de arquivos compactado na pasta `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
```

Você também pode usar o preenchimento da linha de comando para preencher o argumento do caminho digitando parte do caminho e pressionando TAB.

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

## Upload do contêiner e registro dos nós
<a name="api-deploy-upload"></a>

Para carregar a aplicação, use o comando `package-application`. Esse comando carrega ativos da pasta `assets` para um ponto de acesso Amazon S3 que o AWS Panorama gerencia.

**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
```

 A CLI da aplicação do AWS Panorama carrega ativos de contêineres e descritores referenciados pela configuração do pacote (`package.json`) em cada pacote e registra os pacotes como nós no AWS Panorama. Em seguida, referencie esses nós no seu manifesto (`graph.json`) da aplicação para implantar a aplicação.

## Implantar a aplicação
<a name="api-deploy-deploy"></a>

Para implantar o aplicativo, você usa a [CreateApplicationInstance](https://docs.aws.amazon.com/panorama/latest/api/API_CreateApplicationInstance.html)API. Essa ação usa os seguintes parâmetros, entre outros.

****
+ `ManifestPayload`: o manifesto da aplicação (`graph.json`) que define os nós, pacotes, bordas e parâmetros da aplicação.
+ `ManifestOverridesPayload`: um segundo manifesto que substitui os parâmetros do primeiro. O manifesto da aplicação pode ser considerado um recurso estático na origem da aplicação, em que o manifesto de substituição fornece configurações de tempo de implantação que personalizam a implantação.
+ `DefaultRuntimeContextDevice`: o dispositivo de destino.
+ `RuntimeRoleArn`: o ARN de um perfil do IAM que a aplicação usa para acessar os serviços e recursos da AWS.
+ `ApplicationInstanceIdToReplace`: o ID de uma instância de aplicação existente a ser removida do dispositivo.

O manifesto e as cargas de substituição são documentos JSON que devem ser fornecidos como um valor de string aninhado dentro de outro documento. Para fazer isso, o script carrega os manifestos de um arquivo como uma string e usa a [ferramenta jq](https://stedolan.github.io/jq/) para construir o documento aninhado.

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

```
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)"' <<< {})"
```

O script de implantação usa a [ListDevices](https://docs.aws.amazon.com/panorama/latest/api/API_ListDevices.html)API para obter uma lista de dispositivos registrados na região atual e salva a escolha do usuário em um arquivo local para implantações subsequentes.

**Example [5-deploy.sh](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/5-deploy.sh): encontre um 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)
```

O perfil da aplicação é criado por outro script ([1-create-role.sh](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/1-create-role.sh)). O script de implantação obtém o ARN dessa função de. AWS CloudFormation Se a aplicação já estiver implantada no dispositivo, o script obterá o ID dessa instância da aplicação a partir de um arquivo local.

**Example [5-deploy.sh](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/5-deploy.sh): ARN do perfil e argumentos de substituição**  

```
# 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
```

Por fim, o script reúne todas as peças para criar uma instância da aplicação e implantar a aplicação no dispositivo. O serviço responde com um ID de instância que o script armazena para uso posterior.

**Example [5-deploy.sh](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/5-deploy.sh): implante a aplicação**  

```
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
```

## Monitore a implantação
<a name="api-deploy-monitor"></a>

Para monitorar uma implantação, use a [ListApplicationInstances](https://docs.aws.amazon.com/panorama/latest/api/API_ListApplicationInstances.html)API. O script de monitor obtém o ID do dispositivo e o ID da instância da aplicação dos arquivos no diretório da aplicação e os usa para criar um comando da CLI. Em seguida, ele chama em um 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
```

Quando a implantação for concluída, você poderá visualizar os registros chamando a API Amazon CloudWatch Logs. O script de visualização de registros usa a `GetLogEvents` API CloudWatch Logs.

**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
```