先决条件步骤 1：为输出媒体文件创建 S3 存储桶步骤 2：为 MediaConvert 创建 IAM 角色步骤 3：为您的 Lambda 函数创建 IAM 角色步骤 4：创建 Lambda 函数以进行视频转码步骤 5：为 S3 源存储桶配置 Amazon S3 清单步骤 6：为 S3 批量操作创建 IAM 角色步骤 7：设置并运行 S3 批量操作任务步骤 8：检查 S3 目标存储桶中的输出媒体文件步骤 9：清除后续步骤

教程：使用 S3 批量操作对视频进行批量转码

视频消费者使用各种形状、尺寸和年份的设备来享受媒体内容。这种广泛的设备类型给内容创作者和转发者带来了挑战。视频不是一刀切的格式，而是必须进行转换，以便涵盖各种尺寸、格式和比特率。如果大量必须转换的视频，这一转换任务就更具挑战性。

AWS 为您提供了构建可扩展的分布式架构的方法，该架构可执行以下操作：

摄取输入视频
处理视频以便在各种设备上播放
存储转码的媒体文件
交付输出媒体文件以满足需求

如果在 Amazon S3 中存储了大量的视频存储库，您可以将这些视频从源格式转换为多种文件类型，按照特定视频播放器或设备所需的大小、分辨率和格式转换为多种文件类型。具体来说，S3 批量操作为您提供了一个可以为 S3 源存储桶中的现有输入视频调用 AWS Lambda 函数的解决方案。然后，Lambda 函数调用 AWS Elemental MediaConvert 来执行大规模视频转码任务。转换后的输出媒体文件存储在 S3 目标存储桶中。

目标

在本教程中，您将了解如何将 S3 批量操作设置为调用 Lambda 函数对存储在 S3 源存储桶中的视频进行批量转码。Lambda 函数调用 MediaConvert 转码视频。S3 源存储桶中每个视频的输出如下所示：

HTTP 实时流 (HLS) 自适应比特率流，用于在多个大小的设备和不同的带宽上播放。
MP4 视频文件
按间隔收集的缩略图图像

先决条件

在开始本教程之前，您必须有储存要转码视频的 Amazon S3 源存储桶（例如，amzn-s3-demo-source-bucket）。

如果愿意，您可以重新命名存储桶。有关 Amazon S3 存储桶名称的更多信息，请参阅存储桶命名规则。

对于 S3 源存储桶，请保留阻止此存储桶的公有访问设置为默认值（已启用阻止全部公共访问）。有关更多信息，请参阅创建桶。

有关将视频上传到 S3 源存储桶的详细信息，请参阅上传对象。如果将许多大型视频文件上传到 S3 时，您还可以使用 Amazon S3 Transfer Acceleration 配置快速安全的文件传输。Transfer Acceleration 可以加快视频上传到 S3 存储桶的速度，以便远距离传输较大的视频。有关更多信息，请参阅使用 Amazon S3 Transfer Acceleration 配置快速、安全的文件传输。

步骤 1：为输出媒体文件创建 S3 存储桶

在此步骤中，您将创建一个 S3 目标存储桶来存储转换后的输出媒体文件。您还可以创建跨源资源共享（CORS）配置，允许跨源访问存储在 S3 目标存储桶中的转码媒体文件。

分步

为输出媒体文件创建存储桶。
将 CORS 配置添加到 S3 输出存储桶

为输出媒体文件创建存储桶。

登录到AWS Management Console，然后通过以下网址打开 Amazon S3 控制台：https://console.aws.amazon.com/s3/。
在左侧导航窗格中，选择存储桶。
选择创建存储桶。
对于 Bucket Name（存储桶名称），输入您的存储桶的名称（例如 amzn-s3-demo-destination-bucket1）。
对于 Region（区域），选择要放置桶的位置 AWS 区域。
要确保公众访问输出媒体文件，请在阻止此存储桶的公有访问设置，清除阻止全部公有访问权限。

警告
在完成此步骤之前，请查看阻止对您的 Amazon S3 存储的公有访问，以确保您了解并接受允许进行公有访问所涉及的风险。当您关闭屏蔽公共访问权限设置以使您的存储桶变为公有时，Internet 上的任何人都可以访问您的存储桶。我们建议您阻止对存储桶的所有公有访问。
如果您不想清除“屏蔽公共访问权限”设置，可以使用 Amazon CloudFront 将转码的媒体文件传送给查看者（最终用户）。有关更多信息，请参阅教程：使用 Amazon S3、Amazon CloudFront 和 Amazon Route 53 托管点播流视频。
选择旁边的复选框，我确认当前设置可能会导致此存储桶及其中的对象变为公有。
对于其余设置，保留默认值。
选择 Create bucket（创建存储桶）。

将 CORS 配置添加到 S3 输出存储桶

