Automatisez le déploiement des applications - AWS Panorama
Construisez le conteneurTéléchargez le conteneur et enregistrez les nœudsDéployer l'applicationSurveiller le déploiement

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

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'CreateApplicationInstanceAPI.

Pour plus de contexte et d'instructions sur l'utilisation des scripts présentés, suivez les instructions de l'exemple d'application README.

Construisez le conteneur

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.

Exemple 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

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.

Exemple 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

Pour déployer l'application, vous devez utiliser l'CreateApplicationInstanceAPI. 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 pour créer le document imbriqué.

Exemple 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'ListDevicesAPI 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.

Exemple 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). 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.

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

Exemple 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

Pour surveiller un déploiement, utilisez l'ListApplicationInstancesAPI. 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.

Exemple 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'GetLogEventsAPI CloudWatch Logs.

Exemple 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