Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Ejemplo: envío de datos a Kinesis Video Streams mediante PutMedia la API
En este ejemplo se muestra cómo utilizar la [PutMedia](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html)API. Muestra cómo enviar datos que ya están en formato contenedor (MKV). Si los datos deben agruparse en un formato contenedor antes de enviarlos (por ejemplo, si va a agrupar los datos de vídeo de la cámara en fotogramas), consulte[Cargar a Kinesis Video Streams](producer-sdk.md).
**nota**
La `PutMedia` operación solo está disponible en C\$1\$1 y Java SDKs. Esto se debe a la gestión dúplex completa de las conexiones, el flujo de datos y las confirmaciones. No se admite en otros idiomas.
**Topics**
+ [Descarga y configura el código](#examples-putmedia-download)
+ [Escribe y examina el código](#examples-putmedia-write)
+ [Ejecute y verifique el código](#examples-putmedia-run)
## Descarga y configura el código
Siga los pasos para descargar el código de ejemplo de Java, importar el proyecto a su IDE de Java, configurar las ubicaciones de las bibliotecas y configurar el código para usar sus AWS credenciales.
1. Crea un directorio y clona el código fuente del ejemplo desde el GitHub repositorio. El ejemplo de `PutMedia` forma parte de la [Java](producer-sdk-javaapi.md).
```
git clone https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-java
```
1. Abra el IDE de Java que esté utilizando (por ejemplo, [Eclipse](https://www.eclipse.org/) o [IntelliJ](https://www.jetbrains.com/idea/) IDEA) e importe el proyecto Apache Maven que ha descargado:
+ **En Eclipse:** seleccione **File** (Archivo), **Import...** (Importar...), **Maven** (Maven), **Existing Maven Projects** (Proyectos Maven existentes) y vaya a la raíz del paquete descargado. Seleccione el archivo `pom.xml`.
+ **En IntelliJ Idea: **seleccione **Import**. Vaya al archivo `pom.xml` en la raíz del paquete descargado.
Para obtener más información, consulte la documentación del IDE relacionada.
1. Actualice el proyecto, de modo que el IDE pueda encontrar las bibliotecas que ha importado.
+ Para IntelliJ IDEA, realice lo siguiente:
1. Abra el menú contextual (clic secundario) en el directorio **lib** del proyecto y seleccione **Add as library**.
1. **Elija **Archivo** y, a continuación, elija Estructura del proyecto.**
1. En **Project Settings**, seleccione **Modules**.
1. En la pestaña **Sources (Orígenes)**, configure **Language Level (Nivel de lenguaje)** en **7** o más.
+ Para Eclipse, haga lo siguiente:
1. Abra el menú contextual (clic secundario) del proyecto y seleccione **Properties**, **Java Build Path**, **Source**. A continuación, proceda del modo siguiente:
1. En la pestaña **Source**, haga doble clic en **Native library location**.
1. En el asistente **Native Library Folder Configuration**, seleccione **Workspace**.
1. En la opción **Native Library Folder**, seleccione el directorio **lib** del proyecto.
1. Abra el menú contextual (clic secundario) del proyecto y seleccione **Properties**. A continuación, proceda del modo siguiente:
1. En la pestaña **Libraries**, elija **Add Jars**.
1. En el asistente **JAR selection (Selección de JAR)**, seleccione todos los archivos .jar del directorio `lib` del proyecto.
## Escribe y examina el código
El ejemplo de API `PutMedia` () muestra el siguiente patrón de codificación:`PutMediaDemo`
**Topics**
+ [Crea el PutMediaClient](#producersdk-javaapi-writecode-putmediaapi-putmediaclient)
+ [Transmisión de medios y pausa del subproceso](#producersdk-javaapi-writecode-putmediaapi-run)
Los ejemplos de código de esta sección pertenecen a la clase `PutMediaDemo`.
### Crea el PutMediaClient
La creación del `PutMediaClient` objeto requiere los siguientes parámetros:
+ La URI del punto de conexión `PutMedia`.
+ Un `InputStream` que señale al archivo MKV que se ha de transmitir.
+ El nombre de la transmisión. En este ejemplo se utiliza la misma transmisión creada en la [Utilice la biblioteca de productores de Java](producer-sdk-javaapi.md) (`my-stream`). Para utilizar otra transmisión, cambie el siguiente parámetro:
```
private static final String STREAM_NAME="my-stream";
```
**nota**
El ejemplo de la `PutMedia` API no crea una transmisión. Debe crear una transmisión mediante la aplicación de prueba de la [Utilice la biblioteca de productores de Java](producer-sdk-javaapi.md) consola Kinesis Video Streams o AWS CLI la.
+ Marca temporal actual.
+ Tipo de código temporal. En el ejemplo se utiliza `RELATIVE`, lo que indica que la marca temporal es relativa al inicio del contenedor.
+ Un objeto `AWSKinesisVideoV4Signer` que comprueba que los paquetes recibidos han sido enviados por el remitente autorizado.
+ El ancho de banda de subida máximo en Kbps,
+ Un objeto `AckConsumer` para recibir los reconocimientos de los paquetes recibidos.
El siguiente código crea el objeto `PutMediaClient`:
```
/* actually URI to send PutMedia request */
final URI uri = URI.create(KINESIS_VIDEO_DATA_ENDPOINT + PUT_MEDIA_API);
/* input stream for sample MKV file */
final InputStream inputStream = new FileInputStream(MKV_FILE_PATH);
/* use a latch for main thread to wait for response to complete */
final CountDownLatch latch = new CountDownLatch(1);
/* a consumer for PutMedia ACK events */
final AckConsumer ackConsumer = new AckConsumer(latch);
/* client configuration used for AWS SigV4 signer */
final ClientConfiguration configuration = getClientConfiguration(uri);
/* PutMedia client */
final PutMediaClient client = PutMediaClient.builder()
.putMediaDestinationUri(uri)
.mkvStream(inputStream)
.streamName(STREAM_NAME)
.timestamp(System.currentTimeMillis())
.fragmentTimeCodeType("RELATIVE")
.signWith(getKinesisVideoSigner(configuration))
.upstreamKbps(MAX_BANDWIDTH_KBPS)
.receiveAcks(ackConsumer)
.build();
```
### Transmisión de medios y pausa del subproceso
Tras crear el cliente, la muestra inicia el streaming asincrónico con `putMediaInBackground`. Posteriormente, el subproceso principal se pausa con `latch.await` hasta que devuelve `AckConsumer` y en ese punto se cierra el cliente.
```
/* start streaming video in a background thread */
client.putMediaInBackground();
/* wait for request/response to complete */
latch.await();
/* close the client */
client.close();
```
## Ejecute y verifique el código
Para ejecutar el ejemplo de API `PutMedia`, siga estos pasos:
1. Cree una transmisión con el nombre `my-stream` correspondiente en la consola de Kinesis Video Streams o mediante AWS CLI.
1. Cambie el directorio de trabajo actual al directorio del SDK Producer de Java:
```
cd //amazon-kinesis-video-streams-producer-sdk-java/
```
1. Compile el SDK de Java y la aplicación de demostración:
```
mvn package
```
1. Cree un nombre de archivo temporal en el directorio `/tmp`:
```
jar_files=$(mktemp)
```
1. Cree una cadena classpath de dependencias desde el repositorio local a un archivo:
```
mvn -Dmdep.outputFile=$jar_files dependency:build-classpath
```
1. Establezca el valor de la variable de entorno `LD_LIBRARY_PATH` del modo siguiente:
```
export LD_LIBRARY_PATH=//amazon-kinesis-video-streams-producer-sdk-cpp/kinesis-video-native-build/downloads/local/lib:$LD_LIBRARY_PATH
$ classpath_values=$(cat $jar_files)
```
1. Ejecute la demostración desde la línea de comandos de la siguiente manera, proporcionando sus AWS credenciales:
```
java -classpath target/kinesisvideo-java-demo-1.0-SNAPSHOT.jar:$classpath_values -Daws.accessKeyId=${ACCESS_KEY} -Daws.secretKey=${SECRET_KEY} -Djava.library.path=/opt/amazon-kinesis-video-streams-producer-sdk-cpp/kinesis-video-native-build com.amazonaws.kinesisvideo.demoapp.DemoAppMain
```
1. Abra la consola de [Kinesis Video Streams](https://console.aws.amazon.com//kinesisvideo/home/) y elija su transmisión en **la página Administrar** transmisiones. El vídeo se reproduce en el panel **Video Preview**.