Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Steuern des Zugriffs auf Kinesis Video Streams Streams-Ressourcen mithilfe von AWS IoT
In diesem Abschnitt wird beschrieben, wie Sie einem Gerät (z. B. einer Kamera) ermöglichen, Audio- und Videodaten nur an einen bestimmten Kinesis-Videostream zu senden. Sie können dies tun, indem Sie den Anbieter für AWS IoT Anmeldeinformationen und eine AWS Identity and Access Management (IAM-) Rolle verwenden.
Geräte können X.509 Zertifikate verwenden, um AWS IoT mithilfe von Protokollen für die gegenseitige TLS-Authentifizierung eine Verbindung herzustellen. Andere AWS-Services (z. B. Kinesis Video Streams) unterstützen keine zertifikatsbasierte Authentifizierung, können aber mithilfe von AWS Anmeldeinformationen im AWS Signature Version 4-Format aufgerufen werden. Der Signature Version 4-Algorithmus erfordert in der Regel, dass der Anrufer über eine Zugriffsschlüssel-ID und einen geheimen Zugriffsschlüssel verfügt. AWS IoT verfügt über einen Anbieter für Anmeldeinformationen, mit dem Sie das integrierte X.509 Zertifikat als eindeutige Geräteidentität für die Authentifizierung von AWS Anfragen (z. B. Anfragen an Kinesis Video Streams) verwenden können. Dadurch müssen keine Zugriffsschlüssel-ID und kein geheimer Zugriffsschlüssel auf Ihrem Gerät gespeichert werden.
Der Anbieter für Anmeldeinformationen authentifiziert einen Client (in diesem Fall ein Kinesis Video Streams Streams-SDK, das auf der Kamera läuft, die Sie Daten an einen Videostream senden möchten) mithilfe eines X.509 Zertifikats und stellt ein temporäres Sicherheitstoken mit eingeschränkten Rechten aus. Sie können das Token verwenden, um jede AWS Anfrage zu signieren und zu authentifizieren (in diesem Fall ein Aufruf der Kinesis Video Streams). Weitere Informationen finden Sie unter [Autorisieren von direkten Aufrufen](https://docs.aws.amazon.com//iot/latest/developerguide/authorizing-direct-aws.html) von Diensten. AWS
Für diese Art der Authentifizierung der Anfragen Ihrer Kamera an Kinesis Video Streams müssen Sie eine IAM-Rolle erstellen und konfigurieren und der Rolle entsprechende IAM-Richtlinien zuordnen, damit der Anbieter der AWS IoT Anmeldeinformationen die Rolle in Ihrem Namen übernehmen kann.
[Weitere Informationen AWS IoT dazu finden Sie in der Dokumentation.AWS IoT Core](https://docs.aws.amazon.com/iot/?id=docs_gateway) Weitere Informationen über IAM finden Sie unter [AWS Identity and Access Management (IAM)](https://aws.amazon.com/iam/).
**Topics**
+ [AWS IoT ThingName als Streamname](#how-iot-thingnamestreamname)
+ [AWS IoT CertificateId als Streamname](#how-iot-iotcertstreamname)
+ [Verwenden Sie AWS IoT Anmeldeinformationen zum Streamen zu einem fest codierten Stream-Namen](#how-iot-hard-coded-stream)
## AWS IoT ThingName als Streamname
**Topics**
+ [Schritt 1: Erstelle eine AWS IoT Ding-Typ und ein AWS IoT Objekt](#how-iot-create-thing-type)
+ [Schritt 2: Erstellen Sie eine IAM-Rolle, die übernommen werden soll von AWS IoT](#how-iot-add-iot-policy)
+ [Schritt 3: Erstellen und konfigurieren Sie das X.509 Zertifikat](#how-iot-create-cert-keys)
+ [Schritt 4: Testen Sie das AWS IoT Anmeldeinformationen mit Ihrem Kinesis-Videostream](#how-iot-test-it)
+ [Schritt 5: Bereitstellen AWS IoT Zertifikate und Anmeldeinformationen im Dateisystem Ihrer Kamera und Streamen von Daten in Ihren Videostream](#how-iot-deploy)
### Schritt 1: Erstelle eine AWS IoT Ding-Typ und ein AWS IoT Objekt
AWS IoT In ist ein Ding eine Repräsentation eines bestimmten Geräts oder einer logischen Einheit. In diesem Fall steht ein AWS IoT Ding für Ihren Kinesis-Videostream, für den Sie die Zugriffskontrolle auf Ressourcenebene konfigurieren möchten. Um ein Ding zu erstellen, müssen Sie zunächst einen AWS IoT Dingtyp erstellen. Sie können Dingtypen verwenden AWS IoT , um Beschreibungs- und Konfigurationsinformationen zu speichern, die allen Dingen gemeinsam sind, die demselben Dingtyp zugeordnet sind.
1. Der folgende Beispielbefehl erstellt einen Objekttyp `kvs_example_camera`:
```
aws --profile default iot create-thing-type --thing-type-name kvs_example_camera > iot-thing-type.json
```
1. Dieser Beispielbefehl erstellt das `kvs_example_camera_stream` Ding vom Typ `kvs_example_camera` Ding:
```
aws --profile default iot create-thing --thing-name kvs_example_camera_stream --thing-type-name kvs_example_camera > iot-thing.json
```
### Schritt 2: Erstellen Sie eine IAM-Rolle, die übernommen werden soll von AWS IoT
IAM-Rollen ähneln Benutzern, da es sich bei einer Rolle um eine AWS Identität mit Berechtigungsrichtlinien handelt, die festlegen, wofür die Identität zuständig ist und was nicht. AWS Eine Rolle kann von jedem übernommen werden, der sie benötigt. Wenn Sie eine Rolle annehmen, erhalten Sie temporäre Sicherheitsanmeldeinformationen für Ihre Rollensitzung.
Die Rolle, die Sie in diesem Schritt erstellen, kann verwendet werden, AWS IoT um temporäre Anmeldeinformationen vom Security Token Service (STS) abzurufen, wenn Autorisierungsanfragen von einem Client ausgeführt werden. In diesem Fall ist der Client das Kinesis Video Streams SDK, das auf Ihrer Kamera läuft.
Führen Sie die folgenden Schritte aus, um diese IAM-Rolle zu erstellen und zu konfigurieren:
1. Erstellen Sie eine IAM-Rolle.
Der folgende Beispielbefehl erstellt eine IAM-Rolle mit dem Namen `KVSCameraCertificateBasedIAMRole`:
```
aws --profile default iam create-role --role-name KVSCameraCertificateBasedIAMRole --assume-role-policy-document 'file://iam-policy-document.json' > iam-role.json
```
Sie können die folgende JSON-Datei für die Vertrauensrichtlinie `iam-policy-document.json` verwenden:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Fügen Sie als Nächstes der IAM-Rolle, die Sie zuvor erstellt haben, eine Berechtigungsrichtlinie hinzu. Diese Berechtigungsrichtlinie ermöglicht die selektive Zugriffskontrolle (eine Teilmenge der unterstützten Operationen) für eine AWS Ressource. In diesem Fall ist die AWS Ressource der Videostream, den Ihre Kamera Daten senden soll. Mit anderen Worten, sobald alle Konfigurationsschritte abgeschlossen sind, kann diese Kamera Daten nur an diesen Videostream senden.
```
aws --profile default iam put-role-policy --role-name KVSCameraCertificateBasedIAMRole --policy-name KVSCameraIAMPolicy --policy-document 'file://iam-permission-document.json'
```
Sie können den folgenden IAM-Richtlinien-JSON für Folgendes `iam-permission-document.json` verwenden:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"kinesisvideo:DescribeStream",
"kinesisvideo:PutMedia",
"kinesisvideo:TagStream",
"kinesisvideo:GetDataEndpoint"
],
"Resource": "arn:aws:kinesisvideo:*:*:stream/${credentials-iot:ThingName}/*"
}
]
}
```
------
Beachten Sie, dass diese Richtlinie die angegebenen Aktionen nur für einen Videostream (AWS Ressource) autorisiert, der durch den Platzhalter angegeben ist. `(${credentials-iot:ThingName})` Dieser Platzhalter nimmt den Wert des AWS IoT Thing-Attributs an, `ThingName` wenn der Anbieter für AWS IoT Anmeldeinformationen den Namen des Videostreams in der Anfrage sendet.
1. Erstellen Sie als Nächstes einen Rollenalias für Ihre IAM-Rolle. Rollenalias ist ein alternatives Datenmodell, das auf die IAM-Rolle verweist. Eine Anfrage eines Anbieters für AWS IoT Anmeldeinformationen muss einen Rollenalias enthalten, der angibt, welche IAM-Rolle übernommen werden soll, um die temporären Anmeldeinformationen vom STS zu erhalten.
Mit dem folgenden Beispielbefehl wird ein Rollenalias namens `KvsCameraIoTRoleAlias` erstellt:
```
aws --profile default iot create-role-alias --role-alias KvsCameraIoTRoleAlias --role-arn $(jq --raw-output '.Role.Arn' iam-role.json) --credential-duration-seconds 3600 > iot-role-alias.json
```
1. Jetzt können Sie die Richtlinie erstellen, die es ermöglicht, mithilfe des Rollenalias die Rolle mit dem Zertifikat AWS IoT zu übernehmen (sobald es angehängt ist).
Mit dem folgenden Beispielbefehl wird eine Richtlinie für AWS IoT aufgerufen`KvsCameraIoTPolicy`.
```
aws --profile default iot create-policy --policy-name KvsCameraIoTPolicy --policy-document 'file://iot-policy-document.json'
```
Sie können den folgenden Befehl verwenden, um das `iot-policy-document.json` Dokument JSON zu erstellen:
```
cat > iot-policy-document.json <
Die Kommunikation zwischen einem Gerät (Ihrem Videostream) AWS IoT ist durch die Verwendung von X.509 Zertifikaten geschützt.
1. Erstellen Sie das Zertifikat, an das Sie die zuvor erstellte Richtlinie anhängen müssen. AWS IoT
```
aws --profile default iot create-keys-and-certificate --set-as-active --certificate-pem-outfile certificate.pem --public-key-outfile public.pem.key --private-key-outfile private.pem.key > certificate
```
1. Hängen Sie die Richtlinie für AWS IoT (zuvor `KvsCameraIoTPolicy` erstellt) an dieses Zertifikat an.
```
aws --profile default iot attach-policy --policy-name KvsCameraIoTPolicy --target $(jq --raw-output '.certificateArn' certificate)
```
1. Hängen Sie Ihr AWS IoT Ding (`kvs_example_camera_stream`) an das Zertifikat an, das Sie gerade erstellt haben:
```
aws --profile default iot attach-thing-principal --thing-name kvs_example_camera_stream --principal $(jq --raw-output '.certificateArn' certificate)
```
1. Um Anfragen über den Anbieter für AWS IoT Anmeldeinformationen zu autorisieren, benötigen Sie den Endpunkt für AWS IoT Anmeldeinformationen, der für Ihre AWS-Konto ID eindeutig ist. Sie können den folgenden Befehl verwenden, um den Endpunkt der AWS IoT Anmeldeinformationen abzurufen.
```
aws --profile default iot describe-endpoint --endpoint-type iot:CredentialProvider --output text > iot-credential-provider.txt
```
1. Zusätzlich zu dem zuvor erstellten X.509 Zertifikat benötigen Sie auch ein CA-Zertifikat, um über TLS eine Vertrauensstellung mit dem Back-End-Dienst herzustellen. Sie können das CA-Zertifikat mit dem folgenden Befehl abrufen:
```
curl --silent 'https://www.amazontrust.com/repository/SFSRootCAG2.pem' --output cacert.pem
```
### Schritt 4: Testen Sie das AWS IoT Anmeldeinformationen mit Ihrem Kinesis-Videostream
Jetzt können Sie die AWS IoT Anmeldedaten testen, die Sie bisher eingerichtet haben.
1. Erstellen Sie zunächst einen Kinesis-Videostream, mit dem Sie diese Konfiguration testen möchten.
**Wichtig**
Erstellen Sie einen Videostream mit einem Namen, der mit dem Namen des AWS IoT Dings identisch ist, den Sie im vorherigen Schritt erstellt haben (`kvs_example_camera_stream`).
```
aws kinesisvideo create-stream --data-retention-in-hours 24 --stream-name kvs_example_camera_stream
```
1. Rufen Sie als Nächstes den Anbieter AWS IoT für Anmeldeinformationen an, um die temporären Anmeldeinformationen abzurufen:
```
curl --silent -H "x-amzn-iot-thingname:kvs_example_camera_stream" --cert certificate.pem --key private.pem.key https://IOT_GET_CREDENTIAL_ENDPOINT/role-aliases/KvsCameraIoTRoleAlias/credentials --cacert ./cacert.pem > token.json
```
**Anmerkung**
Sie können den folgenden Befehl verwenden, um Folgendes abzurufen`IOT_GET_CREDENTIAL_ENDPOINT`:
```
IOT_GET_CREDENTIAL_ENDPOINT=`cat iot-credential-provider.txt`
```
Die Ausgabe-JSON enthält die `accessKey``secretKey`, und die`sessionToken`, mit denen Sie auf die Kinesis Video Streams zugreifen können.
1. Für Ihren Test können Sie diese Anmeldeinformationen verwenden, um die Kinesis Video Streams `DescribeStream` Streams-API für den `kvs_example_camera_stream` Beispielvideostream aufzurufen.
```
AWS_ACCESS_KEY_ID=$(jq --raw-output '.credentials.accessKeyId' token.json) AWS_SECRET_ACCESS_KEY=$(jq --raw-output '.credentials.secretAccessKey' token.json) AWS_SESSION_TOKEN=$(jq --raw-output '.credentials.sessionToken' token.json) aws kinesisvideo describe-stream --stream-name kvs_example_camera_stream
```
### Schritt 5: Bereitstellen AWS IoT Zertifikate und Anmeldeinformationen im Dateisystem Ihrer Kamera und Streamen von Daten in Ihren Videostream
**Anmerkung**
Die Schritte in diesem Abschnitt beschreiben das Senden von Medien an einen Kinesis-Videostream von einer Kamera, die den [Verwenden Sie die C\+\+-Producer-Bibliothek](producer-sdk-cpp.md) verwendet.
1. Kopieren Sie das X.509 Zertifikat, den privaten Schlüssel und das CA-Zertifikat, das in den vorherigen Schritten generiert wurde, in das Dateisystem Ihrer Kamera. Geben Sie die Pfade an, in denen diese Dateien gespeichert werden, den Rollenaliasnamen und den Endpunkt der AWS IoT Anmeldeinformationen für die Ausführung des `gst-launch-1.0` Befehls oder Ihrer Beispielanwendung.
1. Der folgende Beispielbefehl verwendet die AWS IoT Zertifikatsautorisierung, um Video an Kinesis Video Streams zu senden:
```
gst-launch-1.0 rtspsrc location=rtsp://{{YourCameraRtspUrl}} short-header=TRUE ! rtph264depay ! video/x-h264,format=avc,alignment=au ! h264parse ! kvssink stream-name="kvs_example_camera_stream" aws-region="{{YourAWSRegion}}" iot-certificate="iot-certificate,endpoint={{credential-account-specific-prefix}}.credentials.iot.{{aws-region}}.amazonaws.com,cert-path=/path/to/certificate.pem,key-path=/path/to/private.pem.key,ca-path={{/path/to/cacert.pem}},role-aliases=KvsCameraIoTRoleAlias"
```
## AWS IoT CertificateId als Streamname
Um Ihr Gerät (z. B. Ihre Kamera) durch ein AWS IoT Ding darzustellen, aber einen anderen Streamnamen zu autorisieren, können Sie das AWS IoT `certificateId` Attribut als Ihren Streamnamen verwenden und Kinesis Video Streams Streams-Berechtigungen für den Stream mit erteilen. AWS IoT Die Schritte, um dies zu erreichen, ähneln den zuvor beschriebenen, mit einigen Änderungen.
+ Ändern Sie die Berechtigungsrichtlinie wie folgt auf Ihre IAM-Rolle (`iam-permission-document.json`):
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"kinesisvideo:DescribeStream",
"kinesisvideo:PutMedia",
"kinesisvideo:TagStream",
"kinesisvideo:GetDataEndpoint"
],
"Resource": "arn:aws:kinesisvideo:*:*:stream/${credentials-iot:AwsCertificateId}/*"
}
]
}
```
------
**Anmerkung**
Der Ressourcen-ARN verwendet die Zertifikat-ID als Platzhalter für den Streamnamen. Die IAM-Berechtigung funktioniert, wenn Sie die Zertifikat-ID als Streamnamen verwenden. Rufen Sie die Zertifikat-ID aus dem Zertifikat ab, sodass Sie diese als Streamnamen im folgenden beschreibenden Stream-API-Aufruf verwenden können.
```
export CERTIFICATE_ID=`cat certificate | jq --raw-output '.certificateId'`
```
+ Überprüfen Sie diese Änderung mit dem describe-stream-CLI-Befehl für Kinesis Video Streams:
```
AWS_ACCESS_KEY_ID=$(jq --raw-output '.credentials.accessKeyId' token.json) AWS_SECRET_ACCESS_KEY=$(jq --raw-output '.credentials.secretAccessKey' token.json) AWS_SESSION_TOKEN=$(jq --raw-output '.credentials.sessionToken' token.json) aws kinesisvideo describe-stream --stream-name ${CERTIFICATE_ID}
```
+ Übergeben Sie die certificateId an den Anbieter für AWS IoT Anmeldeinformationen in der [Beispielanwendung](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/blob/master/samples/kvs_gstreamer_sample.cpp) im Kinesis Video Streams C\+\+ SDK:
```
credential_provider = make_unique(iot_get_credential_endpoint,
cert_path,
private_key_path,
role_alias,
ca_cert_path,
certificateId);
```
**Anmerkung**
Beachten Sie, dass Sie das an den Anbieter `thingname` für Anmeldeinformationen weitergeben. AWS IoT Sie können `getenv` es verwenden, um den Dingnamen an die Demo-Anwendung zu übergeben, ähnlich wie bei der Übergabe der anderen AWS IoT Attribute. Verwenden Sie die Zertifikat-ID als Streamnamen in den Befehlszeilenparametern, wenn Sie die Beispielanwendung ausführen.
## Verwenden Sie AWS IoT Anmeldeinformationen zum Streamen zu einem fest codierten Stream-Namen
Um Ihr Gerät (z. B. Ihre Kamera) durch ein AWS IoT Ding darzustellen, aber das Streaming zu einem bestimmten Amazon Kinesis-Videostream zu autorisieren, geben Sie Amazon Kinesis Video Streams-Berechtigungen für den Stream, der verwendet. AWS IoT Der Vorgang ähnelt den vorherigen Abschnitten, mit einigen Änderungen.
Ändern Sie die Berechtigungsrichtlinie wie folgt auf Ihre IAM-Rolle (`iam-permission-document.json`):
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"kinesisvideo:DescribeStream",
"kinesisvideo:PutMedia",
"kinesisvideo:TagStream",
"kinesisvideo:GetDataEndpoint"
],
"Resource": "arn:aws:kinesisvideo:*:*:stream/{{YourStreamName}}/*"
}
]
}
```
------
Kopieren Sie das X.509 in den vorherigen Schritten generierte Zertifikat, den privaten Schlüssel und das CA-Zertifikat in das Dateisystem Ihrer Kamera.
Geben Sie die Pfade an, in denen diese Dateien gespeichert werden, den Rollenaliasnamen, den AWS IoT Namen des Dings und den Endpunkt der AWS IoT Anmeldeinformationen für die Ausführung des `gst-launch-1.0` Befehls oder Ihrer Beispielanwendung.
Der folgende Beispielbefehl verwendet die AWS IoT Zertifikatsautorisierung, um Videos an Amazon Kinesis Video Streams zu senden:
```
gst-launch-1.0 rtspsrc location=rtsp://{{YourCameraRtspUrl}} short-header=TRUE ! rtph264depay ! video/x-h264,format=avc,alignment=au ! h264parse ! kvssink stream-name="{{YourStreamName}}" aws-region="{{YourAWSRegion}}" iot-certificate="iot-certificate,endpoint={{credential-account-specific-prefix}}.credentials.iot.{{aws-region}}.amazonaws.com,cert-path=/path/to/certificate.pem,key-path=/path/to/private.pem.key,ca-path={{/path/to/cacert.pem}},role-aliases=KvsCameraIoTRoleAlias,iot-thing-name={{YourThingName}}"
```