As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Controlando o acesso aos recursos do Kinesis Video Streams usando AWS IoT
Esta seção descreve como permitir que um dispositivo (por exemplo, uma câmera) envie dados de áudio e vídeo somente para um determinado stream de vídeo do Kinesis. Você pode fazer isso usando o provedor de AWS IoT credenciais e uma função AWS Identity and Access Management (IAM).
Os dispositivos podem usar X.509 certificados para se conectar AWS IoT usando protocolos de autenticação mútua TLS. Outros Serviços da AWS (por exemplo, o Kinesis Video Streams) não oferecem suporte à autenticação baseada em certificado, mas podem ser AWS chamados usando AWS credenciais no formato Signature versão 4. O algoritmo Signature Version 4 normalmente exige que o chamador tenha um ID de chave de acesso e uma chave de acesso secreta. AWS IoT tem um provedor de credenciais que permite usar o X.509 certificado integrado como a identidade exclusiva do dispositivo para autenticar AWS solicitações (por exemplo, solicitações para o Kinesis Video Streams). Isso elimina a necessidade de armazenar um ID de chave de acesso e uma chave de acesso secreta em seu dispositivo.
O provedor de credenciais autentica um cliente (nesse caso, um SDK do Kinesis Video Streams que está sendo executado na câmera para a qual você deseja enviar dados para um stream de vídeo) usando um certificado e emite um token de segurança X.509 temporário com privilégios limitados. Você pode usar o token para assinar e autenticar qualquer AWS solicitação (nesse caso, uma chamada para o Kinesis Video Streams). Para obter mais informações, consulte [Autorização de chamadas diretas para AWS serviços](https://docs.aws.amazon.com//iot/latest/developerguide/authorizing-direct-aws.html).
Essa forma de autenticar as solicitações da sua câmera no Kinesis Video Streams exige que você crie e configure uma função do IAM e anexe políticas apropriadas do IAM à função para que o provedor de credenciais possa assumir AWS IoT a função em seu nome.
Para obter mais informações sobre AWS IoT, consulte a [AWS IoT Core documentação](https://docs.aws.amazon.com/iot/?id=docs_gateway). Para obter mais informações sobre o IAM, consulte [AWS Identity and Access Management (IAM)](https://aws.amazon.com/iam/).
**Topics**
+ [AWS IoT ThingName como nome do stream](#how-iot-thingnamestreamname)
+ [AWS IoT CertificateId como nome do stream](#how-iot-iotcertstreamname)
+ [Use AWS IoT credenciais para transmitir para um nome de fluxo codificado](#how-iot-hard-coded-stream)
## AWS IoT ThingName como nome do stream
**Topics**
+ [Etapa 1: criar um AWS IoT tipo de coisa e um AWS IoT objeto](#how-iot-create-thing-type)
+ [Etapa 2: criar uma função do IAM a ser assumida por AWS IoT](#how-iot-add-iot-policy)
+ [Etapa 3: criar e configurar o X.509 certificado](#how-iot-create-cert-keys)
+ [Etapa 4: testar o AWS IoT credenciais com seu stream de vídeo do Kinesis](#how-iot-test-it)
+ [Etapa 5: Implantação AWS IoT certificados e credenciais no sistema de arquivos da sua câmera e dados de streaming para seu stream de vídeo](#how-iot-deploy)
### Etapa 1: criar um AWS IoT tipo de coisa e um AWS IoT objeto
Em AWS IoT, uma coisa é uma representação de um dispositivo específico ou entidade lógica. Nesse caso, AWS IoT algo representa seu stream de vídeo do Kinesis e você deseja configurar o controle de acesso em nível de recurso. Para criar uma coisa, primeiro você deve criar um tipo de AWS IoT coisa. Você pode usar tipos de AWS IoT coisas para armazenar informações de descrição e configuração comuns a todas as coisas associadas ao mesmo tipo de coisa.
1. O comando de exemplo a seguir cria um tipo de coisa `kvs_example_camera`:
```
aws --profile default iot create-thing-type --thing-type-name kvs_example_camera > iot-thing-type.json
```
1. Esse exemplo de comando cria `kvs_example_camera_stream` uma coisa do tipo `kvs_example_camera` coisa:
```
aws --profile default iot create-thing --thing-name kvs_example_camera_stream --thing-type-name kvs_example_camera > iot-thing.json
```
### Etapa 2: criar uma função do IAM a ser assumida por AWS IoT
As funções do IAM são semelhantes às dos usuários, pois uma função é uma AWS identidade com políticas de permissões que determinam o que a identidade pode ou não fazer AWS. Uma função pode ser assumida por qualquer pessoa que precise dela. Quando você assume uma função, ela fornece credenciais de segurança temporárias para sua sessão de função.
A função que você cria nesta etapa pode ser assumida AWS IoT para obter credenciais temporárias do serviço de token de segurança (STS) ao realizar solicitações de autorização de credenciais do cliente. Nesse caso, o cliente é o SDK do Kinesis Video Streams que está sendo executado na sua câmera.
Execute as seguintes etapas para criar e configurar essa função do IAM:
1. Criar um perfil do IAM.
O comando de exemplo a seguir cria uma função do IAM chamada `KVSCameraCertificateBasedIAMRole`:
```
aws --profile default iam create-role --role-name KVSCameraCertificateBasedIAMRole --assume-role-policy-document 'file://iam-policy-document.json' > iam-role.json
```
Você pode usar o seguinte JSON de política de confiança para o `iam-policy-document.json`:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Em seguida, anexe uma política de permissões à função do IAM que você criou anteriormente. Essa política de permissões permite o controle de acesso seletivo (um subconjunto de operações suportadas) para um AWS recurso. Nesse caso, o AWS recurso é o stream de vídeo para o qual você deseja que sua câmera envie dados. Em outras palavras, quando todas as etapas de configuração forem concluídas, essa câmera poderá enviar dados somente para esse streaming de vídeo.
```
aws --profile default iam put-role-policy --role-name KVSCameraCertificateBasedIAMRole --policy-name KVSCameraIAMPolicy --policy-document 'file://iam-permission-document.json'
```
Você pode usar o seguinte JSON de política do IAM para: `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:ThingName}/*"
}
]
}
```
------
Observe que essa política autoriza as ações especificadas somente em um stream de vídeo (AWS recurso) especificado pelo espaço `(${credentials-iot:ThingName})` reservado. Esse espaço reservado assume o valor do atributo AWS IoT thing `ThingName` quando o provedor de AWS IoT credenciais envia o nome do stream de vídeo na solicitação.
1. Em seguida, crie um alias de função para sua função do IAM. O alias da função é um modelo de dados alternativo que aponta para a função do IAM. Uma solicitação de provedor de AWS IoT credenciais deve incluir um alias de função para indicar qual função do IAM assumir para obter as credenciais temporárias do STS.
O exemplo de comando a seguir cria um alias de função chamado `KvsCameraIoTRoleAlias`,
```
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. Agora você pode criar a política que permitirá assumir AWS IoT a função com o certificado (depois de anexado) usando o alias da função.
O exemplo de comando a seguir cria uma política para AWS IoT called`KvsCameraIoTPolicy`.
```
aws --profile default iot create-policy --policy-name KvsCameraIoTPolicy --policy-document 'file://iot-policy-document.json'
```
Você pode usar o comando a seguir para criar o `iot-policy-document.json` documento JSON:
```
cat > iot-policy-document.json <
A comunicação entre um dispositivo (seu stream de vídeo) AWS IoT é protegida pelo uso de X.509 certificados.
1. Crie o certificado ao qual você deve anexar a política AWS IoT que você criou anteriormente.
```
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. Anexe a política para AWS IoT (`KvsCameraIoTPolicy`criada anteriormente) a esse certificado.
```
aws --profile default iot attach-policy --policy-name KvsCameraIoTPolicy --target $(jq --raw-output '.certificateArn' certificate)
```
1. Anexe sua AWS IoT coisa (`kvs_example_camera_stream`) ao certificado que você acabou de criar:
```
aws --profile default iot attach-thing-principal --thing-name kvs_example_camera_stream --principal $(jq --raw-output '.certificateArn' certificate)
```
1. Para autorizar solicitações por meio do provedor de AWS IoT credenciais, você precisa do endpoint de AWS IoT credenciais, que é exclusivo do seu ID. Conta da AWS Você pode usar o comando a seguir para obter o endpoint de AWS IoT credenciais.
```
aws --profile default iot describe-endpoint --endpoint-type iot:CredentialProvider --output text > iot-credential-provider.txt
```
1. Além do X.509 certificado criado anteriormente, você também deve ter um certificado CA para estabelecer confiança com o serviço de back-end por meio do TLS. Você pode obter o certificado CA usando o seguinte comando:
```
curl --silent 'https://www.amazontrust.com/repository/SFSRootCAG2.pem' --output cacert.pem
```
### Etapa 4: testar o AWS IoT credenciais com seu stream de vídeo do Kinesis
Agora você pode testar as AWS IoT credenciais que você configurou até agora.
1. Primeiro, crie um streaming de vídeo do Kinesis com o qual você deseja testar essa configuração.
**Importante**
Crie um stream de vídeo com um nome idêntico ao nome da AWS IoT coisa que você criou na etapa anterior (`kvs_example_camera_stream`).
```
aws kinesisvideo create-stream --data-retention-in-hours 24 --stream-name kvs_example_camera_stream
```
1. Em seguida, ligue para o provedor de AWS IoT credenciais para obter as credenciais temporárias:
```
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
```
**nota**
Você pode usar o comando a seguir para obter o`IOT_GET_CREDENTIAL_ENDPOINT`:
```
IOT_GET_CREDENTIAL_ENDPOINT=`cat iot-credential-provider.txt`
```
O JSON de saída contém o `accessKey``secretKey`, e o`sessionToken`, que você pode usar para acessar o Kinesis Video Streams.
1. Para seu teste, você pode usar essas credenciais para invocar a API Kinesis Video `DescribeStream` Streams para o stream de vídeo de amostra. `kvs_example_camera_stream`
```
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
```
### Etapa 5: Implantação AWS IoT certificados e credenciais no sistema de arquivos da sua câmera e dados de streaming para seu stream de vídeo
**nota**
As etapas desta seção descrevem o envio de mídia para um stream de vídeo do Kinesis a partir de uma câmera que está usando o. [Use a biblioteca de produtores de C\+\+](producer-sdk-cpp.md)
1. Copie o X.509 certificado, a chave privada e o certificado CA gerados nas etapas anteriores para o sistema de arquivos da sua câmera. Especifique os caminhos para onde esses arquivos são armazenados, o nome do alias da função e o endpoint de AWS IoT credenciais para executar o `gst-launch-1.0` comando ou seu aplicativo de amostra.
1. O exemplo de comando a seguir usa autorização de AWS IoT certificado para enviar vídeo para o Kinesis Video Streams:
```
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 como nome do stream
Para representar seu dispositivo (por exemplo, sua câmera) por meio de AWS IoT algo, mas autorizar um nome de stream diferente, você pode usar o AWS IoT `certificateId` atributo como nome do stream e fornecer permissões ao Kinesis Video Streams no stream usando. AWS IoT As etapas para fazer isso são semelhantes às descritas anteriormente, com algumas alterações.
+ Modifique a política de permissões para sua função do IAM (`iam-permission-document.json`) da seguinte forma:
------
#### [ 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}/*"
}
]
}
```
------
**nota**
O ARN do recurso usa o ID do certificado como espaço reservado para o nome de streaming. A permissão do IAM funcionará quando você usar o ID do certificado como nome do stream. Obtenha o ID do certificado para que você possa usá-lo como nome do fluxo na descrição a seguir da chamada da API de fluxo.
```
export CERTIFICATE_ID=`cat certificate | jq --raw-output '.certificateId'`
```
+ Verifique essa alteração usando o comando describe-stream da CLI do 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}
```
+ Passe o CertificateID para o provedor de credenciais AWS IoT no aplicativo de [amostra no SDK para C\+\+ do](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/blob/master/samples/kvs_gstreamer_sample.cpp) Kinesis Video Streams:
```
credential_provider = make_unique(iot_get_credential_endpoint,
cert_path,
private_key_path,
role_alias,
ca_cert_path,
certificateId);
```
**nota**
Observe que você está passando o `thingname` para o provedor de AWS IoT credenciais. Você pode usar `getenv` para passar o nome da coisa para o aplicativo de demonstração da mesma forma que passa os outros AWS IoT atributos. Use o ID do certificado como o nome de streaming nos parâmetros da linha de comando quando estiver executando o aplicativo de amostra.
## Use AWS IoT credenciais para transmitir para um nome de fluxo codificado
Para representar seu dispositivo (por exemplo, sua câmera) por meio de AWS IoT algo, mas autorizar o streaming para um stream de vídeo específico do Amazon Kinesis, forneça permissões do Amazon Kinesis Video Streams no stream usando. AWS IoT O processo é semelhante às seções anteriores, com algumas alterações.
Modifique a política de permissões para sua função do IAM (`iam-permission-document.json`) da seguinte forma:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"kinesisvideo:DescribeStream",
"kinesisvideo:PutMedia",
"kinesisvideo:TagStream",
"kinesisvideo:GetDataEndpoint"
],
"Resource": "arn:aws:kinesisvideo:*:*:stream/{{YourStreamName}}/*"
}
]
}
```
------
Copie o X.509 certificado, a chave privada e o certificado CA gerados nas etapas anteriores para o sistema de arquivos da sua câmera.
Especifique os caminhos para onde esses arquivos são armazenados, o nome do alias da função, o nome da AWS IoT coisa e o endpoint de AWS IoT credenciais para executar o `gst-launch-1.0` comando ou seu aplicativo de amostra.
O exemplo de comando a seguir usa autorização de AWS IoT certificado para enviar vídeo para o Amazon Kinesis Video Streams:
```
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}}"
```