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. # 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)