Tutorial: vídeos de transcodificação em lote com o Operações em Lote do S3

1. Faça login no AWS Management Console e abra o console do Amazon S3 em https://console.aws.amazon.com/s3/.

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

3. Selecione Criar bucket.

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

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

6. 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 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.

7. 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.)

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

9. Selecione Criar bucket.

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 AWS Management Console e abra o console do Amazon S3 em https://console.aws.amazon.com/s3/.

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

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

4. Escolha a aba Permissões.

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

6. 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.

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

7. Escolha Salvar alterações.

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) no Guia do usuário do AWS Elemental MediaConvert.

2. 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).

3. 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) (Nomes de recurso da Amazon (ARNs) em AWS General Reference (Referência geral).

1. Faça login no AWS Management Console e abra o console do IAM em https://console.aws.amazon.com/iam/.

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

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

4. Selecione Next: Permissions (Próximo: permissões).

5. 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.

6. Escolha Próximo: etiquetas.

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

8. Escolha Next: Review (Próximo: revisar).

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

10. Escolha Create role (Criar função).

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 AWS Management Console e abra o console do IAM em https://console.aws.amazon.com/iam/.

2. No painel de navegação à esquerda, escolha Roles.

3. 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).

4. Escolha a guia Permissions (Permissões).

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

6. 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 (por exemplo, tutorial-mediaconvert-role).

   {
       "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"
           }
       ]
   }

7. Escolha Revisar política.

8. Em Nome, insira tutorial-lambda-policy.

9. Escolha Criar política.

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

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

2. 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 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"
       }
     ]
   }

   Mostrar maisMostrar menos

3. 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.

   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.
       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. 
           # 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
       }                                

4. 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                

1. Abra o console AWS Lambda em https://console.aws.amazon.com/lambda/.

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

3. Escolha Create function (Criar função).

4. Escolha Author from scratch (Criar do zero).

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

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

   2. Para Runtime (Tempo de execução), escolha Python 3.8 ou uma versão posterior do Python.

6. 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).

7. 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 (por exemplo, tutorial-lambda-transcode-role).

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

9. Escolha Create function (Criar função).

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).

2. Selecione Upload (Carregar) para selecionar seu arquivo .zip local.

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

4. Escolha Salvar.

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

6. 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.

7. Escolha Salvar.

8. 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).

9. 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.

   • 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. 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.

10. Escolha Salvar.

11. (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.

1. Faça login no AWS Management Console e abra o console do Amazon S3 em https://console.aws.amazon.com/s3/.

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

3. Selecione Criar bucket.

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

5. 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 Conta da AWS diferente.

6. 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).

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

8. Selecione Criar bucket.

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

10. 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).

11. 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.

12. 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).

    {
      "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"
              }
           }
        }
      ]
    }

13. Escolha Salvar alterações.

1. Faça login no AWS Management Console e abra o console do Amazon S3 em https://console.aws.amazon.com/s3/.

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

3. 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).

4. Escolha a guia Management.

5. 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).

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

7. Em Inventory scope (Escopo do inventário), escolha Current version only (Somente versão atual) para Object versions (Versões do objeto) e mantenha as outras configurações de Inventary scope(Escopo do inventário) definidas com os padrões para este tutorial.

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

9. 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 Conta da AWS diferente.

   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.

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

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

12. Em Status, escolha Enabled (Habilitado).

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

    Para ter mais informações, consulte Configurar um inventário usando o console do S3 e Conceder permissão para que o Amazon S3 use a sua chave gerenciada pelo cliente para criptografia.

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

15. Escolha Create (Criar).

1. Faça login no AWS Management Console e abra o console do Amazon S3 em https://console.aws.amazon.com/s3/.

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

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

4. Escolha Management (Gerenciamento).

5. 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, 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.

6. 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).

7. 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.

8. 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.

9. 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).

1. Faça login no AWS Management Console e abra o console do IAM em https://console.aws.amazon.com/iam/.

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

3. Escolha Create policy (Criar política).

4. Escolha a guia JSON.

5. 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 para armazenar os arquivos manifest.json (por exemplo, amzn-s3-demo-destination-bucket2).

   • O nome do bucket que você criou na Etapa 1 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. 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.

     • Na lista de Functions (Funções), escolha o nome da função do Lambda que você criou na Etapa 4 (por exemplo, tutorial-lambda-convert).

     • Escolha Copy ARN (Copiar ARN).

   {
       "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"
               ]
           }
       ]
   }                                          