JSON CORS 配置定义了在一个域中加载的客户端 Web 应用程序（此处上下文的视频播放器）在另一个域中播放转码后的输出媒体文件的方式。

登录到AWS Management Console，然后通过以下网址打开 Amazon S3 控制台：https://console.aws.amazon.com/s3/。
在左侧导航窗格中，选择 Buckets（存储桶）。
在 Buckets（存储桶）列表中，选择之前创建的存储桶名称（例如，amzn-s3-demo-destination-bucket1）。
选择 Permissions (权限) 选项卡。
在 Cross-origin resource sharing（CORS）（跨源资源共享（CORS））部分中，请选择 Edit（编辑）。
在 CORS 配置文本框中，复制并粘贴如下的 CORS 配置。

CORS 配置必须采用 JSON 格式。在此示例中，AllowedOrigins 属性使用通配符 (*) 来指定所有来源。如果您知道您的特定来源，则可以限制 AllowedOrigins 属性添加到您的特定播放器 URL。有关配置此属性和其他属性的更多信息，请参阅 CORS 配置的元素。
```
[
    {
        "AllowedOrigins": [
            "*"
        ],
        "AllowedMethods": [
            "GET"
        ],
        "AllowedHeaders": [
            "*"
        ],
        "ExposeHeaders": []

    }
]                                          
```
选择 Save changes (保存更改)。

步骤 2：为 MediaConvert 创建 IAM 角色

为了使用 AWS Elemental MediaConvert 转码存储在 S3 存储桶中的输入视频，您必须有一个 AWS Identity and Access Management（IAM）服务角色以授予 MediaConvert 权限，以便从 S3 源存储桶读取视频文件以及向 S3 目标存储桶写入视频文件。当您运行转码任务时，MediaConvert 控制台会使用此角色。

为 MediaConvert 创建 IAM 角色

使用您选择的角色名称创建 IAM 角色（例如，tutorial-mediaconvert-role)。要创建此角色，请按照《AWS Elemental MediaConvert 用户指南》的在 IAM（控制台）中创建您的 MediaConvert 角色中的步骤操作。
为 MediaConvert 创建 IAM 角色之后，请在 Role (角色)列表中选择您为 MediaConvert 创建的角色的名称（例如，tutorial-mediaconvert-role)。
在 Summary (摘要) 页面上，复制 Role ARN (角色 ARN) (从 arn:aws:iam:: 开始) 并保存 ARN 以供稍后使用。

有关 ARN 的更多信息，请参阅 AWS 一般参考中的 Amazon Resource Name (ARN)。

步骤 3：为您的 Lambda 函数创建 IAM 角色

要使用 MediaConvert 和 S3 Batch 操作批量转码视频，您可使用 Lambda 函数来连接这两个服务来转换视频。此 Lambda 函数必须具有一个 IAM 角色，该角色可授予 Lambda 函数访问 MediaConvert 和 S3 Batch Operations 的权限。

分步

为 Lambda 函数创建 IAM 角色
为 Lambda 函数的 IAM 角色嵌入内联策略

为 Lambda 函数创建 IAM 角色

登录 AWS Management Console，然后通过以下网址打开 IAM 控制台：https://console.aws.amazon.com/iam/。
在左侧导航窗格中，选择角色，然后选择创建角色。
选择 AWS 服务角色类型，然后在 Common use cases (常见用例)中，选择 Lambda。
选择 Next: Permissions (下一步: 权限)。
在 Attach permissions policies (附加权限策略) 页的 Filter policies (筛选策略) 框中输入 AWSLambdaBasicExecutionRole。若要附加托管策略 AWSLambdaBasicExecutionRole 至此角色，以向 Amazon CloudWatch Logs 授予写入权限，则应选中 AWSLambdaBasicExecutionRole 旁边的复选框。
选择 Next: Tags (下一步：标签)。
（可选）将标签添加到托管策略。
选择 Next: Review (下一步：审核)。
对于 Role name（角色名称），输入 tutorial-lambda-transcode-role。
选择 Create role (创建角色)。

为 Lambda 函数的 IAM 角色嵌入内联策略

您必须使用内联策略，方可向 Lambda 函数执行所需的 MediaConvert 资源授予权限。

登录 AWS Management Console，然后通过以下网址打开 IAM 控制台：https://console.aws.amazon.com/iam/。
在左侧导航窗格中，选择 Roles（角色）。
在 Roles (角色) 列表中，选择您在前面为 Lambda 函数创建的 IAM 角色的名称（例如，tutorial-lambda-transcode-role）。
选择 Permissions (权限) 选项卡。
选择 Add inline policy (添加内联策略)。

选择 JSON 选项卡，然后复制并粘贴以下 JSON 策略。

将在 JSON 策略中的示例 ARN 值 Resource 替换为您在步骤 2中为 MediaConvert 创建的 IAM 角色的角色 ARN（例如，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"
        }
    ]
}

