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.
# Die AWS-Panorama-API
Sie können die öffentliche API des AWS Panorama Panorama-Service verwenden, um Workflows zur Geräte- und Anwendungsverwaltung zu automatisieren. Mit dem AWS Command Line Interface oder dem AWS SDK können Sie Skripte oder Anwendungen entwickeln, die Ressourcen und Bereitstellungen verwalten. Das GitHub Repository dieses Handbuchs enthält Skripte, die Sie als Ausgangspunkt für Ihren eigenen Code verwenden können.
****
+ [aws-panorama-developer-guide/util-scripts](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/util-scripts)
**Topics**
+ [
# Automatisieren Sie die Registrierung von Geräten
](api-provision.md)
+ [
# Appliances mit der AWS Panorama API verwalten
](api-appliance.md)
+ [
# Automatisieren Sie die Anwendungsbereitstellung
](api-deploy.md)
+ [
# Anwendungen mit der AWS-Panorama-API verwalten
](api-applications.md)
+ [
# Verwenden eines VPC-Endpunkts
](api-endpoints.md)
# Automatisieren Sie die Registrierung von Geräten
Verwenden Sie die [ProvisionDevice](https://docs.aws.amazon.com/panorama/latest/api/API_ProvisionDevice.html)API, um eine Appliance bereitzustellen. Die Antwort enthält eine ZIP-Datei mit der Konfiguration des Geräts und temporären Anmeldeinformationen. Dekodieren Sie die Datei und speichern Sie sie in einem Archiv mit dem Präfix`certificates-omni_`.
**Example [provision-device.sh](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/util-scripts/provision-device.sh)**
```
if [[ $# -eq 1 ]] ; then
DEVICE_NAME=$1
else
echo "Usage: ./provision-device.sh "
exit 1
fi
CERTIFICATE_BUNDLE=certificates-omni_${DEVICE_NAME}.zip
aws panorama provision-device --name ${DEVICE_NAME} --output text --query Certificates | base64 --decode > ${CERTIFICATE_BUNDLE}
echo "Created certificate bundle ${CERTIFICATE_BUNDLE}"
```
Die Anmeldeinformationen im Konfigurationsarchiv laufen nach 5 Minuten ab. Übertragen Sie das Archiv mit dem mitgelieferten USB-Laufwerk auf Ihre Appliance.
Verwenden Sie die [CreateNodeFromTemplateJob](https://docs.aws.amazon.com/panorama/latest/api/API_CreateNodeFromTemplateJob.html)API, um eine Kamera zu registrieren. Diese API verwendet eine Übersicht mit Vorlagenparametern für den Benutzernamen, das Passwort und die URL der Kamera. Sie können diese Map mithilfe der Bash-String-Manipulation als JSON-Dokument formatieren.
**Example [register-camera.sh](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/util-scripts/register-camera.sh)**
```
if [[ $# -eq 3 ]] ; then
NAME=$1
USERNAME=$2
URL=$3
else
echo "Usage: ./register-camera.sh "
exit 1
fi
echo "Enter camera stream password: "
read PASSWORD
TEMPLATE='{"Username":"MY_USERNAME","Password":"MY_PASSWORD","StreamUrl": "MY_URL"}'
TEMPLATE=${TEMPLATE/MY_USERNAME/$USERNAME}
TEMPLATE=${TEMPLATE/MY_PASSWORD/$PASSWORD}
TEMPLATE=${TEMPLATE/MY_URL/$URL}
echo ${TEMPLATE}
JOB_ID=$(aws panorama create-node-from-template-job --template-type RTSP_CAMERA_STREAM --output-package-name ${NAME} --output-package-version "1.0" --node-name ${NAME} --template-parameters "${TEMPLATE}" --output text)
```
Alternativ können Sie die JSON-Konfiguration aus einer Datei laden.
```
--template-parameters file://camera-template.json
```
# Appliances mit der AWS Panorama API verwalten
Sie können Appliance-Verwaltungsaufgaben mit der AWS Panorama API automatisieren.
## Geräte anzeigen
Verwenden Sie die [ListDevices](https://docs.aws.amazon.com/panorama/latest/api/API_ListDevices.html)API IDs, um eine Liste der Geräte mit Gerät zu erhalten.
```
$ aws panorama list-devices
"Devices": [
{
"DeviceId": "device-4tafxmplhtmzabv5lsacba4ere",
"Name": "my-appliance",
"CreatedTime": 1652409973.613,
"ProvisioningStatus": "SUCCEEDED",
"LastUpdatedTime": 1652410973.052,
"LeaseExpirationTime": 1652842940.0
}
]
}
```
Verwenden Sie die [DescribeDevice](https://docs.aws.amazon.com/panorama/latest/api/API_DescribeDevice.html)API, um weitere Informationen zu einer Appliance zu erhalten.
```
$ aws panorama describe-device --device-id device-4tafxmplhtmzabv5lsacba4ere
{
"DeviceId": "device-4tafxmplhtmzabv5lsacba4ere",
"Name": "my-appliance",
"Arn": "arn:aws:panorama:us-west-2:123456789012:device/device-4tafxmplhtmzabv5lsacba4ere",
"Type": "PANORAMA_APPLIANCE",
"DeviceConnectionStatus": "ONLINE",
"CreatedTime": 1648232043.421,
"ProvisioningStatus": "SUCCEEDED",
"LatestSoftware": "4.3.55",
"CurrentSoftware": "4.3.45",
"SerialNumber": "GFXMPL0013023708",
"Tags": {},
"CurrentNetworkingStatus": {
"Ethernet0Status": {
"IpAddress": "192.168.0.1/24",
"ConnectionStatus": "CONNECTED",
"HwAddress": "8C:XM:PL:60:C5:88"
},
"Ethernet1Status": {
"IpAddress": "--",
"ConnectionStatus": "NOT_CONNECTED",
"HwAddress": "8C:XM:PL:60:C5:89"
}
},
"LeaseExpirationTime": 1652746098.0
}
```
## Aktualisieren Sie die Appliance-Software
Wenn die `LatestSoftware` Version neuer als die ist`CurrentSoftware`, können Sie das Gerät aktualisieren. Verwenden Sie die [CreateJobForDevices](https://docs.aws.amazon.com/panorama/latest/api/API_CreateJobForDevices.html)API, um einen over-the-air (OTA-) Aktualisierungsjob zu erstellen.
```
$ aws panorama create-job-for-devices --device-ids device-4tafxmplhtmzabv5lsacba4ere \
--device-job-config '{"OTAJobConfig": {"ImageVersion": "4.3.55"}}' --job-type OTA
{
"Jobs": [
{
"JobId": "device-4tafxmplhtmzabv5lsacba4ere-0",
"DeviceId": "device-4tafxmplhtmzabv5lsacba4ere"
}
]
}
```
In einem Skript können Sie das Feld „Image-Version“ in der Job-Konfigurationsdatei mit Bash-String-Manipulation füllen.
**Example [check-updates.sh](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/util-scripts/check-updates.sh)**
```
apply_update() {
DEVICE_ID=$1
NEW_VERSION=$2
CONFIG='{"OTAJobConfig": {"ImageVersion": "NEW_VERSION"}}'
CONFIG=${CONFIG/NEW_VERSION/$NEW_VERSION}
aws panorama create-job-for-devices --device-ids ${DEVICE_ID} --device-job-config "${CONFIG}" --job-type OTA
}
```
Die Appliance lädt die angegebene Softwareversion herunter und aktualisiert sich selbst. Beobachten Sie den Fortschritt des Updates mit der [DescribeDeviceJob](https://docs.aws.amazon.com/panorama/latest/api/API_DescribeDeviceJob.html)API.
```
$ aws panorama describe-device-job --job-id device-4tafxmplhtmzabv5lsacba4ere-0
{
"JobId": "device-4tafxmplhtmzabv5lsacba4ere-0",
"DeviceId": "device-4tafxmplhtmzabv5lsacba4ere",
"DeviceArn": "arn:aws:panorama:us-west-2:559823168634:device/device-4tafxmplhtmzabv5lsacba4ere",
"DeviceName": "my-appliance",
"DeviceType": "PANORAMA_APPLIANCE",
"ImageVersion": "4.3.55",
"Status": "REBOOTING",
"CreatedTime": 1652410232.465
}
```
Um eine Liste aller laufenden Jobs zu erhalten, verwenden Sie den [ListDevicesJobs](https://docs.aws.amazon.com/panorama/latest/api/API_ListDevicesJobs.html).
```
$ aws panorama list-devices-jobs
{
"DeviceJobs": [
{
"DeviceName": "my-appliance",
"DeviceId": "device-4tafxmplhtmzabv5lsacba4ere",
"JobId": "device-4tafxmplhtmzabv5lsacba4ere-0",
"CreatedTime": 1652410232.465
}
]
}
```
Ein Beispielskript, das nach Updates sucht und diese anwendet, finden Sie unter [check-updates.sh](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/util-scripts/check-updates.sh) im GitHub Repository dieses Handbuchs.
## Starten Sie die Geräte neu
Verwenden Sie die [CreateJobForDevices](https://docs.aws.amazon.com/panorama/latest/api/API_CreateJobForDevices.html)API, um eine Appliance neu zu starten.
```
$ aws panorama create-job-for-devices --device-ids device-4tafxmplhtmzabv5lsacba4ere --job-type REBOOT
{
"Jobs": [
{
"JobId": "device-4tafxmplhtmzabv5lsacba4ere-0",
"DeviceId": "device-4tafxmplhtmzabv5lsacba4ere"
}
]
}
```
In einem Skript können Sie eine Liste von Geräten abrufen und eines auswählen, das interaktiv neu gestartet werden soll.
**Example [reboot-device.sh](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/util-scripts/reboot-device.sh) — Verwendung**
```
$ ./reboot-device.sh
Getting devices...
0: device-53amxmplyn3gmj72epzanacniy my-se70-1
1: device-6talxmpl5mmik6qh5moba6jium my-manh-24
Choose a device
1
Reboot device device-6talxmpl5mmik6qh5moba6jium? (y/n)y
{
"Jobs": [
{
"DeviceId": "device-6talxmpl5mmik6qh5moba6jium",
"JobId": "device-6talxmpl5mmik6qh5moba6jium-8"
}
]
}
```
# Automatisieren Sie die Anwendungsbereitstellung
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
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
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
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
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
```
# Anwendungen mit der AWS-Panorama-API verwalten
Sie können Anwendungen mit der AWS-Panorama-API überwachen und verwalten.
## Anwendung anzeigen
Verwenden Sie die [ListApplicationInstances](https://docs.aws.amazon.com/panorama/latest/api/API_ListApplicationInstances.html)API, um eine Liste der Anwendungen abzurufen, die auf einer Appliance ausgeführt werden.
```
$ aws panorama list-application-instances
"ApplicationInstances": [
{
"Name": "aws-panorama-sample",
"ApplicationInstanceId": "applicationInstance-ddaxxmpl2z7bg74ywutd7byxuq",
"DefaultRuntimeContextDevice": "device-4tafxmplhtmzabv5lsacba4ere",
"DefaultRuntimeContextDeviceName": "my-appliance",
"Description": "command-line deploy",
"Status": "DEPLOYMENT_SUCCEEDED",
"HealthStatus": "RUNNING",
"StatusDescription": "Application deployed successfully.",
"CreatedTime": 1661902051.925,
"Arn": "arn:aws:panorama:us-east-2:123456789012:applicationInstance/applicationInstance-ddaxxmpl2z7bg74ywutd7byxuq",
"Tags": {
"client": "sample"
}
},
]
}
```
Verwenden Sie die [ListApplicationInstanceNodeInstances](https://docs.aws.amazon.com/panorama/latest/api/API_ListApplicationInstanceNodeInstances.html)API, um weitere Informationen zu den Knoten einer Anwendungsinstanz zu erhalten.
```
$ aws panorama list-application-instance-node-instances --application-instance-id applicationInstance-ddaxxmpl2z7bg74ywutd7byxuq
{
"NodeInstances": [
{
"NodeInstanceId": "code_node",
"NodeId": "SAMPLE_CODE-1.0-fd3dxmpl-interface",
"PackageName": "SAMPLE_CODE",
"PackageVersion": "1.0",
"PackagePatchVersion": "fd3dxmpl2bdfa41e6fe1be290a79dd2c29cf014eadf7416d861ce7715ad5e8a8",
"NodeName": "interface",
"CurrentStatus": "RUNNING"
},
{
"NodeInstanceId": "camera_node_override",
"NodeId": "warehouse-floor-1.0-9eabxmpl-warehouse-floor",
"PackageName": "warehouse-floor",
"PackageVersion": "1.0",
"PackagePatchVersion": "9eabxmple89f0f8b2f2852cca2a6e7971aa38f1629a210d069045e83697e42a7",
"NodeName": "warehouse-floor",
"CurrentStatus": "RUNNING"
},
{
"NodeInstanceId": "output_node",
"NodeId": "hdmi_data_sink-1.0-9c23xmpl-hdmi0",
"PackageName": "hdmi_data_sink",
"PackageVersion": "1.0",
"PackagePatchVersion": "9c23xmplc4c98b92baea4af676c8b16063d17945a3f6bd8f83f4ff5aa0d0b394",
"NodeName": "hdmi0",
"CurrentStatus": "RUNNING"
},
{
"NodeInstanceId": "model_node",
"NodeId": "SQUEEZENET_PYTORCH-1.0-5d3cabda-interface",
"PackageName": "SQUEEZENET_PYTORCH",
"PackageVersion": "1.0",
"PackagePatchVersion": "5d3cxmplb7113faa1d130f97f619655d8ca12787c751851a0e155e50eb5e3e96",
"NodeName": "interface",
"CurrentStatus": "RUNNING"
}
]
}
```
## Kamerastreams verwalten
Mit der [SignalApplicationInstanceNodeInstances](https://docs.aws.amazon.com/panorama/latest/api/API_SignalApplicationInstanceNodeInstances.html)API können Sie Kamera-Stream-Knoten anhalten und wieder aufnehmen.
```
$ aws panorama signal-application-instance-node-instances --application-instance-id applicationInstance-ddaxxmpl2z7bg74ywutd7byxuq \
--node-signals '[{"NodeInstanceId": "camera_node_override", "Signal": "PAUSE"}]'
{
"ApplicationInstanceId": "applicationInstance-ddaxxmpl2z7bg74ywutd7byxuq"
}
```
In einem Skript können Sie eine Liste von Knoten abrufen und einen Knoten auswählen, den Sie interaktiv anhalten oder fortsetzen möchten.
**Example [pause-camera.sh](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/util-scripts/pause-camera.sh) — Verwendung**
```
my-app$ ./pause-camera.sh
Getting nodes...
0: SAMPLE_CODE RUNNING
1: warehouse-floor RUNNING
2: hdmi_data_sink RUNNING
3: entrance-north PAUSED
4: SQUEEZENET_PYTORCH RUNNING
Choose a node
1
Signalling node warehouse-floor
+ aws panorama signal-application-instance-node-instances --application-instance-id applicationInstance-r3a7xmplcbmpjqeds7vj4b6pjy --node-signals '[{"NodeInstanceId": "warehouse-floor", "Signal": "PAUSE"}]'
{
"ApplicationInstanceId": "applicationInstance-r3a7xmplcbmpjqeds7vj4b6pjy"
}
```
Durch das Anhalten und Wiederaufnehmen von Kameraknoten können Sie eine größere Anzahl von Kamerastreams durchlaufen, als gleichzeitig verarbeitet werden können. Ordnen Sie dazu mehrere Kamerastreams demselben Eingabeknoten in Ihrem Override-Manifest zu.
Im folgenden Beispiel ordnet das Override-Manifest zwei Kamerastreams `warehouse-floor` und demselben Eingabeknoten (`camera_node`) `entrance-north` zu. Der `warehouse-floor` Stream ist aktiv, wenn die Anwendung gestartet wird und der `entrance-north` Knoten auf das Einschalten eines Signals wartet.
**Example [override-multicam.json](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/graphs/my-app/override-multicam.json)**
```
"nodeGraphOverrides": {
"nodes": [
{
"name": "warehouse-floor",
"interface": "123456789012::warehouse-floor.warehouse-floor",
"launch": "onAppStart"
},
{
"name": "entrance-north",
"interface": "123456789012::entrance-north.entrance-north",
"launch": "onSignal"
},
...
"packages": [
{
"name": "123456789012::warehouse-floor",
"version": "1.0"
},
{
"name": "123456789012::entrance-north",
"version": "1.0"
}
],
"nodeOverrides": [
{
"replace": "camera_node",
"with": [
{
"name": "warehouse-floor"
},
{
"name": "entrance-north"
}
]
}
```
Einzelheiten zur Bereitstellung mit der API finden Sie unter. [Automatisieren Sie die Anwendungsbereitstellung](api-deploy.md)
# Verwenden eines VPC-Endpunkts
Wenn Sie in einer VPC ohne Internetzugang arbeiten, können Sie einen [VPC-Endpunkt](#services-vpc-interface) für die Verwendung mit AWS Panorama erstellen. Ein VPC-Endpunkt ermöglicht es Clients, die in einem privaten Subnetz laufen, sich ohne Internetverbindung mit einem AWS-Service zu verbinden.
Einzelheiten zu den von der AWS Panorama Appliance verwendeten Ports und Endpunkten finden Sie unter[Die AWS Panorama Appliance mit Ihrem Netzwerk verbinden](appliance-network.md).
**Topics**
+ [
## Erstellung eines VPC-Endpunkts
](#services-vpc-interface)
+ [
## Eine Appliance mit einem privaten Subnetz verbinden
](#services-vpc-appliance)
+ [
## Beispielvorlagen AWS CloudFormation
](#services-vpc-templates)
## Erstellung eines VPC-Endpunkts
Um eine private Verbindung zwischen Ihrer VPC und AWS Panorama herzustellen, erstellen Sie einen *VPC-Endpunkt*. Für die Verwendung von AWS Panorama ist kein VPC-Endpunkt erforderlich. Sie müssen nur dann einen VPC-Endpunkt erstellen, wenn Sie in einer VPC ohne Internetzugang arbeiten. Wenn die AWS-CLI oder das SDK versucht, eine Verbindung zu AWS Panorama herzustellen, wird der Datenverkehr über den VPC-Endpunkt geleitet.
[Erstellen Sie einen VPC-Endpunkt](https://console.aws.amazon.com//vpc/home#CreateVpcEndpoint:) für AWS Panorama mit den folgenden Einstellungen:
+ **Name des Dienstes** — **com.amazonaws.*us-west-2*.panorama**
+ **Typ** — **Schnittstelle**
Ein VPC-Endpunkt verwendet den DNS-Namen des Services, um Traffic von AWS-SDK-Clients ohne zusätzliche Konfiguration abzurufen. Weitere Informationen zur Verwendung von VPC-Endpunkten finden Sie unter [Interface VPC Endpoints](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html) im *Amazon* VPC-Benutzerhandbuch.
## Eine Appliance mit einem privaten Subnetz verbinden
Die AWS Panorama Appliance kann AWS über eine private VPN-Verbindung mit AWS Site-to-Site VPN oder eine Verbindung herstellen AWS Direct Connect. Mit diesen Services können Sie ein privates Subnetz erstellen, das sich bis zu Ihrem Rechenzentrum erstreckt. Die Appliance stellt eine Verbindung zum privaten Subnetz her und greift über VPC-Endpunkte auf AWS Dienste zu.
Site-to-Site VPN und Direct Connect sind Dienste für die sichere Verbindung Ihres Rechenzentrums mit Amazon VPC. Mit Site-to-Site VPN können Sie handelsübliche Netzwerkgeräte verwenden, um eine Verbindung herzustellen. Direct Connect verwendet ein AWS Gerät, um eine Verbindung herzustellen.
****
+ **Site-to-Site VPN** — [Was ist AWS Site-to-Site VPN?](https://docs.aws.amazon.com/vpn/latest/s2svpn/)
+ **Direct Connect**— [Was ist AWS Direct Connect?](https://docs.aws.amazon.com/directconnect/latest/UserGuide/)
Nachdem Sie Ihr lokales Netzwerk mit einem privaten Subnetz in einer VPC verbunden haben, erstellen Sie VPC-Endpunkte für die folgenden Dienste.
****
+ **Amazon Simple Storage Service** — [AWS PrivateLink für Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/privatelink-interface-endpoints.html)
+ **AWS IoT Core**— [Verwendung AWS IoT Core mit VPC-Endpunkten mit Schnittstelle](https://docs.aws.amazon.com/iot/latest/developerguide/IoTCore-VPC.html) (Datenebene und Credential Provider)
+ **Amazon Elastic Container Registry** — [VPC-Endpunkte mit Amazon Elastic Container Registry-Schnittstelle](https://docs.aws.amazon.com/AmazonECR/latest/userguide/vpc-endpoints.html)
+ **Amazon CloudWatch** — [Verwendung von VPC-Endpunkten CloudWatch mit Schnittstelle](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-and-interface-VPC.html)
+ **Amazon CloudWatch Logs** — [Verwendung von CloudWatch Protokollen mit VPC-Endpunkten der Schnittstelle](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/cloudwatch-logs-and-interface-VPC.html)
Die Appliance benötigt keine Verbindung zum AWS Panorama Panorama-Service. Es kommuniziert mit AWS Panorama über einen Nachrichtenkanal in AWS IoT.
Zusätzlich zu VPC-Endpunkten AWS IoT erfordern Amazon S3 und Amazon die Verwendung von privaten gehosteten Zonen von Amazon Route 53. Die private gehostete Zone leitet den Datenverkehr von Subdomänen, einschließlich Subdomänen für Amazon S3 S3-Zugriffspunkte und MQTT-Themen, an den richtigen VPC-Endpunkt weiter. Informationen zu privat gehosteten Zonen finden Sie unter [Arbeiten mit privat gehosteten Zonen](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/hosted-zones-private.html) im Amazon Route 53-Entwicklerhandbuch.
Eine VPC-Beispielkonfiguration mit VPC-Endpunkten und privaten gehosteten Zonen finden Sie unter. [Beispielvorlagen AWS CloudFormation](#services-vpc-templates)
## Beispielvorlagen AWS CloudFormation
Das GitHub Repository für dieses Handbuch enthält AWS CloudFormation Vorlagen, mit denen Sie Ressourcen für die Verwendung mit AWS Panorama erstellen können. Die Vorlagen erstellen eine VPC mit zwei privaten Subnetzen, einem öffentlichen Subnetz und einem VPC-Endpunkt. Sie können die privaten Subnetze in der VPC verwenden, um Ressourcen zu hosten, die vom Internet isoliert sind. Ressourcen im öffentlichen Subnetz können mit den privaten Ressourcen kommunizieren, aber auf die privaten Ressourcen kann nicht über das Internet zugegriffen werden.
**Example [vpc-endpoint.yml](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/cloudformation-templates/vpc-endpoint.yml) — Private Subnetze**
```
AWSTemplateFormatVersion: 2010-09-09
Resources:
vpc:
Type: AWS::EC2::VPC
Properties:
CidrBlock: 172.31.0.0/16
EnableDnsHostnames: true
EnableDnsSupport: true
Tags:
- Key: Name
Value: !Ref AWS::StackName
privateSubnetA:
Type: AWS::EC2::Subnet
Properties:
VpcId: !Ref vpc
AvailabilityZone:
Fn::Select:
- 0
- Fn::GetAZs: ""
CidrBlock: 172.31.3.0/24
MapPublicIpOnLaunch: false
Tags:
- Key: Name
Value: !Sub ${AWS::StackName}-subnet-a
...
```
Die `vpc-endpoint.yml` Vorlage zeigt, wie ein VPC-Endpunkt für AWS Panorama erstellt wird. Sie können diesen Endpunkt verwenden, um AWS-Panorama-Ressourcen mit dem AWS SDK oder zu verwalten AWS CLI.
**Example [vpc-endpoint.yml — VPC-Endpunkt](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/cloudformation-templates/vpc-endpoint.yml)**
```
panoramaEndpoint:
Type: AWS::EC2::VPCEndpoint
Properties:
ServiceName: !Sub com.amazonaws.${AWS::Region}.panorama
VpcId: !Ref vpc
VpcEndpointType: Interface
SecurityGroupIds:
- !GetAtt vpc.DefaultSecurityGroup
PrivateDnsEnabled: true
SubnetIds:
- !Ref privateSubnetA
- !Ref privateSubnetB
PolicyDocument:
Version: 2012-10-17
Statement:
- Effect: Allow
Principal: "*"
Action:
- "panorama:*"
Resource:
- "*"
```
Das `PolicyDocument` ist eine ressourcenbasierte Berechtigungsrichtlinie, die die API-Aufrufe definiert, die mit dem Endpunkt getätigt werden können. Sie können die Richtlinie ändern, um die Aktionen und Ressourcen einzuschränken, auf die über den Endpunkt zugegriffen werden kann. Weitere Informationen finden Sie unter [Steuerung des Zugriffs auf Services mit VPC-Endpunkten](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints-access.html) im *Amazon-VPC-Benutzerhandbuch*.
Die `vpc-appliance.yml` Vorlage zeigt, wie VPC-Endpunkte und private Hosting-Zonen für Services erstellt werden, die von der AWS Panorama Appliance verwendet werden.
**Example [vpc-appliance.yml](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/cloudformation-templates/vpc-appliance.yml) — Amazon S3 S3-Zugriffspunkt-Endpunkt mit privat gehosteter Zone**
```
s3Endpoint:
Type: AWS::EC2::VPCEndpoint
Properties:
ServiceName: !Sub com.amazonaws.${AWS::Region}.s3
VpcId: !Ref vpc
VpcEndpointType: Interface
SecurityGroupIds:
- !GetAtt vpc.DefaultSecurityGroup
PrivateDnsEnabled: false
SubnetIds:
- !Ref privateSubnetA
- !Ref privateSubnetB
...
s3apHostedZone:
Type: AWS::Route53::HostedZone
Properties:
Name: !Sub s3-accesspoint.${AWS::Region}.amazonaws.com
VPCs:
- VPCId: !Ref vpc
VPCRegion: !Ref AWS::Region
s3apRecords:
Type: AWS::Route53::RecordSet
Properties:
HostedZoneId: !Ref s3apHostedZone
Name: !Sub "*.s3-accesspoint.${AWS::Region}.amazonaws.com"
Type: CNAME
TTL: 600
# first DNS entry, split on :, second value
ResourceRecords:
- !Select [1, !Split [":", !Select [0, !GetAtt s3Endpoint.DnsEntries ] ] ]
```
Die Beispielvorlagen demonstrieren die Erstellung von Amazon VPC- und Route 53-Ressourcen mit einer Beispiel-VPC. Sie können diese an Ihren Anwendungsfall anpassen, indem Sie die VPC-Ressourcen entfernen und die Verweise auf Subnetz, Sicherheitsgruppe und VPC IDs durch die IDs Ihrer Ressourcen ersetzen.