6. Escolha Próximo: etiquetas.

7. Selecione Next: Review (Próximo: revisar).

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

9. Escolha Criar política.

1. Faça login no AWS Management Console e abra o console do IAM em https://console.aws.amazon.com/iam/.

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

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

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

5. Escolha Next: Permissions (Próximo: permissões).

6. Em Attach permissions policies (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).

7. Escolha Próximo: etiquetas.

8. Escolha Next: Review (Próximo: revisar).

9. Em Nome do perfil, insira tutorial-s3batch-role.

10. 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.

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

1. Faça login no AWS Management Console e abra o console do Amazon S3 em https://console.aws.amazon.com/s3/.

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

3. Escolha Criar trabalho.

4. 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.

5. 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]).

   2. Para Manifest object (Objeto de manifesto), escolha Browse S3 (Procurar no S3) para encontrar o bucket que você criou na Etapa 5 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).

   3. (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.

6. Escolha Próximo.

7. 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).

8. 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).

   2. Para Lambda function (Função do Lambda), escolha a função do Lambda que você criou na Etapa 4 (por exemplo, tutorial-lambda-convert).

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

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

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

    Para obter mais informações sobre essas opções, consulte Elementos da solicitação de trabalho de Operações em lote.

11. 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 (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. Um relatório de conclusão mantém um registro dos detalhes do trabalho e das operações executadas.

12. 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 (por exemplo, tutorial-s3batch-role).

13. Escolha Próximo.

14. 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).

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

1. Faça login no AWS Management Console e abra o console do Amazon S3 em https://console.aws.amazon.com/s3/.

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

3. 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.

4. Escolha Run job (Executar trabalho).

5. 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.

6. 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.

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.

2. 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.

3. Escolha results/ (resultados/).

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

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

1. Abra o console AWS Lambda em https://console.aws.amazon.com/lambda/.

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

3. Na lista Functions (Funções), escolha o nome da função do Lambda que você criou na Etapa 4 (por exemplo, tutorial-lambda-convert).

4. Escolha a guia Monitor (Monitorar).

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

6. 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 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 no Guia do desenvolvedor do AWS Lambda.

1. Faça login no AWS Management Console e abra o console do MediaConvert em https://console.aws.amazon.com/mediaconvert/.

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

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

4. 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.

5. 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.

6. 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.

7. 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.

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

1. Faça login no AWS Management Console e abra o console do Amazon S3 em https://console.aws.amazon.com/s3/.

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

3. 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 (por exemplo, amzn-s3-demo-destination-bucket1).

4. 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.

   2. Escolha a pasta Default/ (Padrão/).

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

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

   5. 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.

1. Faça login no AWS Management Console e abra o console do Amazon S3 em https://console.aws.amazon.com/s3/.

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

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

4. Escolha a guia Management.

5. 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 (por exemplo, tutorial-inventory-config).

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

1. Abra o console AWS Lambda em https://console.aws.amazon.com/lambda/.

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

3. Marque a caixa de seleção ao lado da função que você criou na Etapa 4 (por exemplo, tutorial-lambda-convert).

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

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

1. Abra o console do CloudWatch em https://console.aws.amazon.com/cloudwatch/.

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

3. 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 (por exemplo, tutorial-lambda-convert).

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

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

1. Faça login no AWS Management Console e abra o console do IAM em https://console.aws.amazon.com/iam/.

2. 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.

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

4. 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).

1. Faça login no AWS Management Console e abra o console do IAM em https://console.aws.amazon.com/iam/.

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

3. Escolha o botão de opção ao lado da política que você criou na Etapa 6 (por exemplo, tutorial-s3batch-policy). Você pode usar a caixa de pesquisa para filtrar a lista de políticas.

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

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

1. Faça login no AWS Management Console e abra o console do Amazon S3 em https://console.aws.amazon.com/s3/.

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

3. 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).

4. 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).

1. Faça login no AWS Management Console e abra o console do Amazon S3 em https://console.aws.amazon.com/s3/.

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

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

4. Escolha Excluir.

5. 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).