选择 Review Policy (查看策略)。
对于 Name (名称)，请输入 tutorial-lambda-policy。
选择 Create Policy (创建策略)。

创建内联策略后，会自动嵌入您的 Lambda 函数 IAM 角色。

步骤 4：创建 Lambda 函数以进行视频转码

在本教程的此部分中，您使用适用于 Python 的 SDK 构建 Lambda 函数，以便与 S3 批量操作和 MediaConvert 集成。要开始对存储在 S3 源存储桶中的视频进行转码，您可运行 S3 Batch Operation，该任务直接为 S3 源存储桶中的每个视频调用 Lambda 函数。然后，Lambda 函数将每个视频的转码任务提交给 MediaConvert。

分步

编写 Lambda 函数代码并创建部署程序包
使用执行角色创建 Lambda 函数（控制台）
使用 .zip 文件归档部署 Lambda 函数并配置 Lambda 函数（控制台）

编写 Lambda 函数代码并创建部署程序包

在您的本地计算机上，创建名为 batch-transcode 的文件夹。

在 batch-transcode 文件夹中，创建具有 JSON 任务设置的文件。例如，您可以使用本部分中提供的设置并为文件指定名称 job.json。

job.json 文件指定以下内容：

要转码的文件
您希望如何对输入的视频进行转码
您希望创建何种输出媒体文件
要为转码文件指定的名称
在何处保存转码文件
要应用的高级特征等。

在本教程中，我们使用如下 job.json 文件为 S3 源存储桶中的每个视频创建以下输出：

HTTP 实时流 (HLS) 自适应比特率流，用于在多个大小的设备和不同的带宽上播放。
MP4 视频文件
按间隔收集的缩略图图像

此示例 job.json 文件使用质量定义的可变比特率 (QVBR) 来优化视频质量。HTTP 实时流 (HLS) 输出符合苹果标准（从视频解除音频，6 秒的段持续时间，并通过自动 QVBR 优化视频质量）。

如果您不想使用此处提供的示例设置，可以基于您的使用案例生成 job.json 规范。要确保输出的一致性，请确保输入文件具有类似的视频和音频配置。对于具有不同视频和音频配置的任何输入文件，可创建单独的自动化（唯一的 job.json 设置）。有关更多信息，请参阅《AWS Elemental MediaConvert 用户指南》中的 JSON 格式的 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"
    }
  ]
}

显示更多

显示更少

在 batch-transcode 文件夹中，创建 Lambda 函数的文件。您可以使用以下 Python 示例并将文件命名为 convert.py。

S3 Batch Operation 将特定任务数据发送到 Lambda 函数，并要求返回结果数据。对于 Lambda 函数的请求和响应示例、响应和结果代码的信息以及 S3 Batch Operations 的示例 Lambda 函数的信息，请参阅调用 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
    }

若要在本地终端中使用 convert.py 和 job.json 创建部署程序包 (作为名为 lambda.zip 的 .zip 文件)，打开之前创建的 batch-transcode 文件夹，并运行以下命令。

对于 macOS 用户，运行以下命令：
```
zip -r lambda.zip convert.py job.json                
```
对于 Windows 用户，运行以下命令：
```
powershell Compress-Archive convert.py lambda.zip
```
```
powershell Compress-Archive -update job.json lambda.zip                
```

使用执行角色创建 Lambda 函数（控制台）

通过 https://console.aws.amazon.com/lambda/ 打开 AWS Lambda 控制台。
在左侧导航窗格中，选择 Functions (函数)。
选择 Create function (创建函数)。
选择从头开始创作。
在基本信息中，执行以下操作：
1. 对于 Function name (函数名称)，请输入 tutorial-lambda-convert。
2. 对于 Runtime (运行时)，选择 Python 3.8 或更高的 Python 版本。
选择 Change default execution role (更改默认执行角色)，在 Execution role (执行角色)中，选择 Use an existing role (使用现有角色)。
在 Existing role (退出角色) 中，选择步骤 3中您为 Lambda 函数创建的 IAM 角色的名称（例如，tutorial-lambda-transcode-role)。
对于其余设置，保留默认值。
选择 Create function（创建函数）。

使用 .zip 文件归档部署 Lambda 函数并配置 Lambda 函数（控制台）

在您创建的 Lambda 函数代码源部分中（例如，tutorial-lambda-convert），请选择上传自，然后选择 .zip 文件。
选择上传以选择本地 .zip 文件。
选择您之前创建的 lambda.zip 文件，然后选择打开。
选择保存。
在运行时间设置部分，选择编辑。
要告诉 Lambda 运行时要调用 Lambda 函数代码中的哪个处理程序方法，请输入 convert.handler 的处理程序字段。

