Avis de fin de support : le 31 mai 2026, AWS le support de AWS Panorama. Après le 31 mai 2026, vous ne pourrez plus accéder à la AWS Panorama console ni aux AWS Panorama ressources. Pour plus d'informations, voir [AWS Panorama fin du support](https://docs.aws.amazon.com/panorama/latest/dev/panorama-end-of-support.html). 

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Automatisez le déploiement des applications
<a name="api-deploy"></a>

Pour déployer une application, vous utilisez à la fois la CLI de l'application AWS Panorama et AWS Command Line Interface. Après avoir créé le conteneur d'applications, vous le chargez, ainsi que d'autres actifs, sur un point d'accès Amazon S3. Vous déployez ensuite l'application avec l'[CreateApplicationInstance](https://docs.aws.amazon.com/panorama/latest/api/API_CreateApplicationInstance.html)API.

Pour plus de contexte et d'instructions sur l'utilisation des scripts présentés, suivez les instructions de l'[exemple d'application README](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/README.md).

**Topics**
+ [Construisez le conteneur](#api-deploy-build)
+ [Téléchargez le conteneur et enregistrez les nœuds](#api-deploy-upload)
+ [Déployer l'application](#api-deploy-deploy)
+ [Surveiller le déploiement](#api-deploy-monitor)

## Construisez le conteneur
<a name="api-deploy-build"></a>

Pour créer le conteneur d'applications, utilisez la `build-container` commande. Cette commande crée un conteneur Docker et l'enregistre sous forme de système de fichiers compressé dans le `assets` dossier.

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

Vous pouvez également utiliser la complétion par ligne de commande pour renseigner l'argument du chemin en saisissant une partie du chemin, puis en appuyant sur. TAB

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

## Téléchargez le conteneur et enregistrez les nœuds
<a name="api-deploy-upload"></a>

Pour télécharger l'application, utilisez la `package-application` commande. Cette commande télécharge les ressources du `assets` dossier vers un point d'accès Amazon S3 géré par 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
```

 La CLI de l'application AWS Panorama télécharge les ressources de conteneur et de descripteur référencées par la configuration du package (`package.json`) dans chaque package, et enregistre les packages en tant que nœuds dans AWS Panorama. Vous vous référez ensuite à ces nœuds dans le manifeste de votre application (`graph.json`) pour déployer l'application.

## Déployer l'application
<a name="api-deploy-deploy"></a>

Pour déployer l'application, vous devez utiliser l'[CreateApplicationInstance](https://docs.aws.amazon.com/panorama/latest/api/API_CreateApplicationInstance.html)API. Cette action utilise, entre autres, les paramètres suivants.

****
+ `ManifestPayload`— Le manifeste de l'application (`graph.json`) qui définit les nœuds, les packages, les bords et les paramètres de l'application.
+ `ManifestOverridesPayload`— Un deuxième manifeste qui remplace les paramètres du premier. Le manifeste de l'application peut être considéré comme une ressource statique dans la source de l'application, où le manifeste de remplacement fournit des paramètres d'heure de déploiement qui personnalisent le déploiement.
+ `DefaultRuntimeContextDevice`— L'appareil cible.
+ `RuntimeRoleArn`— L'ARN d'un rôle IAM que l'application utilise pour accéder aux services et ressources AWS.
+ `ApplicationInstanceIdToReplace`— L'ID d'une instance d'application existante à supprimer de l'appareil.

Les charges utiles du manifeste et du remplacement sont des documents JSON qui doivent être fournis sous forme de valeur de chaîne imbriquée dans un autre document. Pour ce faire, le script charge les manifestes d'un fichier sous forme de chaîne et utilise l'[outil jq](https://stedolan.github.io/jq/) pour créer le document imbriqué.

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

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

Le script de déploiement utilise l'[ListDevices](https://docs.aws.amazon.com/panorama/latest/api/API_ListDevices.html)API pour obtenir une liste des appareils enregistrés dans la région actuelle et enregistre le choix de l'utilisateur dans un fichier local pour les déploiements ultérieurs.

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

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

Le rôle d'application est créé par un autre script ([1-create-role.sh](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/1-create-role.sh)). Le script de déploiement obtient l'ARN de ce rôle à partir de AWS CloudFormation. Si l'application est déjà déployée sur le périphérique, le script obtient l'ID de cette instance d'application à partir d'un fichier local.

**Example [5-deploy.sh](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/5-deploy.sh) — ARN du rôle et arguments de remplacement**  

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

Enfin, le script réunit tous les éléments pour créer une instance d'application et déployer l'application sur l'appareil. Le service répond avec un ID d'instance que le script stocke pour une utilisation ultérieure.

**Example [5-deploy.sh](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/5-deploy.sh) — déploiement de l'application**  

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

## Surveiller le déploiement
<a name="api-deploy-monitor"></a>

Pour surveiller un déploiement, utilisez l'[ListApplicationInstances](https://docs.aws.amazon.com/panorama/latest/api/API_ListApplicationInstances.html)API. Le script monitor obtient l'ID du périphérique et l'ID de l'instance de l'application à partir des fichiers du répertoire de l'application et les utilise pour créer une commande CLI. Il lance ensuite un appel en boucle.

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

Une fois le déploiement terminé, vous pouvez consulter les journaux en appelant l'API Amazon CloudWatch Logs. Le script View Logs utilise l'`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
```