Automatización de las implementaciones de aplicaciones

Para implementar una aplicación, debe utilizar la CLI de la aplicación AWS Panorama y AWS Command Line Interface. Tras crear el contenedor de la aplicación, debe cargar este y otros recursos a un punto de acceso de Amazon S3. A continuación, implemente la aplicación con la API CreateApplicationInstance.

Para obtener más contexto e instrucciones sobre el uso de los scripts que se muestran, siga las instrucciones del README de la aplicación de ejemplo.

Cree el contenedor

Para crear el contenedor de aplicaciones, utilice el comando build-container. Este comando crea un contenedor de Docker y lo guarda como un sistema de archivos comprimido en la carpeta assets.

ejemplo 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

También puede utilizar la opción de completar la línea de comandos para rellenar el argumento de la ruta; para ello, escriba parte de la ruta y, a continuación, presione TAB.

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

Cargue el contenedor y registre los nodos

Para cargar la aplicación, utilice el comando package-application. Este comando carga recursos de la carpeta de assets a un punto de acceso de Amazon S3 que administra AWS Panorama.

ejemplo 4-package-app.sh

panorama-cli package-application

La CLI de la aplicación AWS Panorama carga los activos de contenedores y descriptores a los que hace referencia la configuración del paquete (package.json) en cada paquete y los registra como nodos en AWS Panorama. A continuación, consulte estos nodos en el manifiesto de la aplicación (graph.json) para implementar la aplicación.

Implementación de la aplicación

Para implementar la aplicación, utilice la API CreateApplicationInstance. Esta acción requiere, entre otros, los siguientes parámetros.

• ManifestPayload: el manifiesto de la aplicación (graph.json) que define los nodos, paquetes, periferias y parámetros de la aplicación.

• ManifestOverridesPayload: un segundo manifiesto que anula los parámetros del primero. El manifiesto de la aplicación se puede considerar un recurso estático en la fuente de la aplicación, mientras que el manifiesto de anulación proporciona ajustes en el momento de la implementación que personalizan la implementación.

• DefaultRuntimeContextDevice: el dispositivo de destino.

• RuntimeRoleArn: el ARN de un rol de IAM que la aplicación utiliza para acceder a los servicios y recursos de AWS.

• ApplicationInstanceIdToReplace: el ID de una instancia de aplicación existente que se va a eliminar del dispositivo.

Las cargas útiles de manifiesto y anulación son documentos JSON que deben proporcionarse como un valor de cadena anidado dentro de otro documento. Para ello, el script carga los manifiestos de un archivo en forma de cadena y utiliza la herramienta jq para construir el documento anidado.

ejemplo 5-deploy.sh: redacta manifiestos

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

El script de implementación usa la API ListDevices para obtener una lista de los dispositivos registrados en la región actual y guarda la elección del usuario en un archivo local para implementaciones posteriores.

ejemplo 5-deploy.sh: busca 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)

El rol de la aplicación se crea mediante otro script (1-create-role.sh). El script de implementación obtiene el ARN de este rol a partir de AWS CloudFormation. Si la aplicación ya está implementada en el dispositivo, el script obtiene el ID de esa instancia de la aplicación de un archivo local.

ejemplo 5-deploy.sh: ARN del rol y argumentos de reemplazo

# 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 último, el script reúne todas las piezas para crear una instancia de aplicación e implementar la aplicación en el dispositivo. El servicio responde con un ID de instancia que el script almacena para su uso posterior.

ejemplo 5-deploy.sh: implementa la aplicación

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

Monitorice la implementación

Para supervisar una implementación, utilice la API ListApplicationInstances. El script del monitor obtiene el ID del dispositivo y el ID de la instancia de la aplicación de los archivos del directorio de la aplicación y los utiliza para construir un comando CLI. A continuación, realiza una llamada en bucle.

ejemplo 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

Cuando se complete la implementación, podrá ver los registros llamando a la API de los Registros de Amazon CloudWatch. El script Ver registros utiliza la API GetLogEvents de Registros de CloudWatch.

ejemplo 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