当您在 Python 中配置函数时，处理程序设置的值是文件名，也是处理程序模块的名称（由点 (.) 分隔）。例如，convert.handler 调用在 convert.py 文件中定义的 handler 方法。
选择保存。
在 Lambda 函数页面上，选择配置选项卡。在左侧导航窗格中的配置选项卡上，选择环境变量，然后选择编辑。
选择 Add environment variable (添加环境变量)。然后，输入以下每个环境变量的指定密钥和值。
- 密钥：DestinationBucket 值：amzn-s3-demo-destination-bucket1
  
  此值是您在步骤 1 中创建的输出媒体文件的 S3 存储桶。
- 密钥：MediaConvertRole 值：arn:aws:iam::111122223333:role/tutorial-mediaconvert-role
  
  此值是您在步骤 2 中创建的 MediaConvert IAM 角色 ARN。）确保用 IAM 角色的实际 ARN 替换此 ARN。
- 密钥：Application 值：Batch-Transcoding
  
  此值是您的应用程序的名称。
选择保存。
（可选）在配置选项卡上，在左侧导航窗格的常规配置部分中，选择编辑。在超时字段中，输入 2 分钟 0 秒。然后，选择保存。

超时 –是Lambda允许函数在停止调用之前为调用运行的时长。默认值为 3 秒。定价基于配置的内存量和代码运行的时间量。有关更多信息，请参阅AWS Lambda 定价。

步骤 5：为 S3 源存储桶配置 Amazon S3 清单

设置 Lambda 函数转码后，创建 S3 Batch Operation 以转码一组视频。首先，您需要您希望 S3 批量操作对其运行指定转码操作的输入视频对象列表。要获取输入视频对象列表，您可以为 S3 源存储桶生成 S3 清单报告（例如 amzn-s3-demo-source-bucket)。

分步

为输入视频的 S3 清单报告创建和配置存储桶
为 S3 视频源存储桶配置 Amazon S3 清单
检查 S3 视频源存储桶清单报告

为输入视频的 S3 清单报告创建和配置存储桶

要存储列出 S3 源存储桶对象的 S3 清单报告，请创建 S3 清单目标存储桶，然后为存储桶配置存储桶策略，将清单文件写入 S3 源存储桶。

登录到AWS Management Console，然后通过以下网址打开 Amazon S3 控制台：https://console.aws.amazon.com/s3/。
在左侧导航窗格中，选择存储桶。
选择创建存储桶。
对于 Bucket Name（存储桶名称），输入您的存储桶的名称（例如 amzn-s3-demo-destination-bucket2）。
对于 AWS 区域，选择要中放置存储桶的 AWS 区域。

目标存储桶必须位于与您为其设置 S3 清单存储桶相同的 AWS 区域中。清单目标存储桶可处于不同的 AWS 账户中。
在阻止此存储桶的公有访问设置中，保留默认设置（已启用阻止全部公有访问）。
对于其余设置，保留默认值。
选择 Create bucket（创建存储桶）。
在存储桶列表中，选择刚刚创建的存储桶名称（例如，amzn-s3-demo-destination-bucket2）。
要授予 Amazon S3 将清单报告的数据写入 S3 清单目标存储桶的权限，您可选择权限选项卡。
向下滚动到存储桶策略部分，然后选择编辑。存储桶策略页面随即打开。

要授予 S3 清单的权限，请在策略字段中，粘贴以下存储桶策略。

将三个示例值替换为以下值：

您为存储库存报告创建的存储桶名称（例如，amzn-s3-demo-destination-bucket2)。
存储输入视频的源存储桶名称（例如，amzn-s3-demo-source-bucket)。
您用于创建 S3 视频源存储桶的 AWS 账户 ID（例如，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"
          }
       }
    }
  ]
}

选择 Save changes（保存更改）。

为 S3 视频源存储桶配置 Amazon S3 清单

若要生成视频对象和元数据的平面文件列表，您必须为 S3 视频源存储桶配置 S3 清单。这些计划清单可以包括存储桶中的所有对象，或者按共享前缀分组的对象。在本教程中，S3 清单报告包含 S3 源存储桶中的所有视频对象。

登录到AWS Management Console，然后通过以下网址打开 Amazon S3 控制台：https://console.aws.amazon.com/s3/。
在左侧导航窗格中，选择存储桶。
要配置 S3 源存储桶中输入视频的 S3 清单报告，请在存储桶列表中，选择 S3 源存储桶的名称（例如，amzn-s3-demo-source-bucket)。
选择管理选项卡。
向下滚动到清单配置部分，然后选择创建清单配置。
对于清单配置名称，输入名称（例如，tutorial-inventory-config)。
在清单范围下，为目标版本选择仅当前版本并保留其他清单范围设置为本教程的默认值。
在报告详细信息下，对于目标存储桶，选择此账户。
对于目的地，选择浏览 S3，然后选择您在上面创建的目标存储桶，以将库存报告保存到其中（例如，amzn-s3-demo-destination-bucket2)。然后，选择选择路径。

