Melayani lalu lintas masuk

Anda dapat memantau atau men-debug aplikasi secara lokal dengan menjalankan server HTTP bersama kode aplikasi Anda. Untuk melayani lalu lintas eksternal, Anda memetakan port pada AWS Panorama Appliance ke port pada wadah aplikasi Anda.

penting

Secara default, AWS Panorama Appliance tidak menerima lalu lintas masuk pada port apa pun. Membuka port pada alat memiliki risiko keamanan implisit. Saat Anda menggunakan fitur ini, Anda harus mengambil langkah tambahanamankan alat Anda dari lalu lintas eksternaldan mengamankan komunikasi antara klien resmi dan alat.

Kode contoh yang disertakan dalam panduan ini adalah untuk tujuan demonstrasi dan tidak menerapkan otentikasi, otorisasi, atau enkripsi.

Anda dapat membuka port di kisaran 8000-9000 pada alat. Port ini, ketika dibuka, dapat menerima lalu lintas dari klien yang dapat dirutekan. Saat Anda menerapkan aplikasi, Anda menentukan port mana yang akan dibuka, dan memetakan port pada alat ke port pada wadah aplikasi Anda. Perangkat lunak alat meneruskan lalu lintas ke wadah, dan mengirimkan tanggapan kembali ke pemohon. Permintaan diterima pada port alat yang Anda tentukan dan tanggapan keluar pada port fana acak.

Mengonfigurasi port masuk

Anda menentukan pemetaan port di tiga tempat dalam konfigurasi aplikasi Anda. Paket kodenyapackage.json, Anda menentukan port yang didengarkan oleh node kode dalamnetworkblok Contoh berikut menyatakan bahwa node mendengarkan pada port 80.

contoh Paket/123456789012-debug_server-1.0/package.json

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

Dalam manifes aplikasi, Anda mendeklarasikan aturan perutean yang memetakan port pada alat ke port pada wadah kode aplikasi. Contoh berikut menambahkan aturan yang memetakan port 8080 pada perangkat ke port 80 padacode_nodekontainer

contoh grafik/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."
                }
            }
        ]

Saat menerapkan aplikasi, Anda menentukan aturan yang sama di konsol AWS Panorama, atau dengan dokumen penggantian yang diteruskan keCreateApplicationInstanceAPI Anda harus menyediakan konfigurasi ini pada waktu penyebaran untuk mengonfirmasi bahwa Anda ingin membuka port pada alat.

contoh grafik/my-app/override.json

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

Jika port perangkat yang ditentukan dalam manifes aplikasi sedang digunakan oleh aplikasi lain, Anda dapat menggunakan dokumen ganti untuk memilih port yang berbeda.

Melayani lalu lintas

Dengan port terbuka pada wadah, Anda dapat membuka soket atau menjalankan server untuk menangani permintaan masuk. Parameterdebug-serversampel menunjukkan implementasi dasar dari server HTTP yang berjalan bersama kode aplikasi visi komputer.

penting

Implementasi sampel tidak aman untuk penggunaan produksi. Untuk menghindari membuat perangkat Anda rentan terhadap serangan, Anda harus menerapkan kontrol keamanan yang sesuai dalam kode dan konfigurasi jaringan Anda.

contoh Paket/123456789012-debug_server-1.0/application.py— Server 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.')

Server menerima permintaan GET di/statuspath untuk mengambil beberapa informasi tentang aplikasi. Hal ini juga menerima permintaan POST untuk/restartuntuk me-restart aplikasi.

Untuk mendemonstrasikan fungsionalitas ini, aplikasi sampel menjalankan klien HTTP pada thread terpisah. Klien memanggil/statusjalur melalui jaringan lokal tak lama setelah startup, dan restart aplikasi beberapa menit kemudian.

contoh Paket/123456789012-debug_server-1.0/application.py— Klien 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")

Loop utama mengelola thread dan restart aplikasi ketika mereka keluar.

contoh Paket/123456789012-debug_server-1.0/application.py— Loop Utama

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

Untuk men-deploy aplikasi sampel, lihatpetunjuk dalam panduan ini GitHub repositori.