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á. # Use a biblioteca de produtores de C\$1\$1 Você pode usar a biblioteca de produtores de C\$1\$1 fornecida pelo Amazon Kinesis Video Streams para escrever código de aplicativo para enviar dados de mídia de um dispositivo para um stream de vídeo do Kinesis. ## Modelo de objeto A biblioteca C\$1\$1 fornece os seguintes objetos para gerenciar o envio de dados para um stream de vídeo do Kinesis: + **KinesisVideoProducer:** contém informações sobre sua fonte de mídia e AWS credenciais e mantém retornos de chamada para relatar eventos do Kinesis Video Streams. + **KinesisVideoStream:** representa o stream de vídeo do Kinesis. Contém informações sobre os parâmetros do stream de vídeo, como nome, período de retenção de dados e tipo de conteúdo de mídia. ## Coloque mídia no stream Você pode usar os métodos fornecidos pela biblioteca C\$1\$1 (por exemplo,`PutFrame`) para colocar dados no `KinesisVideoStream` objeto. Em seguida, ela gerencia o estado interno dos dados, o que pode incluir as seguintes tarefas: + Realizar autenticação. + Verificar se há latência de rede. Se a latência for muito alta, a biblioteca poderá reduzir quadros. + Controlar status do streaming em andamento. ## Interfaces de retorno de chamada Esta camada expõe um conjunto de interfaces de retorno de chamada, que permitem a comunicação com a camada do aplicativo. Essas interfaces de retorno de chamada incluem o seguinte: + **Interface de retorno de chamada de serviço (`CallbackProvider`):** a biblioteca invoca eventos obtidos por meio dessa interface quando cria um fluxo, obtém uma descrição do fluxo e exclui um fluxo. + **Interface de estado pronto para o cliente ou com poucos eventos de armazenamento (`ClientCallbackProvider`):** a biblioteca invoca eventos nessa interface quando o cliente está pronto ou quando detecta que pode ficar sem armazenamento ou memória disponíveis. + **Interface de retorno de chamada de eventos de fluxo (`StreamCallbackProvider`):** a biblioteca invoca eventos nessa interface quando ocorrem eventos de fluxo, como o fluxo entrando no estado pronto, quadros eliminados ou erros de fluxo. O Kinesis Video Streams fornece implementações padrão para essas interfaces. Você também pode fornecer sua própria implementação personalizada, por exemplo, se precisar de uma lógica de rede personalizada ou quiser expor uma condição de armazenamento insuficiente à interface do usuário. Para obter mais informações sobre retornos de chamada nas bibliotecas do produtor, consulte[Retornos de chamada do SDK do produtor](producer-reference-callbacks.md). ## Procedimento: usar o SDK do produtor de C\$1\$1 Esse procedimento demonstra como usar o cliente e as fontes de mídia do Kinesis Video Streams em um aplicativo C\$1\$1 para enviar dados para seu stream de vídeo do Kinesis. Este procedimento inclui as seguintes etapas: **Topics** # Pré-requisitos Antes de configurar o SDK do produtor de C\$1\$1, verifique se você tem os seguintes pré-requisitos: + **Credenciais:** no código de exemplo, você fornece credenciais especificando um perfil que você configurou em seu arquivo de perfil de AWS credenciais. Primeiro, configure seu perfil de credenciais (se ainda não tiver feito isso). Para obter mais informações, consulte [Configurar AWS credenciais e região para desenvolvimento](https://docs.aws.amazon.com//sdk-for-java/v1/developer-guide/setup-credentials.html). + **Integração do armazenamento de certificados:** a biblioteca de produtores do Kinesis Video Streams deve estabelecer confiança com o serviço que ela chama. Isso é feito por meio da validação das autoridades de certificação (CAs) no repositório público de certificados. Em modelos baseados em Linux, esse armazenamento está localizado no diretório `/etc/ssl`/. Faça download do certificado do seguinte local para o armazenamento de certificados: [https://www.amazontrust.com/repository/SFSRootCAG2.pem](https://www.amazontrust.com/repository/SFSRootCAG2.pem) + Instale as seguintes dependências de compilação para o macOS: + [Autoconf 2.69](http://www.gnu.org/software/autoconf/autoconf.html) (Licença GPLv3 \$1/Autoconf: GNU GPL versão 3 ou posterior) + [CMake 3.7 ou 3.8](https://cmake.org/) + [Pkg-Config](https://www.freedesktop.org/wiki/Software/pkg-config/) + xCode (macOS) / clang / gcc (xcode-select versão 2347) + Java Development Kit (JDK) (para compilação de JNI do Java) + [Lib-Pkg](https://github.com/freebsd/pkg/tree/master/libpkg) + Instale as seguintes dependências de compilação para o Ubuntu: + Git: `sudo apt install git` + [CMake](http://kitware.com/cmake): `sudo apt install cmake` + G\$1\$1: `sudo apt install g++` + configuração do pacote: `sudo apt install pkg-config` + OpenJDK: `sudo apt install openjdk-8-jdk` **nota** Isso só é necessário se você estiver criando a Java Native Interface (JNI). + Defina a `JAVA_HOME` variável de ambiente: `export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64/` # Baixe e configure o código da biblioteca do produtor C\$1\$1 Para obter informações sobre como baixar e configurar a biblioteca de produtores de C\$1\$1, consulte [Amazon Kinesis Video Streams CPP](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp) Producer, Plugin and JNI. GStreamer Para obter os pré-requisitos e obter mais informações sobre esse exemplo, consulte. [Use a biblioteca de produtores de C\$1\$1](producer-sdk-cpp.md) ## CMake argumentos Abaixo está uma tabela de referência para os argumentos específicos do C\$1\$1 Producer SDK CMake . Você também pode passar as [ CMake opções padrão](https://cmake.org/cmake/help/latest/manual/cmake-env-variables.7.html) para CMake . **Importante** Tudo isso é opcional. **Sinalizadores para incluir ou excluir determinados recursos** | CMake discussão | Tipo | Padrão | Explicação | | --- | --- | --- | --- | | `BUILD_DEPENDENCIES` | Booleano | ON | Crie dependências a partir da fonte. Caso contrário, use as dependências que já estão instaladas no sistema. Se uma das dependências necessárias não puder ser encontrada, um erro será retornado. | | `BUILD_GSTREAMER_PLUGIN` | Booleano | DESL. | Constrói o kvssink GStreamer plugin. | | `BUILD_JNI` | Booleano | DESL. | Cria a Java Native Interface (JNI) para poder chamar esse código a partir de um ambiente de execução Java. | | `ALIGNED_MEMORY_MODEL` | Booleano | DESL. | Se as alocações de memória precisarem ser alinhadas aos limites de 8 bytes. Algumas arquiteturas não permitem acesso desalinhado à memória. | | `CONSTRAINED_DEVICE` | Booleano | DESL. | Somente fora do Windows. Quando ATIVADO, define o tamanho da pilha de fios como0.5 MiB. Necessário para compilações [do Alpine Linux](https://wiki.alpinelinux.org/wiki/Main_Page). Caso contrário, o padrão do sistema operacional será usado. | | `BUILD_STATIC` | Booleano | DESL. | Crie bibliotecas e executáveis como [compartilhados](https://en.wikipedia.org/wiki/Shared_library) (DESLIGADOS) ou [estáticos](https://en.wikipedia.org/wiki/Static_library) (ATIVADOS). | | `ADD_MUCLIBC` | Booleano | DESL. | Vincule ao [uClibc](https://en.wikipedia.org/wiki/UClibc) em vez da biblioteca C padrão, que é uma biblioteca padrão C menor projetada para sistemas embarcados. | | `OPEN_SRC_INSTALL_PREFIX` | String | .. /código aberto/local | Local para instalar as dependências de código aberto, se estiver compilando a partir do código-fonte. | **Sinalizadores para compilação cruzada** **Importante** Defina-os se as arquiteturas de CPU da máquina de destino e da máquina host forem diferentes. | CMake discussão | Tipo | Padrão | Explicação | | --- | --- | --- | --- | | `BUILD_LOG4CPLUS_HOST` | String | "" | Crie a log4cplus dependência para a arquitetura de CPU especificada. Se não estiver definido, log4cplus detectará automaticamente e usará a arquitetura de CPU da máquina host. | | `BUILD_OPENSSL_PLATFORM` | String | "" | Crie a OpenSSL dependência para a arquitetura de CPU especificada. Se não estiver definido, OpenSSL detectará automaticamente e usará a arquitetura de CPU da máquina host. | **Sinalizadores relacionados a testes** | CMake discussão | Tipo | Padrão | Explicação | | --- | --- | --- | --- | | `BUILD_TEST` | Booleano | DESL. | Crie os testes de unidade e integração. Para executar todos os testes, execute a ./tst/producerTest partir do diretório de compilação. AWS São necessárias credenciais para executar os testes. | | `CODE_COVERAGE` | Booleano | DESL. | Disponível somente para GNU/Clang compiladores. Habilite a coleta de cobertura de código com [gcov e geração](https://gcc.gnu.org/onlinedocs/gcc/Gcov.html) de relatórios. | | `COMPILER_WARNINGS` | Booleano | DESL. | Disponível somente para GNU/Clang compiladores. Ative todos os avisos do compilador. | | `ADDRESS_SANITIZER` | Booleano | DESL. | Disponível somente para GNU/Clang compiladores. Construa com [AddressSanitizer](https://compiler-rt.llvm.org/). | | `MEMORY_SANITIZER` | Booleano | DESL. | Disponível somente para GNU/Clang compiladores. Construa com [MemorySanitizer](https://compiler-rt.llvm.org/). | | `THREAD_SANITIZER` | Booleano | DESL. | Disponível somente para GNU/Clang compiladores. Construa com [ThreadSanitizer](https://compiler-rt.llvm.org/). | | `UNDEFINED_BEHAVIOR_SANITIZER` | Booleano | DESL. | Disponível somente para GNU/Clang compiladores. Construa com [UndefinedBehaviorSanitizer](https://compiler-rt.llvm.org/). | Para usar esses CMake argumentos, passe-os como uma lista de `-Dkey=value` pares separados por espaços seguindo o `cmake ..` comando. Por exemplo: ``` cmake .. -DBUILD_GSTREAMER_PLUGIN=ON -DBUILD_DEPENDENCIES=OFF -DALIGNED_MEMORY_MODEL=ON ``` CMake procurará o conjunto de ferramentas do compilador seguindo a `$PATH` variável. Antes de executar CMake, defina as variáveis de `CXX` ambiente `CC` e as variáveis de ambiente para definir explicitamente o conjunto de ferramentas a ser usado na compilação cruzada. # Escreva e examine o código Nesta seção do[Use a biblioteca de produtores de C\$1\$1](producer-sdk-cpp.md), você examina o código no equipamento de teste C\$1\$1 (`tst/ProducerTestFixture.h`e em outros arquivos). Você fez download desse código na seção anterior. O exemplo de C \$1\$1 **Platform Independent** mostra o seguinte padrão de codificação: + Crie uma instância de `KinesisVideoProducer` para acessar o Kinesis Video Streams. + Crie uma instância de `KinesisVideoStream`. Isso cria um stream de vídeo do Kinesis em seu Conta da AWS caso ainda não exista um stream com o mesmo nome. + Chame `putFrame` em `KinesisVideoStream` para cada quadro de dados (à medida que ele se tornar disponível) para enviá-lo ao streaming. As seções a seguir fornecem mais informações sobre esse padrão de codificação. ## Crie uma instância de KinesisVideoProducer Você cria um objeto `KinesisVideoProducer` chamando o método `KinesisVideoProducer::createSync`. O exemplo a seguir cria `KinesisVideoProducer` no arquivo `ProducerTestFixture.h`: ``` kinesis_video_producer_ = KinesisVideoProducer::createSync(move(device_provider_), move(client_callback_provider_), move(stream_callback_provider_), move(credential_provider_), defaultRegion_); ``` O método `createSync` usa os seguintes parâmetros: + Um objeto `DeviceInfoProvider`, que retorna um objeto `DeviceInfo` contendo informações sobre o dispositivo ou a configuração de armazenamento. **nota** Você deve configurar o tamanho do armazenamento de conteúdo usando o parâmetro `deviceInfo.storageInfo.storageSize`. Seus streamings de conteúdo compartilham o armazenamento de conteúdo. Para determinar o requisito de tamanho do storage, multiplique o tamanho médio do quadro pelo número de quadros armazenados para a duração máxima de todos os streamings. Em seguida, multiplique por 1,2 para considerar a desfragmentação. Por exemplo, suponha que o aplicativo tem a seguinte configuração: Três streamings 3 minutos de duração máxima Cada streaming é de 30 quadros por segundo (FPS) Cada quadro tem 10.000 KB de tamanho O requisito de armazenamento de conteúdo para esse aplicativo é **3 (streams) \$1 3 (minutos) \$1 60 (segundos em um minuto) \$1 10000 (kb) \$1 1,2 (permissão de desfragmentação) = 194,4** Mb \$1 200 Mb. + Um objeto `ClientCallbackProvider`, que retorna ponteiros de função que relatam eventos específicos do cliente. + Um objeto `StreamCallbackProvider`, que retorna ponteiros de função que são chamados de volta quando ocorrem eventos específicos de streaming. + Um `CredentialProvider` objeto que fornece acesso às variáveis de ambiente de AWS credenciais. + O Região da AWS (“us-west-2"). O endpoint de serviço é determinado a partir da região. ## Crie uma instância de KinesisVideoStream Você cria um objeto `KinesisVideoStream` chamando o método `KinesisVideoProducer::CreateStream` com um parâmetro `StreamDefinition`. O exemplo cria o `KinesisVideoStream` no arquivo `ProducerTestFixture.h` com o tipo de trilha como vídeo e com o ID da trilha como 1: ``` auto stream_definition = make_unique(stream_name, hours(2), tags, "", STREAMING_TYPE_REALTIME, "video/h264", milliseconds::zero(), seconds(2), milliseconds(1), true, true, true); return kinesis_video_producer_->createStream(move(stream_definition)); ``` O objeto `StreamDefinition` tem os seguintes campos: + Nome do stream. + Período de retenção de dados. + Tags do streaming. Essas tags podem ser usadas por aplicativos de consumo para encontrar o streaming correto ou obter mais informações sobre o streaming. As tags também podem ser visualizadas no Console de gerenciamento da AWS. + AWS KMS chave de criptografia para o stream. Para obter mais informações, consulte [Proteção de dados no Kinesis Video Streams](how-kms.md). + Tipo de streaming. Atualmente, o único valor válido é `STREAMING_TYPE_REALTIME`. + Tipo de conteúdo de mídia. + Latência de mídia. Esse valor não é usado atualmente e deve ser definido como 0. + Duração da reprodução de cada fragmento. + Escala de código de hora da mídia. + Se a mídia usa ou não fragmentação de keyframe. + Se a mídia usa ou não códigos de hora. + Se a mídia usa ou não horas absolutas de fragmento. ## Adicionar uma faixa de áudio ao stream de vídeo do Kinesis Você pode adicionar detalhes da faixa de áudio a uma definição de fluxo de faixa de vídeo usando o `addTrack` método do`StreamDefinition`: ``` stream_definition->addTrack(DEFAULT_AUDIO_TRACKID, DEFAULT_AUDIO_TRACK_NAME, DEFAULT_AUDIO_CODEC_ID, MKV_TRACK_INFO_TYPE_AUDIO); ``` O `addTrack` método requer os seguintes parâmetros: + ID da faixa (como uma para áudio). Esse valor deve ser exclusivo e diferente de zero. + Nome da faixa definido pelo usuário (por exemplo, “áudio” para a faixa de áudio). + ID do codec para essa faixa (por exemplo, para a faixa de áudio “A\$1AAC”). + Tipo de faixa (por exemplo, use o valor enum de MKV\$1TRACK\$1INFO\$1TYPE\$1AUDIO para áudio). Se tiver dados privados do codec para a trilha de áudio, você poderá transmiti-los ao chamar a função addTrack. Você também pode enviar os dados privados do codec depois de criar o KinesisVideoStream objeto enquanto chama o método start in KinesisVideoStream. ## Coloque um quadro no stream de vídeo do Kinesis Você insere mídia no stream de vídeo do Kinesis usando`KinesisVideoStream::putFrame`, passando um `Frame` objeto que contém o cabeçalho e os dados de mídia. O exemplo chama `putFrame` no arquivo `ProducerApiTest.cpp`: ``` frame.duration = FRAME_DURATION_IN_MICROS * HUNDREDS_OF_NANOS_IN_A_MICROSECOND; frame.size = SIZEOF(frameBuffer_); frame.frameData = frameBuffer_; MEMSET(frame.frameData, 0x55, frame.size); while (!stop_producer_) { // Produce frames timestamp = std::chrono::duration_cast( std::chrono::system_clock::now().time_since_epoch()).count() / DEFAULT_TIME_UNIT_IN_NANOS; frame.index = index++; frame.decodingTs = timestamp; frame.presentationTs = timestamp; // Key frame every 50th frame.flags = (frame.index % 50 == 0) ? FRAME_FLAG_KEY_FRAME : FRAME_FLAG_NONE; ... EXPECT_TRUE(kinesis_video_stream->putFrame(frame)); ``` **nota** O exemplo anterior do produtor de C\$1\$1 envia um buffer de dados de teste. Em uma situação real, você precisa obter o buffer e o tamanho do quadro dos dados do quadro em uma fonte de mídia (como uma câmera). O objeto `Frame` tem os seguintes campos: + Índice de quadros. Este deve ser um valor incremental monotônico. + Sinalizadores associados ao quadro. Por exemplo, se o codificador fosse configurado para produzir um keyframe, esse quadro receberia o sinalizador `FRAME_FLAG_KEY_FRAME`. + Carimbo de data/hora de decodificação. + Carimbo de data e hora da apresentação. + Duração do quadro (para unidades de 100 ns). + Tamanho do quadro em bytes. + Dados de quadro. Para obter mais informações sobre o formato de quadro, consulte [Modelo de dados do Kinesis Video Streams](how-data.md). ## Coloque um KinesisVideoFrame em uma faixa específica de KinesisVideoStream Você pode usar a `PutFrameHelper` classe para colocar dados do quadro em uma faixa específica. Primeiro, chame o `getFrameDataBuffer` para obter um ponteiro para um dos buffers pré-alocados para preencher os dados. `KinesisVideoFrame` Em seguida, você pode chamar o `putFrameMultiTrack` para enviar o `KinesisVideoFrame` junto com o valor booleano para indicar o tipo de dados do quadro. Use true (verdadeiro) se forem dados de vídeo ou false (falso) se o quadro tiver dados de áudio. O `putFrameMultiTrack` método usa um mecanismo de enfileiramento para garantir que os fragmentos MKV mantenham carimbos de data e hora de quadros monotonicamente crescentes e que quaisquer dois fragmentos não se sobreponham. Por exemplo, o timestamp MKV do primeiro quadro de um fragmento deve sempre ser maior do que o timestamp MKV do último quadro do fragmento anterior. `PutFrameHelper` tem os seguintes campos: + Número máximo de quadros de áudio na fila. + Número máximo de quadros de vídeo na fila. + Tamanho a ser alocado para um único quadro de áudio. + Tamanho a ser alocado para um único quadro de vídeo. ## Métricas de acesso e registro de métricas O SDK do produtor de C\$1\$1 inclui funcionalidade para métricas e registro de métricas. Você pode usar as operações `getKinesisVideoMetrics` e da `getKinesisVideoStreamMetrics` API para recuperar informações sobre o Kinesis Video Streams e seus streams ativos. O código a seguir é do arquivo `kinesis-video-pic/src/client/include/com/amazonaws/kinesis/video/client/Include.h`. ``` /** * Gets information about the storage availability. * * @param 1 CLIENT_HANDLE - the client object handle. * @param 2 PKinesisVideoMetrics - OUT - Kinesis Video metrics to be filled. * * @return Status of the function call. */ PUBLIC_API STATUS getKinesisVideoMetrics(CLIENT_HANDLE, PKinesisVideoMetrics); /** * Gets information about the stream content view. * * @param 1 STREAM_HANDLE - the stream object handle. * @param 2 PStreamMetrics - Stream metrics to fill. * * @return Status of the function call. */ PUBLIC_API STATUS getKinesisVideoStreamMetrics(STREAM_HANDLE, PStreamMetrics); ``` O objeto `PClientMetrics` preenchido por `getKinesisVideoMetrics` contém as seguintes informações: + **contentStoreSize:** o tamanho geral em bytes do armazenamento de conteúdo (a memória usada para armazenar dados de streaming). + **contentStoreAvailableTamanho:** a memória disponível no armazenamento de conteúdo, em bytes. + **contentStoreAllocatedTamanho:** A memória alocada no armazenamento de conteúdo. + **totalContentViewsTamanho:** a memória total usada para a visualização do conteúdo. A visualização do conteúdo é uma série de índices de informações no armazenamento de conteúdo. + **totalFrameRate:** o número agregado de quadros por segundo em todos os fluxos ativos. + **totalTransferRate:** o total de bits por segundo (bps) enviados em todos os fluxos. O objeto `PStreamMetrics` preenchido por `getKinesisVideoStreamMetrics` contém as seguintes informações: + **currentViewDuration:** a diferença em unidades de 100 ns entre a cabeça da visualização do conteúdo (quando os quadros são codificados) e a posição atual (quando os dados do quadro são enviados para o Kinesis Video Streams). + **overallViewDuration:** a diferença em unidades de 100 ns entre a parte superior da visualização do conteúdo (quando os quadros são codificados) e a parte final (quando os quadros são apagados da memória, seja porque o espaço total alocado para a visualização do conteúdo foi excedido ou porque uma `PersistedAck` mensagem é recebida do Kinesis Video Streams e os quadros conhecidos por persistirem são liberados). + **currentViewSize:** o tamanho em bytes da visualização do conteúdo do cabeçalho (quando os quadros são codificados) até a posição atual (quando os quadros são enviados para o Kinesis Video Streams). + **overallViewSize:** o tamanho total em bytes da visualização do conteúdo. + **currentFrameRate:** a última taxa medida do stream, em quadros por segundo. + **currentTransferRate:** a última taxa medida do fluxo, em bytes por segundo. ## Desgaste Se quiser enviar os bytes restantes em um buffer e aguardar o `ACK`, você poderá usar o `stopSync`: ``` kinesis_video_stream->stopSync(); ``` Ou você pode chamar `stop` para encerrar o streaming: ``` kinesis_video_stream->stop(); ``` Após interromper o streaming, você pode liberá-lo chamando a seguinte API: ``` kinesis_video_producer_->freeStream(kinesis_video_stream); ``` # Execute e verifique o código Para executar e verificar o código do[Use a biblioteca de produtores de C\$1\$1](producer-sdk-cpp.md), consulte as seguintes instruções específicas do sistema operacional: + [Linux](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/blob/master/docs/linux.md) + [macOS](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/blob/master/docs/macos.md) + [Windows](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/blob/master/docs/windows.md) + [Sistema operacional Raspberry Pi](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/blob/master/docs/raspberry-pi.md) Você pode monitorar o tráfego em seu stream observando as métricas associadas ao seu stream no CloudWatch console da Amazon, como`PutMedia.IncomingBytes`. # Use o SDK do produtor de C\$1\$1 como um plug-in GStreamer [GStreamer](https://gstreamer.freedesktop.org/)é uma estrutura de mídia popular usada por várias câmeras e fontes de vídeo para criar canais de mídia personalizados combinando plug-ins modulares. O plug-in Kinesis GStreamer Video Streams simplifica a integração do GStreamer seu pipeline de mídia existente com o Kinesis Video Streams. Para obter informações sobre como usar o SDK do produtor de C\$1\$1 como um GStreamer plug-in, consulte. [Exemplo: Plugin SDK do GStreamer produtor do Kinesis Video Streams - kvssink](examples-gstreamer-plugin.md) # Use o SDK do produtor de C\$1\$1 como um GStreamer plug-in em um contêiner Docker [GStreamer](https://gstreamer.freedesktop.org/)é uma estrutura de mídia popular usada por várias câmeras e fontes de vídeo para criar canais de mídia personalizados combinando plug-ins modulares. O plug-in Kinesis GStreamer Video Streams simplifica a integração do GStreamer seu pipeline de mídia existente com o Kinesis Video Streams. Além disso, o uso do [Docker]() para criar o GStreamer pipeline padroniza o ambiente operacional do Kinesis Video Streams, o que simplifica a criação e a execução do aplicativo. Para obter informações sobre como usar o SDK do produtor de C\$1\$1 como um GStreamer plug-in em um contêiner do Docker, consulte. [Execute o GStreamer elemento em um contêiner Docker](examples-gstreamer-plugin.md#examples-gstreamer-plugin-docker) # Use o registro com o SDK do produtor de C\$1\$1 Você configura o registro para aplicativos SDK do produtor de C\$1\$1 no `kvs_log_configuration` arquivo na `kinesis-video-native-build` pasta. O exemplo a seguir mostra a primeira linha do arquivo de configuração padrão que configura o aplicativo para gravar entradas em nível de `DEBUG` no Console de gerenciamento da AWS: ``` log4cplus.rootLogger=DEBUG, KvsConsoleAppender ``` Você pode definir o nível de registro em log como `INFO` para log menos detalhado. Para configurar o aplicativo para gravar entradas de registro em um arquivo de log, atualize a primeira linha do arquivo para o seguinte: ``` log4cplus.rootLogger=DEBUG, KvsConsoleAppender, KvsFileAppender ``` Isso configura o aplicativo para gravar entradas de log no `kvs.log` na pasta `kinesis-video-native-build/log`. Para alterar a localização do arquivo de log, atualize a linha a seguir com o novo caminho: ``` log4cplus.appender.KvsFileAppender.File=./log/kvs.log ``` **nota** Se o registro em log for gravado em nível de `DEBUG`, o arquivo de log poderá usar o espaço de armazenamento disponível no dispositivo rapidamente.