目标存储桶必须位于与您为其设置 S3 清单存储桶相同的 AWS 区域中。清单目标存储桶可处于不同的 AWS 账户中。

在目标存储桶字段下目标存储桶权限)添加到目标存储桶策略中允许 Amazon S3 在该存储桶中放置数据。有关更多信息，请参阅创建目标存储桶策略。
在频率下，选择每天。
为输出格式选择 CSV。
对于状态，选择已启用。
在服务器端加密部分下，对于本教程选择禁用。

有关更多信息，请参阅使用 S3 控制台配置清单和向 Amazon S3 授予权限以使用客户自主管理型密钥进行加密。
在其他字段 - 可选部分中，选择大小、上次修改和存储类。
选择 Create（创建）。

有关更多信息，请参阅使用 S3 控制台配置清单。

检查 S3 视频源存储桶清单报告

在清单列表发布后，清单文件将发送到 S3 清单目标存储桶。

登录到AWS Management Console，然后通过以下网址打开 Amazon S3 控制台：https://console.aws.amazon.com/s3/。
在左侧导航窗格中，选择存储桶。
在存储桶列表中，选择视频源存储桶的名称（例如，amzn-s3-demo-source-bucket)。
选择管理。
要查看 S3 清单报告是否准备好，以便您在步骤 7 中创建 S3 Batch Operation 任务，则在清单配置下，检查是否启用从清单创建任务按钮。

注意
交付第一份清单报告可能需要最多 48 小时。如果从清单创建任务按钮处于禁用状态，则第一个清单报告尚未送达。等到第一个清单报告交付，并且从清单创建任务按钮在创建步骤 7中的 S3 Batch Operation 任务之前已启用。
要检查 S3 清单报告（manifest.json），在目标列中，选择您在前面创建的用于存储库存报告的库存目标存储桶名称（例如，amzn-s3-demo-destination-bucket2)。
在对象选项卡上，选择具有 S3 源存储桶名称的现有文件夹（例如，amzn-s3-demo-source-bucket)。然后选择之前创建库存配置时在清单配置名称中输入的名称（例如，tutorial-inventory-config)。

您可以查看以报告生成日期作为其名称的文件夹列表。
要检查某一日期的每日 S3 清单报告，请选择带相应生成日期名称的文件夹，然后选择 manifest.json。
要查看特定日期库存报告的详细信息，请在 manifest.json 页面上，选择下载或打开。

步骤 6：为 S3 批量操作创建 IAM 角色

要使用 S3 Batch Operation 执行批处理转码，您必须首先创建 IAM 角色，让 Amazon S3 拥有执行 S3 批处理操作的权限。

分步

为 S3 批量操作创建 IAM 策略
创建 S3 Batch Operations IAM 角色并附加权限策略。

为 S3 批量操作创建 IAM 策略

您必须创建 IAM 策略，为 S3 Batch Operation 授予读取输入清单、调用 Lambda 函数以及编写 S3 Batch Operation 任务完成报告的权限。

登录 AWS Management Console，然后通过以下网址打开 IAM 控制台：https://console.aws.amazon.com/iam/。
在左侧导航窗格中，选择 Policies（策略）。
选择创建策略。
选择 JSON 选项卡。

在 JSON 文本字段中，粘贴以下 JSON 策略。

在 JSON 策略中，将四个示例值替换为以下值：

存储输入视频的源存储桶名称（例如，amzn-s3-demo-source-bucket)。
您在步骤 5 中创建以存储 manifest.json 文件的清单目标存储桶名称（例如，amzn-s3-demo-destination-bucket2)。
您在步骤 1 中创建以存储输出媒体文件的存储桶名称（例如，amzn-s3-demo-destination-bucket1)。在本教程中，我们将任务完成报告存储在输出媒体文件的目标存储桶中。
您在步骤 4 中创建的 Lambda 函数的角色 ARN。要查找并复制 Lambda 函数的角色 ARN，请执行以下操作：
- 在新浏览器选项卡中，打开 https://console.aws.amazon.com/lambda/home#/functions 中的 Lambda 控制台上的函数页面。
- 在函数列表中，选择在步骤 4 中创建的 Lambda 函数（例如，tutorial-lambda-convert)。
- 选择复制 ARN。


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

选择下一步：标签。
选择下一步：审核。
在名称字段中，输入 tutorial-s3batch-policy。
选择创建策略。

创建 S3 Batch Operations IAM 角色并附加权限策略。

登录 AWS Management Console，然后通过以下网址打开 IAM 控制台：https://console.aws.amazon.com/iam/。
在左侧导航窗格中，选择角色，然后选择创建角色。
选择 AWS 服务 角色类型，然后选择 S3 服务。
在选择您的用例中，选择 S3 批量操作。
选择下一步：权限。
在 Attach permissions policies（附加权限策略）下，于搜索框中输入您以前创建的 IAM 策略的名称（例如，tutorial-s3batch-policy) 以筛选策略列表。选中策略名称旁边的复选框（例如，tutorial-s3batch-policy)。
选择下一步：标签。
请选择下一步：审核。
对于 Role name（角色名称），输入 tutorial-s3batch-role。

