Tutorial: vídeos de transcodificación por lotes con Operaciones por lotes de S3 - Amazon Simple Storage Service
Requisitos previos Paso 1: Cree un bucket de S3 para los archivos multimediaPaso 2: crear un rol de IAM para MediaConvertPaso 3: crear un rol de IAM para su función de Lambda.Paso 4: Cree una función de Lambda para la transcodificación de vídeoPaso 5: Configure un inventario de Amazon S3 para un bucket fuente de S3Paso 6: creación de un rol de IAM para Operaciones por Batch de S3Paso 7: configurar y ejecutar el trabajo de la herramienta de operaciones por lotes de S3Paso 8: Compruebe los archivos multimedia de salida desde su bucket de destino S3Paso 9: limpiarPasos a seguir a continuación

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

Los usuarios de vídeo utilizan dispositivos de todas las formas, tamaños y cosechas para disfrutar del contenido multimedia. Esto supone un desafío para los creadores de contenido y distribuidores. En lugar de tener un formato de tamaño único, los vídeos deben abarcar una amplia gama de tamaños, formatos y velocidades de bits. Esta tarea de conversión es aún más desafiante cuando se cuenta con una gran cantidad de vídeos que se deben convertir.

AWS ofrece un método para crear una arquitectura distribuida y escalable que hace lo siguiente:

  • Ingesta vídeos de entrada

  • Procesa los vídeos para reproducirlos en una amplia gama de dispositivos

  • Almacena los archivos multimedia transcodificados

  • Entrega los archivos multimedia de salida para satisfacer la demanda

Cuando tiene repositorios de vídeo extensos y almacenados en Amazon S3, puede transcodificar estos vídeos desde sus formatos fuente a varios tipos de archivo en el tamaño, la resolución o el formato necesarios para un reproductor de vídeo o dispositivo en particular. En concreto, Operaciones por lotes de S3 le proporciona una solución para invocar funciones de AWS Lambda para los vídeos de entrada existentes en un bucket fuente S3. A continuación, las funciones de Lambda llaman a AWS Elemental MediaConvert para realizar tareas de transcodificación de vídeo a gran escala. Los archivos multimedia de salida convertidos se almacenan en un bucket de destino de S3.

Un diagrama de flujo de trabajo de transcodificación por lotes.
Objetivo

En este tutorial, aprenderá a configurar operaciones por lotes de S3 para invocar una función de Lambda para la transcodificación por lotes de vídeos almacenados en un bucket fuente de S3. La función de Lambda llama a MediaConvert para transcodificar los vídeos. Las salidas para cada vídeo en el bucket fuente de S3 son las que se muestran a continuación:

  • Una transmisión de velocidad de bits adaptable HTTP Live Streaming (HLS) para la replicación en dispositivos de varios tamaños y anchos de banda variables

  • Un archivo de vídeo MP4

  • Imágenes en miniatura recopiladas a intervalos

Requisitos previos

Antes de comenzar este tutorial, necesita tener un bucket fuente de Amazon S3 (por ejemplo, amzn-s3-demo-source-bucket) con vídeos que se transcodificarán ya almacenados en él.

Si lo desea, puede darle otro nombre al bucket. Para obtener más información acerca de los nombres de bucket de Amazon S3, consulte Reglas de nomenclatura de buckets de uso general.

Para el bucket fuente de S3, mantenga la configuración relacionada con la configuración del bloqueo del acceso público para este bucket establecida en los valores predeterminados (la opción de bloqueo de todo el acceso público está habilitada). Para obtener más información, consulte Creación de un bucket de uso general.

Si quiere obtener más información para cargar vídeos en el bucket fuente de S3, consulte Carga de objetos. Cuando carga muchos vídeos grandes a S3, también puede usar Aceleración de transferencias de Amazon S3 para configurar transferencias de archivos rápidas y seguras. Aceleración de transferencias puede acelerar la carga de vídeo en su bucket de S3 para transferir a larga distancia vídeos más grandes. Para obtener más información, consulte Configuración de transferencias de archivos rápidas y seguras con Aceleración de transferencias de Amazon S3.

Paso 1: Cree un bucket de S3 para los archivos multimedia

En este paso, creará un bucket de destino de S3 para almacenar archivos multimedia de salida convertidos. También se crea una configuración de uso compartido de recursos fuente cruzado (CORS) para permitir el acceso fuente cruzado a los archivos multimedia transcodificados almacenados en el bucket de destino de S3.

