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.
# AWS Panorama Anwendungen erstellen
Auf der AWS Panorama Appliance werden Anwendungen ausgeführt, um Computer-Vision-Aufgaben für Videostreams auszuführen. Sie können Computer-Vision-Anwendungen erstellen, indem Sie Python-Code und Modelle für maschinelles Lernen kombinieren und sie über das Internet auf der AWS Panorama Appliance bereitstellen. Anwendungen können Videos an ein Display senden oder das AWS-SDK verwenden, um Ergebnisse an AWS-Services zu senden.
Ein [Modell](applications-models.md) analysiert Bilder, um Personen, Fahrzeuge und andere Objekte zu erkennen. Auf der Grundlage von Bildern, die es während des Trainings gesehen hat, teilt Ihnen das Modell mit, was es für etwas hält und wie sicher es sich bei seiner Vermutung ist. Sie können Modelle mit Ihren eigenen Bilddaten trainieren oder mit einem Beispiel beginnen.
Der [Code](gettingstarted-sample.md) der Anwendung verarbeitet Standbilder aus einem Kamerastream, sendet sie an ein Modell und verarbeitet das Ergebnis. Ein Modell kann mehrere Objekte erkennen und ihre Form und Position zurückgeben. Der Code kann diese Informationen verwenden, um dem Video Text oder Grafiken hinzuzufügen oder Ergebnisse zur Speicherung oder Weiterverarbeitung an einen AWS Dienst zu senden.
Um Bilder aus einem Stream abzurufen, mit einem Modell zu interagieren und Videos auszugeben, verwendet [der Anwendungscode das AWS Panorama Anwendungs-SDK](applications-panoramasdk.md). Das Anwendungs-SDK ist eine Python-Bibliothek, die Modelle unterstützt PyTorch, die mit Apache MXNet und generiert wurden TensorFlow.
**Topics**
+ [Computer-Vision-Modelle](applications-models.md)
+ [Erstellen eines Anwendungsabbilds](applications-image.md)
+ [AWS-Services von Ihrem Anwendungscode aus aufrufen](applications-awssdk.md)
+ [Das AWS Panorama Panorama-Anwendungs-SDK](applications-panoramasdk.md)
+ [Mehrere Threads ausführen](applications-threading.md)
+ [Bedienung des eingehenden Datenverkehrs](applications-ports.md)
+ [Verwendung der GPU](applications-gpuaccess.md)
+ [Eine Entwicklungsumgebung in Windows einrichten](applications-devenvwindows.md)
# Computer-Vision-Modelle
Ein *Computer-Vision-Modell* ist ein Softwareprogramm, das darauf trainiert ist, Objekte in Bildern zu erkennen. Ein Modell lernt, eine Reihe von Objekten zu erkennen, indem es zunächst Bilder dieser Objekte durch Training analysiert. Ein Computer-Vision-Modell verwendet ein Bild als Eingabe und gibt Informationen über die Objekte aus, die es erkennt, z. B. den Objekttyp und seinen Standort. AWS Panorama unterstützt Computer Vision-Modelle PyTorch, die mit Apache MXNet und erstellt wurden TensorFlow.
**Anmerkung**
Eine Liste der vorgefertigten Modelle, die mit AWS Panorama getestet wurden, finden Sie unter [Modellkompatibilität](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/resources/model-compatibility.md).
**Topics**
+ [Modelle im Code verwenden](#applications-models-using)
+ [Ein benutzerdefiniertes Modell erstellen](#applications-models-custom)
+ [Ein Modell verpacken](#applications-models-package)
+ [Modelltraining](#applications-models-training)
## Modelle im Code verwenden
Ein Modell gibt ein oder mehrere Ergebnisse zurück, die Wahrscheinlichkeiten für erkannte Klassen, Ortsinformationen und andere Daten beinhalten können. Das folgende Beispiel zeigt, wie Inferenzen für ein Bild aus einem Videostream ausgeführt und die Ausgabe des Modells an eine Verarbeitungsfunktion gesendet werden.
**Example [application.py — Inferenz](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/packages/123456789012-SAMPLE_CODE-1.0/application.py)**
```
def process_media(self, stream):
"""Runs inference on a frame of video."""
image_data = preprocess(stream.image,self.MODEL_DIM)
logger.debug('Image data: {}'.format(image_data))
# Run inference
inference_start = time.time()
inference_results = self.call({"data":image_data}, self.MODEL_NODE)
# Log metrics
inference_time = (time.time() - inference_start) * 1000
if inference_time > self.inference_time_max:
self.inference_time_max = inference_time
self.inference_time_ms += inference_time
# Process results (classification)
self.process_results(inference_results, stream)
```
Das folgende Beispiel zeigt eine Funktion, die Ergebnisse eines grundlegenden Klassifikationsmodells verarbeitet. Das Beispielmodell gibt eine Reihe von Wahrscheinlichkeiten zurück. Dabei handelt es sich um den ersten und einzigen Wert in der Ergebnismatrix.
**Example [application.py](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/packages/123456789012-SAMPLE_CODE-1.0/application.py) — Ergebnisse werden verarbeitet**
```
def process_results(self, inference_results, stream):
"""Processes output tensors from a computer vision model and annotates a video frame."""
if inference_results is None:
logger.warning("Inference results are None.")
return
max_results = 5
logger.debug('Inference results: {}'.format(inference_results))
class_tuple = inference_results[0]
enum_vals = [(i, val) for i, val in enumerate(class_tuple[0])]
sorted_vals = sorted(enum_vals, key=lambda tup: tup[1])
top_k = sorted_vals[::-1][:max_results]
indexes = [tup[0] for tup in top_k]
for j in range(max_results):
label = 'Class [%s], with probability %.3f.'% (self.classes[indexes[j]], class_tuple[0][indexes[j]])
stream.add_label(label, 0.1, 0.1 + 0.1*j)
```
Der Anwendungscode findet die Werte mit den höchsten Wahrscheinlichkeiten und ordnet sie den Bezeichnungen in einer Ressourcendatei zu, die während der Initialisierung geladen wird.
## Ein benutzerdefiniertes Modell erstellen
Sie können Modelle verwenden, die Sie in Apache PyTorch MXNet - und TensorFlow AWS-Panorama-Anwendungen erstellen. Als Alternative zum Erstellen und Trainieren von Modellen in SageMaker KI können Sie ein trainiertes Modell verwenden oder Ihr eigenes Modell mit einem unterstützten Framework erstellen und trainieren und es in eine lokale Umgebung oder in Amazon exportieren EC2.
**Anmerkung**
Einzelheiten zu den von SageMaker AI Neo unterstützten Framework-Versionen und Dateiformaten finden Sie unter [Unterstützte Frameworks](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-supported-devices-edge-frameworks.html) im Amazon SageMaker AI Developer Guide.
Das Repository für dieses Handbuch enthält eine Beispielanwendung, die diesen Workflow für ein Keras-Modell im TensorFlow `SavedModel` Format demonstriert. Es verwendet TensorFlow 2 und kann lokal in einer virtuellen Umgebung oder in einem Docker-Container ausgeführt werden. Die Beispiel-App enthält auch Vorlagen und Skripte für die Erstellung des Modells auf einer EC2 Amazon-Instance.
****
+ [Beispielanwendung für ein benutzerdefiniertes Modell](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/custom-model)
![\[\]](http://docs.aws.amazon.com/de_de/panorama/latest/dev/images/sample-custom-model.png)
AWS Panorama verwendet SageMaker AI Neo, um Modelle für die Verwendung auf der AWS Panorama Appliance zu kompilieren. Verwenden Sie für jedes Framework das [Format, das von SageMaker AI Neo unterstützt wird](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-compilation-preparing-model.html), und verpacken Sie das Modell in einem `.tar.gz` Archiv.
Weitere Informationen finden Sie unter [Modelle mit Neo kompilieren und bereitstellen](https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html) im Amazon SageMaker AI Developer Guide.
## Ein Modell verpacken
Ein Modellpaket besteht aus einem Deskriptor, einer Paketkonfiguration und einem Modellarchiv. Wie in einem [Anwendungs-Image-Paket](applications-image.md) teilt die Paketkonfiguration dem AWS Panorama Panorama-Service mit, wo das Modell und der Deskriptor in Amazon S3 gespeichert sind.
**Example [packages/123456789012-squeezenet\$1pytorch-1.0/descriptor.json](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/packages/123456789012-SQUEEZENET_PYTORCH-1.0/descriptor.json)**
```
{
"mlModelDescriptor": {
"envelopeVersion": "2021-01-01",
"framework": "PYTORCH",
"frameworkVersion": "1.8",
"precisionMode": "FP16",
"inputs": [
{
"name": "data",
"shape": [
1,
3,
224,
224
]
}
]
}
}
```
**Anmerkung**
Geben Sie nur die Haupt- und Nebenversion der Framework-Version an. Eine Liste der unterstützten Versionen PyTorch MXNet, Apache- und TensorFlow Versionsversionen finden Sie unter [Unterstützte Frameworks](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-supported-devices-edge-frameworks.html).
Verwenden Sie den `import-raw-model` CLI-Befehl AWS Panorama Application, um ein Modell zu importieren. Wenn Sie Änderungen am Modell oder seinem Deskriptor vornehmen, müssen Sie diesen Befehl erneut ausführen, um die Ressourcen der Anwendung zu aktualisieren. Weitere Informationen finden Sie unter [Änderung des Computer-Vision-Modells](gettingstarted-sample.md#gettingstarted-sample-model).
[Das JSON-Schema der Deskriptordatei finden Sie unter AssetDescriptor.schema.json.](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/resources/manifest-schema/ver_2021-01-01/assetDescriptor.schema.json)
## Modelltraining
Wenn Sie ein Modell trainieren, verwenden Sie Bilder aus der Zielumgebung oder aus einer Testumgebung, die der Zielumgebung sehr ähnlich ist. Berücksichtigen Sie die folgenden Faktoren, die sich auf die Modellleistung auswirken können:
****
+ **Beleuchtung** — Die Lichtmenge, die von einem Objekt reflektiert wird, bestimmt, wie viele Details das Modell analysieren muss. Ein Modell, das mit Bildern gut beleuchteter Objekte trainiert wurde, funktioniert in Umgebungen mit wenig Licht oder Gegenlicht möglicherweise nicht gut.
+ **Auflösung** — Die Eingabegröße eines Modells ist in der Regel auf eine Auflösung zwischen 224 und 512 Pixeln in einem quadratischen Seitenverhältnis festgelegt. Bevor Sie ein Videobild an das Modell übergeben, können Sie es verkleinern oder zuschneiden, bis es der gewünschten Größe entspricht.
+ **Bildverzerrung** — Die Brennweite und die Linsenform einer Kamera können dazu führen, dass Bilder außerhalb der Bildmitte verzerrt werden. Die Position einer Kamera bestimmt auch, welche Merkmale eines Motivs sichtbar sind. Beispielsweise zeigt eine Overhead-Kamera mit Weitwinkelobjektiv die Oberseite eines Motivs, wenn es sich in der Bildmitte befindet, und eine schiefe Ansicht der Seite des Motivs, wenn es sich weiter von der Bildmitte entfernt.
Um diese Probleme zu lösen, können Sie Bilder vorverarbeiten, bevor Sie sie an das Modell senden, und das Modell anhand einer größeren Vielfalt von Bildern trainieren, die Abweichungen in realen Umgebungen widerspiegeln. Wenn ein Modell in Lichtsituationen und mit einer Vielzahl von Kameras betrieben werden muss, benötigen Sie mehr Daten für das Training. Sie können nicht nur mehr Bilder erfassen, sondern auch mehr Trainingsdaten gewinnen, indem Sie Variationen Ihrer vorhandenen Bilder erstellen, die schief sind oder unterschiedliche Lichtverhältnisse aufweisen.
# Erstellen eines Anwendungsabbilds
Die AWS Panorama Appliance führt Anwendungen als Container-Dateisysteme aus, die aus einem von Ihnen erstellten Image exportiert werden. Sie geben die Abhängigkeiten und Ressourcen Ihrer Anwendung in einem Dockerfile an, das das Basisimage der AWS Panorama Panorama-Anwendung als Ausgangspunkt verwendet.
Um ein Anwendungs-Image zu erstellen, verwenden Sie Docker und die AWS Panorama Application CLI. Das folgende Beispiel aus der Beispielanwendung dieses Handbuchs veranschaulicht diese Anwendungsfälle.
**Example [Pakete/123456789012-sample\$1code-1.0/Dockerfile](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/packages/123456789012-SAMPLE_CODE-1.0/Dockerfile)**
```
FROM public.ecr.aws/panorama/panorama-application
WORKDIR /panorama
COPY . .
RUN pip install --no-cache-dir --upgrade pip && \
pip install --no-cache-dir -r requirements.txt
```
Die folgenden Dockerfile-Anweisungen werden verwendet.
****
+ `FROM`— Lädt das Basisimage der Anwendung ()`public.ecr.aws/panorama/panorama-application`.
+ `WORKDIR`— Legt das Arbeitsverzeichnis auf dem Image fest. `/panorama`wird für Anwendungscode und zugehörige Dateien verwendet. Diese Einstellung bleibt nur während des Builds bestehen und hat keinen Einfluss auf das Arbeitsverzeichnis Ihrer Anwendung zur Laufzeit (`/`).
+ `COPY`— Kopiert Dateien von einem lokalen Pfad in einen Pfad auf dem Image. `COPY . .`kopiert die Dateien im aktuellen Verzeichnis (dem Paketverzeichnis) in das Arbeitsverzeichnis auf dem Image. Beispielsweise wird der Anwendungscode von `packages/123456789012-SAMPLE_CODE-1.0/application.py` nach kopiert`/panorama/application.py`.
+ `RUN`— Führt während des Builds Shell-Befehle auf dem Image aus. Eine einzelne `RUN` Operation kann mehrere Befehle nacheinander ausführen, indem `&&` zwischen Befehlen verwendet wird. In diesem Beispiel wird der `pip` Paketmanager aktualisiert und anschließend die unter aufgeführten Bibliotheken installiert`requirements.txt`.
Sie können andere Anweisungen verwenden, z. B. `ADD` und`ARG`, die bei der Erstellung nützlich sind. Anweisungen, die dem Container Laufzeitinformationen hinzufügen, wie z. B.`ENV`, funktionieren nicht mit AWS Panorama. AWS Panorama führt keinen Container aus dem Image aus. Es verwendet das Image nur, um ein Dateisystem zu exportieren, das auf die Appliance übertragen wird.
## Angeben von Abhängigkeiten
`requirements.txt`ist eine Python-Anforderungsdatei, die die von der Anwendung verwendeten Bibliotheken spezifiziert. Die Beispielanwendung verwendet Open CV und die AWS SDK für Python (Boto3).
**Example [Pakete/123456789012-sample\$1code-1.0/requirements.txt](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/packages/123456789012-SAMPLE_CODE-1.0/requirements.txt)**
```
boto3==1.24.*
opencv-python==4.6.*
```
Der `pip install` Befehl im Dockerfile installiert diese Bibliotheken im `dist-packages` Python-Verzeichnis darunter`/usr/local/lib`, sodass sie von Ihrem Anwendungscode importiert werden können.
## Lokaler Speicher
AWS Panorama reserviert das `/opt/aws/panorama/storage` Verzeichnis für den Anwendungsspeicher. Ihre Anwendung kann Dateien in diesem Pfad erstellen und ändern. Im Speicherverzeichnis erstellte Dateien bleiben auch nach Neustarts erhalten. Andere Speicherorte für temporäre Dateien werden beim Start gelöscht.
## Image-Objekte erstellen
Wenn Sie mit der AWS Panorama Application CLI ein Image für Ihr Anwendungspaket erstellen, wird die CLI `docker build` im Paketverzeichnis ausgeführt. Dadurch wird ein Anwendungs-Image erstellt, das Ihren Anwendungscode enthält. Die CLI erstellt dann einen Container, exportiert sein Dateisystem, komprimiert ihn und speichert ihn im `assets` Ordner.
```
$ panorama-cli build-container --container-asset-name code_asset --package-path packages/123456789012-SAMPLE_CODE-1.0
docker build -t code_asset packages/123456789012-SAMPLE_CODE-1.0 --pull
docker export --output=code_asset.tar $(docker create code_asset:latest)
gzip -1 code_asset.tar
{
"name": "code_asset",
"implementations": [
{
"type": "container",
"assetUri": "6f67xmpl32743ed0e60c151a02f2f0da1bf70a4ab9d83fe236fa32a6f9b9f808.tar.gz",
"descriptorUri": "1872xmpl129481ed053c52e66d6af8b030f9eb69b1168a29012f01c7034d7a8f.json"
}
]
}
Container asset for the package has been succesfully built at /home/user/aws-panorama-developer-guide/sample-apps/aws-panorama-sample/assets/6f67xmpl32743ed0e60c151a02f2f0da1bf70a4ab9d83fe236fa32a6f9b9f808.tar.gz
```
Der JSON-Block in der Ausgabe ist eine Asset-Definition, die die CLI der Paketkonfiguration (`package.json`) hinzufügt und beim AWS Panorama Panorama-Service registriert. Die CLI kopiert auch die Deskriptordatei, die den Pfad zum Anwendungsskript (den Einstiegspunkt der Anwendung) angibt.
**Example [packages/123456789012-sample\$1code-1.0/descriptor.json](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/aws-panorama-sample/packages/123456789012-SAMPLE_CODE-1.0/descriptor.json)**
```
{
"runtimeDescriptor":
{
"envelopeVersion": "2021-01-01",
"entry":
{
"path": "python3",
"name": "/panorama/application.py"
}
}
}
```
Im Assets-Ordner sind der Deskriptor und das Anwendungsbild nach ihrer SHA-256-Prüfsumme benannt. Dieser Name wird als eindeutige Kennung für das Asset verwendet, wenn es in Amazon S3 gespeichert wird.
# AWS-Services von Ihrem Anwendungscode aus aufrufen
Sie können das verwenden AWS SDK für Python (Boto) , um AWS-Services von Ihrem Anwendungscode aus aufzurufen. Wenn Ihr Modell beispielsweise etwas Ungewöhnliches erkennt, können Sie Metriken an Amazon senden CloudWatch, eine Benachrichtigung mit Amazon SNS senden, ein Bild in Amazon S3 speichern oder eine Lambda-Funktion zur weiteren Verarbeitung aufrufen. Die meisten AWS-Services verfügen über eine öffentliche API, die Sie mit dem AWS-SDK verwenden können.
Die Appliance ist standardmäßig nicht berechtigt, auf AWS-Services zuzugreifen. Um ihr die Erlaubnis zu erteilen, [erstellen Sie eine Rolle für die Anwendung](permissions-application.md) und weisen Sie sie während der Bereitstellung der Anwendungsinstanz zu.
**Topics**
+ [Verwenden von Amazon S3](#applications-awssdk-s3)
+ [Verwenden Sie das AWS IoT MQTT-Thema](#monitoring-messagestream)
## Verwenden von Amazon S3
Sie können Amazon S3 verwenden, um Verarbeitungsergebnisse und andere Anwendungsdaten zu speichern.
```
import boto3
s3_client=boto3.client("s3")
s3_clients3.upload_file(data_file,
s3_bucket_name,
os.path.basename(data_file))
```
## Verwenden Sie das AWS IoT MQTT-Thema
Sie können das SDK for Python (Boto3) verwenden, um Nachrichten an ein [MQTT-Thema](https://docs.aws.amazon.com/iot/latest/developerguide/topics.html) in zu senden. AWS IoT[Im folgenden Beispiel veröffentlicht die Anwendung Beiträge zu einem Thema, das nach dem *Ding-Namen der Appliance benannt ist*, den Sie in der Konsole finden.AWS IoT](https://console.aws.amazon.com/iot/home#/thinghub)
```
import boto3
iot_client=boto3.client('iot-data')
topic = "panorama/panorama_my-appliance_Thing_a01e373b"
iot_client.publish(topic=topic, payload="my message")
```
Wählen Sie einen Namen, der auf die Geräte-ID oder eine andere Kennung Ihrer Wahl hinweist. Um Nachrichten zu veröffentlichen, benötigt die Anwendung eine Anruferlaubnis`iot:Publish`.
**Um eine MQTT-Warteschlange zu überwachen**
1. Öffnen Sie die [Testseite der AWS IoT Konsole](https://console.aws.amazon.com/iot/home?region=us-east-1#/test).
1. Geben Sie **unter Abonnement-Thema** den Namen des Themas ein. Beispiel, `panorama/panorama_my-appliance_Thing_a01e373b`.
1. Wählen Sie **Thema abonnieren** aus.
# Das AWS Panorama Panorama-Anwendungs-SDK
Das AWS Panorama Application SDK ist eine Python-Bibliothek für die Entwicklung von AWS-Panorama-Anwendungen. In Ihrem [Anwendungscode](gettingstarted-sample.md) verwenden Sie das AWS Panorama Application SDK, um ein Computer-Vision-Modell zu laden, Inferenzen auszuführen und Video auf einem Monitor auszugeben.
**Anmerkung**
Um sicherzustellen, dass Sie Zugriff auf die neuesten Funktionen des AWS Panorama Application SDK haben, [aktualisieren Sie die Appliance-Software](appliance-manage.md#appliance-manage-software).
Einzelheiten zu den vom Anwendungs-SDK definierten Klassen und ihren Methoden finden Sie in der [Anwendungs-SDK-Referenz](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/resources/applicationsdk-reference.md).
**Topics**
+ [Hinzufügen von Text und Feldern zum Ausgabevideo](#applications-panoramasdk-overlays)
## Hinzufügen von Text und Feldern zum Ausgabevideo
Mit dem AWS Panorama SDK können Sie einen Videostream auf einem Display ausgeben. Das Video kann Text und Felder enthalten, die die Ausgabe des Modells, den aktuellen Status der Anwendung oder andere Daten zeigen.
Jedes Objekt im `video_in` Array ist ein Bild aus einem Kamerastream, der mit der Appliance verbunden ist. Der Typ dieses Objekts ist`panoramasdk.media`. Es verfügt über Methoden zum Hinzufügen von Text und rechteckigen Feldern zum Bild, die Sie dann dem `video_out` Array zuweisen können.
Im folgenden Beispiel fügt die Beispielanwendung jedem der Ergebnisse eine Bezeichnung hinzu. Jedes Ergebnis befindet sich an derselben linken Position, jedoch auf unterschiedlichen Höhen.
```
for j in range(max_results):
label = 'Class [%s], with probability %.3f.'% (self.classes[indexes[j]], class_tuple[0][indexes[j]])
stream.add_label(label, 0.1, 0.1 + 0.1*j)
```
Um dem Ausgabebild ein Feld hinzuzufügen, verwenden Sie`add_rect`. Diese Methode akzeptiert 4 Werte zwischen 0 und 1, die die Position der oberen linken und unteren rechten Ecke des Felds angeben.
```
w,h,c = stream.image.shape
stream.add_rect(x1/w, y1/h, x2/w, y2/h)
```
# Mehrere Threads ausführen
Sie können Ihre Anwendungslogik auf einem Verarbeitungsthread ausführen und andere Threads für andere Hintergrundprozesse verwenden. Sie können beispielsweise einen Thread erstellen, der [HTTP-Verkehr zum Debuggen bereitstellt](applications-ports.md), oder einen Thread, der Inferenzergebnisse überwacht und Daten an diese sendet. AWS
Um mehrere Threads auszuführen, verwenden Sie das [Threading-Modul](https://docs.python.org/3/library/threading.html) aus der Python-Standardbibliothek, um für jeden Prozess einen Thread zu erstellen. Das folgende Beispiel zeigt die Hauptschleife der Beispielanwendung Debug-Server, die ein Anwendungsobjekt erstellt und es zum Ausführen von drei Threads verwendet.
**Example [packages/123456789012-debug\$1server-1.0/Application.py](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/debug-server/packages/123456789012-DEBUG_SERVER-1.0/application.py) — Hauptschleife**
```
def main():
panorama = panoramasdk.node()
while True:
try:
# Instantiate application
logger.info('INITIALIZING APPLICATION')
app = Application(panorama)
# Create threads for stream processing, debugger, and client
app.run_thread = threading.Thread(target=app.run_cv)
app.server_thread = threading.Thread(target=app.run_debugger)
app.client_thread = threading.Thread(target=app.run_client)
# Start threads
logger.info('RUNNING APPLICATION')
app.run_thread.start()
logger.info('RUNNING SERVER')
app.server_thread.start()
logger.info('RUNNING CLIENT')
app.client_thread.start()
# Wait for threads to exit
app.run_thread.join()
app.server_thread.join()
app.client_thread.join()
logger.info('RESTARTING APPLICATION')
except:
logger.exception('Exception during processing loop.')
```
Wenn alle Threads beendet sind, startet sich die Anwendung selbst neu. Die `run_cv` Schleife verarbeitet Bilder aus Kamerastreams. Wenn sie ein Signal zum Stoppen empfängt, beendet sie den Debugger-Prozess, der auf einem HTTP-Server läuft und sich nicht selbst herunterfahren kann. Jeder Thread muss seine eigenen Fehler behandeln. Wenn ein Fehler nicht abgefangen und protokolliert wird, wird der Thread im Hintergrund beendet.
**Example [packages/123456789012-debug\$1server-1.0/Application.py](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/debug-server/packages/123456789012-DEBUG_SERVER-1.0/application.py) — Verarbeitungsschleife**
```
# Processing loop
def run_cv(self):
"""Run computer vision workflow in a loop."""
logger.info("PROCESSING STREAMS")
while not self.terminate:
try:
self.process_streams()
# turn off debug logging after 15 loops
if logger.getEffectiveLevel() == logging.DEBUG and self.frame_num == 15:
logger.setLevel(logging.INFO)
except:
logger.exception('Exception on processing thread.')
# Stop signal received
logger.info("SHUTTING DOWN SERVER")
self.server.shutdown()
self.server.server_close()
logger.info("EXITING RUN THREAD")
```
Threads kommunizieren über das Objekt der Anwendung. `self` Um die Verarbeitungsschleife der Anwendung neu zu starten, ruft der Debugger-Thread die `stop` Methode auf. Diese Methode setzt ein `terminate` Attribut, das den anderen Threads signalisiert, dass sie heruntergefahren werden sollen.
**Example [packages/123456789012-debug\$1server-1.0/Application.py](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/debug-server/packages/123456789012-DEBUG_SERVER-1.0/application.py) — Stopp-Methode**
```
# Interrupt processing loop
def stop(self):
"""Signal application to stop processing."""
logger.info("STOPPING APPLICATION")
# Signal processes to stop
self.terminate = True
# HTTP debug server
def run_debugger(self):
"""Process debug commands from local network."""
class ServerHandler(SimpleHTTPRequestHandler):
# Store reference to application
application = self
# Get status
def do_GET(self):
"""Process GET requests."""
logger.info('Get request to {}'.format(self.path))
if self.path == "/status":
self.send_200('OK')
else:
self.send_error(400)
# Restart application
def do_POST(self):
"""Process POST requests."""
logger.info('Post request to {}'.format(self.path))
if self.path == '/restart':
self.send_200('OK')
ServerHandler.application.stop()
else:
self.send_error(400)
```
# Bedienung des eingehenden Datenverkehrs
Sie können Anwendungen lokal überwachen oder debuggen, indem Sie einen HTTP-Server zusammen mit Ihrem Anwendungscode ausführen. Um externen Datenverkehr bereitzustellen, ordnen Sie die Ports auf der AWS Panorama Appliance den Ports in Ihrem Anwendungscontainer zu.
**Wichtig**
Standardmäßig akzeptiert die AWS Panorama Appliance keinen eingehenden Datenverkehr an irgendwelchen Ports. Das Öffnen von Ports auf der Appliance birgt ein implizites Sicherheitsrisiko. Wenn Sie diese Funktion verwenden, müssen Sie zusätzliche Maßnahmen ergreifen, um [Ihre Appliance vor externem Datenverkehr](appliance-network.md) zu schützen und die Kommunikation zwischen autorisierten Clients und der Appliance zu sichern.
Der in diesem Handbuch enthaltene Beispielcode dient zu Demonstrationszwecken und implementiert keine Authentifizierung, Autorisierung oder Verschlüsselung.
Sie können Ports im Bereich 8000—9000 an der Appliance öffnen. Wenn diese Ports geöffnet sind, können sie Datenverkehr von jedem routbaren Client empfangen. Wenn Sie Ihre Anwendung bereitstellen, geben Sie an, welche Ports geöffnet werden sollen, und ordnen die Ports auf der Appliance den Ports in Ihrem Anwendungscontainer zu. Die Appliance-Software leitet den Datenverkehr an den Container weiter und sendet Antworten zurück an den Anforderer. Anfragen werden auf dem von Ihnen angegebenen Appliance-Port empfangen und Antworten werden an einem zufälligen kurzlebigen Port gesendet.
## Konfiguration eingehender Ports
Sie geben Portzuordnungen an drei Stellen in Ihrer Anwendungskonfiguration an. In den Codepaketen `package.json` geben Sie den Port an, auf dem der Codeknoten in einem Block lauscht. `network` Das folgende Beispiel deklariert, dass der Knoten auf Port 80 lauscht.
**Example [Pakete/123456789012-debug\$1server-1.0/package.json](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/debug-server/packages/123456789012-DEBUG_SERVER-1.0/package.json)**
```
"outputs": [
{
"description": "Video stream output",
"name": "video_out",
"type": "media"
}
],
"network": {
"inboundPorts": [
{
"port": 80,
"description": "http"
}
]
}
```
Im Anwendungsmanifest deklarieren Sie eine Routing-Regel, die einen Port auf der Appliance einem Port im Codecontainer der Anwendung zuordnet. Im folgenden Beispiel wird eine Regel hinzugefügt, die Port 8080 auf dem Gerät Port 80 auf dem `code_node` Container zuordnet.
**Example [graphs/my-app/graph.json](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/debug-server/graphs/my-app/graph.json)**
```
{
"producer": "model_input_width",
"consumer": "code_node.model_input_width"
},
{
"producer": "model_input_order",
"consumer": "code_node.model_input_order"
}
],
"networkRoutingRules": [
{
"node": "code_node",
"containerPort": 80,
"hostPort": 8080,
"decorator": {
"title": "Listener port 8080",
"description": "Container monitoring and debug."
}
}
]
```
Wenn Sie die Anwendung bereitstellen, geben Sie dieselben Regeln in der AWS-Panorama-Konsole oder mit einem Override-Dokument an, das an die [CreateApplicationInstance](https://docs.aws.amazon.com/panorama/latest/api/API_CreateApplicationInstance.html)API übergeben wird. Sie müssen diese Konfiguration bei der Bereitstellung angeben, um zu bestätigen, dass Sie Ports auf der Appliance öffnen möchten.
**Example [graphs/my-app/override.json](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/debug-server/graphs/my-app/override.json)**
```
{
"replace": "camera_node",
"with": [
{
"name": "exterior-north"
}
]
}
],
"networkRoutingRules":[
{
"node": "code_node",
"containerPort": 80,
"hostPort": 8080
}
],
"envelopeVersion": "2021-01-01"
}
}
```
Wenn der im Anwendungsmanifest angegebene Geräteport von einer anderen Anwendung verwendet wird, können Sie das Override-Dokument verwenden, um einen anderen Port auszuwählen.
## Verkehr bedienen
Wenn die Ports auf dem Container geöffnet sind, können Sie einen Socket öffnen oder einen Server ausführen, um eingehende Anfragen zu bearbeiten. Das `debug-server` Beispiel zeigt eine grundlegende Implementierung eines HTTP-Servers, der zusammen mit Computer-Vision-Anwendungscode ausgeführt wird.
**Wichtig**
Die Beispielimplementierung ist für den Produktionsgebrauch nicht sicher. Um zu verhindern, dass Ihre Appliance anfällig für Angriffe wird, müssen Sie entsprechende Sicherheitskontrollen in Ihrem Code und Ihrer Netzwerkkonfiguration implementieren.
**Example [packages/123456789012-debug\$1server-1.0/Application.py](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/debug-server/packages/123456789012-DEBUG_SERVER-1.0/application.py) — HTTP-Server**
```
# HTTP debug server
def run_debugger(self):
"""Process debug commands from local network."""
class ServerHandler(SimpleHTTPRequestHandler):
# Store reference to application
application = self
# Get status
def do_GET(self):
"""Process GET requests."""
logger.info('Get request to {}'.format(self.path))
if self.path == '/status':
self.send_200('OK')
else:
self.send_error(400)
# Restart application
def do_POST(self):
"""Process POST requests."""
logger.info('Post request to {}'.format(self.path))
if self.path == '/restart':
self.send_200('OK')
ServerHandler.application.stop()
else:
self.send_error(400)
# Send response
def send_200(self, msg):
"""Send 200 (success) response with message."""
self.send_response(200)
self.send_header('Content-Type', 'text/plain')
self.end_headers()
self.wfile.write(msg.encode('utf-8'))
try:
# Run HTTP server
self.server = HTTPServer(("", self.CONTAINER_PORT), ServerHandler)
self.server.serve_forever(1)
# Server shut down by run_cv loop
logger.info("EXITING SERVER THREAD")
except:
logger.exception('Exception on server thread.')
```
Der Server akzeptiert GET-Anfragen im Pfad, um einige Informationen über die Anwendung abzurufen. `/status` Er akzeptiert auch eine POST-Anfrage, `/restart` um die Anwendung neu zu starten.
Um diese Funktionalität zu demonstrieren, führt die Beispielanwendung einen HTTP-Client in einem separaten Thread aus. Der Client ruft den `/status` Pfad kurz nach dem Start über das lokale Netzwerk auf und startet die Anwendung einige Minuten später neu.
**Example [packages/123456789012-debug\$1server-1.0/Application.py](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/debug-server/packages/123456789012-DEBUG_SERVER-1.0/application.py) — HTTP-Client**
```
# HTTP test client
def run_client(self):
"""Send HTTP requests to device port to demnostrate debug server functions."""
def client_get():
"""Get container status"""
r = requests.get('http://{}:{}/status'.format(self.device_ip, self.DEVICE_PORT))
logger.info('Response: {}'.format(r.text))
return
def client_post():
"""Restart application"""
r = requests.post('http://{}:{}/restart'.format(self.device_ip, self.DEVICE_PORT))
logger.info('Response: {}'.format(r.text))
return
# Call debug server
while not self.terminate:
try:
time.sleep(30)
client_get()
time.sleep(300)
client_post()
except:
logger.exception('Exception on client thread.')
# stop signal received
logger.info("EXITING CLIENT THREAD")
```
Die Hauptschleife verwaltet die Threads und startet die Anwendung neu, wenn sie beendet werden.
**Example [packages/123456789012-debug\$1server-1.0/Application.py](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/debug-server/packages/123456789012-DEBUG_SERVER-1.0/application.py) — Hauptschleife**
```
def main():
panorama = panoramasdk.node()
while True:
try:
# Instantiate application
logger.info('INITIALIZING APPLICATION')
app = Application(panorama)
# Create threads for stream processing, debugger, and client
app.run_thread = threading.Thread(target=app.run_cv)
app.server_thread = threading.Thread(target=app.run_debugger)
app.client_thread = threading.Thread(target=app.run_client)
# Start threads
logger.info('RUNNING APPLICATION')
app.run_thread.start()
logger.info('RUNNING SERVER')
app.server_thread.start()
logger.info('RUNNING CLIENT')
app.client_thread.start()
# Wait for threads to exit
app.run_thread.join()
app.server_thread.join()
app.client_thread.join()
logger.info('RESTARTING APPLICATION')
except:
logger.exception('Exception during processing loop.')
```
[Informationen zur Bereitstellung der Beispielanwendung finden Sie in den Anweisungen im Repository dieses Handbuchs. GitHub ](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/debug-server/README.md)
# Verwendung der GPU
Sie können auf den Grafikprozessor (GPU) der AWS Panorama Appliance zugreifen, um GPU-beschleunigte Bibliotheken zu verwenden oder Modelle für maschinelles Lernen in Ihrem Anwendungscode auszuführen. Um den GPU-Zugriff zu aktivieren, fügen Sie GPU-Zugriff als Anforderung zur Paketkonfiguration hinzu, nachdem Sie Ihren Anwendungscode-Container erstellt haben.
**Wichtig**
Wenn Sie den GPU-Zugriff aktivieren, können Sie Modellknoten in keiner Anwendung auf der Appliance ausführen. Aus Sicherheitsgründen ist der GPU-Zugriff eingeschränkt, wenn auf der Appliance ein mit SageMaker AI Neo kompiliertes Modell ausgeführt wird. Beim GPU-Zugriff müssen Sie Ihre Modelle in Anwendungscodeknoten ausführen, und alle Anwendungen auf dem Gerät haben gemeinsam Zugriff auf die GPU.
Um den GPU-Zugriff für Ihre Anwendung zu aktivieren, aktualisieren Sie die [Paketkonfiguration](applications-packages.md), nachdem Sie das Paket mit der AWS Panorama Application CLI erstellt haben. Das folgende Beispiel zeigt den `requirements` Block, der GPU-Zugriff auf den Anwendungscodeknoten hinzufügt.
**Example package.json mit dem Anforderungsblock**
```
{
"nodePackage": {
"envelopeVersion": "2021-01-01",
"name": "SAMPLE_CODE",
"version": "1.0",
"description": "Computer vision application code.",
"assets": [
{
"name": "code_asset",
"implementations": [
{
"type": "container",
"assetUri": "eba3xmpl71aa387e8f89be9a8c396416cdb80a717bb32103c957a8bf41440b12.tar.gz",
"descriptorUri": "4abdxmpl5a6f047d2b3047adde44704759d13f0126c00ed9b4309726f6bb43400ba9.json",
"requirements": [
{
"type": "hardware_access",
"inferenceAccelerators": [
{
"deviceType": "nvhost_gpu",
"sharedResourcePolicy": {
"policy" : "allow_all"
}
}
]
}
]
}
]
}
],
"interfaces": [
...
```
Aktualisieren Sie die Paketkonfiguration zwischen den Build- und Paketierungsschritten in Ihrem Entwicklungsworkflow.
**Um eine Anwendung mit GPU-Zugriff bereitzustellen**
1. Verwenden Sie den `build-container` Befehl, um den Anwendungscontainer zu erstellen.
```
$ panorama-cli build-container --container-asset-name code_asset --package-path packages/123456789012-SAMPLE_CODE-1.0
```
1. Fügen Sie den `requirements` Block zur Paketkonfiguration hinzu.
1. Verwenden Sie den `package-application` Befehl, um das Container-Asset und die Paketkonfiguration hochzuladen.
```
$ panorama-cli package-application
```
1. Stellen Sie die Anwendung bereit.
Beispielanwendungen, die GPU-Zugriff verwenden, finden Sie im [aws-panorama-samples](https://github.com/aws-samples/aws-panorama-samples) GitHub Repository.
# Eine Entwicklungsumgebung in Windows einrichten
Um eine AWS-Panorama-Anwendung zu erstellen, verwenden Sie Docker, Befehlszeilentools und Python. In Windows können Sie eine Entwicklungsumgebung einrichten, indem Sie Docker Desktop mit Windows-Subsystem für Linux und Ubuntu verwenden. Dieses Tutorial führt Sie durch den Einrichtungsprozess für eine Entwicklungsumgebung, die mit AWS-Panorama-Tools und Beispielanwendungen getestet wurde.
**Topics**
+ [Voraussetzungen](#applications-devenvwindows-prerequisites)
+ [Installieren Sie WSL 2 und Ubuntu](#applications-devenvwindows-wsl2)
+ [Installieren von Docker](#applications-devenvwindows-docker)
+ [Konfigurieren Sie Ubuntu](#applications-devenvwindows-ubuntu)
+ [Nächste Schritte](#applications-devenvwindows-nextsteps)
## Voraussetzungen
Um diesem Tutorial folgen zu können, benötigen Sie eine Version von Windows, die das Windows-Subsystem für Linux 2 (WSL 2) unterstützt.
****
+ Windows 10 Version 1903 und höher (Build 18362 und höher) oder Windows 11
+ Windows-Funktionen
+ Windows-Subsystem für Linux
+ Hyper-V
+ Plattform für virtuelle Maschinen
Dieses Tutorial wurde mit den folgenden Softwareversionen entwickelt.
****
+ Ubuntu 20.04
+ Python 3.8.5
+ Docker 20.10.8
## Installieren Sie WSL 2 und Ubuntu
Wenn Sie Windows 10 Version 2004 und höher (Build 19041 und höher) haben, können Sie WSL 2 und Ubuntu 20.04 mit dem folgenden Befehl installieren. PowerShell
```
> wsl --install -d Ubuntu-20.04
```
Folgen Sie für ältere Windows-Versionen den Anweisungen in der WSL 2-Dokumentation: [Manuelle](https://docs.microsoft.com/en-us/windows/wsl/install-manual) Installationsschritte für ältere Versionen
## Installieren von Docker
[Um Docker Desktop zu installieren, laden Sie das Installationspaket von hub.docker.com herunter und führen Sie es aus.](https://hub.docker.com/editions/community/docker-ce-desktop-windows/) [Wenn Sie auf Probleme stoßen, folgen Sie den Anweisungen auf der Docker-Website: Docker Desktop WSL 2-Backend.](https://docs.docker.com/desktop/windows/wsl/)
Führen Sie Docker Desktop aus und folgen Sie dem Tutorial zur ersten Ausführung, um einen Beispielcontainer zu erstellen.
**Anmerkung**
Docker Desktop aktiviert Docker nur in der Standarddistribution. ****Wenn Sie vor der Ausführung dieses Tutorials andere Linux-Distributionen installiert haben, aktivieren Sie Docker in der neu installierten Ubuntu-Distribution im Docker Desktop-Einstellungsmenü unter Ressourcen, WSL-Integration.****
## Konfigurieren Sie Ubuntu
Sie können jetzt Docker-Befehle in Ihrer virtuellen Ubuntu-Maschine ausführen. Um ein Befehlszeilenterminal zu öffnen, führen Sie die Distribution über das Startmenü aus. Wenn Sie es zum ersten Mal ausführen, konfigurieren Sie einen Benutzernamen und ein Passwort, mit denen Sie Administratorbefehle ausführen können.
Um die Konfiguration Ihrer Entwicklungsumgebung abzuschließen, aktualisieren Sie die Software der virtuellen Maschine und installieren Sie Tools.
**Um die virtuelle Maschine zu konfigurieren**
1. Aktualisieren Sie die mit Ubuntu gelieferte Software.
```
$ sudo apt update && sudo apt upgrade -y && sudo apt autoremove
```
1. Installieren Sie Entwicklungstools mit Apt.
```
$ sudo apt install unzip python3-pip
```
1. Installieren Sie Python-Bibliotheken mit pip.
```
$ pip3 install awscli panoramacli
```
1. Öffnen Sie ein neues Terminal und führen Sie es dann aus, `aws configure` um das AWS CLI zu konfigurieren.
```
$ aws configure
```
Wenn Sie keine Zugriffsschlüssel haben, können Sie diese in der [IAM-Konsole](https://console.aws.amazon.com/iamv2/home?#/users) generieren.
Laden Sie abschließend die Beispielanwendung herunter und importieren Sie sie.
**Um die Beispielanwendung zu erhalten**
1. Laden Sie die Beispielanwendung herunter und extrahieren Sie sie.
```
$ wget https://github.com/awsdocs/aws-panorama-developer-guide/releases/download/v1.0-ga/aws-panorama-sample.zip
$ unzip aws-panorama-sample.zip
$ cd aws-panorama-sample
```
1. Führen Sie die mitgelieferten Skripts aus, um die Kompilierung zu testen, den Anwendungscontainer zu erstellen und Pakete auf AWS Panorama hochzuladen.
```
aws-panorama-sample$ ./0-test-compile.sh
aws-panorama-sample$ ./1-create-role.sh
aws-panorama-sample$ ./2-import-app.sh
aws-panorama-sample$ ./3-build-container.sh
aws-panorama-sample$ ./4-package-app.sh
```
Die AWS Panorama Application CLI lädt Pakete hoch und registriert sie beim AWS Panorama Panorama-Service. Sie können [die Beispiel-App jetzt mit der AWS-Panorama-Konsole bereitstellen](gettingstarted-deploy.md#gettingstarted-deploy-deploy).
## Nächste Schritte
Um die Projektdateien zu untersuchen und zu bearbeiten, können Sie den Datei-Explorer oder eine integrierte Entwicklungsumgebung (IDE) verwenden, die WSL unterstützt.
Um auf das Dateisystem der virtuellen Maschine zuzugreifen, öffnen Sie den Datei-Explorer und geben Sie `\\wsl$` in der Navigationsleiste den Text ein. Dieses Verzeichnis enthält einen Link zum Dateisystem der virtuellen Maschine (`Ubuntu-20.04`) und zu den Dateisystemen für die Docker-Daten. Unter befindet `Ubuntu-20.04` sich Ihr Benutzerverzeichnis unter`home\username`.
**Anmerkung**
Um von Ubuntu aus auf Dateien in Ihrer Windows-Installation zuzugreifen, navigieren Sie zu dem `/mnt/c` Verzeichnis. Sie können beispielsweise Dateien in Ihrem Download-Verzeichnis auflisten, indem Sie den Befehl ausführen`ls /mnt/c/Users/windows-username/Downloads`.
Mit Visual Studio Code können Sie Anwendungscode in Ihrer Entwicklungsumgebung bearbeiten und Befehle mit einem integrierten Terminal ausführen. Besuchen Sie [code.visualstudio.com](https://code.visualstudio.com/), um Visual Studio Code zu installieren. [Fügen Sie nach der Installation die Remote WSL-Erweiterung hinzu.](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-wsl)
Das Windows-Terminal ist eine Alternative zum Standard-Ubuntu-Terminal, in dem Sie Befehle ausgeführt haben. Es unterstützt mehrere Tabs und kann für jede andere Linux-Variante, die Sie installieren, die Befehlszeile und Terminals ausführen PowerShell. Es unterstützt Kopieren und Einfügen mit Ctrl C und Ctrl V , anklickbare URLs Funktionen und andere nützliche Verbesserungen. Besuchen Sie [microsoft.com](https://www.microsoft.com/en-us/p/windows-terminal/9n0dx20hk701), um Windows Terminal zu installieren.