选择 Create role（创建角色）。

创建 S3 批量操作的 IAM 角色后，以下信任策略将自动附加到该角色。此信任策略允许 S3 批量操作服务主体担任 IAM 角色。


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

步骤 7：设置并运行 S3 批量操作任务

要创建 S3 批量操作任务以处理 S3 源存储桶中的输入视频，您必须为此特定任务指定参数。

注意

在开始创建 S3 批量操作任务之前，请确保启用从清单创建任务按钮。有关更多信息，请参阅检查 S3 视频源存储桶清单报告。如果从清单创建任务按钮处于禁用状态，则第一个清单报告尚未送达，您必须等到启用该按钮。在步骤 5 中为 S3 源存储桶配置 Amazon S3 清单后，交付第一个清单报告可能需要最长 48 小时。

分步

创建 S3 批量操作任务
运行 S3 批量操作任务以调用 Lambda 函数
（可选）检查您的完成报告
（可选）在 Lambda 控制台中监控每个 Lambda 调用
（可选）监控 MediaConvert 控制台中的每个 MediaConvert 视频转码任务

创建 S3 批量操作任务

登录到AWS Management Console，然后通过以下网址打开 Amazon S3 控制台：https://console.aws.amazon.com/s3/。
在左侧导航窗格中，选择批量操作。
选择创建任务。
对于 AWS 区域，选择要在其中创建任务的区域。

在本教程中，要使用 S3 批量操作任务调用 Lambda 函数，您必须在清单中引用的对象所在的 S3 视频源存储桶所在的同一区域中创建任务。
在清单部分中执行以下操作：
1. 对于 Manifest format（清单格式），选择 S3 清单报告 (manifest.json)。
2. 针对清单对象，选择浏览 S3查找您在步骤 5 中创建用于存储清单报告的存储桶（例如，amzn-s3-demo-destination-bucket2)。在清单对象页面中，浏览对象名称直到找到特定日期的 manifest.json 文件。此文件列出了有关要批量转码的所有视频的信息。当您找到要使用的 manifest.json 文件之后，选择旁边的选项按钮。然后，选择选择路径。
3. （可选）对于清单对象版本 ID - 可选，如果您希望使用其他版本而不是最新版本，则输入清单对象的版本 ID。
选择下一步。
要使用 Lambda 函数来转码选定 manifest.json 文件中列出的所有对象，在操作类型中，选择调用 AWS Lambda 函数。
在调用 Lambda 函数部分中，执行以下操作：
1. 选择从账户中的函数选择。
2. 对于 Lambda 函数，选择您在步骤 4 中创建的 Lambda 函数（例如，tutorial-lambda-convert)。
3. 对于 Lambda 函数版本，请保留默认值 $LATEST。
选择下一步。配置其他选项页面随即打开。
在其他选项部分下，请保留默认设置。

有关这些选项的详细信息，请参阅批量操作任务请求元素。
在完成报告部分，对于完成报告目的地的路径，选择浏览 S3。查找您在步骤 1 中创建以存储输出媒体文件的存储桶名称（例如，amzn-s3-demo-destination-bucket1)。选择该存储桶名称旁边的选项按钮。然后，选择选择路径。

对于其余的完成报告设置，请保留默认值。有关完成报告设置的更多信息，请参阅批量操作任务请求元素。完成报告维护任务详细信息和执行的操作的记录。
在权限部分下，选择从现有 IAM 角色中进行选择。对于 IAM 角色，选择您在步骤 6 中创建的 S3 批量操作任务的 IAM 角色（例如，tutorial-s3batch-role)。
选择下一步。
在审阅页面上，检查您的设置。然后选择创建任务。

S3 读取 S3 批量操作任务清单后，它会将任务的状态设为等待确认运行。要查看任务状态的更新，请刷新页面。直到任务状态为等待确认运行，您才可运行任务。

运行 S3 批量操作任务以调用 Lambda 函数

运行批量操作任务以调用 Lambda 函数进行视频转码。如果任务失败，您可以检查完成报告以确定原因。

运行 S3 批量操作任务

登录到AWS Management Console，然后通过以下网址打开 Amazon S3 控制台：https://console.aws.amazon.com/s3/。
在左侧导航窗格中，选择批量操作。
从任务列表中，在第一行上选择任务的任务 ID，这是之前创建的 S3 批量操作任务。
选择运行任务。
再次复核您的任务参数，并确认清单中列出的对象总数与清单中对象的数量相同。然后选择运行任务。

您的 S3 批量操作任务页面打开。
任务开始运行后，在任务页面上的状态下，检查 S3 批量操作任务的进度，例如状态、已完成百分比、成功总数（费率）、失败总数（速率）、终止日期和终止原因。

S3 批量操作任务完成后，查看任务页面上的数据，确认已按预期完成任务。

如果在尝试超过 1,000 个操作后，超过 50% 的 S3 批量操作任务的对象操作失败，该任务将自动失败。要检查完成报告确定失败的原因，请使用下面的可选步骤。

（可选）检查您的完成报告

您可以使用完成报告来确定哪些对象失败以及失败的原因。

要检查完成报告以了解有关失败对象的详细信息

在 S3 批量操作任务的页面上，向下滚动至完成报告部分，然后选择完成报告目标下的链接。

S3 输出目标存储桶页面打开。
在对象选项卡上，选择之前创建的 S3 批量操作务以任务 ID 名称结尾的文件夹。
选择结果/。
选中 .csv 文件旁边的复选框。
要查看任务报告，请选择打开或者下载。

（可选）在 Lambda 控制台中监控每个 Lambda 调用

S3 批量操作任务开始运行后，任务将为每个输入视频对象调用 Lambda 函数。S3 将每次 Lambda 调用的日志写入到 CloudWatch Logs。您可以使用 Lambda 控制台的监控控制面板来监控 Lambda 函数。

通过 https://console.aws.amazon.com/lambda/ 打开 AWS Lambda 控制台。
在左侧导航窗格中，选择 Functions（函数）。
在函数列表中，选择在步骤 4 中创建的 Lambda 函数（例如，tutorial-lambda-convert)。
选择监控选项卡。
在指标下，请参阅 Lambda 函数的运行时间指标。
在日志下，通过 CloudWatch Logs Insights 查看每个 Lambda 调用的日志数据。

注意
将 S3 批量操作与 Lambda 函数结合使用时，会在每个对象上调用 Lambda 函数。如果您的 S3 批量操作任务很大，可以同时调用多个 Lambda 函数，从而导致 Lambda 并发峰值。
对于每个区域，每个 AWS 账户都有 Lambda 并发配额。有关更多信息，请参阅 AWS Lambda 开发人员指南中的 AWS Lambda 函数扩展。将 Lambda 函数与 S3 批量操作结合使用的最佳做法是对 Lambda 函数本身设置并发限制。设置并发限制会使您的任务不会占用大部分 Lambda 并发，并可能会限制您账户中的其他函数。有关更多信息，请参阅 AWS Lambda 开发人员指南中的管理 Lambda 预留并发。

（可选）监控 MediaConvert 控制台中的每个 MediaConvert 视频转码任务

MediaConvert 任务执行转换媒体文件的工作。当您的 S3 批量操作任务为每个视频调用 Lambda 函数时，每个 Lambda 函数调用都会为每个输入视频创建一个 MediaConvert 转码任务。

登录到 AWS Management Console，然后在 https://console.aws.amazon.com/mediaconvert/ 打开 MediaConvert 控制台。
如果显示 MediaConvert 介绍页面，请选择开始。
从任务列表中，查看每行以监控每个输入视频的转码任务。
确定要检查的任务行，然后选择任务 ID 链接打开任务详细信息页面。
在任务摘要页面，在输出中，根据浏览器支持的内容，选择 HLS、MP4 或缩略图输出的链接，转到输出媒体文件的 S3 目标存储桶。
在 S3 输出目标存储桶的相应文件夹（HLS、MP4 或缩略图）中，选择输出媒体文件对象的名称。

将打开对象的详细信息页面。
在对象的详细信息页面上，在对象概述中，选择对象 URL 下的链接观看转码输出媒体文件。

步骤 8：检查 S3 目标存储桶中的输出媒体文件

若要从 S3 目标存储桶检查输出媒体文件

登录到AWS Management Console，然后通过以下网址打开 Amazon S3 控制台：https://console.aws.amazon.com/s3/。
在左侧导航窗格中，选择存储桶。
从存储桶列表中，选择您在步骤 1 中创建的输出媒体文件的 S3 目标存储桶名称（例如，amzn-s3-demo-destination-bucket1)。
在对象选项卡上，每个输入视频都有一个带输入视频名称的文件夹。每个文件夹都包含输入视频的转码输出媒体文件。

要检查输出媒体文件中的输入视频，请执行以下操作：
1. 选择要检查的输入视频名称文件夹。
2. 选择Default/文件夹。
3. 选择转码格式的文件夹（本教程中的 HLS、MP4 或缩略图）。
4. 选择输出媒体文件的名称。
5. 要观看转码后的文件，在对象的详细信息页面上，选择对象 URL 下的链接。
  
  HLS 格式的输出媒体文件被拆分为短段。要播放这些视频，您需要嵌入 .m3u8 文件的对象 URL 在兼容的播放器中。

