Serving von Datenverkehr

Sie können Anwendungen lokal überwachen oder debuggen, indem Sie neben Ihrem Anwendungscode einen HTTP-Server ausführen. Um externen Datenverkehr zu bedienen, ordnen Sie Ports auf der AWS Panorama Appliance Ports in Ihrem Anwendungscontainer zu.

Wichtig

Standardmäßig akzeptiert die AWS Panorama 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 Schritte ausführen, umschützen Sie Ihre Appliance vor externem Datenverkehrund sichere Kommunikation zwischen autorisierten Clients und der Appliance.

Der in diesem Handbuch enthaltene Beispielcode dient zu Demonstrationszwecken und implementiert keine Authentifizierung, Autorisierung oder Verschlüsselung.

Sie können Ports im Bereich von 8000 bis 9000 auf der Appliance öffnen. Wenn diese Ports geöffnet sind, können sie Datenverkehr von jedem routingfähigen Client empfangen. Wenn Sie Ihre Anwendung bereitstellen, geben Sie an, welche Ports geöffnet werden sollen, und ordnen Ports auf der Appliance Ports in Ihrem Anwendungscontainer zu. Die Appliance-Software leitet den Datenverkehr an den Container weiter und sendet Antworten an den Anforderer zurück. Anfragen werden an dem von Ihnen angegebenen Appliance-Port empfangen, und die Antworten werden an einem zufälligen kurzlebigen Port ausgegeben.

Konfigurieren von Ports eingehender Abfragen

Sie geben Portzuordnungen an drei Stellen in Ihrer Anwendungskonfiguration an. Das Codepaket istpackage.jsonverwenden, geben Sie den Port an, den der Codeknoten in einemnetworkBlock. Das folgende Beispiel erklärt, dass der Knoten auf Port 80 lauscht.

Beispiel Pakete/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 dercode_nodeContainer.

Beispiel 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 Panorama-Konsole oder mit einem Override-Dokument an, das an dieCreateApplicationInstanceAPI. Sie müssen diese Konfiguration bei der Bereitstellung angeben, um zu bestätigen, dass Sie Ports auf der Appliance öffnen möchten.

Beispiel graphs/meine-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äte-Port von einer anderen Anwendung verwendet wird, können Sie das Override-Dokument verwenden, um einen anderen Port auszuwählen.

Serving Datenverkehr

Wenn Ports auf dem Container geöffnet sind, können Sie einen Socket öffnen oder einen Server ausführen, um eingehende Anfragen zu bearbeiten. Diedebug-serverBeispiel zeigt eine grundlegende Implementierung eines HTTP-Servers, der zusammen mit Computer Vision-Anwendungscode ausgeführt wird.

Wichtig

Die Beispielimplementierung ist für die Produktion nicht sicher. Um zu vermeiden, dass Ihre Appliance anfällig für Angriffe wird, müssen Sie geeignete Sicherheitskontrollen in Ihrem Code und Ihrer Netzwerkkonfiguration implementieren.

Beispiel Pakete/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 auf der/status-Pfad, um einige Informationen über die Anwendung abzurufen. Es akzeptiert auch eine POST-Anfrage an/restartum die Anwendung neu zu starten.

Um diese Funktionalität zu demonstrieren, führt die Beispielanwendung einen HTTP-Client in einem separaten Thread aus. Der Kunde ruft den/status-Pfad kurz nach dem Start über das lokale Netzwerk und startet die Anwendung einige Minuten später neu.

Beispiel Pakete/123456789012-debug_server-1.0/application.py— HTTP-Clients

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

Beispiel Pakete/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 derAnweisungen in diesem Handbuch GitHub Repository.