Tutorial: vídeos de transcodificación por lotes con Operaciones por lotes de S3

1. Inicie sesión AWS Management Console Management Console y abra la consola de Amazon S3 en https://console.aws.amazon.com/s3/.

2. En el panel de navegación izquierdo, elija Instancias.

3. Elija Crear bucket.

4. En Bucket name (Nombre de bucket), ingrese el nombre del bucket (por ejemplo, amzn-s3-demo-destination-bucket1).

5. En Región, elija la Región de AWS en la que desea que se encuentre el bucket.

6. Para garantizar el acceso público a los archivos multimedia de salida, en Configuración de Bloquear acceso público para este bucket, desactive Bloquear todo acceso público.

   aviso

   Antes de completar este paso, consulte Bloquear el acceso público a su almacenamiento de Amazon S3 para asegurarse de que comprende y acepta los riesgos que implica otorgar el acceso público. Cuando desactiva la configuración de Block Public Access para que el bucket sea público, cualquier usuario de Internet puede acceder al bucket. Le recomendamos que bloquee todo el acceso público a sus buckets.

   Si no desea borrar la configuración de Block Public Access, puede utilizar Amazon CloudFront para entregar los archivos multimedia transcodificados a los lectores (usuarios finales). Para obtener más información, consulte Tutorial: Alojamiento de video en streaming bajo demanda con Amazon S3, Amazon CloudFront y Amazon Route 53.

7. Seleccione la casilla de verificación junto a I acknowledge that the current settings may result in this bucket and the objects within becoming public (Reconozco que la configuración actual podría dar lugar a que este bucket y los objetos dentro se conviertan en públicos).

8. Mantenga la configuración restante establecida en los valores predeterminados.

9. Elija Crear bucket.

La configuración JSON CORS define una manera para que las aplicaciones web cliente (reproductores de video en este contexto) que estén cargadas en un dominio puedan reproducir archivos multimedia de salida y transcodificados en un dominio diferente.

1. Inicie sesión AWS Management Console Management Console y abra la consola de Amazon S3 en https://console.aws.amazon.com/s3/.

2. En el panel de navegación izquierdo, elija Instancias.

3. En la lista Buckets, busque y elija el nombre del bucket que creó anteriormente (por ejemplo, amzn-s3-demo-destination-bucket1).

4. Elija la pestaña Permisos.

5. En la sección Cross-origin resource sharing (CORS) (Compartir recursos entre orígenes [CORS]), elija Edit (Editar).

6. En el cuadro de texto de configuración CORS, copie y pegue la siguiente configuración CORS.

   La configuración de CORS debe estar en formato JSON. En este ejemplo, el atributo AllowedOrigins usa el carácter de comodín (*) para especificar todos los orígenes. Si conoce su origen específico, puede restringir el atributo AllowedOrigins a la URL específica de su reproductor. Para obtener más información sobre la configuración y otros atributos, consulte Elementos de una configuración de CORS.

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

7. Elija Guardar cambios.

Para crear un rol de IAM para MediaConvert

1. Puede crear un rol de IAM con un nombre de rol que usted elija (por ejemplo, tutorial-mediaconvert-role). Para crear este rol, siga los pasos que se detallan en Crear el rol de MediaConvert en IAM (consola) en la Guía del usuario de AWS Elemental MediaConvert.

2. Después de crear el rol de IAM para MediaConvert, en la lista de roles, elija el nombre del rol de MediaConvert que ha creado (por ejemplo, tutorial-mediaconvert-role).

3. En la página Summary (Resumen), copie el ARN de rol, que comienza con arn:aws:iam::, y guarde el ARN para utilizarlo más tarde.

   Para obtener más información sobre los ARN, consulte Nombres de recursos de Amazon (ARN) en la AWS Referencia general.

1. Inicie sesión en AWS Management Console Management Console y abra la consola IAM en https://console.aws.amazon.com/iam/.

2. En el panel de navegación izquierdo, elija Roles y luego, Create role (Crear rol).

3. Elija el tipo de rol del servicio de AWS y luego, en Common use cases (Casos de uso comunes), elija en Lambda.

4. Elija Siguiente: permisos.

5. En la página Attach Permissions policies (Adjuntar políticas de permisos), ingrese AWSLambdaBasicExecutionRole en el cuadro Filter policies (Filtrar políticas). Para adjuntar la política administrada AWSLambdaBasicExecutionRole a este rol a fin de otorgar permisos de escritura a Amazon CloudWatch Logs, seleccione la casilla de verificación junto a AWSLambdaBasicExecutionRole.

