Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Inviare dati a un flusso video di Amazon Kinesis
Questa sezione descrive come inviare dati multimediali da una videocamera al flusso video Kinesis creato nella sezione precedente. Questa sezione usa il [Usa la libreria Producer C\$1\$1](producer-sdk-cpp.md) come [Esempio: plugin SDK per GStreamer produttori di Kinesis Video Streams - kvssink](examples-gstreamer-plugin.md) plugin.
Per inviare contenuti multimediali da una varietà di dispositivi su una varietà di sistemi operativi, questo tutorial utilizza la [GStreamer](https://gstreamer.freedesktop.org/)libreria per produttori Kinesis Video Streams C\$1\$1 e un framework multimediale open source che standardizza l'accesso alle telecamere e ad altre fonti multimediali.
**Topics**
+ [Crea l'SDK e gli esempi](#send-data-build-sdk)
+ [Esegui gli esempi per caricare contenuti multimediali su Kinesis Video Streams](#send-data-run-samples)
+ [Rivedi gli oggetti di riconoscimento](#gs-review-acks)
## Crea l'SDK e gli esempi
Puoi creare l'SDK e gli esempi sul tuo computer o in. AWS Cloud9 Segui le procedure appropriate riportate di seguito.
------
#### [ Build on your computer ]
Utilizzate le istruzioni contenute nel [file readme](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp) per creare la libreria Producer e l'applicazione di esempio.
Questo include:
+ Installazione delle dipendenze
+ Clonazione del repository
+ **Usare **CMake**per generare makefile**
+ **Compilare i file binari usando make**
------
#### [ Build in AWS Cloud9 ]
Segui queste procedure per caricare su Kinesis Video AWS Cloud9 Streams in. Non dovrai scaricare nulla sul tuo computer.
1. Nel Console di gestione AWS, aperto [AWS Cloud9](https://us-west-2.console.aws.amazon.com/cloud9control/home).
Seleziona **Crea ambiente**.
1. Nella schermata **Crea ambiente**, completa quanto segue:
+ **Nome**: digita un nome per il nuovo ambiente.
+ **Piattaforma**: seleziona **Ubuntu Server 22.04 LTS**.
Puoi lasciare gli altri campi con le selezioni predefinite.
1. Una volta creato l'ambiente, seleziona **Apri nella colonna** IDE **Cloud9**.
Nella parte medio-bassa dello schermo, vedi. `Admin:~/environment $` Questo è il terminale AWS Cloud9 (Amazon EC2).
**Nota**
Se chiudi accidentalmente il terminale, seleziona **Finestra**, **Nuovo terminale**.
Esegui i seguenti comandi nel terminale per modificare il volume a 20 GiB.
1. Scarica lo script .
```
wget https://awsj-iot-handson.s3-ap-northeast-1.amazonaws.com/kvs-workshop/resize_volume.sh
```
1. Assegna i permessi di esecuzione dello script.
```
chmod +x resize_volume.sh
```
1. Eseguire lo script.
```
./resize_volume.sh
```
1. Recupera le informazioni più recenti su tutto il software che puoi installare o aggiornare tramite l'Advanced Packaging Tool (APT).
Questo comando non aggiorna il software stesso, ma assicura che il sistema sappia quali sono le ultime versioni disponibili.
```
sudo apt-get update
```
1. Installa le dipendenze C\$1\$1 Producer SDK.
```
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. Usa git per clonare l'SDK del produttore C\$1\$1.
```
git clone https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp.git
```
1. Prepara una directory di compilazione.
```
cd amazon-kinesis-video-streams-producer-sdk-cpp
mkdir build
cd build
```
1. Usa CMake per generare makefile.
```
cmake .. -DBUILD_GSTREAMER_PLUGIN=TRUE -DBUILD_DEPENDENCIES=OFF
```
La fine dell'output previsto è la seguente:
```
-- Build files have been written to: /home/ubuntu/environment/amazon-kinesis-video-streams-producer-sdk-cpp/build
```
1. Usa make per compilare l'SDK e le applicazioni di esempio, oltre a creare gli eseguibili finali.
```
make
```
La fine dell'output previsto è simile alla seguente:
```
[100%] Linking CXX executable kvs_gstreamer_file_uploader_sample
[100%] Built target kvs_gstreamer_file_uploader_sample
```
1. Conferma che i file di esempio sono stati creati. Elenca i file nella directory corrente:
```
ls
```
Verificate che siano presenti i seguenti file:
+ kvs\$1gstreamer\$1sample
+ libgstkvssink.so
1. (Facoltativo) È possibile aggiungere l'impostazione della variabile di ambiente GST\$1PLUGIN\$1PATH allo script di avvio della shell. Questo assicura che GST\$1PLUGIN\$1PATH sia impostato correttamente durante una nuova sessione di terminale. In AWS Cloud9, lo script di avvio della shell è:. `~/.bashrc`
Esegui il comando seguente per aggiungere il comando alla fine dello script di avvio della shell.
```
echo "export GST_PLUGIN_PATH=~/environment/amazon-kinesis-video-streams-producer-sdk-cpp/build" >> ~/.bashrc
```
Digitate quanto segue per eseguire lo script di avvio della shell:
```
source ~/.bashrc
```
Conferma che GST\$1PLUGIN\$1PATH è impostato.
```
echo $GST_PLUGIN_PATH
```
Se impostate l'output correttamente, vedrete il seguente output. Se l'output è vuoto, la variabile di ambiente non è impostata correttamente.
```
/home/ubuntu/environment/amazon-kinesis-video-streams-producer-sdk-cpp/build
```
------
## Esegui gli esempi per caricare contenuti multimediali su Kinesis Video Streams
L'applicazione di esempio non supporta le credenziali IMDS. Nel tuo terminale, esporta AWS le credenziali per il tuo utente o ruolo IAM e la regione in cui si trova lo stream.
```
export AWS_ACCESS_KEY_ID=YourAccessKey
export AWS_SECRET_ACCESS_KEY=YourSecretKey
export AWS_DEFAULT_REGION=YourAWSRegion
```
Se utilizzi AWS credenziali temporanee, esporta anche il token di sessione:
```
export AWS_SESSION_TOKEN=YourSessionToken
```
------
#### [ .mp4 files ]
Scarica un video di esempio in formato.mp4 da caricare su Kinesis Video Streams.
```
wget https://awsj-iot-handson.s3-ap-northeast-1.amazonaws.com/kvs-workshop/sample.mp4
```
Specifiche video:
+ **Risoluzione**: 1280 x 720 pixel
+ **Frequenza fotogrammi**: 30 fotogrammi al secondo
+ **Durata**: 14,0 secondi
+ **Codifica video**: H.264, nella traccia 1
+ **Fotogrammi chiave**: ogni 3 secondi, con una durata del frammento (nota anche come dimensione di un gruppo di immagini (GoP)) di 3 secondi, con il frammento finale di 2 secondi.
Esegui il seguente comando con il nome dello stream che hai creato in precedenza. Se non hai ancora creato uno stream, consulta[Crea un flusso video Amazon Kinesis](gs-createstream.md).
```
./kvs_gstreamer_sample YourStreamName ./sample.mp4
```
------
#### [ Sample video from GStreamer ]
Usa il seguente comando per generare un video utilizzando GStreamer.
Indica GStreamer dove collocare il `kvssink` GStreamer plugin. Nella directory di compilazione, specifica il percorso della cartella contenente il `libgstkvssink.so` file.
Dalla directory di compilazione, esegui il seguente comando:
```
export GST_PLUGIN_PATH=`pwd`
```
Questa GStreamer pipeline genera un flusso video di prova dal vivo con uno schema di test standard che viene eseguito a 10 fotogrammi al secondo con una risoluzione di 640x480 pixel. Viene aggiunto un overlay che mostra l'ora e la data correnti del sistema. Il video viene quindi codificato in formato H.264 e i fotogrammi chiave vengono generati al massimo ogni 10 fotogrammi, con una durata del frammento (nota anche come dimensione del gruppo di immagini (GoP)) di 1 secondo. `kvssink`prende il flusso video con codifica H.264, lo impacchetta nel formato contenitore Matroska (MKV) e lo carica nel flusso video Kinesis.
Esegui il comando seguente:
```
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"
```
**Per interrompere la GStreamer pipeline, selezionate la finestra del terminale e premete CTRL\$1C.**
------
**Nota**
Per ulteriori informazioni sull'utilizzo del GStreamer plug-in per lo streaming di video da uno stream RTSP da una videocamera o da una videocamera USB, consultate. [Esempio: plugin SDK per GStreamer produttori di Kinesis Video Streams - kvssink](examples-gstreamer-plugin.md)
## Rivedi gli oggetti di riconoscimento
Durante il caricamento, Kinesis Video Streams invierà gli oggetti di riconoscimento al client che esegue il caricamento. Dovresti vederli stampati nell'output del comando. Un esempio è simile al seguente:
```
{"EventType":"PERSISTED","FragmentTimecode":1711124585823,"FragmentNumber":"12345678901234567890123456789012345678901234567"}
```
Se la conferma `EventType` è`PERSISTED`, significa che Kinesis Video Streams ha archiviato e crittografato in modo duraturo questo blocco di file multimediali per il recupero, l'analisi e l'archiviazione a lungo termine.
Per ulteriori informazioni sui riconoscimenti, consulta. [PutMedia](API_dataplane_PutMedia.md)