Cree un bucket para los archivos multimedia de salida

  1. Inicie sesión en la AWS 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 Buckets.

  3. Elija Crear bucket.

  4. En Nombre del 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.

Agregar una configuración CORS a un bucket de salida de S3

La configuración JSON CORS define una manera para que las aplicaciones web cliente (reproductores de vídeo 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 en la AWS 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 Buckets.

  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 Compartir recursos entre orígenes (CORS), elija 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. Seleccione Save changes (Guardar cambios).

Paso 2: crear un rol de IAM para MediaConvert

Para utilizar AWS Elemental MediaConvert para transcodificar los vídeos de entrada almacenados en el bucket de S3, debe tener un rol de servicio de AWS Identity and Access Management (IAM) para otorgar permisos a MediaConvert para leer y escribir archivos de vídeo desde los buckets de origen y de destino de S3. Cuando ejecuta trabajos de transcodificación, la consola de MediaConvert utiliza este rol.

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.

Paso 3: crear un rol de IAM para su función de Lambda.

Para transcodificar vídeos por lotes con MediaConvert y operaciones por lotes de S3, necesita tener una función de Lambda para conectar estos dos servicios a fin de convertir vídeos. Esta función de Lambda necesita tener un rol de IAM que le otorgue permisos para acceder a MediaConvert y a las operaciones por lotes de S3.

Cree un rol de IAM para su función de Lambda

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

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

  3. Elija el tipo de rol del servicio de AWS y luego, en Casos de uso comunes, elija 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.

  7. En Nombre del rol, ingrese tutorial-lambda-transcode-role.

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

  9. Elija Create role (Crear rol).

Incruste una política en línea para el rol de IAM de su función de Lambda

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, elija 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. Elija 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.

Paso 4: Cree una función de Lambda para la transcodificación de vídeo

En esta sección del tutorial, crea una función de Lambda con el SDK para Python a fin de integrarse con las operaciones por lote de S3 y MediaConvert. Para comenzar a transcodificar los vídeos ya almacenados en el bucket fuente de S3, debe ejecutar un trabajo de operaciones por lote de S3 que invoca directamente la función de Lambda para cada vídeo del bucket fuente de S3. A continuación, la función de Lambda envía un trabajo de transcodificación para cada vídeo a MediaConvert.

Escriba el código de la función de Lambda y cree un paquete de implementación

  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 vídeos 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 vídeo en el bucket fuente de S3:

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

    • Un archivo de vídeo 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 (QVBR) para optimizar la calidad del vídeo. La salida HLS es compatible con Apple (audio sin mezcla de vídeo, duración de segmento adecuada de 6 segundos y calidad de vídeo 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 vídeo y audio similares. Cree automatizaciones separadas (única configuración de job.json) para cualquier archivo de entrada con diferentes configuraciones de vídeo 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

Crear una función de Lambda con un rol de ejecución (consola)

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

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

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

  4. Elija Crear desde cero.

  5. Bajo Información básica, haga lo siguiente:

    1. En Nombre de la función, introduzca tutorial-lambda-convert.

    2. En Tiempo de ejecución, seleccione Python 3.12.

  6. Elija Cambiar el rol de ejecución predeterminado y, en Rol de ejecución, elija Usar un rol 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. Seleccione Creación de función.

Implemente su función de Lambda con archivos.zip y configure la función de Lambda (consola)

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

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

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

  11. (Opcional) En la pestaña Configuración, en la sección Configuración general del panel de navegación izquierdo, elija Editar. En el campo Tiempo de espera, escriba 2 min 0 s. A continuación, elija Guardar.

    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.

Paso 5: Configure un inventario de Amazon S3 para un bucket fuente de S3

Después de configurar la función de Lambda de transcodificación, cree un trabajo de operaciones por lote de S3 para transcodificar un conjunto de vídeos. En primer lugar, necesita una lista de los objetos de vídeo de entrada en los que quiere que Operaciones Batch de S3 ejecute la acción de transcodificación especificada. Para obtener una lista de objetos de vídeo de entrada, puede generar un informe de inventario de S3 para su bucket fuente de S3 (por ejemplo, amzn-s3-demo-source-bucket).

Cree y configure un bucket para los informes de inventario de S3 de vídeos de entrada

Para almacenar informes de inventario de S3 que muestran los objetos del bucket fuente de S3, debe crear un bucket de destino de inventario de S3 y configurar una política de bucket para que el bucket escriba archivos de inventario en el bucket fuente de S3.

  1. Inicie sesión en la AWS 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 Buckets.

  3. Elija Crear bucket.

  4. En Nombre del 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 Política de bucket y luego elija Editar. Se abre la página de la política de bucket.

  12. Para otorgar permisos para el inventario de S3, en el campo 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 vídeos de entrada (por ejemplo, amzn-s3-demo-source-bucket).

    • El ID de la Cuenta de AWS que utilizó para crear el bucket fuente de vídeo 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. Seleccione Save changes (Guardar cambios).

Configuración del inventario de Amazon S3 para un bucket fuente de vídeo de S3

Debe configurar el inventario de S3 para generar una lista de archivos planos de objetos de vídeo y metadatos para su bucket fuente de vídeo S3. Estos informes programados de inventario pueden incluir todos los objetos del bucket u objetos agrupados por un prefijo compartido. En este tutorial, el informe de inventario de S3 incluye todos los objetos de vídeo del bucket fuente de S3.

  1. Inicie sesión en la AWS 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 Buckets.

  3. Para configurar un informe de inventario de S3 de los vídeos 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 Administración.

  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.

Para obtener más información, consulte Configuración del inventario mediante la consola de S3.

Verifique el informe de inventario para su bucket fuente de vídeo de S3

Cuando se publica un informe de inventario, los archivos de manifiesto se envían al bucket de destino del inventario de S3.

  1. Inicie sesión en la AWS 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 Buckets.

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

  4. Elija 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 Configuración del inventario, verifique si el botón 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 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 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 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.

Paso 6: creación de un rol de IAM para Operaciones por Batch de S3

Para utilizar operaciones por lote de S3 para realizar la transcodificación por lote, primero debe crear un rol de IAM a fin de otorgar permisos a Amazon S3 para realizar operaciones por lote de S3.

Creación de una política de IAM para Operaciones Batch de S3

Debe crear una política de IAM que otorgue permiso a las operaciones por lote de S3 para leer el manifiesto de entrada, invocar a la función de Lambda y escribir el informe de finalización de trabajos de operaciones por lote de S3.

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

  2. En el panel de navegación izquierdo, elija 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 vídeos 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: 

    {
    "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. Seleccione Crear política.

Cree un rol de IAM y asigne permisos de Operaciones por lotes de S3 para su ejecución.

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

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

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

  4. En Seleccione su caso de uso, elija Operaciones por lotes de S3.

  5. Elija Siguiente.

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

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

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

Paso 7: configurar y ejecutar el trabajo de la herramienta de operaciones por lotes de S3

Para crear un trabajo de operaciones por lote de S3 a fin de procesar los vídeos de entrada en el bucket fuente de S3, debe especificar parámetros para este trabajo concreto.

nota

Para comenzar a crear un trabajo de operaciones por lote de S3, debe asegurarse de que el botón Crear trabajo a partir de manifiesto está habilitado. Para obtener más información, consulte Verifique el informe de inventario para su bucket fuente de vídeo de S3. Si el botón Create job from manifest (Crear trabajo a partir del manifiesto) está desactivado, el primer informe de inventario no se entrega y tiene que esperar hasta que el botón se habilite. Después de configurar el inventario de Amazon S3 para el bucket fuente de S3 en el Paso 5, puede tardar hasta 48 horas en entregar el primer informe de inventario.

Creación de un trabajo de Operaciones por lotes de S3

  1. Inicie sesión en la AWS 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 Operaciones por lotes.

  3. Seleccione Crear tarea.

  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 vídeo 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 Objeto de manifiesto, elija 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 Objeto de 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 vídeos 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 Elegir ruta.

    3. (Opcional) Para 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 Tipo de operación, elija Invocar función de AWS Lambda.

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

    1. SeleccionarElija una de las funciones de su cuenta.

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

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

  9. Elija Siguiente. Se abre la página Configurar opciones adicionales.

  10. En 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 Informe de finalización, en Ruta al destino del informe de finalización, elija 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 Elegir ruta.

    Para la configuración restante 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 Permisos, elija 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 Revisar, revise la configuración. Después elija 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 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 En espera de su confirmación para ejecutarse.

Ejecute el trabajo de Operaciones Batch de S3 para invocar a su función de Lambda

Ejecute su trabajo de operaciones Batch para invocar su función de Lambda para la transcodificación de vídeo. Si el trabajo falla, puede verifica el informe de finalización para identificar la causa.

Para ejecutar el trabajo de operaciones Batch de S3

  1. Inicie sesión en la AWS 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 Operaciones por lotes.

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

  4. Elija 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 Ejecutar trabajo.

    Se abrirá la página de trabajos de Operaciones por lotes de S3.

  6. Después de que el trabajo comience a ejecutarse, en la página de trabajo, en Estado, compruebe el progreso de su trabajo de Operaciones por lotes de S3, como Estado, % completo, Total correcto (tasa), Total fallado (tasa),Fecha de finalización, y Motivo 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.

(Opcional) Verificación del informe de finalización

Puede utilizar el informe de finalización para determinar qué objetos han fallado y la causa de los errores.

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 Informe de finalización, elija el enlace de Destino del informe de finalización.

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

  2. En la pestaña 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 Abrir o Descargar.

(Opcional) Supervisar cada invocación de Lambda en la consola de Lambda

Después de que el trabajo de operaciones por lote de S3 comienza a ejecutarse, el trabajo invoca la función de Lambda para cada objeto de vídeo de entrada. S3 escribe registros de cada invocación de Lambda en CloudWatch Logs. Puede utilizar el panel de monitoreo de la consola de Lambda para monitorear sus funciones y aplicaciones de Lambda.

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

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

  3. En la lista 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 Supervisar.

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

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

    nota

    Cuando se utiliza Operaciones por lotes de S3 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.

(Opcional) Supervise cada trabajo de transcodificación de vídeo de MediaConvert en la consola de MediaConvert

Una tarea de MediaConvert se encarga de transcodificar un archivo multimedia. Cuando su trabajo de operaciones por lote de S3 invoca la función de Lambda para cada vídeo, cada invocación de Lambda crea un trabajo de transcodificación de MediaConvert para cada vídeo de entrada.

  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 vídeo 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.

Paso 8: Compruebe los archivos multimedia de salida desde su bucket de destino S3

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

  1. Inicie sesión en la AWS 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 Buckets.

  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ágina Objetos, cada vídeo de entrada tiene una carpeta con el nombre del vídeo de entrada. Cada carpeta contiene los archivos de medios de salida transcodificados para un vídeo de entrada.

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

    1. Elija la carpeta con el nombre del vídeo 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 URL del objeto.

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

Paso 9: limpiar

Si transcodificó vídeos con Operaciones por lotes de S3, Lambda y MediaConvert solo como ejercicio de aprendizaje, elimine los recursos AWS que asignó para que ya no acumule cargos.

Elimine la configuración del inventario de S3 para el bucket de código fuente de S3

  1. Inicie sesión en la AWS 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 Buckets.

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

  4. Seleccione la pestaña Administración.

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

  6. Elija Eliminar y, a continuación, Confirmar.

Elimine la función de Lambda

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

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

  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.

Eliminación del grupo de registros de CloudWatch

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

  2. En el panel de navegación izquierdo, elija Registros y luego 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 Acciones y, a continuación, elija Eliminar grupo de registros.

  5. En el cuadro de diálogo Eliminar grupos de registros, elija Eliminar.

Eliminar los roles de IAM junto con las directivas en línea para los roles de IAM

Para eliminar los roles de IAM que creó en el Paso 2, Paso 3, y Paso 6, realice una de las siguientes opciones:

  1. Inicie sesión en la AWS Management Console y abra la consola de 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 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.

Elimine la política de IAM administrada por el cliente

Para eliminar la política de IAM administrada por el cliente que creó en el Paso 6, realice lo siguiente:

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

  2. En el panel de navegación izquierdo, elija 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 Eliminar.

Vacíe los buckets de S3

Para vaciar los buckets de S3 que creó en Requisitos previos, Paso 1 y Paso 5, realice lo siguiente:

  1. Inicie sesión en la AWS 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 Buckets.

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

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

Eliminación del bucket de S3

Para eliminar los buckets de S3 que creó en Requisitos previos, Paso 1 y Paso 5, realice lo siguiente:

  1. Inicie sesión en la AWS 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 Buckets.

  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 Eliminar bucket, confirme que desea eliminar el bucket introduciendo el nombre del bucket en el campo de texto y, a continuación, elija Eliminar bucket.

Pasos a seguir a continuación

Después de completar este tutorial, puede explorar más a fondo otros casos de uso relevantes: