Hinweis zum Ende des Supports: Am 31. Mai 2026 AWS endet der Support für AWS Panorama. Nach dem 31. Mai 2026 können Sie nicht mehr auf die AWS Panorama Konsole oder AWS Panorama die Ressourcen zugreifen. Weitere Informationen finden Sie unter [AWS Panorama Ende des Supports](https://docs.aws.amazon.com/panorama/latest/dev/panorama-end-of-support.html). 

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
<a name="api-deploy"></a>

Um eine Anwendung bereitzustellen, verwenden Sie sowohl die AWS Panorama Application CLI als auch AWS Command Line Interface. Nachdem Sie den Anwendungscontainer erstellt haben, laden Sie ihn und andere Ressourcen auf einen Amazon S3 S3-Zugriffspunkt hoch. Anschließend stellen Sie die Anwendung mit der [CreateApplicationInstance](https://docs.aws.amazon.com/panorama/latest/api/API_CreateApplicationInstance.html)API bereit.

Weitere Informationen und Anweisungen zur Verwendung der abgebildeten Skripts finden Sie in der [README-Datei der Beispielanwendung](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/README.md).

**Topics**
+ [Erstellen Sie den Container](#api-deploy-build)
+ [Laden Sie den Container hoch und registrieren Sie die Knoten](#api-deploy-upload)
+ [Bereitstellen der Anwendung](#api-deploy-deploy)
+ [Überwachen Sie die Bereitstellung](#api-deploy-monitor)

## Erstellen Sie den Container
<a name="api-deploy-build"></a>

Verwenden Sie den `build-container` Befehl, um den Anwendungscontainer zu erstellen. Dieser Befehl erstellt einen Docker-Container und speichert ihn als komprimiertes Dateisystem im `assets` Ordner.

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

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

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

## Laden Sie den Container hoch und registrieren Sie die Knoten
<a name="api-deploy-upload"></a>

Verwenden Sie den `package-application` Befehl, um die Anwendung hochzuladen. Mit diesem Befehl werden Assets aus dem `assets` Ordner auf einen Amazon S3 S3-Zugriffspunkt hochgeladen, den AWS Panorama verwaltet.

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

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

## Bereitstellen der Anwendung
<a name="api-deploy-deploy"></a>

Um die Anwendung bereitzustellen, verwenden Sie die [CreateApplicationInstance](https://docs.aws.amazon.com/panorama/latest/api/API_CreateApplicationInstance.html)API. 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 des ersten überschreibt. 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.

Bei den Payloads Manifest und Override handelt es sich um JSON-Dokumente, die als in einem anderen Dokument verschachtelter Zeichenkettenwert bereitgestellt werden müssen. Zu diesem Zweck lädt das Skript die Manifeste aus einer Datei als Zeichenfolge und verwendet das [jq-Tool, um das verschachtelte](https://stedolan.github.io/jq/) Dokument zu erstellen.

**Example [5-deploy.sh — Manifeste](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/5-deploy.sh) 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 die [ListDevices](https://docs.aws.amazon.com/panorama/latest/api/API_ListDevices.html)API, um eine Liste der registrierten Geräte in der aktuellen Region abzurufen, und speichert die Auswahl des Benutzers in einer lokalen Datei für nachfolgende Bereitstellungen.

**Example [5-deploy.sh](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/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 ([1-create-role.sh](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/1-create-role.sh)) erstellt. Das Deploy-Skript ruft den ARN dieser Rolle ab AWS CloudFormation. Wenn die Anwendung bereits auf dem Gerät bereitgestellt wurde, ruft das Skript die ID dieser Anwendungsinstanz aus einer lokalen Datei ab.

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

**Example [5-deploy.sh](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/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 die Bereitstellung
<a name="api-deploy-monitor"></a>

Verwenden Sie die [ListApplicationInstances](https://docs.aws.amazon.com/panorama/latest/api/API_ListApplicationInstances.html)API, um eine Bereitstellung zu überwachen. 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.

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

Wenn die Bereitstellung abgeschlossen ist, können Sie die Protokolle anzeigen, indem Sie die Amazon CloudWatch Logs API aufrufen. Das Skript zum Anzeigen von Protokollen verwendet die CloudWatch `GetLogEvents` Logs-API.

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