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á.
# Enviar dados para um stream de vídeo do Amazon Kinesis
Esta seção descreve como enviar dados de mídia de uma câmera para o stream de vídeo do Kinesis que você criou na seção anterior. Esta seção usa o [Use a biblioteca de produtores de C\$1\$1](producer-sdk-cpp.md) como um plug-in [Exemplo: Plugin SDK do GStreamer produtor do Kinesis Video Streams - kvssink](examples-gstreamer-plugin.md).
Para enviar mídia de vários dispositivos em vários sistemas operacionais, este tutorial usa a [GStreamer](https://gstreamer.freedesktop.org/)biblioteca de produtores de C\$1\$1 do Kinesis Video Streams e uma estrutura de mídia de código aberto que padroniza o acesso a câmeras e outras fontes de mídia.
**Topics**
+ [Crie o SDK e as amostras](#send-data-build-sdk)
+ [Execute as amostras para fazer upload de mídia para o Kinesis Video Streams](#send-data-run-samples)
+ [Revise os objetos de reconhecimento](#gs-review-acks)
## Crie o SDK e as amostras
Você pode criar o SDK e as amostras no seu computador ou no AWS Cloud9. Siga os procedimentos apropriados abaixo.
------
#### [ Build on your computer ]
Use as instruções no [arquivo readme](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp) para criar a biblioteca do produtor e o aplicativo de amostra.
Isso inclui:
+ Instalar as dependências
+ Clonando o repositório
+ Usando **CMake**para gerar **makefiles**
+ Construindo os arquivos binários usando **make**
------
#### [ Build in AWS Cloud9 ]
Siga estes procedimentos para fazer o upload para o Kinesis Video AWS Cloud9 Streams em. Você não precisará baixar nada para o seu computador.
1. No Console de gerenciamento da AWS, abra [AWS Cloud9](https://us-west-2.console.aws.amazon.com/cloud9control/home).
Selecione **Criar ambiente**.
1. Na tela **Criar ambiente**, faça o seguinte:
+ **Nome** - digite um nome para seu novo ambiente.
+ **Plataforma** - Selecione **Ubuntu Server 22.04 LTS**.
Você pode deixar os outros campos com as seleções padrão.
1. Quando o ambiente tiver sido criado, selecione **Abrir** na coluna **Cloud9 IDE**.
Na área central inferior da tela, você vê. `Admin:~/environment $` Este é o terminal AWS Cloud9 (Amazon EC2).
**nota**
Se você fechar acidentalmente o terminal, selecione **Janela**, **Novo terminal**.
Execute os seguintes comandos no terminal para alterar o volume para 20 GiB.
1. Baixe o script .
```
wget https://awsj-iot-handson.s3-ap-northeast-1.amazonaws.com/kvs-workshop/resize_volume.sh
```
1. Conceda permissões de execução ao script.
```
chmod +x resize_volume.sh
```
1. Executar o script.
```
./resize_volume.sh
```
1. Obtenha as informações mais recentes sobre todos os softwares que você pode instalar ou atualizar por meio da Advanced Packaging Tool (APT).
Esse comando não atualiza o software em si, mas garante que seu sistema saiba quais são as versões mais recentes disponíveis.
```
sudo apt-get update
```
1. Instale as dependências do SDK do produtor de C\$1\$1.
```
sudo apt-get install -y cmake m4 git build-essential pkg-config libssl-dev libcurl4-openssl-dev \
liblog4cplus-dev libgstreamer1.0-dev libgstreamer-plugins-base1.0-dev \
gstreamer1.0-plugins-base-apps gstreamer1.0-plugins-bad gstreamer1.0-plugins-good \
gstreamer1.0-plugins-ugly gstreamer1.0-tools
```
1. Use o git para clonar o SDK do produtor de C\$1\$1.
```
git clone https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp.git
```
1. Prepare um diretório de compilação.
```
cd amazon-kinesis-video-streams-producer-sdk-cpp
mkdir build
cd build
```
1. Use CMake para gerar makefiles.
```
cmake .. -DBUILD_GSTREAMER_PLUGIN=TRUE -DBUILD_DEPENDENCIES=OFF
```
O final da saída esperada tem a seguinte aparência:
```
-- Build files have been written to: /home/ubuntu/environment/amazon-kinesis-video-streams-producer-sdk-cpp/build
```
1. Use make para compilar o SDK e os aplicativos de amostra, bem como criar os executáveis finais.
```
make
```
O final da saída esperada tem a seguinte aparência:
```
[100%] Linking CXX executable kvs_gstreamer_file_uploader_sample
[100%] Built target kvs_gstreamer_file_uploader_sample
```
1. Confirme se os arquivos de amostra foram criados. Liste os arquivos no diretório atual:
```
ls
```
Confirme se os seguintes arquivos estão presentes:
+ kvs\$1gstreamer\$1sample
+ libgstkvssink.so
1. (Opcional) Você pode adicionar a configuração da variável de ambiente GST\$1PLUGIN\$1PATH ao script de inicialização do seu shell. Isso garante que GST\$1PLUGIN\$1PATH seja configurado corretamente durante uma nova sessão de terminal. Dentro AWS Cloud9, o script de inicialização do shell é:. `~/.bashrc`
Execute o comando a seguir para anexar o comando ao final do script de inicialização do shell.
```
echo "export GST_PLUGIN_PATH=~/environment/amazon-kinesis-video-streams-producer-sdk-cpp/build" >> ~/.bashrc
```
Digite o seguinte para executar o script de inicialização do shell:
```
source ~/.bashrc
```
Confirme se GST\$1PLUGIN\$1PATH está definido.
```
echo $GST_PLUGIN_PATH
```
Se você definir a saída corretamente, verá a seguinte saída. Se a saída estiver em branco, a variável de ambiente não será definida corretamente.
```
/home/ubuntu/environment/amazon-kinesis-video-streams-producer-sdk-cpp/build
```
------
## Execute as amostras para fazer upload de mídia para o Kinesis Video Streams
O aplicativo de amostra não oferece suporte às credenciais do IMDS. No seu terminal, exporte AWS as credenciais do seu usuário ou função do IAM e da região em que seu stream está localizado.
```
export AWS_ACCESS_KEY_ID=YourAccessKey
export AWS_SECRET_ACCESS_KEY=YourSecretKey
export AWS_DEFAULT_REGION=YourAWSRegion
```
Se você estiver usando AWS credenciais temporárias, exporte também seu token de sessão:
```
export AWS_SESSION_TOKEN=YourSessionToken
```
------
#### [ .mp4 files ]
Baixe uma amostra de vídeo.mp4 para fazer o upload para o Kinesis Video Streams.
```
wget https://awsj-iot-handson.s3-ap-northeast-1.amazonaws.com/kvs-workshop/sample.mp4
```
Especificações de vídeo:
+ **Resolução** - 1280 x 720 pixels
+ **Taxa de quadros** - 30 quadros por segundo
+ **Duração** - 14,0 segundos
+ **Codificação de vídeo** - H.264, na faixa 1
+ **Quadros-chave** - A cada 3 segundos, resultando em uma duração de fragmento (também conhecida como tamanho de grupo de imagens (GoP)) de 3 segundos, com o fragmento final tendo 2 segundos de duração.
Execute o comando a seguir com o nome do stream que você criou anteriormente. Se você ainda não criou um stream, consulte[Crie um stream de vídeo do Amazon Kinesis](gs-createstream.md).
```
./kvs_gstreamer_sample YourStreamName ./sample.mp4
```
------
#### [ Sample video from GStreamer ]
Use o comando a seguir para gerar um vídeo usando GStreamer.
Diga GStreamer onde localizar o `kvssink` GStreamer plugin. No seu diretório de compilação, especifique o caminho para a pasta que contém o `libgstkvssink.so` arquivo.
No seu diretório de compilação, execute o seguinte comando:
```
export GST_PLUGIN_PATH=`pwd`
```
Esse GStreamer pipeline gera um stream de vídeo de teste ao vivo com um padrão de teste padrão executado a 10 quadros por segundo com uma resolução de 640x480 pixels. Uma sobreposição é adicionada exibindo a hora e a data atuais do sistema. O vídeo é então codificado no formato H.264 e os quadros-chave são gerados no máximo a cada 10 quadros, resultando em uma duração do fragmento (também conhecida como tamanho de grupo de imagens (GoP)) de 1 segundo. `kvssink`pega o stream de vídeo codificado em H.264, o empacota no formato de contêiner Matroska (MKV) e o carrega no seu stream de vídeo do Kinesis.
Execute este comando: .
```
gst-launch-1.0 -v videotestsrc is-live=true \
! video/x-raw,framerate=10/1,width=640,height=480 \
! clockoverlay time-format="%a %B %d, %Y %I:%M:%S %p" \
! x264enc bframes=0 key-int-max=10 \
! h264parse \
! kvssink stream-name="YourStreamName"
```
Para interromper o GStreamer pipeline, selecione a janela do terminal e pressione **CTRL\$1C**.
------
**nota**
Para obter mais informações sobre como usar o GStreamer plug-in para transmitir vídeo de um fluxo RTSP de uma câmera ou de uma câmera USB, consulte. [Exemplo: Plugin SDK do GStreamer produtor do Kinesis Video Streams - kvssink](examples-gstreamer-plugin.md)
## Revise os objetos de reconhecimento
Durante o upload, o Kinesis Video Streams enviará objetos de confirmação de volta ao cliente que está realizando o upload. Você deve vê-los impressos na saída do comando. Um exemplo se parece com o seguinte:
```
{"EventType":"PERSISTED","FragmentTimecode":1711124585823,"FragmentNumber":"12345678901234567890123456789012345678901234567"}
```
Se a confirmação `EventType` for`PERSISTED`, significa que o Kinesis Video Streams armazenou e criptografou de forma durável esse pedaço de mídia para recuperação, análise e armazenamento a longo prazo.
Para obter mais informações sobre reconhecimentos, consulte. [PutMedia](API_dataplane_PutMedia.md)