Aviso de fim do suporte: em 31 de maio de 2026, AWS encerrará o suporte para AWS Panorama. Depois de 31 de maio de 2026, você não poderá mais acessar o AWS Panorama console ou os AWS Panorama recursos. Para obter mais informações, consulte [AWS Panorama Fim do suporte](https://docs.aws.amazon.com/panorama/latest/dev/panorama-end-of-support.html). 

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Nós da aplicação
<a name="applications-nodes"></a>

Os nós são modelos, código, streams de câmera, saída e parâmetros. Um nó tem uma interface, que define suas entradas e saídas. A interface pode ser definida em um pacote na sua conta, em um pacote fornecido pelo AWS Panorama ou em um tipo incorporado.

No exemplo a seguir, `code_node` e `model_node` referem-se aos pacotes de exemplo de código e modelo incluídos na aplicação de exemplo. `camera_node` usa um pacote fornecido pelo AWS Panorama para criar um espaço reservado para um stream de câmera que você especifica durante a implantação.

**Example graph.json: nós**  

```
        "nodes": [
            {
                "name": "code_node",
                "interface": "123456789012::SAMPLE_CODE.interface"
            },
            {
                "name": "model_node",
                "interface": "123456789012::SQUEEZENET_PYTORCH_V1.interface"
            },
            {
                "name": "camera_node",
                "interface": "panorama::abstract_rtsp_media_source.rtsp_v1_interface",
                "overridable": true,
                "overrideMandatory": true,
                "decorator": {
                    "title": "IP camera",
                    "description": "Choose a camera stream."
                }
            }
      ]
```

## Edges (Bordas)
<a name="applications-manifest-edges"></a>

As bordas mapeiam a saída de um nó para a entrada de outro. No exemplo a seguir, a primeira borda mapeia a saída de um nó de stream de câmera para a entrada de um nó de código da aplicação. Os nomes `video_in` e `video_out` são definidos nas interfaces dos pacotes de nós.

**Example graph.json: bordas**  

```
        "edges": [
            {
                "producer": "camera_node.video_out",
                "consumer": "code_node.video_in"
            },
            {
                "producer": "code_node.video_out",
                "consumer": "output_node.video_in"
            },
```

 No código da aplicação, use os atributos `inputs` e `outputs` para obter imagens do stream de entrada e enviar imagens para o stream de saída.

**Example application.py: entrada e saída de vídeo**  

```
    def process_streams(self):
        """Processes one frame of video from one or more video streams."""
        frame_start = time.time()
        self.frame_num += 1
        logger.debug(self.frame_num)
        # Loop through attached video streams
        streams = self.inputs.video_in.get()
        for stream in streams:
            self.process_media(stream)
        ...
        self.outputs.video_out.put(streams)
```

## Nós abstratos
<a name="applications-manifest-abstract"></a>

Em um manifesto de aplicação, um nó abstrato se refere a um pacote definido pelo AWS Panorama, que você pode usar como espaço reservado no manifesto da sua aplicação. O AWS Panorama fornece dois tipos de nós abstratos.

****
+ **Stream de câmera**: escolha o stream de câmera que a aplicação usa durante a implantação.

  *Nome do pacote*: `panorama::abstract_rtsp_media_source`

  *Nome da interface*: `rtsp_v1_interface`
+ **Saída HDMI**: indica que a aplicação envia vídeo.

  *Nome do pacote*: `panorama::hdmi_data_sink`

  *Nome da interface*: `hdmi0`

O exemplo a seguir mostra um conjunto básico de pacotes, nós e bordas para uma aplicação que processa streams de câmera e envia vídeo para um monitor. O nó da câmera, que usa a interface do pacote `abstract_rtsp_media_source` no AWS Panorama, pode aceitar vários streams de câmera como entrada. O nó de saída, que faz referência a `hdmi_data_sink`, dá ao código da aplicação acesso a um buffer de vídeo que é enviado pela porta HDMI do dispositivo.

**Example graph.json: nós abstratos**  

```
{
    "nodeGraph": {
        "envelopeVersion": "2021-01-01",
        "packages": [
            {
                "name": "123456789012::SAMPLE_CODE",
                "version": "1.0"
            },
            {
                "name": "123456789012::SQUEEZENET_PYTORCH_V1",
                "version": "1.0"
            },
            {
                "name": "panorama::abstract_rtsp_media_source",
                "version": "1.0"
            },
            {
                "name": "panorama::hdmi_data_sink",
                "version": "1.0"
            }
        ],
        "nodes": [
            {
                "name": "camera_node",
                "interface": "panorama::abstract_rtsp_media_source.rtsp_v1_interface",
                "overridable": true,
                "decorator": {
                    "title": "IP camera",
                    "description": "Choose a camera stream."
                }
            },
            {
                "name": "output_node",
                "interface": "panorama::hdmi_data_sink.hdmi0"
            }
        ],
        "edges": [
            {
                "producer": "camera_node.video_out",
                "consumer": "code_node.video_in"
            },
            {
                "producer": "code_node.video_out",
                "consumer": "output_node.video_in"
            }
        ]
    }
}
```