6. Elija Siguiente: etiquetas.

7. (Opcional) Agregue etiquetas a la política administrada.

8. Elija Next: Review (Siguiente: revisar).

9. En Role name (Nombre del rol), introduzca tutorial-lambda-transcode-role.

10. Elija Create role (Crear rol).

Debe utilizar una política en línea para otorgar permisos al recurso MediaConvert necesario para la ejecución de la función de Lambda.

1. Inicie sesión en AWS Management Console Management Console y abra la consola IAM en https://console.aws.amazon.com/iam/.

2. En el panel de navegación izquierdo, seleccione Roles.

3. En la lista Roles, elija el nombre del rol de IAM que ha creado anteriormente para la función de Lambda (por ejemplo, tutorial-lambda-transcode-role).

4. Elija la pestaña Permisos.

5. Elija Add inline policy (Agregar política insertada).

6. Elija la pestaña JSON y luego, copie y pegue la siguiente política JSON.

   Reemplace el valor ARN de ejemplo de Resource en la política JSON con el ARN del rol de IAM para MediaConvert que creó en el Paso 2 (por ejemplo, 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. Elija Review Policy (Revisar la política).

8. En Name (Nombre), ingrese tutorial-lambda-policy.

9. Seleccione Crear política.

   Una vez que cree una política en línea, se integra automáticamente en el rol de IAM de su función de Lambda.

1. En el equipo local, cree un archivo con el nombre batch-transcode.

2. En la carpeta batch-transcode, cree un archivo con la configuración de trabajo de JSON. Por ejemplo, puede utilizar la configuración que se proporcionó en esta sección y nombrar al archivo job.json.

   Un archivo job.json especifica lo siguiente:

   • Qué archivos transcodificar

   • Cómo quiere transcodificar sus videos de entrada

   • Qué archivos multimedia de salida desea crear

   • Cómo nombrar a los archivos transcodificados

   • Dónde guardar los archivos transcodificados

   • Qué características avanzadas aplicar, etc.

   En este tutorial, utilizamos el archivo job.json para crear las siguientes salidas para cada video en el bucket fuente de S3:

   • Una transmisión de velocidad de bits adaptable HTTP Live Streaming (HLS) para la reproducción en dispositivos de diferentes tamaños y con varias bandas anchas

   • Un archivo de video MP4

   • Imágenes en miniatura recopiladas a intervalos

   Este archivo job.json de ejemplo utiliza la velocidad de bits variable definida en función de la calidad (QVCR) para optimizar la calidad del video. La salida HLS es compatible con Apple (audio sin mezcla de video, duración de segmento adecuada de 6 segundos y calidad de video optimizada a través de QVBR automático).

   Si no desea utilizar la configuración de ejemplo que se proporciona aquí, puede generar una especificación de job.json según su caso de uso. Para garantizar la coherencia entre las salidas, asegúrese de que los archivos de entrada tienen configuraciones de video y audio similares. Cree automatizaciones separadas (única configuración de job.json) para cualquier archivo de entrada con diferentes configuraciones de video y audio. Para obtener más información, consulte Ejemplos de configuración de tareas de AWS Elemental MediaConvert en JSON en la Guía del usuario de 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 másMostrar menos

3. En la carpeta batch-transcode, cree un archivo con una función de Lambda. Puede usar el siguiente ejemplo de Python y nombrar el archivoconvert.py.

   Operaciones por lotes de S3 envía datos específicos de tareas a una función de Lambda y requiere datos de resultados de vuelta. Para obtener ejemplos de solicitud y respuesta para la función de Lambda, información sobre códigos de respuesta y resultado, y ejemplos de funciones de Lambda para operaciones por lote de S3, consulte Invocar a la función 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 crear un paquete de implementación con convert.py y job.json como un archivo .zip llamado lambda.zip, en su terminal local, abra la carpeta batch-transcode que creó anteriormente y ejecute el comando siguiente.

   Para usuarios de macOS, ejecute el siguiente comando:

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

   Para usuarios de Windows, ejecute los siguientes comandos:

   powershell Compress-Archive convert.py lambda.zip

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

1. Abra la consola de AWS Lambda en https://console.aws.amazon.com/lambda/.

2. En el panel de navegación izquierdo, elija Instancias.

3. Elija Create function (Crear función).

4. Elija Author from scratch (Crear desde cero).

5. Bajo Basic information (Información básica), haga lo siguiente:

   1. En Function name (Nombre de la función), introduzca tutorial-lambda-convert.

   2. Para Runtime (Tiempo de ejecución), elija Python 3.8 o una versión posterior.

6. SeleccionarCambiar la función de ejecución predeterminadaEnRol de ejecución, elijaUso de una función existente.

7. En Existing role (Rol existente), elija el nombre del rol de IAM que creó para su función de Lambda en el Paso 3 (por ejemplo, tutorial-lambda-transcode-role).

8. Mantenga la configuración restante establecida en los valores predeterminados.

9. Elija Crear función.

1. En la sección Code source (Código fuente) de la página para la función de Lambda que creó anteriormente (por ejemplo, tutorial-lambda-convert), elija Upload from (Cargar desde) y luego, el archivo .zip.

2. Seleccione Upload (Cargar) para seleccionar el archivo .zip local.

3. Elija el archivo lambda.zip que creó anteriormente y luego, Open (Abrir).

4. Seleccione Guardar.

5. En la sección Runtime settings (Configuración de tiempo de ejecución), elija Edit (Editar).

6. Para indicarle al tiempo de ejecución de Lambda qué método de controlador en su código de función de Lambda invocar, ingrese convert.handler en el campo Handler (Controlador).

   ‎Al configurar una función en Python, el valor de la configuración del controlador es el nombre del archivo y el nombre de un módulo del controlador exportado, separados por un punto (.). Por ejemplo, convert.handler llama al método handler definido en convert.py.

7. Seleccione Guardar.

8. En la página de la función de Lambda, seleccione la opciónConfiguraciónPestaña. En el panel de navegación izquierdo de la pestaña Configuration (Configuración), elija Environment variables (Variables de entorno) y luego, Edit (Editar).

9. Elija Add environment variable (Añadir variable de entorno). Después ingrese la clave y el valor para cada una de las siguientes variables de entorno:

   • Clave: DestinationBucket Valor: amzn-s3-demo-destination-bucket1

     Este valor es el bucket de S3 para los archivos multimedia de salida que creó en el Paso 1.

   • Clave: MediaConvertRole Valor: arn:aws:iam::111122223333:role/tutorial-mediaconvert-role

     Este valor es el ARN del rol de IAM para MediaConvert que creó en el Paso 2. Asegúrese de reemplazar este ARN con el ARN real de su rol de IAM.

   • Clave: Application Valor: Batch-Transcoding

     Este valor es el nombre de la aplicación.

10. Seleccione Guardar.

11. (Opcional) En elConfiguración, en la pestañaConfiguración generalEn el panel de navegación izquierdo, elijaEditar. En el campo Timeout (Tiempo de espera), escriba 2 min 0 sec. A continuación, elija Save (Guardar).

    Timeout (Tiempo de espera): período durante el cual Lambda permite que se ejecute una función antes de pararla. El valor predeterminado es de 3 segundos. Los precios se basan en la cantidad de memoria configurada y en la cantidad de tiempo durante la que se ejecuta el código. Para más información, consulte Precios de AWS Lambda.

1. Inicie sesión AWS Management Console Management Console y abra la consola de Amazon S3 en https://console.aws.amazon.com/s3/.

2. En el panel de navegación izquierdo, elija Instancias.

3. Elija Crear bucket.

4. En Bucket name (Nombre de bucket), ingrese el nombre del bucket (por ejemplo, amzn-s3-demo-destination-bucket2).

5. En Región de AWS, elija la Región de AWS en la que desea que se encuentre el bucket.

   El bucket de destino del inventario debe estar en la misma Región de AWS que el bucket fuente en el que configura el inventario de S3. El bucket de destino del inventario puede estar en una Cuenta de AWS diferente.

6. En la configuración de Block Public Access para este bucket, mantenga la configuración predeterminada (la opción Block all public access [Bloquear todo el acceso público] está habilitada).

7. Mantenga la configuración restante establecida en los valores predeterminados.

8. Elija Crear bucket.

9. En la lista de Buckets, busque y seleccione el nombre del bucket de que creó anteriormente (por ejemplo: amzn-s3-demo-destination-bucket2).

10. Para otorgar permiso a Amazon S3 para escribir los datos de los informes de inventario en el bucket de destino de inventario de S3, elija la pestaña Permissions (Permisos).

11. Desplácese hacia abajo hasta la sección Bucket policy (Política de bucket) y luego, elija Edit (Editar). Se abre la página de la política de bucket.

12. Para otorgar permisos para el inventario de S3, en el campo Policy (Política), pegue la siguiente política de bucket.

    Reemplace los tres valores de ejemplo por los siguientes valores:

    • El nombre del bucket que ha creado para almacenar los informes de inventario (por ejemplo:amzn-s3-demo-destination-bucket2).

    • El nombre del bucket fuente que almacena los videos de entrada (por ejemplo, amzn-s3-demo-source-bucket).

    • El ID de la Cuenta de AWS que utilizó para crear el bucket fuente de video de S3 (por ejemplo, 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. Elija Guardar cambios.

1. Inicie sesión AWS Management Console Management Console y abra la consola de Amazon S3 en https://console.aws.amazon.com/s3/.

2. En el panel de navegación izquierdo, elija Instancias.

3. Para configurar un informe de inventario de S3 de los videos de entrada en el bucket fuente de S3, en la lista Buckets, elija el nombre del bucket fuente de S3 (por ejemplo, amzn-s3-demo-source-bucket).

4. Seleccione la pestaña Management.

5. Desplácese hasta la sección Inventory configurations (Configuraciones de inventario) y elija Create inventory configuration (Creación de la configuración de inventario).

6. ParaNombre de la configuración del inventario, escriba un nombre (por ejemplo:tutorial-inventory-config).

7. En Inventory scope (Alcance del inventario), elija Current version only (Versión actual solamente) para Object versions (Versiones de objetos) y mantenga la otra configuración de Inventory scope (Alcance del inventario) establecida en los valores predeterminados de este tutorial.

8. En la sección Report details (Datos del informe), para Destination bucket (Bucket de destino), elija This account (Esta cuenta).

9. Para Destination (Destino), elija Browse SE (Examinar S3) y el bucket de destino que creó anteriormente para guardar los informes de inventario (por ejemplo,amzn-s3-demo-destination-bucket2). Luego, elija Choose path (Elegir ruta).

   El bucket de destino del inventario debe estar en la misma Región de AWS que el bucket fuente en el que configura el inventario de S3. El bucket de destino del inventario puede estar en una Cuenta de AWS diferente.

   En el campo para bucket Destination (Destino) verá el permiso de bucket de destino que se agrega a la política de bucket de destino para permitir que Amazon S3 coloque datos en ese bucket. Para obtener más información, consulte Creación de una política de bucket de destino.

10. Para Frequency (Frecuencia), elija Daily (Diario).

11. Elija CSV para Output format (Formato de salida).

12. Para Status (Estado), elija Enabled (Habilitado).

13. En la sección Server-side encryption (Cifrado en el servidor), elija Disable (Deshabilitar) para este tutorial.

    Para obtener más información, consulte Configuración del inventario mediante la consola de S3 y Concesión de permiso a Amazon S3 con el fin de utilizar su clave administrada por el cliente para el cifrado.

14. En la sección Additional fields - optional (Campos adicionales: opcional), seleccione Size (Tamaño), Last modified (Última modificación) y Storage class (Clase de almacenamiento).

15. Seleccione Crear.

1. Inicie sesión AWS Management Console Management Console y abra la consola de Amazon S3 en https://console.aws.amazon.com/s3/.

2. En el panel de navegación izquierdo, elija Instancias.

3. En la lista Buckets, elija el nombre del bucket de código fuente de video (por ejemplo: amzn-s3-demo-source-bucket).

4. Elija Management (Administración).

5. Para ver si el informe de inventario de S3 está listo para crear un trabajo de operaciones por lote de S3 en el Paso 7, en Inventory configurations (Configuración del inventario), verifique si el botón Create job from manifest (Crear trabajo a partir del manifiesto) está habilitado.

   nota

   Se pueden tardar hasta 48 horas en entregar el primer informe. Si el archivo deCrear trabajo a partir del manifiestoestá desactivado, no se ha entregado el primer informe de inventario. Espere hasta que se entregue el primer informe de inventario y se habilite el botón Create job from manifest (Crear trabajo a partir del manifiesto) para crear un trabajo de operaciones por lote de S3 en el Paso 7.

6. Para verificar un informe de inventario de S3 (manifest.json), en la columna Destination (Destino), elija el nombre del bucket de destino de inventario que creó anteriormente para almacenar informes de inventario (por ejemplo, amzn-s3-demo-destination-bucket2).

7. En la pestaña Objects (Objetos), elija la carpeta existente con el nombre del bucket fuente de S3 (por ejemplo, amzn-s3-demo-source-bucket). Luego elija el nombre que ingresó en Inventory configuration name (Nombre de la configuración del inventario) cuando creó la configuración de inventario (por ejemplo, tutorial-inventory-config).

   Puede ver una lista de carpetas con las fechas de generación de los informes como sus nombres.

8. Para verificar el informe diario de inventario de S3 en una fecha, elija una carpeta con un nombre de fecha de generación y luego, elija manifest.json.

9. Para comprobar los detalles del informe de inventario en una fecha específica, en la página manifest.json, elija Descargar o Abrir.

1. Inicie sesión en AWS Management Console Management Console y abra la consola IAM en https://console.aws.amazon.com/iam/.

2. En el panel de navegación izquierdo, elija Policies (Políticas).

3. Elija Create Policy (Crear política).

4. Seleccione la pestaña JSON.

5. Copie la siguiente política de confianza en el campo de texto JSON.

   En la política JSON, sustituya los cuatro valores de ejemplo por los siguientes:

   • El nombre del bucket fuente que almacena los videos de entrada (por ejemplo, amzn-s3-demo-source-bucket).

   • El nombre del bucket de destino de inventario que ha creado en el Paso 5 para almacenar archivos manifest.json (por ejemplo: amzn-s3-demo-destination-bucket2).

   • El nombre del bucket que creó en el Paso 1 para almacenar archivos multimedia de salida (por ejemplo, amzn-s3-demo-destination-bucket1). En este tutorial, ponemos los informes de finalización de trabajos en el bucket de destino para los archivos de medios de salida.

   • El rol ARN de la función de Lambda que ha creado en el Paso 4. Para buscar y copiar el ARN de rol de la función de Lambda, haga lo siguiente:

     • En una nueva pestaña del navegador, abra la página Functions (Funciones) en la consola de Lambda en https://console.aws.amazon.com/lambda/home#/functions.

     • En la lista Functions (Funciones), elija el nombre de la función de Lambda que creó en el Paso 4 (por ejemplo, tutorial-lambda-convert).

     • Seleccionar 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. Elija Siguiente: Etiquetas.

7. Elija Siguiente: Revisar.

8. En el campo Name (Nombre), escriba tutorial-s3batch-policy.

9. Elija Crear política.

1. Inicie sesión en AWS Management Console Management Console y abra la consola IAM en https://console.aws.amazon.com/iam/.

2. En el panel de navegación izquierdo, elija Roles y luego, Create role (Crear rol).

3. Elija el tipo de rol de Servicio de AWS y luego, el servicio de S3.

4. En Select your use case (Seleccione su caso de uso), elija S3 Batch Operations (Operaciones por lotes de S3).

5. Elija Siguiente: permisos.

6. En Attach permissions policies (Adjuntar políticas de permisos), ingrese el nombre de la política de IAM que creó anteriormente (por ejemplo, tutorial-s3batch-policy) en el cuadro de búsqueda para filtrar la lista de políticas. Seleccione la casilla de verificación junto al nombre de la política (por ejemplo, tutorial-s3batch-policy).

7. Elija Siguiente: Etiquetas.

8. Elija Next: Review (Siguiente: revisar).

9. En Role name (Nombre del rol), introduzca tutorial-s3batch-role.

10. Elija Create role (Crear rol).

    Después de crear el rol de IAM para las operaciones por lote de S3, la siguiente política de confianza se adjunta automáticamente al rol. La política de confianza permite que la entidad del servicio de las operaciones por lote de S3 pueda asumir el rol de IAM.

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

1. Inicie sesión AWS Management Console Management Console y abra la consola de Amazon S3 en https://console.aws.amazon.com/s3/.

2. En el panel de navegación izquierdo, elija Batch Operations (Operaciones por lote).

3. Seleccione Crear trabajo.

4. Para Región de AWS, elija la región en la que desea crear el trabajo.

   En este tutorial, para utilizar el trabajo de operaciones por lote de S3 para invocar una función de Lambda, debe crear el trabajo en la misma región que el bucket fuente de video de S3 donde se encuentran los objetos a los que se hace referencia en el manifiesto.

5. En la sección Manifest (Manifiesto), haga lo siguiente:

   1. En Manifest format (Formato del manifiesto), elija S3 Inventory report (manifest.json) (Informe de S3 Inventory [manifest.json]).

   2. Para Manifest object (Objeto del manifiesto), elija Browse S3 (Examinar S3) a fin de encontrar el bucket que creó en el Paso 5para almacenar informes de inventario (por ejemplo, amzn-s3-demo-destination-bucket2). En la página Manifest object (Objeto del manifiesto), navegue por los nombres de los objetos hasta encontrar un archivo manifest.json para una fecha específica. Este archivo enumera la información sobre todos los videos que desea transcodificar por lotes. Cuando encuentre el archivo manifest.json que desea utilizar, elija el botón de opción situado junto a él. Luego, elija Choose path (Elegir ruta).

   3. (Opcional) Para Manifest object version ID - optional (ID de versión del objeto de manifiesto: opcional), ingrese el ID de versión del objeto de manifiesto si desea utilizar otra versión que no sea la más reciente.

6. Elija Siguiente.

7. Para utilizar la función de Lambda para transcodificar todos los objetos enumerados en el archivo manifest.json en Operation type (Tipo de operación), elija Invoke AWS Lambda function (Invocar función).

8. En la sección Invoke Lambda function (Invocar función de Lambda), haga lo siguiente:

   1. SeleccionarElija una de las funciones de su cuenta.

   2. Para Lambda function (Función de Lambda), elija la función de Lambda que creó en el Paso 4 (por ejemplo, tutorial-lambda-convert).

   3. Para Lambda function version (Versión de función de Lambda), conserve el valor predeterminado $LATEST.

9. Elija Siguiente. Se abre la página Configure additional options (Configurar opciones adicionales).

10. En Additional options (Opciones adicionales), conserve la configuración predeterminada.

    Para obtener más información sobre estas opciones, consulte Elementos de una solicitud de trabajo de Operaciones por lotes.

11. En la sección Completion report (Informe de finalización), para Path to completion report destination (Ruta al destino del informe de finalización), elija Browse S3 (Examinar S3). Busque el bucket que creó en el Paso 1 para los archivos multimedia de salida (por ejemplo, amzn-s3-demo-destination-bucket1). Elija el botón de opción junto al nombre de ese bucket. Luego, elija Choose path (Elegir ruta).

    Para la configuración restante Completion report (informe de finalización), mantenga los valores predeterminados. Para obtener más información sobre cómo configurar los informes, consulte Elementos de una solicitud de trabajo de Operaciones por lotes. Un informe de finalización mantiene un registro de los detalles del trabajo y las operaciones realizadas.

12. En la sección Permissions (Permisos), elija Choose from existing IAM roles (Elegir entre los roles de IAM existentes). Para Rol de IAM, elija el rol de IAM para el trabajo de Operaciones Batch de S3 que ha creado en el Paso 6 (por ejemplo: tutorial-s3batch-role).

13. Elija Siguiente.

14. En la página Review (Revisar), revise la configuración. Después elija Create job (Crear trabajo).

    Después de que S3 termina de leer el manifiesto del trabajo de operaciones por lote de S3, configura el estado del trabajo en Awaiting your confirmation to run (En espera de su confirmación para ejecutarse). Para ver las actualizaciones del estado del trabajo, actualice la página. No puede ejecutar el trabajo hasta que el estado sea Awaiting your confirmation to run (En espera de su confirmación para ejecutarse).

Para ejecutar el trabajo de operaciones Batch de S3

1. Inicie sesión AWS Management Console Management Console y abra la consola de Amazon S3 en https://console.aws.amazon.com/s3/.

2. En el panel de navegación izquierdo, elija Batch Operations (Operaciones por lote).

3. En la lista Jobs (Trabajos), elija la opción Job ID (ID de trabajo)del trabajo en la primera fila, que es el trabajo de operaciones por lote de S3 que creó anteriormente.

4. Elija Run job (Ejecutar trabajo).

5. Revise los parámetros de trabajo de nuevo y confirme que el valor deTotal de objetos enumerados en el manifiestoEs el mismo que el número de objetos en el manifiesto. Después elija Run job (Ejecutar trabajo).

   Se abrirá la página de trabajos de Operaciones Batch de S3.

6. Después de que el trabajo comience a ejecutarse, en la página de trabajo, enEstado, compruebe el progreso de su trabajo de Operaciones Batch de S3, comoEstado,% completo,Total correcto (tasa),Total fallado (tasa),Fecha de finalización, yMotivo de la terminación.

   Cuando finalice el trabajo de operaciones por lote de S3, vea los datos en la página de trabajo para confirmar que el trabajo se haya completado como se esperaba.

   Si más del 50 por ciento de las operaciones de objetos de un trabajo de operaciones por lote de S3 falla después de que se hayan intentado más de 1000 operaciones, el trabajo falla automáticamente. Para verificar el informe de finalización para identificar la causa de los errores, consulte el procedimiento opcional que aparece a continuación.

Para verificar el informe completo en busca de detalles acerca de los objetos con errores

1. En la página de su trabajo de operaciones por lote de S3, en la sección Completion report (Informe de finalización), elija el enlace de Completion report destination (Destino del informe de finalización).

   Se abre la página del bucket de destino de salida de S3.

2. En la pestaña Objects (Objetos), elija la carpeta que tiene un nombre que termina con el ID de trabajo del trabajo de operaciones por lote de S3 que creó anteriormente.

3. SeleccionarResultados/.

4. Seleccione la casilla de verificación situada junto al grupo de .csv.

5. Para ver el informe de trabajo, elija Open (Abrir) o Download (Descargar).

1. Abra la consola de AWS Lambda en https://console.aws.amazon.com/lambda/.

2. En el panel de navegación izquierdo, elija Instancias.

3. En la lista Functions (Funciones), elija el nombre de la función de Lambda que creó en el Paso 4 (por ejemplo, tutorial-lambda-convert).

4. Elija la pestaña Monitor (Monitorear).

5. En Metrics (Métricas), consulte las métricas de tiempo de ejecución de su función de Lambda.

6. En Logs (Registros), vea los datos de registro de cada invocación de Lambda a través de CloudWatch Logs Insights.

   nota

   Cuando se utiliza S3 Batch Operations con una función de Lambda, se invoca la función de Lambda en cada objeto. Si su trabajo de operaciones Batch de S3 es grande, puede invocar varias funciones de Lambda al mismo tiempo, causando un aumento en la concurrencia de Lambda.

   Cada Cuenta de AWS tiene una cuota de concurrencia de Lambda por región. Para obtener más información, consulte el escalado de funciones de AWS Lambda en la Guía para desarrolladores de AWS Lambda. Una práctica recomendada para usar funciones Lambda con Operaciones Batch de S3 es establecer un límite de concurrencia en la propia función de Lambda. Esto evita que su trabajo consuma la mayor parte de su concurrencia de Lambda y potencialmente limita otras funciones de su cuenta. Para obtener más información, consulte Managing Lambda reserved concurrency (Gestión de la simultaneidad reservada de Lambda) en la Guía para desarrolladores de AWS Lambda.

1. Inicie sesión en laAWS Management Consoley abra la consola de MediaConvert enhttps://console.aws.amazon.com/mediaconvert/.

2. Si aparece la página de introducción a MediaConvert, elija Get Started.

3. En la lista deTrabajos, vea cada fila para supervisar la tarea de transcodificación de cada video de entrada.

4. Identifique la fila de un trabajo que desea verificar y elija el enlace Job ID (ID de trabajo) para abrir la página de detalles del trabajo.

5. En la páginaResumen del Jobpágina, enSalidas, elija el enlace para la salida HLS, MP4 o Thumbnails, dependiendo de lo que admita su navegador, para ir al bucket de destino S3 para los archivos multimedia de salida.

6. En la carpeta correspondiente (HLS, MP4 o Thumbnails) del bucket de destino de salida S3, elija el nombre del objeto de archivo de medios de salida.

   Se abre la página de detalles del objeto.

7. En la página de objetos, en Object overview (Información general del objeto), elija el enlace de URL del objeto para ver el archivo multimedia de salida transcodificado.

Para verificar los archivos multimedia de salida desde el bucket de destino de S3

1. Inicie sesión AWS Management Console Management Console y abra la consola de Amazon S3 en https://console.aws.amazon.com/s3/.

2. En el panel de navegación izquierdo, elija Instancias.

3. En la lista Buckets, elija el nombre del bucket de destino de S3 para los archivos multimedia de salida que creó en el Paso 1 (por ejemplo, amzn-s3-demo-destination-bucket1).

4. En la páginaObjetos, cada video de entrada tiene una carpeta con el nombre del video de entrada. Cada carpeta contiene los archivos de medios de salida transcodificados para un video de entrada.

   Para comprobar los archivos de medios de salida en busca de un video de entrada, haga lo siguiente:

   1. Elija la carpeta con el nombre del video de entrada que desea verificar.

   2. Elija la carpeta Default/.

   3. Elija la carpeta para un formato transcodificado (HLS, MP4 o miniaturas en este tutorial).

   4. Elija el nombre del archivo de medios de salida.

   5. Para ver el archivo transcodificado, en la página de detalles del objeto, elija el enlace situado en Object URL (URL del objeto).

      Los archivos de medios de salida en formato HLS se dividen en segmentos cortos. Para reproducir estos videos, debe incrustar la URL del objeto del archivo .m3u8 en un reproductor compatible.

1. Inicie sesión AWS Management Console Management Console y abra la consola de Amazon S3 en https://console.aws.amazon.com/s3/.

2. En el panel de navegación izquierdo, elija Instancias.

3. En la lista Buckets, elija el nombre del bucket fuente (por ejemplo: amzn-s3-demo-source-bucket).

4. Seleccione la pestaña Management.

5. En la sección Inventory configurations (Configuración del inventario), elija la configuración de inventario que creó en el Paso 5 (por ejemplo, tutorial-inventory-config).

6. Elija Delete (Eliminar) y, a continuación, Confirm (Confirmar).

1. Abra la consola de AWS Lambda en https://console.aws.amazon.com/lambda/.

2. En el panel de navegación izquierdo, elija Instancias.

3. Seleccione la casilla de verificación junto a la función que creó en el Paso 4 (por ejemplo, tutorial-lambda-convert).

4. Elija Acciones y, a continuación, elija Eliminar.

5. En el cuadro de diálogo Eliminar función, elija Eliminar.

1. Abra la consola de CloudWatch en https://console.aws.amazon.com/cloudwatch/.

2. En el panel de navegación izquierdo, elija Logs (Registros) y luego, Log groups (Grupos de registros).

3. Seleccione la casilla de verificación junto al grupo de registros que tiene un nombre que termina con la función de Lambda que ha creó en el Paso 4 (por ejemplo, tutorial-lambda-convert).

4. Elija Actions (Acciones) y, a continuación, elija Delete log group (Eliminar grupo de registro).

5. En el cuadro de diálogo Delete log group(s), Eliminar grupo(s) de registro(s) elija Delete (Eliminar).

1. Inicie sesión en AWS Management Console Management Console y abra la consola IAM en https://console.aws.amazon.com/iam/.

2. En el panel de navegación izquierdo, elija Roles y luego, seleccione las casillas de verificación junto a los nombres de rol que desee eliminar.

3. En la parte superior de la página, elija Delete (Eliminar).

4. En el cuadro de diálogo de confirmación, escriba la respuesta necesaria en el campo de entrada de texto basado en la solicitud de datos y elija Eliminar.

1. Inicie sesión en AWS Management Console Management Console y abra la consola IAM en https://console.aws.amazon.com/iam/.

2. En el panel de navegación izquierdo, elija Policies (Políticas).

3. Elija el botón de opción situado junto a la política que creó en el Paso 6 (por ejemplo, tutorial-s3batch-policy). Puede utilizar el cuadro de búsqueda para filtrar la lista de políticas.

4. Elija Acciones y, a continuación, elija Eliminar.

5. Confirme que desea eliminar esta política; para ello, ingrese su nombre en el campo de texto y elija Delete (Eliminar).

1. Inicie sesión AWS Management Console Management Console y abra la consola de Amazon S3 en https://console.aws.amazon.com/s3/.

2. En el panel de navegación izquierdo, elija Instancias.

3. En la lista Buckets, elija el botón de opción del bucket junto al nombre del bucket que desea vaciar y luego, Empty (Vaciar).

4. En la página Empty bucket (Vaciar bucket), confirme que desea vaciar el bucket; para ello, ingrese permanently delete en el campo de texto y luego, elija Empty (Vaciar).

1. Inicie sesión AWS Management Console Management Console y abra la consola de Amazon S3 en https://console.aws.amazon.com/s3/.

2. En el panel de navegación izquierdo, elija Instancias.

3. En la lista Buckets, elija el botón de opción junto al nombre del bucket que desea eliminar.

4. Elija Eliminar.

5. En la página Delete bucket (Eliminar bucket) confirme que desea eliminar el bucket introduciendo el nombre del bucket en el campo de texto y, a continuación, elija Delete bucket (Eliminar bucket).