

# Tutorial: vídeos de transcodificação em lote com o Operações em Lote do S3
<a name="tutorial-s3-batchops-lambda-mediaconvert-video"></a>

Os consumidores de vídeo usam dispositivos de todas as formas, tamanhos e épocas para desfrutar de conteúdo de mídia. Essa grande variedade de dispositivos representa um desafio para criadores e distribuidores de conteúdo. Em vez um formato de tamanho único, os vídeos precisam abranger uma ampla variedade de tamanhos, formatos e bitrates. Essa tarefa de conversão é ainda mais desafiadora quando você tem um grande número de vídeos a serem convertidos.

AWSA oferece um método para construir uma arquitetura escalável e distribuída que faz o seguinte: 
+ Ingere vídeos de entrada
+ Processa os vídeos para reprodução em uma ampla variedade de dispositivos
+ Armazena os arquivos de mídia transcodificados
+ Fornece os arquivos de mídia de saída para atender à demanda

Quando você tem extensos repositórios de vídeo armazenados no Amazon S3, pode transcodificar esses vídeos de seus formatos na fonte para vários tipos de arquivo, no tamanho, resolução e formato necessários para um determinado player ou dispositivo de vídeo. Mais especificamente, as [operações em lote do S3](https://aws.amazon.com/s3/features/batch-operations) fornecem uma solução para chamar as funções do AWS Lambda para vídeos de entrada existentes em um bucket de origem do S3. Depois, as funções do Lambda chamam o [AWS Elemental MediaConvert](https://aws.amazon.com/mediaconvert/) para realizar tarefas de transcodificação de vídeo em grande escala. Os arquivos de mídia de saída convertidos são armazenados em um bucket de destino do S3. 

![\[Um diagrama de fluxo de trabalho de transcodificação em lote.\]](http://docs.aws.amazon.com/pt_br/AmazonS3/latest/userguide/images/batchops-example-image-global.png)


**Objetivo**  
Neste tutorial, você aprenderá como configurar as operações em lote do S3 para chamar uma função Lambda para transcodificação em lote de vídeos armazenados em um bucket de origem do S3. A função Lambda chama o MediaConvert para transcodificar os vídeos. As saídas para cada vídeo no bucket de origem do S3 são as seguintes:
+ Um fluxo de bitrate adaptativa [HTTP Live Streaming (HLS)](http://wikipedia.org/wiki/HTTP_Live_Streaming) para reprodução em dispositivos de vários tamanhos e larguras de banda variáveis
+ Um arquivo de vídeo MP4
+ Imagens em miniatura coletadas em intervalos

**Topics**
+ [Pré-requisitos](#batchops-s3-prerequisites)
+ [Etapa 1: Criar um bucket do S3 para os arquivos de mídia de saída](#batchops-s3-step1)
+ [Etapa 2: criar uma função do IAM para MediaConvert](#batchops-s3-step2)
+ [Etapa 3: criar uma função do IAM para a função Lambda](#batchops-s3-step3)
+ [Etapa 4: Criar uma função do Lambda para transcodificação de vídeo](#batchops-s3-step4)
+ [Etapa 5: Configurar o inventário do Amazon S3 para seu bucket de origem do S3](#batchops-s3-step5)
+ [Etapa 6: criar uma função do IAM para operações em lote do S3](#batchops-s3-step6)
+ [Etapa 7: criar e executar um trabalho de operações em lote do S3](#batchops-s3-step7)
+ [Etapa 8: Conferir os arquivos de mídia de saída do bucket de destino do S3](#batchops-s3-step8)
+ [Etapa 9: limpar](#batchops-s3-step9)
+ [Próximas etapas](#batchops-s3-next-steps)

## Pré-requisitos
<a name="batchops-s3-prerequisites"></a>

Antes de iniciar este tutorial, você deve ter um bucket de origem do Amazon S3 (por exemplo, `amzn-s3-demo-source-bucket`) com vídeos a serem transcodificados já armazenados nele.

Você pode dar ao bucket outro nome, se desejar. Para obter mais informações sobre os nomes de bucket do Amazon S3, consulte [Regras de nomenclatura de buckets de uso geral](bucketnamingrules.md).

Para o bucket de origem do S3, mantenha as configurações relacionadas a **Block Public Access settings for this bucket** (Configurações de bloquear acesso público a este bucket) definidas com os padrões (**Block *all* public access** (Bloquear todo o acesso público) está habilitado). Para obter mais informações, consulte [Criar um bucket de uso geral](create-bucket-overview.md). 

Para obter mais informações sobre como carregar vídeos para o bucket de origem do S3, consulte [Fazer upload de objetos](upload-objects.md). Se você for carregar muitos arquivos de vídeo grandes para o S3, pode ser interessante usar o [Amazon S3 Transfer Acceleration](https://aws.amazon.com/s3/transfer-acceleration) para configurar transferências de arquivos rápidas e seguras. O Transfer Acceleration pode acelerar o carregamento de vídeo no seu bucket do S3 para transferências de longa distância de vídeos maiores. Para obter mais informações, consulte [Configurar transferências de arquivos rápidas e seguras usando o Amazon S3 Transfer Acceleration](transfer-acceleration.md). 

## Etapa 1: Criar um bucket do S3 para os arquivos de mídia de saída
<a name="batchops-s3-step1"></a>

Nesta etapa, você cria um bucket de destino do S3 para armazenar os arquivos de mídia de saída convertidos. Você também cria uma configuração CORS (Cross Origin Resource Sharing) para permitir acesso de origem cruzada aos arquivos de mídia transcodificados armazenados no bucket de destino do S3. 

**Topics**
+ [Criar um bucket para os arquivos de mídia de saída](#batchops-s3-step1-create-bucket)
+ [Para adicionar uma configuração CORS a um bucket de saída do S3](#batchops-s3-step1-cors)

### Criar um bucket para os arquivos de mídia de saída
<a name="batchops-s3-step1-create-bucket"></a>



1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

1. No painel de navegação à esquerda, escolha **Buckets**.

1. Selecione **Criar bucket**. 

1. Em **Bucket name** (Nome do bucket), insira um nome para o seu bucket (por exemplo, `amzn-s3-demo-destination-bucket1`). 

1. Em **Region** (Região), escolha a Região da AWS onde deseja que o bucket resida. 

1. Para garantir o acesso público aos arquivos de mídia de saída, em **Block Public Access settings for this bucket** (Configurações de bloqueio de acesso público para este bucket), desmarque **Block *all* public access** (Bloquear todo acesso público). 
**Atenção**  
Antes de concluir esta etapa, revise [Bloquear o acesso público ao armazenamento do Amazon S3](access-control-block-public-access.md) para garantir que você entenda e aceite os riscos envolvidos em permitir o acesso público. Quando você desativa as configurações Block Public Access (Bloquear acesso público) para tornar seu bucket público, qualquer pessoa na Internet pode acessá-lo. Recomendamos que você bloqueie todo o acesso público aos seus buckets.  
Se você não quiser limpar as configurações de Block Public Access (Bloquear acesso público), pode usar o Amazon CloudFront para entregar os arquivos de mídia transcodificados aos visualizadores (usuários finais). Para obter mais informações, consulte [Tutorial: Hospedagem de transmissão sob demanda com o Amazon S3, Amazon CloudFront e Amazon Route 53](tutorial-s3-cloudfront-route53-video-streaming.md). 

1. Marque a caixa de seleção ao lado de **I acknowledge that the current settings might result in this bucket and the objects within becoming public** (Eu reconheço que as configurações atuais podem fazem com que o bucket e os objetos fiquem públicos.)

1. Mantenha as configurações restantes definidas conforme os padrões. 

1. Selecione **Criar bucket**.

### Para adicionar uma configuração CORS a um bucket de saída do S3
<a name="batchops-s3-step1-cors"></a>

Uma configuração de CORS JSON define uma maneira para as aplicações Web clientes (players de vídeo neste contexto) que são carregadas em um domínio reproduzirem os arquivos de mídia de saída transcodificados em um domínio diferente. 

1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

1. No painel de navegação à esquerda, escolha **Buckets**.

1. Na lista **Buckets**, escolha o nome do bucket que você criou antes (por exemplo, `amzn-s3-demo-destination-bucket1`).

1. Escolha a aba **Permissões**.

1. Na seção **Cross-origin resource sharing (CORS)** (Compartilhamento de recursos de origem cruzada (CORS)) escolha **Edit** (Editar).

1. Na caixa de texto de configuração de CORS, copie e cole a seguinte configuração de CORS.

   A configuração do CORS deve estar no formato JSON. Neste exemplo, o atributo `AllowedOrigins` usa o caractere curinga (`*`) para especificar todas as origens. Se você souber qual é a sua origem específica, pode restringir o atributo `AllowedOrigins` ao URL do seu player específico. Para obter mais informações sobre esse e outros atributos, consulte [Elementos de uma configuração de CORS](ManageCorsUsing.md).

   ```
   [
       {
           "AllowedOrigins": [
               "*"
           ],
           "AllowedMethods": [
               "GET"
           ],
           "AllowedHeaders": [
               "*"
           ],
           "ExposeHeaders": []
   
       }
   ]
   ```

1. Escolha **Salvar alterações**.

## Etapa 2: criar uma função do IAM para MediaConvert
<a name="batchops-s3-step2"></a>

Para usar o AWS Elemental MediaConvert para transcodificar vídeos de entrada armazenados no bucket do S3, você deve ter um perfil de serviço do AWS Identity and Access Management (IAM) para conceder ao MediaConvert permissões para ler e gravar arquivos de vídeo entre os buckets de origem e de destino do S3. Quando você executa trabalhos de transcodificação, o console do MediaConvert usa essa função. 

**Para criar uma função do IAM para MediaConvert**

1. Crie uma função do IAM com um nome de função que você escolhe (por exemplo, **tutorial-mediaconvert-role**). Para criar essa função, siga as etapas em [Criar função do MediaConvert no IAM (console)](https://docs.aws.amazon.com/mediaconvert/latest/ug/creating-the-iam-role-in-iam.html) no *Guia do usuário do AWS Elemental MediaConvert*.

1. Depois de criar a função do IAM para o MediaConvert, na lista **Roles** (Funções), escolha o nome da função para o MediaConvert que você criou (por exemplo, **tutorial-mediaconvert-role**).

1. Na página **Summary** (Resumo), copie o **Role ARN** (ARN da função) (que começa com `arn:aws:iam::`) e salve o ARN para uso posterior. 

   Para obter mais informações sobre os ARNs, consulte [Amazon Resource Names (ARNs)](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) (Nomes de recurso da Amazon (ARNs) em *AWS General Reference* (Referência geral). 

## Etapa 3: criar uma função do IAM para a função Lambda
<a name="batchops-s3-step3"></a>

Para transcodificar vídeos em lote com o MediaConvert e operações em lote do S3, você usa uma função do Lambda para conectar esses dois serviços para converter vídeos. Essa função do Lambda precisa ter uma função do IAM que conceda permissões à função do Lambda para acessar o MediaConvert e as operações em lote do S3. 

**Topics**
+ [Criar uma função do IAM para sua função Lambda](#batchops-s3-step3-role)
+ [Incorpore uma política em linha para a função do IAM da sua função Lambda](#batchops-s3-step3-inline-policy)

### Criar uma função do IAM para sua função Lambda
<a name="batchops-s3-step3-role"></a>

1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. No painel de navegação à esquerda, escolha **Roles** (Funções) e **Create role** (Criar função). 

1. Escolha o tipo de função **AWS service** (serviço da WS) e em **Common use cases** (Casos de uso comuns), escolha **Lambda**. 

1. Escolha **Próximo: Permissões**. 

1. Na página **Attach Permissions policies** (Anexar políticas de permissões), insira **AWSLambdaBasicExecutionRole** na caixa **Filter policies** (Filtrar políticas). Para anexar a política gerenciada **AWSLambdaBasicExecutionRole** a esta função para conceder permissões de gravação a Amazon CloudWatch Logs, marque a caixa de seleção ao lado de **AWSLambdaBasicExecutionRole**.

1. Escolha **Próximo**.

1. Em **Nome do perfil**, insira **tutorial-lambda-transcode-role**.

1. (Opcional) Adicione etiquetas à política gerenciada.

1. Selecione **Criar perfil**.

### Incorpore uma política em linha para a função do IAM da sua função Lambda
<a name="batchops-s3-step3-inline-policy"></a>

Para conceder permissões para o recurso do MediaConvert que é necessário para que a função do Lambda seja executada, você deve usar uma política em linha.

1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. No painel de navegação à esquerda, selecione **Perfis**. 

1. Na lista **Roles** (Funções), escolha o nome da função do IAM que você criou antes para a sua função do Lambda (por exemplo, **tutorial-lambda-transcode-role**).

1. Escolha a guia **Permissions** (Permissões).

1. Escolha **Add inline policy** (Adicionar política em linha).

1. Escolha a guia **JSON** e copie e cole a política JSON a seguir.

   Na política JSON, substitua o valor de `Resource` do ARN do exemplo pelo ARN da função do IAM para o MediaConvert que você criou na [Etapa 2](#batchops-s3-step2) (por exemplo, **tutorial-mediaconvert-role**).

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Action": [
                   "logs:CreateLogGroup",
                   "logs:CreateLogStream",
                   "logs:PutLogEvents"
               ],
               "Resource": "*",
               "Effect": "Allow",
               "Sid": "Logging"
           },
           {
               "Action": [
                   "iam:PassRole"
               ],
               "Resource": [
                   "arn:aws:iam::111122223333:role/tutorial-mediaconvert-role"
               ],
               "Effect": "Allow",
               "Sid": "PassRole"
           },
           {
               "Action": [
                   "mediaconvert:*"
               ],
               "Resource": [
                   "*"
               ],
               "Effect": "Allow",
               "Sid": "MediaConvertService"
           },
           {
               "Action": [
                   "s3:*"
               ],
               "Resource": [
                   "*"
               ],
               "Effect": "Allow",
               "Sid": "S3Service"
           }
       ]
   }
   ```

------

1. Escolha **Revisar política**.

1. Em **Nome**, insira **tutorial-lambda-policy**.

1. Escolha **Create Policy**.

   Após a criação de uma política em linha, ela é automaticamente incorporada à função do IAM de sua função Lambda.

## Etapa 4: Criar uma função do Lambda para transcodificação de vídeo
<a name="batchops-s3-step4"></a>

Nesta seção do tutorial, você constrói uma função do Lambda usando o SDK for Python para integrar com as operações em lote do S3 e o MediaConvert. Para iniciar a transcodificação dos vídeos já armazenados no bucket de origem do S3, você executa um trabalho de operações em lote do S3 que invoca diretamente a função do Lambda para cada vídeo no bucket de origem do S3. Em seguida, a função Lambda envia um trabalho de transcodificação de cada vídeo para MediaConvert.

**Topics**
+ [Grave o código de função Lambda e crie um pacote de implantação](#batchops-s3-step4-write-function)
+ [Crie uma função Lambda com uma função de execução (console)](#batchops-s3-step4-create-function)
+ [Implante sua função Lambda com arquivos .zip e configure a função Lambda (console)](#batchops-s3-step4-deploy-function)

### Grave o código de função Lambda e crie um pacote de implantação
<a name="batchops-s3-step4-write-function"></a>

1. Na sua máquina local, crie uma pasta denominada `batch-transcode`.

1. Na pasta `batch-transcode`, crie um arquivo com as configurações de trabalho de JSON. Por exemplo, use as configurações fornecidas nesta seção e dê ao arquivo o nome de `job.json`. 

   Um arquivo `job.json` especifica o seguinte: 
   + Quais arquivos devem ser transcodificados
   + Como você deseja transcodificar seus vídeos de entrada
   + Quais arquivos de mídia de saída você deseja criar
   + Como dar nomes aos arquivos transcodificados
   + Onde salvar os arquivos transcodificados
   + Quais recursos avançados aplicar e assim por diante

   Neste tutorial, usamos o arquivo `job.json` a seguir para criar as seguintes saídas para cada vídeo no bucket de origem do S3:
   + Um fluxo de bitrate adaptativa HTTP Live Streaming (HLS) para reprodução em dispositivos de diversos tamanhos e diferentes larguras de banda
   + Um arquivo de vídeo MP4
   + Imagens em miniatura coletadas em intervalos

   Este exemplo de arquivo `job.json` usa bitrare variável definia por qualidade (QVCR - Quality-Defined Variable Bitrate) para otimizar a qualidade do vídeo. A saída HTTP Live Streaming (HLS) é compatível com Apple (áudio de vídeo não mixado, duração de segmento de 6 segundos e qualidade de vídeo otimizada por QVBR automática). 

   Se você não quiser usar as configurações de exemplo fornecidas aqui, pode gerar uma especificação de `job.json` baseada em seu caso de uso. Para garantir a consistência em todas as saídas, certifique-se de que os arquivos de entrada tenham configurações de vídeo e áudio semelhantes. Para arquivos de entrada com diferentes configurações de vídeo e áudio, crie automações separadas (configurações de `job.json` exclusivas). Para obter mais informações, consulte [Exemplos de configuração de trabalhos do AWS Elemental MediaConvert em JSON](https://docs.aws.amazon.com/mediaconvert/latest/ug/example-job-settings.html) no *Guia do usuário do AWS Elemental MediaConvert*. 

   ```
   {
     "OutputGroups": [
       {
         "CustomName": "HLS",
         "Name": "Apple HLS",
         "Outputs": [
           {
             "ContainerSettings": {
               "Container": "M3U8",
               "M3u8Settings": {
                 "AudioFramesPerPes": 4,
                 "PcrControl": "PCR_EVERY_PES_PACKET",
                 "PmtPid": 480,
                 "PrivateMetadataPid": 503,
                 "ProgramNumber": 1,
                 "PatInterval": 0,
                 "PmtInterval": 0,
                 "TimedMetadata": "NONE",
                 "VideoPid": 481,
                 "AudioPids": [
                   482,
                   483,
                   484,
                   485,
                   486,
                   487,
                   488,
                   489,
                   490,
                   491,
                   492
                 ]
               }
             },
             "VideoDescription": {
               "Width": 640,
               "ScalingBehavior": "DEFAULT",
               "Height": 360,
               "TimecodeInsertion": "DISABLED",
               "AntiAlias": "ENABLED",
               "Sharpness": 50,
               "CodecSettings": {
                 "Codec": "H_264",
                 "H264Settings": {
                   "InterlaceMode": "PROGRESSIVE",
                   "NumberReferenceFrames": 3,
                   "Syntax": "DEFAULT",
                   "Softness": 0,
                   "GopClosedCadence": 1,
                   "GopSize": 2,
                   "Slices": 1,
                   "GopBReference": "DISABLED",
                   "MaxBitrate": 1200000,
                   "SlowPal": "DISABLED",
                   "SpatialAdaptiveQuantization": "ENABLED",
                   "TemporalAdaptiveQuantization": "ENABLED",
                   "FlickerAdaptiveQuantization": "DISABLED",
                   "EntropyEncoding": "CABAC",
                   "FramerateControl": "INITIALIZE_FROM_SOURCE",
                   "RateControlMode": "QVBR",
                   "CodecProfile": "MAIN",
                   "Telecine": "NONE",
                   "MinIInterval": 0,
                   "AdaptiveQuantization": "HIGH",
                   "CodecLevel": "AUTO",
                   "FieldEncoding": "PAFF",
                   "SceneChangeDetect": "TRANSITION_DETECTION",
                   "QualityTuningLevel": "SINGLE_PASS_HQ",
                   "FramerateConversionAlgorithm": "DUPLICATE_DROP",
                   "UnregisteredSeiTimecode": "DISABLED",
                   "GopSizeUnits": "SECONDS",
                   "ParControl": "INITIALIZE_FROM_SOURCE",
                   "NumberBFramesBetweenReferenceFrames": 2,
                   "RepeatPps": "DISABLED"
                 }
               },
               "AfdSignaling": "NONE",
               "DropFrameTimecode": "ENABLED",
               "RespondToAfd": "NONE",
               "ColorMetadata": "INSERT"
             },
             "OutputSettings": {
               "HlsSettings": {
                 "AudioGroupId": "program_audio",
                 "AudioRenditionSets": "program_audio",
                 "SegmentModifier": "$dt$",
                 "IFrameOnlyManifest": "EXCLUDE"
               }
             },
             "NameModifier": "_360"
           },
           {
             "ContainerSettings": {
               "Container": "M3U8",
               "M3u8Settings": {
                 "AudioFramesPerPes": 4,
                 "PcrControl": "PCR_EVERY_PES_PACKET",
                 "PmtPid": 480,
                 "PrivateMetadataPid": 503,
                 "ProgramNumber": 1,
                 "PatInterval": 0,
                 "PmtInterval": 0,
                 "TimedMetadata": "NONE",
                 "TimedMetadataPid": 502,
                 "VideoPid": 481,
                 "AudioPids": [
                   482,
                   483,
                   484,
                   485,
                   486,
                   487,
                   488,
                   489,
                   490,
                   491,
                   492
                 ]
               }
             },
             "VideoDescription": {
               "Width": 960,
               "ScalingBehavior": "DEFAULT",
               "Height": 540,
               "TimecodeInsertion": "DISABLED",
               "AntiAlias": "ENABLED",
               "Sharpness": 50,
               "CodecSettings": {
                 "Codec": "H_264",
                 "H264Settings": {
                   "InterlaceMode": "PROGRESSIVE",
                   "NumberReferenceFrames": 3,
                   "Syntax": "DEFAULT",
                   "Softness": 0,
                   "GopClosedCadence": 1,
                   "GopSize": 2,
                   "Slices": 1,
                   "GopBReference": "DISABLED",
                   "MaxBitrate": 3500000,
                   "SlowPal": "DISABLED",
                   "SpatialAdaptiveQuantization": "ENABLED",
                   "TemporalAdaptiveQuantization": "ENABLED",
                   "FlickerAdaptiveQuantization": "DISABLED",
                   "EntropyEncoding": "CABAC",
                   "FramerateControl": "INITIALIZE_FROM_SOURCE",
                   "RateControlMode": "QVBR",
                   "CodecProfile": "MAIN",
                   "Telecine": "NONE",
                   "MinIInterval": 0,
                   "AdaptiveQuantization": "HIGH",
                   "CodecLevel": "AUTO",
                   "FieldEncoding": "PAFF",
                   "SceneChangeDetect": "TRANSITION_DETECTION",
                   "QualityTuningLevel": "SINGLE_PASS_HQ",
                   "FramerateConversionAlgorithm": "DUPLICATE_DROP",
                   "UnregisteredSeiTimecode": "DISABLED",
                   "GopSizeUnits": "SECONDS",
                   "ParControl": "INITIALIZE_FROM_SOURCE",
                   "NumberBFramesBetweenReferenceFrames": 2,
                   "RepeatPps": "DISABLED"
                 }
               },
               "AfdSignaling": "NONE",
               "DropFrameTimecode": "ENABLED",
               "RespondToAfd": "NONE",
               "ColorMetadata": "INSERT"
             },
             "OutputSettings": {
               "HlsSettings": {
                 "AudioGroupId": "program_audio",
                 "AudioRenditionSets": "program_audio",
                 "SegmentModifier": "$dt$",
                 "IFrameOnlyManifest": "EXCLUDE"
               }
             },
             "NameModifier": "_540"
           },
           {
             "ContainerSettings": {
               "Container": "M3U8",
               "M3u8Settings": {
                 "AudioFramesPerPes": 4,
                 "PcrControl": "PCR_EVERY_PES_PACKET",
                 "PmtPid": 480,
                 "PrivateMetadataPid": 503,
                 "ProgramNumber": 1,
                 "PatInterval": 0,
                 "PmtInterval": 0,
                 "TimedMetadata": "NONE",
                 "VideoPid": 481,
                 "AudioPids": [
                   482,
                   483,
                   484,
                   485,
                   486,
                   487,
                   488,
                   489,
                   490,
                   491,
                   492
                 ]
               }
             },
             "VideoDescription": {
               "Width": 1280,
               "ScalingBehavior": "DEFAULT",
               "Height": 720,
               "TimecodeInsertion": "DISABLED",
               "AntiAlias": "ENABLED",
               "Sharpness": 50,
               "CodecSettings": {
                 "Codec": "H_264",
                 "H264Settings": {
                   "InterlaceMode": "PROGRESSIVE",
                   "NumberReferenceFrames": 3,
                   "Syntax": "DEFAULT",
                   "Softness": 0,
                   "GopClosedCadence": 1,
                   "GopSize": 2,
                   "Slices": 1,
                   "GopBReference": "DISABLED",
                   "MaxBitrate": 5000000,
                   "SlowPal": "DISABLED",
                   "SpatialAdaptiveQuantization": "ENABLED",
                   "TemporalAdaptiveQuantization": "ENABLED",
                   "FlickerAdaptiveQuantization": "DISABLED",
                   "EntropyEncoding": "CABAC",
                   "FramerateControl": "INITIALIZE_FROM_SOURCE",
                   "RateControlMode": "QVBR",
                   "CodecProfile": "MAIN",
                   "Telecine": "NONE",
                   "MinIInterval": 0,
                   "AdaptiveQuantization": "HIGH",
                   "CodecLevel": "AUTO",
                   "FieldEncoding": "PAFF",
                   "SceneChangeDetect": "TRANSITION_DETECTION",
                   "QualityTuningLevel": "SINGLE_PASS_HQ",
                   "FramerateConversionAlgorithm": "DUPLICATE_DROP",
                   "UnregisteredSeiTimecode": "DISABLED",
                   "GopSizeUnits": "SECONDS",
                   "ParControl": "INITIALIZE_FROM_SOURCE",
                   "NumberBFramesBetweenReferenceFrames": 2,
                   "RepeatPps": "DISABLED"
                 }
               },
               "AfdSignaling": "NONE",
               "DropFrameTimecode": "ENABLED",
               "RespondToAfd": "NONE",
               "ColorMetadata": "INSERT"
             },
             "OutputSettings": {
               "HlsSettings": {
                 "AudioGroupId": "program_audio",
                 "AudioRenditionSets": "program_audio",
                 "SegmentModifier": "$dt$",
                 "IFrameOnlyManifest": "EXCLUDE"
               }
             },
             "NameModifier": "_720"
           },
           {
             "ContainerSettings": {
               "Container": "M3U8",
               "M3u8Settings": {}
             },
             "AudioDescriptions": [
               {
                 "AudioSourceName": "Audio Selector 1",
                 "CodecSettings": {
                   "Codec": "AAC",
                   "AacSettings": {
                     "Bitrate": 96000,
                     "CodingMode": "CODING_MODE_2_0",
                     "SampleRate": 48000
                   }
                 }
               }
             ],
             "OutputSettings": {
               "HlsSettings": {
                 "AudioGroupId": "program_audio",
                 "AudioTrackType": "ALTERNATE_AUDIO_AUTO_SELECT_DEFAULT"
               }
             },
             "NameModifier": "_audio"
           }
         ],
         "OutputGroupSettings": {
           "Type": "HLS_GROUP_SETTINGS",
           "HlsGroupSettings": {
             "ManifestDurationFormat": "INTEGER",
             "SegmentLength": 6,
             "TimedMetadataId3Period": 10,
             "CaptionLanguageSetting": "OMIT",
             "Destination": "s3://EXAMPLE-BUCKET/HLS/",
             "DestinationSettings": {
               "S3Settings": {
                 "AccessControl": {
                   "CannedAcl": "PUBLIC_READ"
                 }
               }
             },
             "TimedMetadataId3Frame": "PRIV",
             "CodecSpecification": "RFC_4281",
             "OutputSelection": "MANIFESTS_AND_SEGMENTS",
             "ProgramDateTimePeriod": 600,
             "MinSegmentLength": 0,
             "DirectoryStructure": "SINGLE_DIRECTORY",
             "ProgramDateTime": "EXCLUDE",
             "SegmentControl": "SEGMENTED_FILES",
             "ManifestCompression": "NONE",
             "ClientCache": "ENABLED",
             "StreamInfResolution": "INCLUDE"
           }
         }
       },
       {
         "CustomName": "MP4",
         "Name": "File Group",
         "Outputs": [
           {
             "ContainerSettings": {
               "Container": "MP4",
               "Mp4Settings": {
                 "CslgAtom": "INCLUDE",
                 "FreeSpaceBox": "EXCLUDE",
                 "MoovPlacement": "PROGRESSIVE_DOWNLOAD"
               }
             },
             "VideoDescription": {
               "Width": 1280,
               "ScalingBehavior": "DEFAULT",
               "Height": 720,
               "TimecodeInsertion": "DISABLED",
               "AntiAlias": "ENABLED",
               "Sharpness": 100,
               "CodecSettings": {
                 "Codec": "H_264",
                 "H264Settings": {
                   "InterlaceMode": "PROGRESSIVE",
                   "ParNumerator": 1,
                   "NumberReferenceFrames": 3,
                   "Syntax": "DEFAULT",
                   "Softness": 0,
                   "GopClosedCadence": 1,
                   "HrdBufferInitialFillPercentage": 90,
                   "GopSize": 2,
                   "Slices": 2,
                   "GopBReference": "ENABLED",
                   "HrdBufferSize": 10000000,
                   "MaxBitrate": 5000000,
                   "ParDenominator": 1,
                   "EntropyEncoding": "CABAC",
                   "RateControlMode": "QVBR",
                   "CodecProfile": "HIGH",
                   "MinIInterval": 0,
                   "AdaptiveQuantization": "AUTO",
                   "CodecLevel": "AUTO",
                   "FieldEncoding": "PAFF",
                   "SceneChangeDetect": "ENABLED",
                   "QualityTuningLevel": "SINGLE_PASS_HQ",
                   "UnregisteredSeiTimecode": "DISABLED",
                   "GopSizeUnits": "SECONDS",
                   "ParControl": "SPECIFIED",
                   "NumberBFramesBetweenReferenceFrames": 3,
                   "RepeatPps": "DISABLED",
                   "DynamicSubGop": "ADAPTIVE"
                 }
               },
               "AfdSignaling": "NONE",
               "DropFrameTimecode": "ENABLED",
               "RespondToAfd": "NONE",
               "ColorMetadata": "INSERT"
             },
             "AudioDescriptions": [
               {
                 "AudioTypeControl": "FOLLOW_INPUT",
                 "AudioSourceName": "Audio Selector 1",
                 "CodecSettings": {
                   "Codec": "AAC",
                   "AacSettings": {
                     "AudioDescriptionBroadcasterMix": "NORMAL",
                     "Bitrate": 160000,
                     "RateControlMode": "CBR",
                     "CodecProfile": "LC",
                     "CodingMode": "CODING_MODE_2_0",
                     "RawFormat": "NONE",
                     "SampleRate": 48000,
                     "Specification": "MPEG4"
                   }
                 },
                 "LanguageCodeControl": "FOLLOW_INPUT",
                 "AudioType": 0
               }
             ]
           }
         ],
         "OutputGroupSettings": {
           "Type": "FILE_GROUP_SETTINGS",
           "FileGroupSettings": {
             "Destination": "s3://EXAMPLE-BUCKET/MP4/",
             "DestinationSettings": {
               "S3Settings": {
                 "AccessControl": {
                   "CannedAcl": "PUBLIC_READ"
                 }
               }
             }
           }
         }
       },
       {
         "CustomName": "Thumbnails",
         "Name": "File Group",
         "Outputs": [
           {
             "ContainerSettings": {
               "Container": "RAW"
             },
             "VideoDescription": {
               "Width": 1280,
               "ScalingBehavior": "DEFAULT",
               "Height": 720,
               "TimecodeInsertion": "DISABLED",
               "AntiAlias": "ENABLED",
               "Sharpness": 50,
               "CodecSettings": {
                 "Codec": "FRAME_CAPTURE",
                 "FrameCaptureSettings": {
                   "FramerateNumerator": 1,
                   "FramerateDenominator": 5,
                   "MaxCaptures": 500,
                   "Quality": 80
                 }
               },
               "AfdSignaling": "NONE",
               "DropFrameTimecode": "ENABLED",
               "RespondToAfd": "NONE",
               "ColorMetadata": "INSERT"
             }
           }
         ],
         "OutputGroupSettings": {
           "Type": "FILE_GROUP_SETTINGS",
           "FileGroupSettings": {
             "Destination": "s3://EXAMPLE-BUCKET/Thumbnails/",
             "DestinationSettings": {
               "S3Settings": {
                 "AccessControl": {
                   "CannedAcl": "PUBLIC_READ"
                 }
               }
             }
           }
         }
       }
     ],
     "AdAvailOffset": 0,
     "Inputs": [
       {
         "AudioSelectors": {
           "Audio Selector 1": {
             "Offset": 0,
             "DefaultSelection": "DEFAULT",
             "ProgramSelection": 1
           }
         },
         "VideoSelector": {
           "ColorSpace": "FOLLOW"
         },
         "FilterEnable": "AUTO",
         "PsiControl": "USE_PSI",
         "FilterStrength": 0,
         "DeblockFilter": "DISABLED",
         "DenoiseFilter": "DISABLED",
         "TimecodeSource": "EMBEDDED",
         "FileInput": "s3://EXAMPLE-INPUT-BUCKET/input.mp4"
       }
     ]
   }
   ```

1. Na pasta `batch-transcode`, crie um arquivo com uma função Lambda. Você pode usar o seguinte exemplo Python e nomear o arquivo `convert.py`.

   As operações em lote do S3 enviam dados de tarefa específicos para uma função do Lambda e requerem os dados do resultado de volta. Para obter exemplos de solicitação e resposta para a função do Lambda, informações sobre códigos de resposta e de resultados, e exemplos de funções do Lambda para operações em lote do S3, consulte [Invocar função do AWS Lambda](batch-ops-invoke-lambda.md). 

   ```
   import json
   import os
   from urllib.parse import urlparse
   import uuid
   import boto3
   
   """
   When you run an S3 Batch Operations job, your job  
   invokes this Lambda function. Specifically, the Lambda function is 
   invoked on each video object listed in the manifest that you specify 
   for the S3 Batch Operations job in Step 5.  
   
   Input parameter "event": The S3 Batch Operations event as a request
                            for the Lambda function.
   
   Input parameter "context": Context about the event.
   
   Output: A result structure that Amazon S3 uses to interpret the result 
           of the operation. It is a job response returned back to S3 Batch Operations.
   """
   def handler(event, context):
   
       invocation_schema_version = event['invocationSchemaVersion']
       invocation_id = event['invocationId']
       task_id = event['tasks'][0]['taskId']
   
       source_s3_key = event['tasks'][0]['s3Key']
       source_s3_bucket = event['tasks'][0]['s3BucketArn'].split(':::')[-1]
       source_s3 = 's3://' + source_s3_bucket + '/' + source_s3_key
   
       result_list = []
       result_code = 'Succeeded'
       result_string = 'The input video object was converted successfully.'
   
       # The type of output group determines which media players can play 
       # the files transcoded by MediaConvert.
       # For more information, see [Creating outputs with AWS Elemental MediaConvert](https://docs.aws.amazon.com/mediaconvert/latest/ug/creating-streaming-and-file-outputs.html).
       output_group_type_dict = {
           'HLS_GROUP_SETTINGS': 'HlsGroupSettings',
           'FILE_GROUP_SETTINGS': 'FileGroupSettings',
           'CMAF_GROUP_SETTINGS': 'CmafGroupSettings',
           'DASH_ISO_GROUP_SETTINGS': 'DashIsoGroupSettings',
           'MS_SMOOTH_GROUP_SETTINGS': 'MsSmoothGroupSettings'
       }
   
       try:
           job_name = 'Default'
           with open('job.json') as file:
               job_settings = json.load(file)
   
           job_settings['Inputs'][0]['FileInput'] = source_s3
   
           # The path of each output video is constructed based on the values of 
           # the attributes in each object of OutputGroups in the job.json file. 
           destination_s3 = 's3://{0}/{1}/{2}' \
               .format(os.environ['amzn-s3-demo-destination-bucket'],
                       os.path.splitext(os.path.basename(source_s3_key))[0],
                       os.path.splitext(os.path.basename(job_name))[0])
   
           for output_group in job_settings['OutputGroups']:
               output_group_type = output_group['OutputGroupSettings']['Type']
               if output_group_type in output_group_type_dict.keys():
                   output_group_type = output_group_type_dict[output_group_type]
                   output_group['OutputGroupSettings'][output_group_type]['Destination'] = \
                       "{0}{1}".format(destination_s3,
                                       urlparse(output_group['OutputGroupSettings'][output_group_type]['Destination']).path)
               else:
                   raise ValueError("Exception: Unknown Output Group Type {}."
                                    .format(output_group_type))
   
           job_metadata_dict = {
               'assetID': str(uuid.uuid4()),
               'application': os.environ['Application'],
               'input': source_s3,
               'settings': job_name
           }
   
           region = os.environ['AWS_DEFAULT_REGION']
           endpoints = boto3.client('mediaconvert', region_name=region) \
               .describe_endpoints()
           client = boto3.client('mediaconvert', region_name=region, 
                                  endpoint_url=endpoints['Endpoints'][0]['Url'], 
                                  verify=False)
   
           try:
               client.create_job(Role=os.environ['MediaConvertRole'], 
                                 UserMetadata=job_metadata_dict, 
                                 Settings=job_settings)
           # You can customize error handling based on different error codes that 
           # MediaConvert can return.
           # For more information, see [MediaConvert error codes](https://docs.aws.amazon.com/mediaconvert/latest/ug/mediaconvert_error_codes.html). 
           # When the result_code is TemporaryFailure, S3 Batch Operations retries 
           # the task before the job is completed. If this is the final retry, 
           # the error message is included in the final report.
           except Exception as error:
               result_code = 'TemporaryFailure'
               raise
       
       except Exception as error:
           if result_code != 'TemporaryFailure':
               result_code = 'PermanentFailure'
           result_string = str(error)
   
       finally:
           result_list.append({
               'taskId': task_id,
               'resultCode': result_code,
               'resultString': result_string,
           })
   
       return {
           'invocationSchemaVersion': invocation_schema_version,
           'treatMissingKeyAs': 'PermanentFailure',
           'invocationId': invocation_id,
           'results': result_list
       }
   ```

1. Para criar um pacote de implantação com `convert.py` e `job.json` como um arquivo `.zip`, denominado `lambda.zip` em seu terminal local, abra a pasta `batch-transcode` que você criou antes e execute o comando a seguir.

   Para **usuários do macOS**, execute o seguinte comando:

   ```
   zip -r lambda.zip convert.py job.json                
   ```

   Para **usuários do Windows**, execute os seguintes comandos:

   ```
   powershell Compress-Archive convert.py lambda.zip
   ```

   ```
   powershell Compress-Archive -update job.json lambda.zip                
   ```

### Crie uma função Lambda com uma função de execução (console)
<a name="batchops-s3-step4-create-function"></a>

1. 

   Abra o console AWS Lambda em [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).

1. No painel de navegação à esquerda, escolha **Functions** (Funções).

1. Escolha **Create function** (Criar função).

1. Escolha **Author from scratch** (Criar do zero).

1. Em **Basic information** (Informações básicas), faça o seguinte:

   1. Em **Function name** (Nome da função), insira **tutorial-lambda-convert**.

   1. Em **Runtime**, selecione **Python 3.13**.

1. Escolha **Change default execution role** (Alterar a função de execução padrão) e, em **Execution role** (Função de execução), escolha **Use an existing role** (Usar uma função existente).

1. Em **Exiting role** (Função de saída), escolha o nome da função do IAM que você criou para sua função do Lambda na [Etapa 3](#batchops-s3-step3) (por exemplo, **tutorial-lambda-transcode-role**).

1. Mantenha as configurações restantes definidas conforme os padrões.

1. Escolha **Create function** (Criar função).

### Implante sua função Lambda com arquivos .zip e configure a função Lambda (console)
<a name="batchops-s3-step4-deploy-function"></a>

1. Na seção **Code Source** (Código-fonte) da página da função do Lambda que você criou (por exemplo, **tutorial-lambda-convert**), escolha **Upload from** (Carregar de) e depois **.zip file** (arquivo .zip).

1. Selecione **Upload** (Carregar) para selecionar seu arquivo `.zip` local.

1. Selecione o arquivo `lambda.zip` que você criou antes e escolha **Open** (Abrir).

1. Escolha **Salvar**.

1. Na seção **Runtime settings** (Configurações do tempo de execução), escolha **Edit** (Editar). 

1. Para informar ao tempo de execução do Lambda qual método de handler em seu código de função do Lambda deve invocar, insira no campo **convert.handler** **Handler**.

   Ao configurar uma função em Python, o valor da configuração do handler é o nome do arquivo e o nome do módulo do handler exportado, separados por um ponto (`.`). Por exemplo, `convert.handler` chama o método `handler` definido no arquivo `convert.py`.

1. Escolha **Salvar**.

1. Em sua página da função Lambda, escolha a guia **Configuration** (Configuração). No painel de navegação esquerdo na guia **Configuration** (Configuração), escolha **Environment variables** (Variáveis de ambiente) e, depois, escolha **Edit** (Editar).

1. Escolha **Add environment variable (Adicionar variável de ambiente)**. Em seguida, insira a **Key** (Chave) e o **Value** (Valor) especificados para cada uma das seguintes variáveis de ambiente:
   + **Key** (Chave): **DestinationBucket** **Value** (Valor): **amzn-s3-demo-destination-bucket1** 

     Este valor é o bucket do S3 para os arquivos de mídia de saída que você criou na [Etapa 1](#batchops-s3-step1).
   + **Key** (Chave): **MediaConvertRole** **Value** (Valor): **arn:aws:iam::*111122223333*:role/tutorial-mediaconvert-role** 

     Este valor é o ARN da função do IAM para MediaConvert que você criou na [Etapa 2](#batchops-s3-step2). Certifique-se de substituir esse ARN pelo ARN real da sua função do IAM.
   + **Key** (Chave): **Application** **Value** (Valor): **Batch-Transcoding** 

     Esse valor é o nome da sua aplicação.

1. Escolha **Salvar**.

1. (Opcional) Na guia **Configuration** (Configuração), na seção **General configuration** (Configuração geral) do painel de navegação à esquerda, escolha **Edit** (Editar). No campo **Timeout** (Tempo limite), insira **2** min **0** segundos. Selecione **Salvar**.

   **Timeout** (Tempo limite) é a quantidade de tempo durante a qual o Lambda permite que uma função seja executada entes de interrompê-la. O padrão é 3 segundos. O preço é baseado na quantidade de memória configurada e na quantidade de tempo em que o código é executado. Para obter mais informações, consulte [Preços do AWS Lambda](https://aws.amazon.com/lambda/pricing/?icmpid=docs_console_unmapped).

## Etapa 5: Configurar o inventário do Amazon S3 para seu bucket de origem do S3
<a name="batchops-s3-step5"></a>

Depois de configurar a função de transcodificação do Lambda, crie um trabalho de operações em lote do S3 para transcodificar um conjunto de vídeos. Primeiro, você precisa de uma lista de objetos de vídeo de entrada nos quais deseja que as operações em lote do S3 executem a ação de transcodificação especificada. Para obter uma lista de objetos de vídeo de entrada, você pode gerar um relatório de inventário do S3 para o bucket de origem do S3 (por exemplo, `amzn-s3-demo-source-bucket`). 

**Topics**
+ [Crie e configure um bucket para relatórios de inventário do S3 para vídeos de entrada](#batchops-s3-step5-bucket)
+ [Configure o inventário do Amazon S3 para o bucket de origem de vídeo do S3](#batchops-s3-step5-inventory)
+ [Confira o relatório de inventário para o seu bucket de origem de vídeo S3](#batchops-s3-step5-manifest)

### Crie e configure um bucket para relatórios de inventário do S3 para vídeos de entrada
<a name="batchops-s3-step5-bucket"></a>

Para armazenar relatórios de inventário do S3 que listam os objetos do bucket de origem do S3, você precisa criar um bucket de destino de inventário do S3 e depois configurar uma política de bucket para que o bucket grave os arquivos de inventário no bucket de origem do S3.

1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

1. No painel de navegação à esquerda, escolha **Buckets**.

1. Selecione **Criar bucket**. 

1. Em **Bucket name** (Nome do bucket), insira um nome para o seu bucket (por exemplo, `amzn-s3-demo-destination-bucket2`). 

1. Em **Região da AWS**, escolha a Região da AWS na qual você deseja que o bucket resida. 

   O bucket de destino do inventário deve estar na mesma Região da AWS que o bucket de origem para o qual você está configurando o inventário do S3. O bucket de destino do inventário pode estar em uma diferente Conta da AWS. 

1. Em **Block Public Access settings for this bucket** (Configurações de bloquear acesso público para este bucket), mantenha as configurações padrão (**Block *all *public access** (Bloquear todo acesso público) está habilitado). 

1. Mantenha as configurações restantes definidas conforme os padrões. 

1. Selecione **Criar bucket**.

1. Na lista de **Buckets**, escolha o nome do bucket que você acabou de criar (por exemplo, `amzn-s3-demo-destination-bucket2`).

1. Para conceder permissão ao Amazon S3 para gravar dados para os relatórios de inventário no bucket de destino de inventário do S3, escolha a guia **Permissions** (Permissões).

1. Role para baixo até a seção **Bucket policy** (Política de bucket) e escolha **Edit** (Editar). A página **Bucket policy** (Política de bucket) se abre.

1. Para conceder permissões para o inventário do S3, no campo **Policy** (Política), cole a seguinte política de bucket.

   Substitua os três valores do exemplo pelos seguintes valores: 
   + O nome do bucket criado para armazenar os relatórios de inventário (por exemplo, `amzn-s3-demo-destination-bucket2`).
   + O nome do bucket de origem que armazena os vídeos de entrada (por exemplo, `amzn-s3-demo-source-bucket`). 
   + O ID da Conta da AWS que você usou para criar o bucket de origem do vídeo S3 (por exemplo, `111122223333`).

------
#### [ JSON ]

****  

   ```
   {
     "Version":"2012-10-17",		 	 	 
     "Statement":[
       {
         "Sid":"InventoryAndAnalyticsExamplePolicy",
         "Effect":"Allow",
         "Principal": {"Service": "s3.amazonaws.com"},
         "Action":"s3:PutObject",
         "Resource":["arn:aws:s3:::amzn-s3-demo-destination-bucket2/*"],
         "Condition": {
             "ArnLike": {
                 "aws:SourceArn": "arn:aws:s3:::amzn-s3-demo-source-bucket"
              },
            "StringEquals": {
                "aws:SourceAccount": "111122223333",
                "s3:x-amz-acl": "bucket-owner-full-control"
             }
          }
       }
     ]
   }
   ```

------

1. Escolha **Salvar alterações**.

### Configure o inventário do Amazon S3 para o bucket de origem de vídeo do S3
<a name="batchops-s3-step5-inventory"></a>

Para gerar uma lista de arquivos simples de objetos de vídeo e metadados, você deve configurar o inventário do S3 para o seu bucket de origem de vídeo do S3. Esses relatórios programados podem incluir todos os objetos no bucket ou objetos agrupados por um prefixo compartilhado. Neste tutorial, o relatório de inventário do S3 inclui todos os objetos de vídeo em seu bucket de origem do S3.

1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

1. No painel de navegação à esquerda, escolha **Buckets**.

1. Para configurar um relatório de inventário do S3 dos vídeos de entrada no bucket de origem do S3, na seção **Buckets**, escolha o nome do bucket de origem do S3 (por exemplo, `amzn-s3-demo-source-bucket`).

1. Escolha a guia **Gerenciamento**.

1. Role para baixo até a seção **Inventory configurations** (Configurações de inventário), e escolha **Create Inventory configuration** (Criar configuração de inventário). 

1. Para **Inventory configuration name** (Nome da configuração de inventário), insira um nome (por exemplo, **tutorial-inventory-config**). 

1. Em **Escopo do inventário**, escolha **Somente versão atual** para **Versões do objeto** e, para este tutorial, mantenha as outras configurações de **Escopo do inventário** definidas com os padrões. 

1. Na seção **Report details** (Detalhes do relatório), para **Destination bucket** (Bucket de destino), escolha **This account** (Esta conta). 

1. Para **Destination** (Destino), escolha **Browse S3** (Procurar no S3) e escolha o bucket de destino que você criou antes para salvar os relatórios de inventário (por exemplo, `amzn-s3-demo-destination-bucket2`). Em seguida, escolha **Choose path** (Escolher caminho). 

   O bucket de destino do inventário deve estar na mesma Região da AWS que o bucket de origem para o qual você está configurando o inventário do S3. O bucket de destino do inventário pode estar em uma diferente Conta da AWS. 

   No campo de bucket de **Destination** (Destino), a **Destination bucket permission** (Permissão do bucket de destino) é adicionada à política de bucket de destino para permitir que o Amazon S3 coloque dados nesse bucket de destino do inventário. Para obter mais informações, consulte [Criação de uma política de bucket de destino](configure-inventory.md#configure-inventory-destination-bucket-policy).

1. Em **Frequency** (Frequência), escolha **Daily** (Diária).

1. Em **Output format** (Formato de saída), escolha **CSV**. 

1. Em **Status**, escolha **Enabled** (Habilitado). 

1. Em **Server-side encryption** (Criptografia do lado do servidor), escolha **Disable** (Desabilitar) para este tutorial. 

   Para obter mais informações, consulte [Configurar um inventário usando o console do S3](configure-inventory.md#configure-inventory-console) e [Conceder permissão para que o Amazon S3 use a sua chave gerenciada pelo cliente para criptografia](configure-inventory.md#configure-inventory-kms-key-policy). 

1. Na seção **Additional fields - *optional*** (Campos adicionais - opcionais), escolha **Size** (Tamanho), **Last modified** (Última modificação) e **Storage class** (Classe de armazenamento). 

1. Escolha **Criar**.

Para obter mais informações, consulte [Configurar um inventário usando o console do S3](configure-inventory.md#configure-inventory-console).

### Confira o relatório de inventário para o seu bucket de origem de vídeo S3
<a name="batchops-s3-step5-manifest"></a>

Quando um relatório de inventário é publicado, os arquivos manifestos são enviados para o bucket de destino do S3.

1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

1. No painel de navegação à esquerda, escolha **Buckets**.

1. Na lista de **Buckets**, escolha o nome do bucket de origem de vídeo (por exemplo, `amzn-s3-demo-source-bucket`).

1. Escolha **Management** (Gerenciamento).

1. Para ver se o relatório de inventário do S3 está pronto para você poder criar um trabalho de operações em lote do S3 na [Etapa 7](#batchops-s3-step7), em **Inventory configurations** (Configurações do inventário), confira se o botão **Create job from manifest** (Criar trabalho a partir do manifesto) está habilitado.
**nota**  
O primeiro relatório de inventário pode demorar até 48 horas para ser entregue. Se o botão **Create job from manifest** (Criar trabalho do manifesto) estiver desativado, o primeiro relatório de inventário não foi entregue. Espere até que o primeiro relatório de inventário seja entregue e o botão **Create job from manifest** (Criar trabalho a partir do manifesto) esteja habilitado para criar um trabalho de operações em lote do S3 na [Etapa 7](#batchops-s3-step7). 

1. Para conferir um relatório de inventário do S3 (`manifest.json`), na coluna **Destination** (Destino), escolha o nome do bucket de destino do inventário que você criou antes para armazenar relatórios de inventário (por exemplo, `amzn-s3-demo-destination-bucket2`).

1. Na guia **Objects** (Objetos), escolha a pasta existente com o nome do seu bucket de origem do S3 (por exemplo, `amzn-s3-demo-source-bucket`). Em seguida, escolha o nome que você inseriu em **Inventory configuration name** (Nome da configuração do inventário) quando criou a configuração de inventário antes (por exemplo, **tutorial-inventory-config**).

   Você pode ver uma lista de pastas com as datas de geração dos relatórios como seus nomes. 

1. Para conferir o relatório de inventário diário do S3 para uma determinada data, escolha a pasta com um nome de data de geração e depois escolha `manifest.json`. 

1. Para verificar os detalhes do relatório de inventário em uma data específica, na página **manifesto.json**, escolha **Download** (Baixar) ou **Open** (Abrir).

## Etapa 6: criar uma função do IAM para operações em lote do S3
<a name="batchops-s3-step6"></a>

Para usar as operações em lote do S3 para fazer transcodificação em lote, você deve primeiro criar uma função do IAM para conceder permissões ao Amazon S3 para executar as operações em lote do S3. 

**Topics**
+ [Criar uma política do IAM para operações em lote do S3](#batchops-s3-step6-policy)
+ [Crie uma função do IAM de operações em lote do S3 e anexe políticas de permissão](#batchops-s3-step6-role)

### Criar uma política do IAM para operações em lote do S3
<a name="batchops-s3-step6-policy"></a>

Você deve criar uma política do IAM que conceda permissão às operações em lote do S3 para ler o manifesto de entrada, invocar a função do Lambda e gravar o relatório de conclusão do trabalho de operações em lote do S3. 

1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. No painel de navegação à esquerda, escolha **Políticas**.

1. Escolha **Criar política**.

1. Escolha a guia **JSON**.

1. No campo de texto **JSON**, cole a política JSON a seguir.

   Na política JSON, substitua os quatro valores do exemplo pelos seguintes valores:
   + O nome do bucket de origem que armazena vídeos de entrada (por exemplo, `amzn-s3-demo-source-bucket`).
   + O nome do bucket de destino de inventário que você criou na [Etapa 5](#batchops-s3-step5) para armazenar os arquivos `manifest.json` (por exemplo, `amzn-s3-demo-destination-bucket2`).
   + O nome do bucket que você criou na [Etapa 1](#batchops-s3-step1) para armazenar arquivos de mídia de saída (por exemplo, `amzn-s3-demo-destination-bucket1`). Neste tutorial, colocamos relatórios de conclusão de trabalho no bucket de destino para arquivos de mídia de saída. 
   + A função ARN da função Lambda que você criou na [Etapa 4](#batchops-s3-step4). Para localizar e copiar o ARN da função do Lambda, faça o seguinte: 
     + Em uma nova guia do navegador, abra a página **Functions** (Funções) no console do Lambda em [https://console.aws.amazon.com/lambda/home#/functions](https://console.aws.amazon.com/lambda/home#/functions).
     + Na lista de **Functions** (Funções), escolha o nome da função do Lambda que você criou na [Etapa 4](#batchops-s3-step4) (por exemplo, **tutorial-lambda-convert**).
     + Escolha **Copy ARN** (Copiar ARN).

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Sid": "S3Get",
               "Effect": "Allow",
               "Action": [
                   "s3:GetObject",
                   "s3:GetObjectVersion"
               ],
               "Resource": [
                   "arn:aws:s3:::amzn-s3-demo-source-bucket/*",
                   "arn:aws:s3:::amzn-s3-demo-destination-bucket2/*"
               ]
           },
           {
               "Sid": "S3PutJobCompletionReport",
               "Effect": "Allow",
               "Action": "s3:PutObject",
               "Resource": "arn:aws:s3:::amzn-s3-demo-destination-bucket1/*"
           },
           {
               "Sid": "S3BatchOperationsInvokeLambda",
               "Effect": "Allow",
               "Action": [
                   "lambda:InvokeFunction"
               ],
               "Resource": [
                   "arn:aws:lambda:us-west-2:111122223333:function:tutorial-lambda-convert"
               ]
           }
       ]
   }
   ```

------

1. Escolha **Próximo: tags**.

1. Selecione **Próximo: revisar**.

1. No campo **Name** (Nome), insira **tutorial-s3batch-policy**.

1. Escolha **Criar política**.

### Crie uma função do IAM de operações em lote do S3 e anexe políticas de permissão
<a name="batchops-s3-step6-role"></a>

1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. No painel de navegação à esquerda, escolha **Roles** (Funções) e **Create role** (Criar função).

1. Escolha o tipo de função **AWS service (Serviço da AWS)** e depois escolha o serviço **S3**.

1. Em **Select your use case** (Selecionar seu caso de uso), escolha **S3 Batch Operations** (Operações em lote do S3).

1. Escolha **Próximo**.

1. Em **Anexar políticas de permissões**, insira o nome da política do IAM que você criou antes (por exemplo, **tutorial-s3batch-policy**) na caixa de pesquisa para filtrar a lista de políticas. Marque a caixa de seleção ao lado do nome da política (por exemplo, **tutorial-s3batch-policy**). 

1. Escolha **Próximo**.

1. Em **Nome do perfil**, insira **tutorial-s3batch-role**.

1. Escolha **Create role** (Criar função).

   Depois que você cria a função do IAM para as operações em lote do S3, a política de confiança a seguir é anexada automaticamente à função. Essa política de confiança permite que o principal das operações em lote do S3 assuma a função do IAM.

------
#### [ JSON ]

****  

   ```
   {
      "Version":"2012-10-17",		 	 	 
      "Statement":[
         {
            "Effect":"Allow",
            "Principal":{
               "Service":"batchoperations.s3.amazonaws.com"
            },
            "Action":"sts:AssumeRole"
         }
      ]
   }
   ```

------

## Etapa 7: criar e executar um trabalho de operações em lote do S3
<a name="batchops-s3-step7"></a>

Para criar um trabalho de operações em lote do S3 para processar os vídeos de entrada no bucket de origem do S3, você deve especificar os parâmetros para esse trabalho específico.

**nota**  
Antes de começar a criar um trabalho de operações em lote do S3, certifique-se de que o botão **Create job from manifest** (Criar trabalho a partir do manifesto) esteja habilitado. Para obter mais informações, consulte [Confira o relatório de inventário para o seu bucket de origem de vídeo S3](#batchops-s3-step5-manifest). Se o botão **Create job from manifest** (Criar trabalho a partir do manifesto) estiver desabilitado, o primeiro relatório de inventário não foi entregue e você deve esperar até que o botão esteja habilitado. Depois de configurar o inventário do Amazon S3 para o bucket de origem do S3 na [Etapa 5](#batchops-s3-step5), a entrega do primeiro relatório de inventário pode levar até 48 horas.

**Topics**
+ [Criar um trabalho de operações em lote do S3](#batchops-s3-step7-create-job)
+ [Execute o trabalho de operações em lote do S3 para chamar a função Lambda](#batchops-s3-step7-run-job)
+ [(Opcional) Verificar seu relatório de conclusão](#batchops-s3-step7-check-report)
+ [(Opcional) Monitore cada chamada do Lambda no console do Lambda](#batchops-s3-step7-monitor-lambda)
+ [(Opcional) Monitore cada trabalho de transcodificação de vídeo MediaConvert no console do MediaConvert](#batchops-s3-step7-monitor-mediaconvert)

### Criar um trabalho de operações em lote do S3
<a name="batchops-s3-step7-create-job"></a>

1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

1. No painel de navegação esquerdo, escolha **Batch Operations** (Operações em lote).

1. Escolha **Criar trabalho**.

1. Para **Região da AWS**, escolha a região onde você deseja criar o trabalho.

   Neste tutorial, para usar o trabalho de operações em lote do S3 para invocar uma função do Lambda, você deve criar o trabalho na mesma região que o bucket de origem de vídeo do S3 onde os objetos referenciados no manifesto estão localizados.

1. Na seção **Manifest** (Manifesto), faça o seguinte:

   1. Para **Manifest format** (Formato do manifesto), escolha **S3 Inventory report (manifest.json)** (Relatório do S3 Inventory [manifest.json]).

   1. Para **Manifest object** (Objeto de manifesto), escolha **Browse S3** (Procurar no S3) para encontrar o bucket que você criou na [Etapa 5](#batchops-s3-step5) para armazenar relatórios de inventário (por exemplo, `amzn-s3-demo-destination-bucket2`). Na página **Manifest object**, (Objeto de manifesto) navegue pelos nomes de objetos até encontrar um arquivo `manifest.json` para uma data específica. Este arquivo lista as informações sobre todos os vídeos que você deseja transcodificar em lote. Quando encontrar o arquivo `manifest.json` que você deseja usar, escolha o botão de opção ao lado dele. Em seguida, escolha **Choose path** (Escolher caminho).

   1. (Opcional) Para **Manifest object version ID - *optional*** (ID da versão do objeto de manifesto - opcional) insira o ID de versão do objeto de manifesto se quiser usar uma versão que não seja a mais recente.

1. Escolha **Próximo**.

1. Para usar a função do Lambda para transcodificar todos os objetos listados no arquivo `manifest.json` selecionado, em **Operation type** (Tipo de operação), escolha **Invoke AWS Lambda function** (Invocar função do IAM).

1. Na seção **Invoke Lambda Function** (Invocar função do Lambda), faça o seguinte:

   1. Escolha **Choose from functions in your account** (Escolher das funções de sua conta).

   1. Para **Lambda function** (Função do Lambda), escolha a função do Lambda que você criou na [Etapa 4](#batchops-s3-step4) (por exemplo, **tutorial-lambda-convert**).

   1. Para **Lambda function version** (Versão da função do Lambda), mantenha o valor padrão **\$1LATER**.

1. Escolha **Próximo**. A página **Configure additional options** (Configurar opções adicionais) se abre.

1. Na seção **Additional options** (Opções adicionais), mantenha as configurações padrão.

   Para saber mais sobre essas opções, consulte [Elementos da solicitação de trabalho de Operações em lote](batch-ops-create-job.md#batch-ops-create-job-request-elements).

1. Na seção **Completion report** (Relatório de conclusão) para **Path to completion report destination** (Caminho para o destino do relatório de conclusão), escolha **Browse S3** (Procurar no S3). Encontre o nome do bucket para armazenar os arquivos de mídia de saída que você criou na [Etapa 1](#batchops-s3-step1) (por exemplo, `amzn-s3-demo-destination-bucket1`). Escolha o botão de opção ao lado do nome desse bucket. Em seguida, escolha **Choose path** (Escolher caminho).

   Para as demais configurações de **Relatório de conclusão**, mantenha os padrões. Para obter mais informações sobre conclusão de configurações do relatório, consulte [Elementos da solicitação de trabalho de Operações em lote](batch-ops-create-job.md#batch-ops-create-job-request-elements). Um relatório de conclusão mantém um registro dos detalhes do trabalho e das operações executadas.

1. Em **Permissions** (Permissões), escolha **Choose from existing IAM roles** (Escolher entre as funções do IAM existentes). Para **IAM role** (Função do IAM), escolha a função do IAM para seu trabalho de operações em lote do S3 que você criou na [Etapa 6](#batchops-s3-step6) (por exemplo, **tutorial-s3batch-role**).

1. Escolha **Próximo**.

1. Na página **Review** (Revisão), revise as configurações. Depois, escolha **Create Job** (Criar trabalho).

   Depois que o S3 termina de ler o manifesto do trabalho de operações em lote do S3, ele define o **Status** do trabalho como **Awaiting your confirmation to run** (Aguardando sua confirmação para ser executado). Para ver as atualizações do status do trabalho, atualize a página. Você não pode executar seu trabalho até que o status dele seja **Awaiting your confirmation to run** (Aguardando sua confirmação para ser executado).

### Execute o trabalho de operações em lote do S3 para chamar a função Lambda
<a name="batchops-s3-step7-run-job"></a>

Execute seu trabalho de operações em lote para chamar sua função Lambda para transcodificação de vídeo. Se o trabalho falhar, você pode conferir o relatório da conclusão para identificar a causa.

**Para executar o trabalho de operações em lote do S3**

1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

1. No painel de navegação esquerdo, escolha **Batch Operations** (Operações em lote).

1. Na lista **Jobs** (Trabalhos), escolha a opção **Job ID** (ID do trabalho) na primeira linha, que é o trabalho das operações em lote do S3 que você criou antes.

1. Escolha **Run job** (Executar trabalho). 

1. Revise os parâmetros do job novamente e confirme se o valor para **Total objects listed in manifest** (Total de objeto listados no manifesto) é o mesmo do número de objetos no manifesto. Em seguida, selecione **Run job** (Executar trabalho).

   A página de trabalho de operações em lote do S3 é aberta.

1. Depois que o trabalho começar a execução, em sua página de trabalho em **Status**, verifique o andamento de seu trabalho de operações em lote do S3, como **Status**, **% Complete** (% de conclusão), **Total succeeded (rate)** (Total com êxito [taxa]), **Total failed (rate)** (Total com falha [taxa]), **Date terminated** (Data de término) e **Reason for termination** (Motivo do término).

   Quando o trabalho de operações em lote do S3 for concluído, visualize os dados na página do trabalho para confirmar que o trabalho foi concluído conforme esperado. 

   Se mais de 50% das operações de objeto do trabalho das operações em lote do S3 falharem após mais de 1.000 tentativas, o trabalho automaticamente falha. Para conferir o relatório de conclusão para identificar a causa das falhas, consulte o procedimento opcional abaixo.

### (Opcional) Verificar seu relatório de conclusão
<a name="batchops-s3-step7-check-report"></a>

Você pode usar o relatório de conclusão para determinar quais objetos falharam e a causa das falhas.

**Para conferir o relatório de conclusão para obter detalhes sobre os objetos que falharam**

1. Na página do trabalho de operações em lote do S3, role para baixo até a seção **Completion report** (Relatório de conclusão) e escolha o link em **Completion report destination** (Destino do relatório de conclusão).

   A página do bucket de destino de saída do S3 se abre.

1. Na guia **Objects** (Objetos), escolha a pasta que tem um nome que termina com o ID do trabalho de operações em lote do S3 que você criou antes.

1. Escolha **results/** (resultados/).

1. Marque a caixa de seleção próxima ao arquivo `.csv`.

1. Para visualizar o relatório de trabalhos, escolha **Open** (Abrir) ou **Download** (Baixar).

### (Opcional) Monitore cada chamada do Lambda no console do Lambda
<a name="batchops-s3-step7-monitor-lambda"></a>

Depois que o trabalho de operações em lote do S3 começa a ser executado, o trabalho invoca a função do Lambda para cada objeto de vídeo de entrada. O S3 grava logs de cada chamada do Lambda no CloudWatch Logs. Você pode usar o painel de monitoramento do console do Lambda para monitorar sua função Lambda. 

1. Abra o console AWS Lambda em [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).

1. No painel de navegação à esquerda, escolha **Functions** (Funções).

1. Na lista **Functions** (Funções), escolha o nome da função do Lambda que você criou na [Etapa 4](#batchops-s3-step4) (por exemplo, **tutorial-lambda-convert**).

1. Escolha a guia **Monitor** (Monitorar).

1. Em **Metrics** (Métricas), consulte as métricas de tempo de execução para sua função Lambda.

1. Em **Logs**, visualize dados de log para cada chamada do Lambda por meio do CloudWatch Logs Insights
**nota**  
Quando você usa as operações em lote do S3 com uma função Lambda, essa função Lambda é chamada em cada objeto. Se o trabalho de operações em lote do S3 for grande, ele poderá chamar várias funções Lambda ao mesmo tempo, causando um pico na simultaneidade do Lambda.   
Cada Conta da AWS tem uma cota de simultaneidade do Lambda por região. Para obter mais informações, consulte [Escalabilidade de função do AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/invocation-scaling.html) no *Guia do desenvolvedor do AWS Lambda*. Uma prática recomendada para usar funções Lambda com operações em lote do S3 é definir um limite de simultaneidade na própria função Lambda. Definir um limite de simultaneidade evita que seu trabalho consuma a maior parte de sua simultaneidade do Lambda e potencialmente restrinja a utilização de outras funções em sua conta. Para obter mais informações, consulte [Gerenciamento de simultaneidade reservada do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-concurrency.html) no *Guia do desenvolvedor do AWS Lambda*.

### (Opcional) Monitore cada trabalho de transcodificação de vídeo MediaConvert no console do MediaConvert
<a name="batchops-s3-step7-monitor-mediaconvert"></a>

Um trabalho do MediaConvert se encarrega da transcodificação de um arquivo de mídia. Quando o trabalho de operações em lote do S3 invoca sua função do Lambda para cada vídeo, cada invocação da função do Lambda cria um trabalho de transcodificação do MediaConvert para cada vídeo de entrada. 

1. Faça login no Console de gerenciamento da AWS e abra o console do MediaConvert em [https://console.aws.amazon.com/mediaconvert/](https://console.aws.amazon.com/mediaconvert/).

1. Se a página introdutória MediaConvert for exibida, escolha **Get started** (Conceitos básicos).

1. Na lista de **Jobs** (Trabalhos), visualize cada linha para monitorar a tarefa de transcodificação para cada vídeo de entrada. 

1. Identifique a linha de um trabalho que você deseja conferir e escolha o link **Job ID** (ID do trabalho) para abrir a página de detalhes do trabalho.

1. Na página **Job summary** (Resumo do trabalho) em **Outputs** (Saídas), escolha o link para a saída HLS, MP4 ou miniaturas, dependendo do que é suportado pelo navegador, para ir para o bucket de destino do S3 para os arquivos de mídia de saída.

1. Na pasta correspondente (HLS, MP4 ou Thumbnails [Miniaturas]) do bucket de destino de saída do S3, escolha o nome do objeto de arquivo de mídia de saída.

   A página de details do objeto se abre.

1. Na página de detalhes do objeto, em **Object overview** (Visão geral do objeto), escolha o link em **Object URL** (URL do objeto) para assistir ao arquivo de mídia de saída transcodificado.

## Etapa 8: Conferir os arquivos de mídia de saída do bucket de destino do S3
<a name="batchops-s3-step8"></a>

**Para conferir os arquivos de mídia de saída do bucket de destino do S3**

1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

1. No painel de navegação à esquerda, escolha **Buckets**.

1. Na lista **Buckets**, escolha o nome do bucket de destino do S3 para os arquivos de mídia de saída que você criou na [Etapa 1](#batchops-s3-step1) (por exemplo, `amzn-s3-demo-destination-bucket1`).

1. Na guia **Objects** (Objetos), cada vídeo de entrada tem uma pasta com o nome do vídeo de entrada. Cada pasta contém os arquivos de mídia de saída transcodificados para um vídeo de entrada.

   Para verificar os arquivos de mídia de saída para um vídeo de entrada, faça o seguinte:

   1. Escolha a pasta com o nome do vídeo de entrada que você deseja conferir.

   1. Escolha a pasta **Default/** (Padrão/).

   1. Escolha a pasta para um formato transcodificado (HLS, MP4 ou miniaturas neste tutorial). 

   1. Escolha o nome do arquivo de mídia de saída.

   1. Para ver o arquivo transcodificado, na página de detalhes do objeto, escolha o link em **Object URL** (URL do objeto). 

      Os arquivos de mídia de saída no formato HLS são divididos em segmentos curtos. Para reproduzir esses vídeos, incorpore o URL do objeto do arquivo `.m3u8` em um player compatível.

## Etapa 9: limpar
<a name="batchops-s3-step9"></a>

Se você transcodificou vídeos usando as operações em lote do S3, o Lambda e o MediaConvert somente como um exercício de aprendizado, exclua os recursos da AWS alocados para que não haja mais encargos. 

**Topics**
+ [Exclua a configuração do inventário do S3 para o bucket de origem do S3](#batchops-s3-step9-delete-inventory)
+ [Excluir a função Lambda](#batchops-s3-step9-delete-lambda)
+ [Excluir o grupo de logs do CloudWatch](#batchops-s3-step9-delete-cw)
+ [Exclua as funções do IAM junto com as políticas em linha das funções do IAM](#batchops-s3-step9-delete-role)
+ [Exclua a política do IAM gerenciada pelo cliente](#batchops-s3-step9-delete-policy)
+ [Esvaziar os buckets do S3](#batchops-s3-step9-empty-bucket)
+ [Excluir os buckets do S3](#batchops-s3-step9-delete-bucket)

### Exclua a configuração do inventário do S3 para o bucket de origem do S3
<a name="batchops-s3-step9-delete-inventory"></a>

1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

1. No painel de navegação à esquerda, escolha **Buckets**.

1. Na lista de **Buckets**, selecione o nome do bucket de origem (por exemplo, `amzn-s3-demo-source-bucket`).

1. Escolha a guia **Gerenciamento**.

1. Em **Inventory configurations** (Configurações do inventário), escolha o botão de opção ao lado da configuração de inventário que você criou na [Etapa 5](#batchops-s3-step5) (por exemplo, **tutorial-inventory-config**).

1. Escolha **Delete** (Excluir) e, em seguida, escolha **Confirm** (Confirmar).

### Excluir a função Lambda
<a name="batchops-s3-step9-delete-lambda"></a>

1. 

   Abra o console AWS Lambda em [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).

1. No painel de navegação à esquerda, escolha **Functions** (Funções).

1. Marque a caixa de seleção ao lado da função que você criou na [Etapa 4](#batchops-s3-step4) (por exemplo, **tutorial-lambda-convert**).

1. Escolha **Ações** e, em seguida, escolha **Excluir**.

1. Na caixa de diálogo **Delete function** (Excluir função), escolha **Delete** (Excluir).

### Excluir o grupo de logs do CloudWatch
<a name="batchops-s3-step9-delete-cw"></a>

1. Abra o console do CloudWatch em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. No painel de navegação à esquerda, escolha **Logs** e, em seguida, escolha **Log groups** (Grupos de log).

1. Marque a caixa de seleção ao lado do grupo de logs que tem um nome que termina com a função do Lambda que você criou na [Etapa 4](#batchops-s3-step4) (por exemplo, **tutorial-lambda-convert**).

1. Escolha **Actions** (Ações) e **Delete log group(s)** (Excluir grupo(s) de log).

1. Na caixa de diálogo **Delete log group(s)** (Excluir grupo(s) de logs), escolha **Delete** (Excluir).

### Exclua as funções do IAM junto com as políticas em linha das funções do IAM
<a name="batchops-s3-step9-delete-role"></a>

Para excluir as funções do IAM criadas na [Etapa 2](#batchops-s3-step2), [Etapa 3](#batchops-s3-step3) e [Etapa 6](#batchops-s3-step6), faça o seguinte: 

1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. No painel de navegação da esquerda, escolha **Roles** (Funções) e marque as caixas de seleção ao lado do nome da função que você deseja excluir.

1. Na parte superior da página, escolha **Delete** (Excluir).

1. Na caixa de diálogo de confirmação, insira a resposta necessária no campo de entrada de texto com base no prompt e escolha **Delete** (Excluir). 

### Exclua a política do IAM gerenciada pelo cliente
<a name="batchops-s3-step9-delete-policy"></a>

Para excluir a política do IAM gerenciada pelo cliente que você criou na [Etapa 6](#batchops-s3-step6), faça o seguinte:

1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. No painel de navegação à esquerda, escolha **Políticas**.

1. Escolha o botão de opção ao lado da política que você criou na [Etapa 6](#batchops-s3-step6) (por exemplo, **tutorial-s3batch-policy**). É possível usar a caixa de pesquisa para filtrar a lista de políticas.

1. Escolha **Actions** (Ações) e, em seguida, escolha **Delete** (Excluir). 

1. Confirme que deseja excluir esta política, inserindo o nome da política no campo de texto, e escolha **Delete** (Excluir). 

### Esvaziar os buckets do S3
<a name="batchops-s3-step9-empty-bucket"></a>

Para esvaziar os buckets do S3 criados em [Pré-requisitos](#batchops-s3-prerequisites), [Etapa 1](#batchops-s3-step1) e [Etapa 5](#batchops-s3-step5), faça o seguinte: 

1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

1. No painel de navegação à esquerda, escolha **Buckets**.

1. Na lista **Buckets**, escolha o botão de opção ao lado do nome do bucket que você deseja esvaziar e depois escolha **Empty** (Esvaziar).

1. Na página **Empty bucket** (Esvaziar bucket), confirme se deseja esvaziar o bucket inserindo **permanently delete** no campo de texto e depois escolha **Empty** (Esvaziar).

### Excluir os buckets do S3
<a name="batchops-s3-step9-delete-bucket"></a>

Para excluir os buckets do S3 criados em [Pré-requisitos](#batchops-s3-prerequisites), [Etapa 1](#batchops-s3-step1) e [Etapa 5](#batchops-s3-step5), faça o seguinte: 

1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

1. No painel de navegação à esquerda, escolha **Buckets**.

1. Na lista **Buckets**, escolha o botão de opção ao lado do nome do bucket que você deseja excluir.

1. Escolha **Excluir**.

1. Na página **Delete bucket** (Excluir bucket), confirme se deseja excluir o bucket inserindo o nome do bucket no campo de texto e escolha **Delete bucket** (Excluir bucket).

## Próximas etapas
<a name="batchops-s3-next-steps"></a>

Depois de concluir este tutorial, você poderá explorar outros casos de uso relevantes:
+ Você pode usar o Amazon CloudFront para transmitir os arquivos de mídia transcodificados para espectadores em todo o mundo. Para obter mais informações, consulte [Tutorial: Hospedagem de transmissão sob demanda com o Amazon S3, Amazon CloudFront e Amazon Route 53](tutorial-s3-cloudfront-route53-video-streaming.md).
+ Você pode transcodificar vídeos no momento em que os carrega para o bucket de origem do S3. Para fazer isso, você pode configurar um acionador de evento do Amazon S3 que invoca automaticamente a função do Lambda para transcodificar novos objetos no S3 com o MediaConvert. Para obter mais informações, consulte o [Tutorial: Uso de um acionador do Amazon S3 para invocar uma função do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/with-s3-example.html) no *Guia do desenvolvedor do AWS Lambda*. 