步骤 9：清除

如果您只使用 S3 批量操作、Lambda 和 MediaConvert 转码视频作为学习练习，请删除 AWS 您分配的资源，以免继续产生费用。

分步

删除 S3 源存储桶的 S3 清单配置
删除 Lambda 函数
删除 CloudWatch 日志组
删除 IAM 角色以及 IAM 角色的内联策略
删除客户管理型 IAM 策略
清空 S3 存储桶
删除 S3 存储桶

删除 S3 源存储桶的 S3 清单配置

登录到AWS Management Console，然后通过以下网址打开 Amazon S3 控制台：https://console.aws.amazon.com/s3/。
在左侧导航窗格中，选择存储桶。
在存储桶列表中，选择您的源存储桶名称（例如，amzn-s3-demo-source-bucket)。
选择管理选项卡。
在清单配置部分中，选择您在步骤 5 中创建的清单配置旁边的选项按钮（例如，tutorial-inventory-config)。
选择删除，然后选择确认。

删除 Lambda 函数

通过 https://console.aws.amazon.com/lambda/ 打开 AWS Lambda 控制台。
在左侧导航窗格中，选择 Functions（函数）。
选择在步骤 4 中创建的函数旁边的复选框（例如，tutorial-lambda-convert)。
选择操作，然后选择删除。
在删除函数对话框中，选择删除。

删除 CloudWatch 日志组

访问 https://console.aws.amazon.com/cloudwatch/ 打开 CloudWatch 控制台。
在左侧导航窗格中，选择日志，然后选择日志组。
选中日志组旁边的复选框，该复选框的名称以在步骤 4 中创建的 Lambda 函数结尾（例如，tutorial-lambda-convert)。
选择操作，然后选择删除日志组。
在删除日志组对话框中，选择删除。

删除 IAM 角色以及 IAM 角色的内联策略

删除您在步骤 2、步骤 3 和步骤 6 中创建的 IAM 角色，执行以下操作：

登录 AWS Management Console，然后通过以下网址打开 IAM 控制台：https://console.aws.amazon.com/iam/。
在左侧导航窗格中，选择角色，然后选中要删除的角色名称旁的复选框。
在页面的顶部，选择删除。
在确认对话框中，根据提示在文本输入字段中输入所需的响应，然后选择删除。

删除客户管理型 IAM 策略

若要删除您在步骤 6 中创建的客户托管 IAM 策略，执行以下操作：

登录 AWS Management Console，然后通过以下网址打开 IAM 控制台：https://console.aws.amazon.com/iam/。
在左侧导航窗格中，选择 Policies（策略）。
选择您在步骤 6 中创建的策略旁边的选项按钮（例如，tutorial-s3batch-policy)。您可以使用搜索框筛选策略列表。
选择 Actions，然后选择 Delete。
在文本字段中输入名称，确认您要删除的策略，然后选择删除。

清空 S3 存储桶

若要清空您在先决条件、步骤 1 和步骤 5 中创建的 S3 存储桶，执行以下操作：

登录到AWS Management Console，然后通过以下网址打开 Amazon S3 控制台：https://console.aws.amazon.com/s3/。
在左侧导航窗格中，选择存储桶。
在存储桶列表中，选择要清空的存储桶名称旁边的选项图标，然后选择清空。
在清空存储桶页面上，通过在文本字段中输入 permanently delete 来确认要清空存储桶，然后选择清空。

删除 S3 存储桶

若要删除您在先决条件、步骤 1 和步骤 5 中创建的 S3 存储桶，执行以下操作：

登录到AWS Management Console，然后通过以下网址打开 Amazon S3 控制台：https://console.aws.amazon.com/s3/。
在左侧导航窗格中，选择存储桶。
在存储桶列表中，选择要删除的存储桶名称旁边的选项按钮。
选择删除。
在删除存储桶页面上，通过在文本字段中输入存储桶名称来确认要删除存储桶，然后选择删除存储桶。

后续步骤

完成本教程后，您可以进一步探索其他相关使用案例：

您可以使用 Amazon CloudFront 将转码后的媒体文件流式传输到全球各地的查看者。有关更多信息，请参阅教程：使用 Amazon S3、Amazon CloudFront 和 Amazon Route 53 托管点播流视频。
将视频上传到 S3 源存储桶时，您可以对视频进行转码。为此，您可以配置 Amazon S3 事件触发器，该触发器自动调用 Lambda 函数以使用 MediaConvert 转码 S3 中的新对象。有关更多信息，请参阅 AWS Lambda 开发人员指南中的教程：使用 Amazon S3 触发器调用 Lambda函数。

Javascript 在您的浏览器中被禁用或不可用。

要使用 Amazon Web Services 文档，必须启用 Javascript。请参阅浏览器的帮助页面以了解相关说明。

文档惯例

关闭依法保留

排查批量操作问题