Avis de fin de support : le 31 mai 2026, AWS le support de AWS Panorama. Après le 31 mai 2026, vous ne pourrez plus accéder à la AWS Panorama console ni aux AWS Panorama ressources. Pour plus d'informations, voir [AWS Panorama fin du support](https://docs.aws.amazon.com/panorama/latest/dev/panorama-end-of-support.html).
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.
# L'API AWS Panorama
Vous pouvez utiliser l'API publique du service AWS Panorama pour automatiser les flux de travail de gestion des appareils et des applications. Avec le SDK AWS Command Line Interface ou le AWS SDK, vous pouvez développer des scripts ou des applications qui gèrent les ressources et les déploiements. Le GitHub référentiel de ce guide inclut des scripts que vous pouvez utiliser comme point de départ pour votre propre code.
****
+ [aws-panorama-developer-guide/util-scripts](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/util-scripts)
**Topics**
+ [
# Automatisez l'enregistrement des appareils
](api-provision.md)
+ [
# Gérez les appareils avec l'API AWS Panorama
](api-appliance.md)
+ [
# Automatisez le déploiement des applications
](api-deploy.md)
+ [
# Gérez les applications avec l'API AWS Panorama
](api-applications.md)
+ [
# Utilisation de points de terminaison d’un VPC
](api-endpoints.md)
# Automatisez l'enregistrement des appareils
Pour configurer une appliance, utilisez l'[ProvisionDevice](https://docs.aws.amazon.com/panorama/latest/api/API_ProvisionDevice.html)API. La réponse inclut un fichier ZIP contenant la configuration de l'appareil et des informations d'identification temporaires. Décodez le fichier et enregistrez-le dans une archive avec le préfixe`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}"
```
Les informations d'identification figurant dans l'archive de configuration expirent au bout de 5 minutes. Transférez l'archive sur votre appareil à l'aide de la clé USB incluse.
Pour enregistrer une caméra, utilisez l'[CreateNodeFromTemplateJob](https://docs.aws.amazon.com/panorama/latest/api/API_CreateNodeFromTemplateJob.html)API. Cette API utilise une carte des paramètres du modèle pour le nom d'utilisateur, le mot de passe et l'URL de la caméra. Vous pouvez formater cette carte en tant que document JSON en utilisant la manipulation de chaînes Bash.
**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)
```
Vous pouvez également charger la configuration JSON à partir d'un fichier.
```
--template-parameters file://camera-template.json
```
# Gérez les appareils avec l'API AWS Panorama
Vous pouvez automatiser les tâches de gestion des appareils avec l'API AWS Panorama.
## Afficher les appareils
Pour obtenir la liste des appareils dotés d'un appareil IDs, utilisez l'[ListDevices](https://docs.aws.amazon.com/panorama/latest/api/API_ListDevices.html)API.
```
$ aws panorama list-devices
"Devices": [
{
"DeviceId": "device-4tafxmplhtmzabv5lsacba4ere",
"Name": "my-appliance",
"CreatedTime": 1652409973.613,
"ProvisioningStatus": "SUCCEEDED",
"LastUpdatedTime": 1652410973.052,
"LeaseExpirationTime": 1652842940.0
}
]
}
```
Pour obtenir plus de détails sur une appliance, utilisez l'[DescribeDevice](https://docs.aws.amazon.com/panorama/latest/api/API_DescribeDevice.html)API.
```
$ 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
}
```
## Mise à niveau logicielle de l'appliance
Si la `LatestSoftware` version est plus récente que la`CurrentSoftware`, vous pouvez mettre à niveau l'appareil. Utilisez l'[CreateJobForDevices](https://docs.aws.amazon.com/panorama/latest/api/API_CreateJobForDevices.html)API pour créer une tâche de mise à jour over-the-air (OTA).
```
$ 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"
}
]
}
```
Dans un script, vous pouvez renseigner le champ de version de l'image dans le fichier de configuration de la tâche à l'aide de la manipulation de chaînes Bash.
**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
}
```
L'appliance télécharge la version logicielle spécifiée et se met à jour elle-même. Suivez la progression de la mise à jour avec l'[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
}
```
Pour obtenir la liste de toutes les tâches en cours d'exécution, utilisez le [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
}
]
}
```
Pour un exemple de script qui vérifie et applique les mises à jour, consultez le [fichier check-updates.sh](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/util-scripts/check-updates.sh) dans le GitHub référentiel de ce guide.
## Redémarrer les appareils
Pour redémarrer une appliance, utilisez l'[CreateJobForDevices](https://docs.aws.amazon.com/panorama/latest/api/API_CreateJobForDevices.html)API.
```
$ aws panorama create-job-for-devices --device-ids device-4tafxmplhtmzabv5lsacba4ere --job-type REBOOT
{
"Jobs": [
{
"JobId": "device-4tafxmplhtmzabv5lsacba4ere-0",
"DeviceId": "device-4tafxmplhtmzabv5lsacba4ere"
}
]
}
```
Dans un script, vous pouvez obtenir une liste de périphériques et en choisir un à redémarrer de manière interactive.
**Example [reboot-device.sh](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/util-scripts/reboot-device.sh) — utilisation**
```
$ ./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"
}
]
}
```
# 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'[CreateApplicationInstance](https://docs.aws.amazon.com/panorama/latest/api/API_CreateApplicationInstance.html)API.
Pour plus de contexte et d'instructions sur l'utilisation des scripts présentés, suivez les instructions de l'[exemple d'application README](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/README.md).
**Topics**
+ [
## Construisez le conteneur
](#api-deploy-build)
+ [
## Téléchargez le conteneur et enregistrez les nœuds
](#api-deploy-upload)
+ [
## Déployer l'application
](#api-deploy-deploy)
+ [
## Surveiller le déploiement
](#api-deploy-monitor)
## 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.
**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
```
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.
**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
```
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'[CreateApplicationInstance](https://docs.aws.amazon.com/panorama/latest/api/API_CreateApplicationInstance.html)API. 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](https://stedolan.github.io/jq/) pour créer le document imbriqué.
**Example [5-deploy.sh](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/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'[ListDevices](https://docs.aws.amazon.com/panorama/latest/api/API_ListDevices.html)API 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.
**Example [5-deploy.sh](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/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](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/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.
**Example [5-deploy.sh](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/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.
**Example [5-deploy.sh](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/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'[ListApplicationInstances](https://docs.aws.amazon.com/panorama/latest/api/API_ListApplicationInstances.html)API. 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.
**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
```
Une fois le déploiement terminé, vous pouvez consulter les journaux en appelant l'API Amazon CloudWatch Logs. Le script View Logs utilise l'`GetLogEvents`API CloudWatch Logs.
**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
```
# Gérez les applications avec l'API AWS Panorama
Vous pouvez surveiller et gérer les applications à l'aide de l'API AWS Panorama.
## Affichage des applications
Pour obtenir la liste des applications exécutées sur une appliance, utilisez l'[ListApplicationInstances](https://docs.aws.amazon.com/panorama/latest/api/API_ListApplicationInstances.html)API.
```
$ 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"
}
},
]
}
```
Pour obtenir plus de détails sur les nœuds d'une instance d'application, utilisez l'[ListApplicationInstanceNodeInstances](https://docs.aws.amazon.com/panorama/latest/api/API_ListApplicationInstanceNodeInstances.html)API.
```
$ 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"
}
]
}
```
## Gérez les flux de caméras
Vous pouvez suspendre et reprendre les nœuds de flux de caméras avec l'[SignalApplicationInstanceNodeInstances](https://docs.aws.amazon.com/panorama/latest/api/API_SignalApplicationInstanceNodeInstances.html)API.
```
$ aws panorama signal-application-instance-node-instances --application-instance-id applicationInstance-ddaxxmpl2z7bg74ywutd7byxuq \
--node-signals '[{"NodeInstanceId": "camera_node_override", "Signal": "PAUSE"}]'
{
"ApplicationInstanceId": "applicationInstance-ddaxxmpl2z7bg74ywutd7byxuq"
}
```
Dans un script, vous pouvez obtenir une liste de nœuds et en choisir un à suspendre ou à reprendre de manière interactive.
**Example [pause-camera.sh](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/util-scripts/pause-camera.sh) — utilisation**
```
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"
}
```
En interrompant et en reprenant les nœuds de caméra, vous pouvez parcourir un plus grand nombre de flux de caméras que ceux pouvant être traités simultanément. Pour ce faire, mappez plusieurs flux de caméras vers le même nœud d'entrée dans votre manifeste de dérogation.
Dans l'exemple suivant, le manifeste de remplacement mappe deux flux de caméras `warehouse-floor` et `entrance-north` le même nœud d'entrée (`camera_node`). Le `warehouse-floor` flux est actif lorsque l'application démarre et que le `entrance-north` nœud attend l'activation d'un signal.
**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"
}
]
}
```
Pour plus de détails sur le déploiement à l'aide de l'API, consultez[Automatisez le déploiement des applications](api-deploy.md).
# Utilisation de points de terminaison d’un VPC
Si vous travaillez dans un VPC sans accès à Internet, vous pouvez créer un point de [terminaison VPC](#services-vpc-interface) à utiliser avec AWS Panorama. Un point de terminaison VPC permet aux clients s'exécutant dans un sous-réseau privé de se connecter à un service AWS sans connexion Internet.
Pour plus de détails sur les ports et les points de terminaison utilisés par l'appliance AWS Panorama, consultez[Connexion de l'appliance AWS Panorama à votre réseau](appliance-network.md).
**Topics**
+ [
## Création d’un point de terminaison d’un VPC
](#services-vpc-interface)
+ [
## Connexion d'une appliance à un sous-réseau privé
](#services-vpc-appliance)
+ [
## Exemples de AWS CloudFormation modèles
](#services-vpc-templates)
## Création d’un point de terminaison d’un VPC
*Pour établir une connexion privée entre votre VPC et AWS Panorama, créez un point de terminaison VPC.* Il n'est pas nécessaire de disposer d'un point de terminaison VPC pour utiliser AWS Panorama. Vous ne devez créer un point de terminaison VPC que si vous travaillez dans un VPC sans accès à Internet. Lorsque la CLI ou le SDK AWS tente de se connecter à AWS Panorama, le trafic est acheminé via le point de terminaison VPC.
[Créez un point de terminaison VPC](https://console.aws.amazon.com//vpc/home#CreateVpcEndpoint:) pour AWS Panorama à l'aide des paramètres suivants :
+ **Nom du service** — **com.amazonaws.*us-west-2*.panorama**
+ **Type** — **Interface**
Un point de terminaison VPC utilise le nom DNS du service pour obtenir le trafic des clients du SDK AWS sans aucune configuration supplémentaire. *Pour plus d'informations sur l'utilisation des points de terminaison VPC, consultez la section Points de terminaison [VPC d'interface dans le guide de l'](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html)utilisateur Amazon VPC.*
## Connexion d'une appliance à un sous-réseau privé
L'appliance AWS Panorama peut se connecter AWS via une connexion VPN privée avec AWS Site-to-Site VPN ou AWS Direct Connect. Grâce à ces services, vous pouvez créer un sous-réseau privé qui s'étend à votre centre de données. L'appliance se connecte au sous-réseau privé et accède aux AWS services via les points de terminaison VPC.
Site-to-Site Les VPN Direct Connect sont des services permettant de connecter votre centre de données à Amazon VPC en toute sécurité. Avec le Site-to-Site VPN, vous pouvez utiliser des appareils réseau disponibles dans le commerce pour vous connecter. Direct Connect utilise un AWS appareil pour se connecter.
****
+ **Site-to-Site VPN** — [Qu'est-ce que c'est AWS Site-to-Site VPN ?](https://docs.aws.amazon.com/vpn/latest/s2svpn/)
+ **Direct Connect**— [Qu'est-ce que c'est AWS Direct Connect ?](https://docs.aws.amazon.com/directconnect/latest/UserGuide/)
Après avoir connecté votre réseau local à un sous-réseau privé d'un VPC, créez des points de terminaison VPC pour les services suivants.
****
+ **Amazon Simple Storage Service** — [AWS PrivateLink pour Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/privatelink-interface-endpoints.html)
+ **AWS IoT Core**— [Utilisation AWS IoT Core avec les points de terminaison VPC de l'interface](https://docs.aws.amazon.com/iot/latest/developerguide/IoTCore-VPC.html) (plan de données et fournisseur d'informations d'identification)
+ **Amazon Elastic Container Registry** — Points de terminaison [VPC de l'interface Amazon Elastic Container Registry](https://docs.aws.amazon.com/AmazonECR/latest/userguide/vpc-endpoints.html)
+ **Amazon CloudWatch** — [Utilisation CloudWatch avec des points de terminaison VPC d'interface](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-and-interface-VPC.html)
+ **Amazon CloudWatch Logs** — [Utilisation des CloudWatch journaux avec des points de terminaison VPC d'interface](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/cloudwatch-logs-and-interface-VPC.html)
L'appliance n'a pas besoin d'être connectée au service AWS Panorama. Il communique avec AWS Panorama via un canal de messagerie en AWS IoT.
Outre les points de terminaison VPC, Amazon S3 AWS IoT nécessite l'utilisation de zones hébergées privées Amazon Route 53. La zone hébergée privée achemine le trafic depuis les sous-domaines, y compris les sous-domaines des points d'accès Amazon S3 et des sujets MQTT, vers le point de terminaison VPC approprié. Pour plus d'informations sur les zones hébergées privées, consultez la section [Travailler avec des zones hébergées privées](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/hosted-zones-private.html) dans le guide du développeur Amazon Route 53.
Pour un exemple de configuration VPC avec des points de terminaison VPC et des zones hébergées privées, consultez. [Exemples de AWS CloudFormation modèles](#services-vpc-templates)
## Exemples de AWS CloudFormation modèles
Le GitHub référentiel de ce guide fournit des AWS CloudFormation modèles que vous pouvez utiliser pour créer des ressources à utiliser avec AWS Panorama. Les modèles créent un VPC avec deux sous-réseaux privés, un sous-réseau public et un point de terminaison VPC. Vous pouvez utiliser les sous-réseaux privés du VPC pour héberger des ressources isolées d'Internet. Les ressources du sous-réseau public peuvent communiquer avec les ressources privées, mais les ressources privées ne sont pas accessibles depuis Internet.
**Example [vpc-endpoint.yml](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/cloudformation-templates/vpc-endpoint.yml) — Sous-réseaux privés**
```
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
...
```
Le `vpc-endpoint.yml` modèle montre comment créer un point de terminaison VPC pour AWS Panorama. Vous pouvez utiliser ce point de terminaison pour gérer les ressources AWS Panorama avec le AWS SDK ou AWS CLI.
**Example [vpc-endpoint.yml — Point de terminaison](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/cloudformation-templates/vpc-endpoint.yml) VPC**
```
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:
- "*"
```
`PolicyDocument`Il s'agit d'une politique d'autorisation basée sur les ressources qui définit les appels d'API qui peuvent être effectués avec le point de terminaison. Vous pouvez modifier la politique afin de restreindre les actions et les ressources accessibles via le point de terminaison. Pour plus d’informations, consultez [Contrôle de l’accès aux services avec points de terminaison d’un VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints-access.html) dans le *Guide de l’utilisateur Amazon VPC*.
Le `vpc-appliance.yml` modèle montre comment créer des points de terminaison VPC et des zones hébergées privées pour les services utilisés par l'appliance AWS Panorama.
**Example [vpc-appliance.yml](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/cloudformation-templates/vpc-appliance.yml) — Point de terminaison du point d'accès Amazon S3 avec zone hébergée privée**
```
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 ] ] ]
```
Les exemples de modèles illustrent la création de ressources Amazon VPC et Route 53 avec un exemple de VPC. Vous pouvez les adapter à votre cas d'utilisation en supprimant les ressources VPC et en remplaçant les références au sous-réseau, au groupe de sécurité et au VPC IDs par celles de vos ressources. IDs