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à.
# Invia dati a uno streaming 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 di produzione C\+\+](producer-sdk-cpp.md) come [Esempio: plug-in GStreamer SDK del produttore di Kinesis Video Streams - kvssink](examples-gstreamer-plugin.md) plugin.
Per inviare contenuti multimediali da una varietà di dispositivi su diversi sistemi operativi, questo tutorial utilizza la libreria di produzione C\+\+ Kinesis Video Streams e [ GStreamer](https://gstreamer.freedesktop.org/), 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)
+ [Eseguite 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 nel file [ readme ](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp) per creare la libreria di produzione e l'applicazione di esempio.
Questo include:
+ Installazione delle dipendenze
+ Clonazione del repository
+ Usare ** CMake per generare makefile ** ** **
+ Creazione dei file binari usando make ** **
------
#### [ Build in AWS Cloud9 ]
Segui queste procedure per caricarli su Kinesis Video Streams in. AWS Cloud9 Non dovrai scaricare nulla sul tuo computer.
1. In Console di gestione AWS, apri [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 le autorizzazioni 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 del produttore SDK di C\+\+.
```
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 il C\+\+ producer SDK.
```
git clone https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp.git
```
1. Prepara una cartella 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 è la 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
```
Conferma che siano presenti i seguenti file:
+ kvs\_gstreamer\_sample
+ libgstkvssink.so
1. (Facoltativo) Puoi aggiungere l'impostazione della variabile di ambiente GST\_PLUGIN\_PATH allo script di avvio della shell. Ciò garantisce che GST\_PLUGIN\_PATH 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\_PLUGIN\_PATH sia impostato.
```
echo $GST_PLUGIN_PATH
```
Se imposti l'output correttamente, vedrai 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
```
------
## Eseguite 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 il tuo 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 .mp4 di esempio 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 comando seguente con il nome dello stream che hai creato in precedenza. Se non hai ancora creato uno stream, consulta[Crea uno streaming video Amazon Kinesis](gs-createstream.md).
```
./kvs_gstreamer_sample {{YourStreamName}} ./sample.mp4
```
------
#### [ Sample video from GStreamer ]
Usa il seguente comando per generare un video usando GStreamer.
Indica a GStreamer dove localizzare il plugin GStreamer. `kvssink` Nella tua cartella di compilazione, specifica il percorso della cartella contenente il file. `libgstkvssink.so`
Dalla cartella di compilazione, esegui il comando seguente:
```
export GST_PLUGIN_PATH=`pwd`
```
Questa pipeline GStreamer genera un flusso video di test live 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 H.264 formato e i fotogrammi chiave vengono generati al massimo ogni 10 fotogrammi, con una durata del frammento (nota anche come dimensione di un gruppo di immagini (GoP)) di 1 secondo. `kvssink`prende il flusso H.264-encoded video, 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 pipeline GStreamer, selezionate la finestra del terminale e premete CTRL\+C. ** **
------
**Nota**
Per ulteriori informazioni sull'utilizzo del plugin GStreamer per lo streaming di video da un flusso RTSP da una videocamera o da una videocamera USB, consulta. [Esempio: plug-in GStreamer SDK del produttore 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` è sì`PERSISTED`, significa che Kinesis Video Streams ha archiviato e crittografato in modo duraturo questo blocco di contenuti multimediali per il recupero, l'analisi e l'archiviazione a lungo termine.
Per ulteriori informazioni sui riconoscimenti, vedere. [ PutMedia ](https://docs.aws.amazon.com/kinesisvideostreams/latest/APIReference/API_dataplane_PutMedia.html)