Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Exemple : envoi de données à Kinesis Video Streams à l'aide PutMedia de l'API
Cet exemple montre comment utiliser l'[PutMedia](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html)API. Il montre comment envoyer des données déjà au format conteneur (MKV). Si vos données doivent être assemblées dans un format conteneur avant d'être envoyées (par exemple, si vous assemblez les données vidéo de la caméra en images), voir[Transférer vers Kinesis Video Streams](producer-sdk.md).
**Note**
L'`PutMedia`opération n'est disponible qu'en C\$1\$1 et en Java SDKs. Cela est dû à la gestion en duplex intégral des connexions, du flux de données et des accusés de réception. Il n'est pas pris en charge dans les autres langues.
**Topics**
+ [Téléchargez et configurez le code](#examples-putmedia-download)
+ [Rédiger et examiner le code](#examples-putmedia-write)
+ [Exécutez et vérifiez le code](#examples-putmedia-run)
## Téléchargez et configurez le code
Suivez les étapes pour télécharger l'exemple de code Java, importer le projet dans votre IDE Java, configurer les emplacements des bibliothèques et configurer le code pour utiliser vos AWS informations d'identification.
1. Créez un répertoire et clonez l'exemple de code source à partir du GitHub référentiel. L'exemple `PutMedia` fait partit de [Java](producer-sdk-javaapi.md).
```
git clone https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-java
```
1. Ouvrez l'IDE Java que vous utilisez (par exemple, [Eclipse](https://www.eclipse.org/) ou [IntelliJ IDEA](https://www.jetbrains.com/idea/)) et importez le projet Apache Maven que vous avez téléchargé :
+ **Dans Eclipse :** Choisissez **Fichier**, **Importer**, **Maven**, **Projets Maven existants** et accédez à la racine du package téléchargé. Sélectionnez le fichier `pom.xml`.
+ **Dans IntelliJ Idea : ** Choisissez **Importer**. Naviguez vers le fichier `pom.xml` dans la racine du package téléchargé.
Pour plus d'informations, consultez la documentation relative à IDE.
1. Mettez à jour le projet de manière à ce que IDE trouve l'emplacement des bibliothèques que vous avez importées.
+ Pour IntelliJ IDEA, procédez comme suit :
1. Ouvrez le menu contextuel (via un clic droit) du répertoire **lib** du projet, puis choisissez **Ajouter en tant que bibliothèque**.
1. Choisissez **Fichier**, puis **Structure du projet**.
1. Sous **Paramètres du projet**, choisissez **Modules**.
1. Dans l'onglet **Sources**, définissez **Niveau de langue** sur**7** ou une valeur supérieure.
+ Pour Eclipse, procédez comme suit :
1. Ouvrez le menu contextuel (clic droit) du projet et choisissez **Propriétés**, **Chemin de création Java**, **Source**. Ensuite, procédez comme suit :
1. Sur l'onglet **Source**, double-cliquez sur **Emplacement de la bibliothèque native**.
1. Dans l'assistant **Configuration du dossier de la bibliothèque Native**, choisissez **Workspace**.
1. Dans la sélection **Dossier de la bibliothèque native**, choisissez le répertoire **lib** dans le projet.
1. Ouvrez le menu contextuel (clic droit) pour le projet et choisissez **Propriétés**. Ensuite, procédez comme suit :
1. Dans l'onglet **Bibliothèques**, choisissez **Ajouter Jars**.
1. Dans l'assistant **Sélection JAR**, choisissez tous les fichiers .jars dans le répertoire `lib` du projet.
## Rédiger et examiner le code
L'exemple d'API `PutMedia` () présente le modèle de codage suivant :`PutMediaDemo`
**Topics**
+ [Créez le PutMediaClient](#producersdk-javaapi-writecode-putmediaapi-putmediaclient)
+ [Diffuser du média et interrompre le thread](#producersdk-javaapi-writecode-putmediaapi-run)
Les exemples de code de cette section proviennent de la clase `PutMediaDemo`.
### Créez le PutMediaClient
La création de `PutMediaClient` l'objet nécessite les paramètres suivants :
+ L'URI pour le point de terminaison `PutMedia`.
+ Un `InputStream` indiquant le fichier MKV à diffuser.
+ Nom du flux. Cet exemple utilise le flux qui a été créé dans [Utiliser la bibliothèque Java Producer](producer-sdk-javaapi.md) (`my-stream`). Pour utiliser un flux différent, modifiez le paramètre suivant :
```
private static final String STREAM_NAME="my-stream";
```
**Note**
L'exemple `PutMedia` d'API ne crée pas de flux. Vous devez créer un flux soit à l'aide de l'application de test pour la [Utiliser la bibliothèque Java Producer](producer-sdk-javaapi.md) console Kinesis Video Streams, soit AWS CLIà l'aide du.
+ L'horodatage actuel.
+ Le type de time code. L'exemple utilise `RELATIVE`, indiquant que l'horodatage est relatif au début du conteneur.
+ Un objet `AWSKinesisVideoV4Signer` qui vérifie que les paquets reçus ont été envoyés par l'expéditeur autorisé.
+ Le montant maximum de la bande passante en Kbps.
+ Un objet `AckConsumer` pour recevoir les accusés de réception des paquets reçus.
Le code suivant crée l'objet `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();
```
### Diffuser du média et interrompre le thread
Une fois le client créé, l'échantillon commence la diffusion asynchrone avec `putMediaInBackground`. Le thread principal est alors interrompu avec `latch.await` jusqu'au retour de `AckConsumer`, le client est alors fermé.
```
/* start streaming video in a background thread */
client.putMediaInBackground();
/* wait for request/response to complete */
latch.await();
/* close the client */
client.close();
```
## Exécutez et vérifiez le code
Pour exécuter l'exemple d'API `PutMedia`, procédez comme suit :
1. Créez un flux nommé `my-stream` dans la console Kinesis Video Streams ou à l'aide AWS CLI du.
1. Remplacez votre répertoire de travail par le répertoire du kit SDK Producteur Java :
```
cd //amazon-kinesis-video-streams-producer-sdk-java/
```
1. Compilez le kit SDK Java et l'application de démonstration :
```
mvn package
```
1. Créez un nom de fichier temporaire dans le répertoire `/tmp` :
```
jar_files=$(mktemp)
```
1. Créez une chaîne de chemin de classe de dépendances à partir du référentiel local vers un fichier :
```
mvn -Dmdep.outputFile=$jar_files dependency:build-classpath
```
1. Définissez la valeur de la variable d'environnement `LD_LIBRARY_PATH` comme suit :
```
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. Exécutez la démo à partir de la ligne de commande comme suit, en fournissant vos AWS informations d'identification :
```
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. Ouvrez la console [Kinesis Video Streams](https://console.aws.amazon.com//kinesisvideo/home/) et choisissez votre flux sur **la page Gérer les** flux. La vidéo est lue dans le volet **Aperçu vidéo**.