Tutorial: videos de transcodificación por lotes con operaciones por lotes de S3, AWS Lambda, y AWS Elemental MediaConvert - 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 videoPaso 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: limpiarSiguientes pasos

Tutorial: videos de transcodificación por lotes con operaciones por lotes de S3, AWS Lambda, y AWS Elemental MediaConvert

Los usuarios de video 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 videos 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 videos que se deben convertir.

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

  • Ingesta videos de entrada

  • Procesa los videos 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 video extensos y almacenados en Amazon S3, puede transcodificar estos videos desde sus formatos fuente a varios tipos de archivo en el tamaño, la resolución o el formato necesarios para un reproductor de video o dispositivo en particular. En concreto, Operaciones por lotes de S3 le proporciona una solución para invocar funciones de AWS Lambda para los videos 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 videos almacenados en un bucket fuente de S3. La función de Lambda llama a MediaConvert para transcodificar los videos. Las salidas para cada video 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 reproducción en dispositivos de varios tamaños y anchos de banda variables

  • Un archivo de video 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, tutorial-bucket-1) con videos 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.

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 Crear un bucket.

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

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 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, tutorial-bucket-2).

  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 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, tutorial-bucket-2).

  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 Configuración de CORS.

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

    }
]

  7. Elija 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 videos 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 videos. 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, 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).

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

Paso 4: Cree una función de Lambda para la transcodificación de video

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 videos 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 video del bucket fuente de S3. A continuación, la función de Lambda envía un trabajo de transcodificación para cada video 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 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['DestinationBucket'],
                    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 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.

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 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: tutorial-bucket-2

      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.

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 videos. En primer lugar, necesita una lista de los objetos de video 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 video de entrada, puede generar un informe de inventario de S3 para su bucket fuente de S3 (por ejemplo, tutorial-bucket-1).

Cree y configure un bucket para los informes de inventario de S3 de videos 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 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, tutorial-bucket-3).

  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: tutorial-bucket-3).

  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:tutorial-bucket-3).

    • El nombre del bucket fuente que almacena los videos de entrada (por ejemplo, tutorial-bucket-1).

    • 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:::tutorial-bucket-3/*"],
      "Condition": {
          "ArnLike": {
              "aws:SourceArn": "arn:aws:s3:::tutorial-bucket-1"
           },
         "StringEquals": {
             "aws:SourceAccount": "111122223333",
             "s3:x-amz-acl": "bucket-owner-full-control"
          }
       }
    }
  ]
}

  13. Elija Guardar cambios.

Configuración del inventario de Amazon S3 para un bucket fuente de video de S3

Debe configurar el inventario de S3 para generar una lista de archivos planos de objetos de video y metadatos para su bucket fuente de video 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 video del bucket fuente 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. 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, tutorial-bucket-1).

  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,tutorial-bucket-3). 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 video 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 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: tutorial-bucket-1).

  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, tutorial-bucket-3).

  7. En la pestaña Objects (Objetos), elija la carpeta existente con el nombre del bucket fuente de S3 (por ejemplo, tutorial-bucket-1). 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.

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 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, tutorial-bucket-1).

    • El nombre del bucket de destino de inventario que ha creado en el Paso 5 para almacenar archivos manifest.json (por ejemplo: tutorial-bucket-3).

    • El nombre del bucket que creó en el Paso 1 para almacenar archivos multimedia de salida (por ejemplo, tutorial-bucket-2). 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:::tutorial-bucket-1/*",
                "arn:aws:s3:::tutorial-bucket-3/*"
            ]
        },
        {
            "Sid": "S3PutJobCompletionReport",
            "Effect": "Allow",
            "Action": "s3:PutObject",
            "Resource": "arn:aws:s3:::tutorial-bucket-2/*"
        },
        {
            "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.

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

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 videos de entrada en el bucket fuente de S3, debe especificar parámetros para este trabajo concreto.

nota

Para comenzar a crear un trabajo de operacones por lote de S3, debe asegurarse de que el botón Create job from manifest (Crear trabajo a partir del manifiesto) está habilitado. Para obtener más información, consulte Verifique el informe de inventario para su bucket fuente de video 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 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, tutorial-bucket-3). 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, tutorial-bucket-2). 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).

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

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

(Opcional) Supervisar cada invocación de Lambda en la consola 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 video 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 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.

(Opcional) Supervise cada trabajo de transcodificación de video 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 video, cada invocación de Lambda crea un trabajo de transcodificación de MediaConvert para cada video 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 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.

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 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, tutorial-bucket-2).

  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.

Paso 9: limpiar

Si transcodificó videos 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 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: tutorial-bucket-1).

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

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

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

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

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

Vacíe los buckets de S3

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

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

Eliminación del bucket de S3

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

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

Siguientes pasos

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