Diffusion du trafic entrant

Vous pouvez surveiller ou déboguer des applications localement en exécutant un serveur HTTP en même temps que le code de votre application. Pour traiter le trafic externe, vous mappez les ports de l'appliance AWS Panorama aux ports de votre conteneur d'applications.

Important

Par défaut, l'appliance AWS Panorama n'accepte le trafic entrant sur aucun port. L'ouverture de ports sur l'appliance présente un risque de sécurité implicite. Lorsque vous utilisez cette fonction, vous devez prendre des mesures supplémentaires poursécurisez votre appliance contre le trafic externeet des communications sécurisées entre les clients autorisés et l'appliance.

L'exemple de code inclus dans ce guide est fourni à des fins de démonstration et n'implémente pas l'authentification, l'autorisation ou le chiffrement.

Vous pouvez ouvrir des ports compris entre 8000 et 9000 sur l'appliance. Ces ports, lorsqu'ils sont ouverts, peuvent recevoir du trafic provenant de n'importe quel client routable. Lorsque vous déployez votre application, vous spécifiez les ports à ouvrir et vous mappez les ports de l'appliance aux ports de votre conteneur d'applications. Le logiciel de l'appliance transmet le trafic au conteneur et renvoie les réponses au demandeur. Les demandes sont reçues sur le port de l'appliance que vous spécifiez et les réponses sont envoyées sur un port éphémère aléatoire.

Configuration des ports entrants

Vous spécifiez des mappages de ports à trois endroits dans la configuration de votre application. Le package de codepackage.json, vous spécifiez le port sur lequel le nœud de code écoute dans unnetworkbloquer. L'exemple suivant déclare que le nœud écoute sur le port 80.

Exemple /Paquets/123456789012-debug_server-1.0/package.json

                "outputs": [
                    {
                        "description": "Video stream output",
                        "name": "video_out",
                        "type": "media"
                    }
                ],
                "network": {
                    "inboundPorts": [
                        {
                            "port": 80,
                            "description": "http"
                        }
                    ]
                }

Dans le manifeste de l'application, vous déclarez une règle de routage qui mappe un port de l'appliance à un port du conteneur de code de l'application. L'exemple suivant ajoute une règle qui mappe le port 8080 de l'appareil au port 80 ducode_nodeconteneur.

Exemple graphs/mon-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."
                }
            }
        ]

Lorsque vous déployez l'application, vous spécifiez les mêmes règles dans la console AWS Panorama ou avec un document de remplacement transmis auCreateApplicationInstanceAPI. Vous devez fournir cette configuration au moment du déploiement pour confirmer que vous souhaitez ouvrir des ports sur l'appliance.

Exemple graphiques/mon-app/override.json

            {
                "replace": "camera_node",
                "with": [
                    {
                        "name": "exterior-north"
                    }
                ]
            }
        ],
        "networkRoutingRules":[
            {
                "node": "code_node",
                "containerPort": 80,
                "hostPort": 8080
            }
        ],
        "envelopeVersion": "2021-01-01"
    }
}

Si le port de périphérique spécifié dans le manifeste de l'application est utilisé par une autre application, vous pouvez utiliser le document de remplacement pour choisir un autre port.

Diffusion du trafic

Lorsque les ports sont ouverts sur le conteneur, vous pouvez ouvrir un socket ou exécuter un serveur pour gérer les requêtes entrantes. Ledebug-serverL'exemple montre une implémentation de base d'un serveur HTTP exécuté parallèlement au code d'application de vision par ordinateur.

Important

L'exemple d'implémentation n'est pas sécurisé pour une utilisation en production. Pour éviter de rendre votre appliance vulnérable aux attaques, vous devez implémenter des contrôles de sécurité appropriés dans votre code et votre configuration réseau.

Exemple /Paquets/123456789012-debug_server-1.0/application.py— Serveur HTTP

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

Le serveur accepte les requêtes GET au niveau du/statuschemin pour récupérer certaines informations sur l'application. Il accepte également une demande POST vers/restartpour redémarrer l'application.

Pour démontrer cette fonctionnalité, l'exemple d'application exécute un client HTTP sur un thread distinct. Le client appelle le/statuschemin sur le réseau local peu de temps après le démarrage et redémarre l'application quelques minutes plus tard.

Exemple /Paquets/123456789012-debug_server-1.0/application.py— Client HTTP

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

La boucle principale gère les threads et redémarre l'application lorsqu'ils quittent.

Exemple /Paquets/123456789012-debug_server-1.0/application.py— Boucle principale

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

Pour déployer l'exemple d'application, consultezinstructions de ce guide GitHub repository.