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á.
# Transmita vídeo usando CloudFront
Os fluxos de trabalho de mídia geralmente armazenam conteúdo finalizado — arquivos de vídeo sob demanda (VOD), pacotes HTTP Live Streaming (HLS), imagens e gráficos — em um volume FSx for ONTAP no qual editores, produtores e sistemas de automação gravam usando NFS ou SMB.
Com um ponto de acesso Amazon S3 conectado ao volume FSx for ONTAP, CloudFront pode servir conteúdo diretamente do volume. Editores e sistemas de produção publicam no volume via NFS ou SMB da maneira que sempre fizeram, CloudFront buscam conteúdo por meio do ponto de acesso e os espectadores recebem o conteúdo do ponto de presença mais próximo. CloudFront
Neste tutorial, você codifica um vídeo de amostra como um pacote de taxa de bits adaptável HLS, carrega a saída em um ponto de acesso conectado a um volume FSx for ONTAP, configura uma CloudFront distribuição com controle de acesso de origem para que os espectadores não possam desviar para alcançar o volume diretamente e verifica CloudFront se o stream é reproduzido de ponta a ponta.
**nota**
Este tutorial leva aproximadamente **40 a 60 minutos** para ser concluído. Os Serviços da AWS usados incorrem em cobranças pelos recursos que você cria. Se você concluir todas as etapas, incluindo a seção **Limpeza** imediatamente, o custo esperado é inferior a **$1** no Leste dos EUA (Norte da Virgínia) Região da AWS. Essa estimativa não inclui cobranças contínuas do FSx para o volume do ONTAP em si.
## Como o padrão funciona
O fluxo de solicitações é:
+ O player de um espectador (navegador, aplicativo móvel, smart TV) solicita a playlist principal do HLS do CloudFront domínio.
+ CloudFront verifica seu cache de borda. Caso contrário, CloudFront assina uma solicitação usando o Signature Version 4 (SigV4) com seu controle de acesso de origem (OAC) e a encaminha para o endpoint Amazon S3 do ponto de acesso.
+ O ponto de acesso autoriza a solicitação de acordo com sua política de acesso, que permite que o principal de CloudFront serviço defina o escopo de sua distribuição e retorna o objeto solicitado do volume FSx for ONTAP.
+ CloudFront armazena em cache a resposta na borda e a retorna ao visualizador.
Os pacotes HLS combinam dois tipos de arquivos que se beneficiam de políticas de cache diferentes:
+ **As playlists** (`.m3u8`) descrevem quais segmentos compõem o stream. Use um `Cache-Control` TTL curto para poder publicar playlists atualizadas rapidamente.
+ **Os segmentos** (`.ts`) contêm o vídeo e o áudio codificados. Depois de escrito, o conteúdo de um segmento nunca muda, então use um TTL longo e imutável`Cache-Control`.
## Pré-requisitos
+ Um volume FSx for ONTAP com um ponto de acesso Amazon S3 conectado. O ponto de acesso deve ter uma origem de rede **na Internet** para que CloudFront possa alcançá-lo. Para instruções, consulte [Criar um ponto de acesso](fsxn-creating-access-points.md).
+ AWS CLI versão 2 instalada e configurada com credenciais que podem criar CloudFront distribuições, controles de acesso de origem e políticas de pontos de acesso.
+ [FFmpeg](https://ffmpeg.org/) instalado localmente, para codificar o vídeo de amostra em HLS.
+ Um arquivo de vídeo de origem. Este tutorial usa o [trailer Sintel](https://download.blender.org/durian/trailer/sintel_trailer-1080p.mp4) da Blender Foundation, um clipe 1080p de 52 segundos lançado sob Creative Commons.
## Etapa 1: codificar o vídeo de origem como um pacote HLS
Use o FFmpeg para produzir um pacote HLS de três variantes em 360p, 720p e 1080p com taxas de bits realistas over-the-top (OTT). O pacote resultante inclui uma playlist principal que faz referência a playlists por variante, cada uma listando segmentos de stream de transporte de quatro segundos.
1. Baixe o vídeo de origem.
```
$ mkdir -p ~/media && cd ~/media
curl -sSL -o sintel-1080p.mp4 \
https://download.blender.org/durian/trailer/sintel_trailer-1080p.mp4
```
1. Codifique o vídeo em HLS com três variantes de taxa de bits adaptável.
```
$ mkdir hls && cd hls
ffmpeg -i ../sintel-1080p.mp4 \
-filter_complex "[0:v]split=3[v1][v2][v3]; \
[v1]scale=w=640:h=360[v1out]; \
[v2]scale=w=1280:h=720[v2out]; \
[v3]scale=w=1920:h=1080[v3out]" \
-map "[v1out]" -c:v:0 libx264 -b:v:0 800k -maxrate:v:0 856k -bufsize:v:0 1200k \
-map "[v2out]" -c:v:1 libx264 -b:v:1 3000k -maxrate:v:1 3200k -bufsize:v:1 4500k \
-map "[v3out]" -c:v:2 libx264 -b:v:2 5500k -maxrate:v:2 5900k -bufsize:v:2 8250k \
-preset veryfast -g 48 -keyint_min 48 -sc_threshold 0 \
-map a:0 -map a:0 -map a:0 -c:a aac -b:a:0 96k -b:a:1 128k -b:a:2 128k \
-f hls -hls_time 4 -hls_playlist_type vod -hls_flags independent_segments \
-hls_segment_filename "stream_%v/seg_%03d.ts" \
-master_pl_name master.m3u8 \
-var_stream_map "v:0,a:0,name:360p v:1,a:1,name:720p v:2,a:2,name:1080p" \
"stream_%v/playlist.m3u8"
```
O comando produz uma árvore de diretórios com uma playlist principal, três playlists variantes e os segmentos de fluxo de transporte para cada variante.
```
hls/
├── master.m3u8
├── stream_360p/
│ ├── playlist.m3u8
│ ├── seg_000.ts
│ └── ...
├── stream_720p/
│ ├── playlist.m3u8
│ ├── seg_000.ts
│ └── ...
└── stream_1080p/
├── playlist.m3u8
├── seg_000.ts
└── ...
```
## Etapa 2: Carregar o pacote HLS no ponto de acesso
Faça o upload do pacote duas vezes: uma para playlists com TTL curto e outra para segmentos com TTL longo e imutável. Definir o correto `Content-Type` é importante: a maioria dos jogadores exige `application/vnd.apple.mpegurl` para `.m3u8` e `video/mp2t` para`.ts`.
{{access-point-alias}}Substitua pelo alias do seu ponto de acesso.
```
$ # Playlists: short TTL, m3u8 content type
aws s3 cp ~/media/hls/ "s3://{{access-point-alias}}/content/sintel/" \
--recursive --exclude "*" --include "*.m3u8" \
--content-type "application/vnd.apple.mpegurl" \
--cache-control "max-age=60"
# Segments: long immutable TTL, ts content type
aws s3 cp ~/media/hls/ "s3://{{access-point-alias}}/content/sintel/" \
--recursive --exclude "*" --include "*.ts" \
--content-type "video/mp2t" \
--cache-control "max-age=31536000,immutable"
```
Verifique se os dois arquivos foram carregados com os tipos de conteúdo e cabeçalhos de cache esperados.
```
$ aws s3api head-object --bucket {{access-point-alias}} \
--key content/sintel/master.m3u8 \
--query '{ContentType:ContentType,CacheControl:CacheControl}'
```
## Etapa 3: criar um controle de acesso de origem
Um controle de acesso de origem (OAC) permite CloudFront assinar solicitações em seu ponto de acesso para que somente CloudFront possa buscar objetos. Sem o OAC, os espectadores poderiam ignorar CloudFront solicitando objetos diretamente do endpoint de acesso.
```
$ aws cloudfront create-origin-access-control \
--origin-access-control-config \
'Name=fsxn-media-oac,SigningProtocol=sigv4,SigningBehavior=always,OriginAccessControlOriginType=s3'
```
Observe o `Id` na resposta. Ele será usado na próxima etapa.
## Etapa 4: criar a CloudFront distribuição
Crie uma CloudFront distribuição com o alias do ponto de acesso como domínio de origem. Use a política de cache `CachingOptimized` gerenciado, que respeita os `Cache-Control` cabeçalhos que você definiu na Etapa 2.
1. Salve a configuração a seguir em um arquivo chamado`dist.json`, substituindo os espaços reservados.
```
{
"CallerReference": "fsxn-media-1",
"Comment": "FSx for ONTAP media delivery",
"Enabled": true,
"DefaultRootObject": "",
"Origins": {
"Quantity": 1,
"Items": [{
"Id": "fsxn-ap",
"DomainName": "{{access-point-alias}}.s3.{{region}}.amazonaws.com",
"S3OriginConfig": {"OriginAccessIdentity": ""},
"OriginAccessControlId": "{{oac-id}}",
"ConnectionAttempts": 3,
"ConnectionTimeout": 10
}]
},
"DefaultCacheBehavior": {
"TargetOriginId": "fsxn-ap",
"ViewerProtocolPolicy": "redirect-to-https",
"AllowedMethods": {
"Quantity": 2, "Items": ["GET", "HEAD"],
"CachedMethods": {"Quantity": 2, "Items": ["GET", "HEAD"]}
},
"Compress": true,
"CachePolicyId": "658327ea-f89d-4fab-a63d-7e88639e58f6"
},
"PriceClass": "PriceClass_100",
"ViewerCertificate": {"CloudFrontDefaultCertificate": true}
}
```
**nota**
`PriceClass_100`usa pontos CloudFront de presença somente na América do Norte e na Europa, o que mantém o custo mais baixo neste tutorial. Para cobertura de borda global, altere o valor para`PriceClass_All`. Para obter mais informações, consulte [Escolha da classe de preço para uma CloudFront distribuição](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/PriceClass.html).
1. Crie a distribuição.
```
$ aws cloudfront create-distribution --distribution-config file://dist.json \
--query 'Distribution.{Id:Id,DomainName:DomainName,ARN:ARN}'
```
Anote o ID de distribuição, o ARN e o nome do domínio na resposta. A distribuição leva aproximadamente cinco minutos para ser implantada. Você pode continuar na Etapa 5 enquanto ela é implantada.
## Etapa 5: anexar uma política de ponto de acesso que permita CloudFront
A política de ponto de acesso concede ao principal do CloudFront serviço permissão para ler objetos, com escopo de acordo com sua distribuição específica usando a `AWS:SourceArn` condição.
1. Salve a política a seguir em um arquivo chamado`ap-policy.json`, substituindo os espaços reservados.
```
{
"Version": "2012-10-17",
"Statement": [{
"Sid": "AllowCloudFrontServicePrincipal",
"Effect": "Allow",
"Principal": {"Service": "cloudfront.amazonaws.com"},
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:{{region}}:{{account-id}}:accesspoint/{{access-point-name}}/object/*",
"Condition": {
"StringEquals": {
"AWS:SourceArn": "arn:aws:cloudfront::{{account-id}}:distribution/{{distribution-id}}"
}
}
}]
}
```
1. Anexe a política ao ponto de acesso.
```
$ aws s3control put-access-point-policy \
--account-id {{account-id}} \
--name {{access-point-name}} \
--policy file://ap-policy.json
```
## Etapa 6: verificar a reprodução
Aguarde até que a distribuição alcance `Deployed` o status.
```
$ aws cloudfront get-distribution --id {{distribution-id}} \
--query 'Distribution.Status'
```
Acesse a playlist principal. CloudFront
```
$ curl -sS "https://{{distribution-domain}}/content/sintel/master.m3u8"
```
A resposta deve listar as três variantes.
```
#EXTM3U
#EXT-X-VERSION:6
#EXT-X-STREAM-INF:BANDWIDTH=1031744,RESOLUTION=640x360,CODECS="avc1.64001e,mp4a.40.2"
stream_360p/playlist.m3u8
#EXT-X-STREAM-INF:BANDWIDTH=3497301,RESOLUTION=1280x720,CODECS="avc1.64001f,mp4a.40.2"
stream_720p/playlist.m3u8
#EXT-X-STREAM-INF:BANDWIDTH=6311285,RESOLUTION=1920x1080,CODECS="avc1.640028,mp4a.40.2"
stream_1080p/playlist.m3u8
```
Verifique os cabeçalhos de resposta quanto ao tipo correto de conteúdo, controle de cache e status do cache.
```
$ curl -sSI "https://{{distribution-domain}}/content/sintel/stream_1080p/seg_000.ts"
```
Uma resposta bem-sucedida mostra `content-type: video/mp2t``cache-control: max-age=31536000,immutable`, e um `x-cache` cabeçalho indicando se a resposta veio da borda ou da origem.
Por fim, reproduza o stream de ponta a ponta com o FFmpeg para confirmar se todos os segmentos foram buscados e decodificados corretamente.
```
$ ffprobe -v error \
-show_entries stream=codec_name,width,height \
-show_entries format=duration \
"https://{{distribution-domain}}/content/sintel/master.m3u8"
```
[Você também pode abrir o URL principal da playlist no Safari ou no VLC ou incorporá-lo em uma página da Web usando um JavaScript player como o hls.js.](https://github.com/video-dev/hls.js)
## Estendendo o padrão
+ **Use um domínio personalizado com HTTPS.** Solicite um certificado ACM para seu domínio, anexe-o à distribuição e adicione um registro CNAME apontando para o CloudFront domínio. Para obter instruções, consulte Como [usar URLs personalizados com CloudFront](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cnames-and-https-procedures.html).
+ **Proteja o conteúdo premium com URLs assinados ou cookies assinados.** Para conteúdo que requer autorização (serviços de assinatura, visualizações prévias de acesso antecipado, conteúdo com cercas geográficas), use CloudFront URLs assinados ou cookies assinados. Consulte Como [veicular conteúdo privado com URLs assinados e cookies assinados](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/private-content-signed-urls.html).
+ **Invalide o cache ao publicar um novo conteúdo.** Ao substituir uma playlist ou carregar um novo pacote HLS, use `aws cloudfront create-invalidation` para remover as versões antigas das CloudFront bordas. Para segmentos imutáveis com TTLs longos, a invalidação geralmente é desnecessária porque os nomes dos arquivos dos segmentos são exclusivos por pacote.
+ **Ative o CORS para players baseados em navegador.** Se um player HLS baseado em navegador em um domínio diferente carregar seu stream, adicione `Access-Control-Allow-Origin` cabeçalhos às respostas usando uma CloudFront política de cabeçalhos de resposta.
+ **Registre as solicitações do visualizador.** Ative o registro CloudFront padrão ou os registros em tempo real para capturar as solicitações dos espectadores para análise, cobrança ou detecção de abusos.
## Solução de problemas
403 Proibido de CloudFront
A política de ponto de acesso está ausente, não inclui o responsável pelo CloudFront serviço ou a `AWS:SourceArn` condição faz referência ao ARN de distribuição errado. Verifique se a política `aws s3control get-access-point-policy` e confirme se o ARN de distribuição corresponde ao da sua `aws cloudfront create-distribution` resposta.
O player carrega a playlist principal, mas não consegue reproduzi-la
Verifique se os arquivos do segmento têm `Content-Type: video/mp2t` e se as playlists têm`Content-Type: application/vnd.apple.mpegurl`. Alguns jogadores rejeitam segmentos com tipos de conteúdo genéricos. Re-upload com a `--content-type` bandeira correta.
Novas playlists demoram para alcançar os espectadores
CloudFront armazena playlists para o TTL definido pelo seu cabeçalho. `Cache-Control` Se você precisar de um TTL mais curto, recarregue a playlist com um `max-age` valor menor ou crie uma invalidação. Os segmentos não têm esse problema porque seu conteúdo não muda.
`x-cache: Miss from cloudfront`em cada solicitação
Isso é normal na primeira vez que um visualizador em uma região solicita um arquivo. CloudFront busca da origem em caso de erro e armazena em cache a resposta para o TTL. Solicitações subsequentes para o mesmo arquivo desse local de borda retornam`Hit from cloudfront`.
O acesso direto ao ponto de acesso é negado
Isso é esperado. O OAC exige SigV4-signed solicitações de CloudFront, e a política de ponto de acesso restringe o acesso ao principal do CloudFront serviço. Os espectadores só podem acessar o conteúdo por meio do domínio de distribuição.
## Limpeza
Desative e exclua a distribuição e, em seguida, exclua os recursos restantes. A distribuição deve ser desativada antes de ser excluída, o que leva alguns minutos.
A desativação requer dois valores`get-distribution-config`: `ETag` for `--if-match` e `DistributionConfig` objeto interno for `--distribution-config` (a resposta completa também contém a ETag, que `update-distribution` não aceita).
```
$ # Capture the current ETag and the DistributionConfig body
GET_ETAG=$(aws cloudfront get-distribution-config --id {{distribution-id}} \
--query 'ETag' --output text)
aws cloudfront get-distribution-config --id {{distribution-id}} \
--query 'DistributionConfig' --output json \
| jq '.Enabled = false' > dist-updated.json
# Disable the distribution. The response returns a new ETag.
UPDATE_ETAG=$(aws cloudfront update-distribution --id {{distribution-id}} \
--if-match "$GET_ETAG" --distribution-config file://dist-updated.json \
--query 'ETag' --output text)
# Wait for Status to reach Deployed before deleting.
aws cloudfront get-distribution --id {{distribution-id}} \
--query 'Distribution.Status'
# Delete the distribution using the ETag from the update call.
aws cloudfront delete-distribution --id {{distribution-id}} \
--if-match "$UPDATE_ETAG"
# Fetch the OAC ETag, then delete the OAC.
OAC_ETAG=$(aws cloudfront get-origin-access-control --id {{oac-id}} \
--query 'ETag' --output text)
aws cloudfront delete-origin-access-control --id {{oac-id}} \
--if-match "$OAC_ETAG"
aws s3control delete-access-point-policy \
--account-id {{account-id}} --name {{access-point-name}}
aws s3 rm "s3://{{access-point-alias}}/content/sintel/" --recursive
```