Automatisieren Sie die Anwendungsbereitstellung - AWS Panorama
Baue den ContainerLaden Sie den Container hoch und registrieren Sie die KnotenBereitstellen der AnwendungÜberwachen Sie den Einsatz

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Automatisieren Sie die Anwendungsbereitstellung

Um eine Anwendung bereitzustellen, verwenden Sie sowohl die AWS Panorama Application CLI als auchAWS Command Line Interface. Nachdem Sie den Anwendungscontainer erstellt haben, laden Sie ihn und andere Assets auf einen Amazon S3-Access Point hoch. Anschließend stellen Sie die Anwendung mit dem bereitCreateApplicationInstanceAPI.

Weitere Informationen und Anweisungen zur Verwendung der abgebildeten Skripts finden Sie in derBeispielanwendung README.

Baue den Container

Um den Anwendungscontainer zu erstellen, verwenden Sie denbuild-containerBefehl. Dieser Befehl erstellt einen Docker-Container und speichert ihn als komprimiertes Dateisystem imassetsOrdner.

Beispiel 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

Sie können auch die Befehlszeilenvervollständigung verwenden, um das Pfadargument auszufüllen, indem Sie einen Teil des Pfads eingeben und dann drückenTAB.

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

Laden Sie den Container hoch und registrieren Sie die Knoten

Um die Bewerbung hochzuladen, verwenden Sie denpackage-applicationBefehl. Dieser Befehl lädt Assets aus dem hochassetsOrdner zu einem Amazon S3-Zugriffspunkt, den AWS Panorama verwaltet.

Beispiel 4-package-app.sh
panorama-cli package-application

Die CLI der AWS Panorama-Anwendung lädt Container- und Deskriptor-Assets hoch, auf die in der Paketkonfiguration verwiesen wird (package.json) in jedem Paket und registriert die Pakete als Knoten in AWS Panorama. Anschließend verweisen Sie in Ihrem Anwendungsmanifest auf diese Knoten (graph.json), um die Anwendung bereitzustellen.

Bereitstellen der Anwendung

Um die Anwendung bereitzustellen, verwenden Sie denCreateApplicationInstanceAPI. Diese Aktion verwendet unter anderem die folgenden Parameter.

  • ManifestPayload— Das Anwendungsmanifest (graph.json), das die Knoten, Pakete, Kanten und Parameter der Anwendung definiert.

  • ManifestOverridesPayload— Ein zweites Manifest, das die Parameter im ersten Manifest außer Kraft setzt. Das Anwendungsmanifest kann als statische Ressource in der Anwendungsquelle betrachtet werden, wobei das Override-Manifest Einstellungen für die Bereitstellungszeit bereitstellt, mit denen die Bereitstellung angepasst werden kann.

  • DefaultRuntimeContextDevice— Das Zielgerät.

  • RuntimeRoleArn— Der ARN einer IAM-Rolle, die die Anwendung für den Zugriff auf AWS-Services und -Ressourcen verwendet.

  • ApplicationInstanceIdToReplace— Die ID einer vorhandenen Anwendungsinstanz, die vom Gerät entfernt werden soll.

Die Payloads Manifest und Override sind JSON-Dokumente, die als Zeichenfolgenwert bereitgestellt werden müssen, der in einem anderen Dokument verschachtelt ist. Dazu lädt das Skript die Manifeste aus einer Datei als String und verwendet diejq-Toolum das verschachtelte Dokument zu erstellen.

Beispiel 5-deploy.sh— Manifeste verfassen

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

Das Deploy-Skript verwendet dieListDevicesAPI zum Abrufen einer Liste registrierter Geräte in der aktuellen Region und speichert die Auswahl des Benutzers in einer lokalen Datei für nachfolgende Bereitstellungen.

Beispiel 5-deploy.sh— finde ein Gerät
    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)

Die Anwendungsrolle wird durch ein anderes Skript erstellt (1-create-role.sh). Das Deploy-Skript ruft den ARN dieser Rolle ab vonAWS CloudFormation. Wenn die Anwendung bereits auf dem Gerät bereitgestellt ist, ruft das Skript die ID dieser Anwendungsinstanz aus einer lokalen Datei ab.

Beispiel 5-deploy.sh— Rollen-ARN und Ersatzargumente
# 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

Schließlich setzt das Skript alle Teile zusammen, um eine Anwendungsinstanz zu erstellen und die Anwendung auf dem Gerät bereitzustellen. Der Dienst antwortet mit einer Instanz-ID, die das Skript für die spätere Verwendung speichert.

Beispiel 5-deploy.sh— Anwendung bereitstellen
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

Überwachen Sie den Einsatz

Um ein Deployment zu überwachen, verwenden Sie denListApplicationInstancesAPI. Das Monitor-Skript ruft die Geräte-ID und die Anwendungsinstanz-ID aus Dateien im Anwendungsverzeichnis ab und verwendet sie, um einen CLI-Befehl zu erstellen. Es ruft dann in einer Schleife auf.

Beispiel 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

Wenn die Bereitstellung abgeschlossen ist, können Sie die Protokolle einsehen, indem Sie Amazon anrufenCloudWatchProtokollierungs-API. Das View-Logs-Skript verwendet dieCloudWatchLogsGetLogEventsAPI.

Beispiel 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