必要條件步驟 1：為您的輸出媒體檔案建立 S3 儲存貯體步驟 2：建立IAM角色 MediaConvert 步驟 3：為您的 Lambda 函數建立IAM角色步驟 4：為影片轉碼建立 Lambda 函數步驟 5：為您的 S3 來源儲存貯體設定 Amazon S3 清查步驟 6：為 S3 Batch 操作建立IAM角色步驟 7：建立並執行 S3 批次操作任務步驟 8：從 S3 目的地儲存貯體檢查輸出媒體檔案步驟 9：清除後續步驟

教學課程：使用 S3 Batch 操作進行 Batch 轉碼影片、 AWS Lambda和 AWS Elemental MediaConvert

影片消費者使用各種類型、尺寸和年份的裝置來觀賞媒體內容。各式各樣的裝置對內容創作者和發行者來說是一項挑戰。視頻必須轉換，而不是 one-size-fits-all 格式，以便它們可以跨越廣泛的大小，格式和比特率。當您有大量必須轉換的影片時，這項轉換任務更具挑戰性。

AWS 為您提供了一種構建可擴展的分佈式架構的方法，該架構可執行以下操作：

擷取輸入影片
處理影片，以在各種裝置上播放
存放轉碼後的媒體檔案
交付輸出媒體檔案，以滿足需求

當您在 Amazon S3 中存放了大量的影片儲存庫時，您可以將這些影片從其來源格式轉碼為特定影片播放器或裝置所需的大小、解析度和格式各異的多種檔案類型。具體而言，S3 Batch 操作提供您叫用的解決方案 AWS Lambda S3 來源儲存貯體中現有輸入視訊的功能。然後，Lambda 函數調用 AWS Elemental MediaConvert執行大規模的視頻轉碼任務。轉換後的輸出媒體檔案會存放在 S3 目的地儲存貯體中。

目標

在本教學課程中，您將學習如何設定 S3 批次操作來叫用 Lambda 函數，以對存放在 S3 來源儲存貯體中的影片進行批次轉碼。Lambda 函數會呼叫 MediaConvert 將視訊轉碼。S3 來源儲存貯體中的每個影片輸出如下：

HTTP即時串流 (HLS) 適應位元速率串流，可在多種尺寸和不同頻寬的裝置上播放
視MP4頻文件
每隔一段時間收集的縮圖影像

必要條件

在您開始此教學課程之前，您必須有 Amazon S3 來源儲存貯體 (例如 tutorial-bucket-1），並且其中已存放了要轉碼的影片。

如果您想要，可以為儲存貯體命名另一個名稱。如需 Amazon S3 中儲存貯體名稱的詳細資訊，請參閱儲存貯體命名規則。

對於 S3 來源儲存貯體，請將與 Block Public Access settings for this bucket (此儲存貯體的封鎖公開存取設定) 相關的設定保留為預設值 (已啟用 Block all public access (封鎖所有公開存取))。如需詳細資訊，請參閱建立儲存貯體。

如需有關將影片上傳至 S3 來源儲存貯體的詳細資訊，請參閱上傳物件。如果您正在上傳許多大型影片到 S3，您會想要使用 Amazon S3 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/。
在左側導覽窗格中，選擇 Buckets (儲存貯體)。
選擇建立儲存貯體。
針對 Bucket name (儲存貯體名稱)，輸入儲存貯體的名稱 (例如 tutorial-bucket-2)。
對於「區域」，請選擇 AWS 區域您希望存儲桶所在的位置。
若要確保公開存取您的輸出媒體檔案，請在 Block Public Access settings for this bucket (此儲存貯體的封鎖公開存取設定) 中，清除 Block all public access (封鎖所有公開存取)。

警告
在完成此步驟之前，請檢閱封鎖對 Amazon S3 儲存體的公開存取權以確保您了解並接受允許公開存取所涉及的風險。當您關閉 Block Public Access (封鎖公開存取) 設定以公開儲存貯體時，網際網路上的任何人都可以存取您的儲存貯體。我們建議您封鎖對儲存貯體的所有公用存取權。
如果您不想清除「封鎖公開存取」設定，可以使用 Amazon CloudFront 將轉碼的媒體檔案交付給檢視者 (最終使用者)。如需詳細資訊，請參閱教學課程：使用 Amazon S3、Amazon 和 Amazon Route 53 託管隨選串流視訊 CloudFront。
選取 I acknowledge that the current settings might result in this bucket and the objects within becoming public (我確認目前的設定可能會導致此儲存貯體及其中的物件變為公開) 旁的核取方塊。
將其餘設定保持為預設值。
選擇建立儲存貯體。

將CORS組態新增至 S3 輸出儲存貯體

JSONCORS組態定義了載入一個網域中的用戶端 Web 應用程式 (此內容中的視訊播放程式) 的方式，以播放不同網域中的轉碼輸出媒體檔案。

登入 AWS Management Console 並打開 Amazon S3 控制台https://console.aws.amazon.com/s3/。
在左側導覽窗格中，選擇 Buckets (儲存貯體)。
在 Buckets (儲存貯體) 清單中，選擇您先前建立的儲存貯體名稱 (例如，tutorial-bucket-2)。
選擇許可索引標籤標籤。
在「跨來源資源共用 (CORS)」區段中，選擇 「編輯」。
在CORS模型組態文字方塊中，複製並貼上以下CORS模型組態。

組CORS態必須為格JSON式。在此範例中，AllowedOrigins 屬性使用萬用字元 (*) 來指定所有來源伺服器。如果您知道自己的特定來源，則可以將AllowedOrigins屬性限制為您的特定玩家URL。如需有關設定此屬性和其他屬性的詳細資訊，請參閱 CORS模型組態的元素。
```
[
    {
        "AllowedOrigins": [
            "*"
        ],
        "AllowedMethods": [
            "GET"
        ],
        "AllowedHeaders": [
            "*"
        ],
        "ExposeHeaders": []

    }
]                                          
```
選擇 Save changes (儲存變更)。

步驟 2：建立IAM角色 MediaConvert

使用 AWS Elemental MediaConvert 要對存儲在 S3 存儲桶中的輸入視頻進行轉碼，您必須具有 AWS Identity and Access Management (IAM) 服務角色，可 MediaConvert 授與從 S3 來源和目標儲存貯體讀取和寫入視訊檔案的權限。當您執行轉碼工作時， MediaConvert 主控台會使用此角色。

若要建立IAM角色 MediaConvert

使用您選擇的IAM角色名稱來建立角色 (例如，tutorial-mediaconvert-role)。若要建立此角色，請依照在 IAM(主控台) 中建立 MediaConvert 角色中的步驟執行 AWS Elemental MediaConvert 使用者指南。
創建IAM角色后 MediaConvert，請在「角色」列表中選擇您所創建的角色名稱（例如，tutorial-mediaconvert-role）。 MediaConvert
在 [摘要] 頁面上，複製角色 ARN (開頭為arn:aws:iam::)，然後儲存以ARN供稍後使用。

如需有關的詳細資訊ARNs，請參閱中的 Amazon 資源名稱 (ARNs) AWS 一般參考。

步驟 3：為您的 Lambda 函數建立IAM角色

若要使用 MediaConvert 和 S3 Batch 操作對影片進行批次轉碼，您可以使用 Lambda 函數連接這兩個服務以轉換影片。此 Lambda 函數必須具有授與 Lambda 函數存取權限 MediaConvert 和 S3 Batch 操作的IAM角色。

子步驟

為您的 Lambda 函數建立IAM角色
針對 Lambda 函數的IAM角色內嵌內嵌政策

為您的 Lambda 函數建立IAM角色

登入 AWS Management Console 並在打開IAM控制台https://console.aws.amazon.com/iam/。
在左側導覽窗格中，選擇 Roles (角色)，然後選擇 Create role (建立角色)。
選擇 AWS 服務角色類型，然後在常見使用案例下選擇 Lambda。
選擇下一步：許可。
在 Attach Permissions policies (連接許可政策) 頁面上，於 Filter policies (篩選政策) 方塊中輸入 AWSLambdaBasicExecutionRole。若要將受管政策附加AWSLambdaBasicExecutionRole到此角色以授與寫入權限給 Amazon CloudWatch Logs，請選取旁邊的核取方塊AWSLambdaBasicExecutionRole。
選擇下一步：標籤。
(選用) 新增標籤至受管政策。
選擇下一步：檢閱。
在角色名稱中，輸入 tutorial-lambda-transcode-role。
選擇建立角色。

針對 Lambda 函數的IAM角色內嵌內嵌政策

若要將權限授與執行 Lambda 函數所需的 MediaConvert 資源，您必須使用內嵌政策。

登入 AWS Management Console 並在打開IAM控制台https://console.aws.amazon.com/iam/。
在左側導覽窗格中，選擇 Roles (角色)。
在 [角色] 清單中，選擇您先前為 Lambda 函數建立的IAM角色名稱 (例如tutorial-lambda-transcode-role)。
選擇 Permissions (許可) 標籤。
選擇 Add inline policy (新增內嵌政策)。

選擇索JSON引標籤，然後複製並貼上下列JSON原則。

在JSON原則中，將的Resource範例ARN值取代為 MediaConvert 您在步驟 2 中建立的IAM角色角色 (例如tutorial-mediaconvert-role)。ARN


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

選擇檢閱政策。
對於 Name (名稱)，輸入 tutorial-lambda-policy。
選擇 建立政策 。

建立內嵌政策之後，它會自動內嵌在 Lambda 函數的IAM角色中。

步驟 4：為影片轉碼建立 Lambda 函數

在本教學課程的這一節中，您會使用 Python 來建置 Lambda 函數，以便與 S3 Batch 操作和 MediaConvert. SDK 若要開始轉碼已存放在 S3 來源儲存貯體中的影片，您需要執行 S3 批次操作任務，該任務會直接為 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) 來最佳化視訊品質。HLS輸出符合 Apple 標準（視訊中未混合的音訊、6 秒的片段持續時間，以及透過 auto 優化視訊品質）。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 批次操作會將特定的任務資料傳送至 Lambda 函數，並需要傳回結果資料。如需 Lambda 函數的請求和回應範例、回應和結果程式碼的資訊，以及 S3 批次操作的範例 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['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
    }

若要將含有 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 函數

打開 AWS Lambda 控制台位於https://console.aws.amazon.com/lambda/。
在左側導覽窗格中，選擇 Functions (函數)。
選擇建立函數。
選擇 Author from scratch (從頭開始撰寫)。
在基本資訊下，請執行下列動作：
1. 針對 函數名稱 ，請輸入 tutorial-lambda-convert。
2. 針對 Runtime (執行時間)，選擇 Python 3.8 或更新的 Python 版本。
選擇 Change default execution role (變更預設執行角色)，並在 Execution role (執行角色) 下，選擇 Use an existing role (使用現有角色)。
在「現有角色」下，選擇您在步驟 3 中為 Lambda 函數建立的IAM角色名稱 (例如tutorial-lambda-transcode-role)。
對於其他設定，請保留預設值。
選擇建立函數。

使用 .zip 檔案封存部署您的 Lambda 函數，並設定 Lambda 函數 (主控台)

在頁面的 Code Source (程式碼來源) 區段中，為您先前建立的 Lambda 函數 (例如，tutorial-lambda-convert)，依次選擇 Upload from (上傳來源) 和 .zip 檔案。
選擇 Upload (上傳) 以選取您的本機 .zip 檔案。
選擇您之前建立的 lambda.zip 檔案，然後選擇 Open (開啟)。
選擇 Save (儲存)。
在 Runtime settings (執行時間設定) 區段中，選擇 Edit (編輯)。
若要告知 Lambda 執行時間要叫用 Lambda 函數程式碼中的處理常式方法，請在 Handler (處理常式) 欄位中輸入 convert.handler。

當您設定 Python 函式時，處理常式的設定值就是檔案名稱加上處理常式模組名稱，並且以點 (.) 分隔。例如，convert.handler 會呼叫 convert.py 檔案中定義的 handler 方法。
選擇 Save (儲存)。
在 Lambda 函數頁面上，選擇 Configuration (組態) 標籤。在 Configuration (組態) 索引標籤的左側導覽窗格中，選擇 Environment variables (環境變數)，然後選擇 Edit (編輯)。
選擇 Add environment variable (新增環境變數)。然後，為以下每個環境變數輸入指定的 Key (索引鍵) 和 Value (數值)：
- Key (索引鍵)：DestinationBucket Value (數值)：tutorial-bucket-2
  
  該數值是您在步驟 1 中建立的輸出媒體檔案的 S3 儲存貯體。
- Key (索引鍵)：MediaConvertRole Value (數值)：arn:aws:iam::111122223333:role/tutorial-mediaconvert-role
  
  此值是您在步驟 2 中 MediaConvert 建立ARN之IAM角色的值。確保將其替換為您ARN的IAM角色ARN的實際值。
- Key (索引鍵)：Application Value (數值)：Batch-Transcoding
  
  這是應用程式名稱的值。
選擇 Save (儲存)。
(選用) 在 Configuration (組態) 標籤上，在左側導覽窗格的 General configuration (一般組態) 區段中，選擇 Edit (編輯)。在 Timeout (逾時) 欄位中，輸入 2 分 0 秒。然後選擇 Save (儲存)。

Timeout (逾時) 是 Lambda 在停用函數前允許函數執行叫用的時間。預設為 3 秒。定價是根據設定的記憶體數量和程式碼執行的時間量而定。如需詳細資訊，請參閱 AWS Lambda 定價。

步驟 5：為您的 S3 來源儲存貯體設定 Amazon S3 清查

設定 Lambda 函數轉碼後，您會建立 S3 批次操作任務以轉碼一組影片。首先，您需要一份您希望 S3 批次操作對其執行指定轉碼動作的輸入影片物件清單。若要取得輸入影片物件的清單，您可以為 S3 來源儲存貯體 (例如，tutorial-bucket-1) 產生 S3 清查報告。

子步驟

為輸入影片的 S3 清查報告建立並設定儲存貯體
為 S3 影片來源儲存貯體設定 Amazon S3 清查
檢查您的 S3 影片來源儲存貯體的清查報告

為輸入影片的 S3 清查報告建立並設定儲存貯體

若要存放列出 S3 來源儲存貯體物件的 S3 清查報告，請建立 S3 清查目的地儲存貯體，然後為儲存貯體設定儲存貯體政策，以便將清查檔案寫入 S3 來源儲存貯體。

登入 AWS Management Console 並打開 Amazon S3 控制台https://console.aws.amazon.com/s3/。
在左側導覽窗格中，選擇 Buckets (儲存貯體)。
選擇建立儲存貯體。
針對 Bucket name (儲存貯體名稱)，輸入儲存貯體的名稱 (例如 tutorial-bucket-3)。
針對 AWS 區域，選擇 AWS 區域您希望存儲桶所在的位置。

存貨目的地值區必須位於相同 AWS 區域做為您設定 S3 庫存的來源儲存貯體。存貨目的地值區可以位於不同 AWS 帳戶.
在 Block Public Access settings for this bucket (此儲存貯體的封鎖公開存取設定) 中，保留預設設定 (已啟用 Block all public access (封鎖所有公開存取))。
對於其他設定，請保留預設值。
選擇建立儲存貯體。
在 Buckets (儲存貯體) 清單中，選擇您剛剛建立的儲存貯體名稱 (例如，tutorial-bucket-3)。
若要授予 Amazon S3 將清查報告的資料寫入 S3 清查目的地儲存貯體的許可，請選擇 Permissions (許可) 標籤。
向下捲動到 Bucket policy (儲存貯體政策) 區段，然後選擇 Edit (編輯)。Bucket policy (儲存貯體政策) 頁面隨即開啟。

若要授予 S3 清查的許可，請在 Policy (政策) 欄位中，貼上以下儲存貯體政策。

將三個範例值取代為下列值：

您為存放清查報告而建立的儲存貯體名稱 (例如，tutorial-bucket-3)。
存放輸入影片的來源儲存貯體名稱 (例如，tutorial-bucket-1)。
所以此 AWS 帳戶您用來建立 S3 視訊來源儲存貯體的 ID (例如，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"
          }
       }
    }
  ]
}

選擇 Save changes (儲存變更)。

為 S3 影片來源儲存貯體設定 Amazon S3 清查

若要產生影片物件和中繼資料的一般檔案清單，您需要為 S3 影片來源儲存貯體設定 S3 清查。這些排程清查報告可以包含儲存貯體中的所有物件，或是依共用字首分組的物件。在本教學課程中，S3 清查報告包含 S3 來源儲存貯體中的所有影片物件。

登入 AWS Management Console 並打開 Amazon S3 控制台https://console.aws.amazon.com/s3/。
在左側導覽窗格中，選擇 Buckets (儲存貯體)。
若要在 S3 來源儲存貯體中設定輸入影片的 S3 清查報告，請在 Buckets (儲存貯體) 清單中，選擇 S3 來源儲存貯體的名稱 (例如，tutorial-bucket-1)。
選擇 Management (管理) 標籤，
向下捲動至 Inventory configurations (清查組態) 區段，然後選擇 Create inventory configuration (建立清查組態)。
在 Inventory configuration name (清查組態名稱) 中，輸入一個名稱 (例如，tutorial-inventory-config)。
在 Inventory scope (清查範圍) 下，針對 Object versions (物件版本) 選擇 Current version only (僅限目前版本)，並將其他 Inventory scope (清查範圍) 設定為本教學課程保留預設值。
在 Report details (報告詳細資訊) 區段中，針對 Destination bucket (目的地儲存貯體)，選擇 This account (此帳戶)。
針對 Destination (目的地)，選擇 Browse S3 (瀏覽 S3)，然後選擇您先前建立的目的地儲存貯體，以儲存清查報告 (例如，tutorial-bucket-3)。然後，選擇 Choose path (選擇路徑)。

存貨目的地值區必須位於相同 AWS 區域做為您設定 S3 庫存的來源儲存貯體。存貨目的地值區可以位於不同 AWS 帳戶.

在 Destination bucket (目的地儲存貯體) 欄位下，您會看到 Destination bucket permission (目的地儲存貯體許可)，這會新增至清查目的地儲存貯體政策，以允許 Amazon S3 將資料放入清查目的地儲存貯體中。如需詳細資訊，請參閱建立目的地儲存貯體政策。
針對 Frequency (頻率)，請選擇 Daily (每日)。
對於「輸出格式」，請選擇CSV。
針對 Status (狀態)，請選擇 Enable (啟用)。
在 Server-side encryption (伺服器端加密) 區段中，為此教學課程選擇 Disable (停用)。

如需詳細資訊，請參閱使用 S3 主控台設定清查和對 Amazon S3 授予許可使用您的客戶受管金鑰進行加密。
在 Additional fields - optional (其他欄位 - 選用) 區段中，選取 Size (大小)、Last modified (上次修改) 及 Storage class (儲存方案)。
選擇 Create (建立)。

如需詳細資訊，請參閱使用 S3 主控台設定清查。

檢查您的 S3 影片來源儲存貯體的清查報告

發佈清查報告時，資訊清單檔案會傳送到 S3 清查目的地儲存貯體。

登入 AWS Management Console 並打開 Amazon S3 控制台https://console.aws.amazon.com/s3/。
在左側導覽窗格中，選擇 Buckets (儲存貯體)。
在 Buckets (儲存貯體) 清單中，選擇影片來源儲存貯體的名稱 (例如，tutorial-bucket-1)。
選擇 Management (管理)。
若要查看 S3 清查報告是否準備好讓您在步驟 7 中建立 S3 批次操作任務，則在 Inventory configurations (清查組態) 下，檢查是否已啟用 Create job from manifest (從資訊清單建立任務) 按鈕。

注意
最多可能需要 48 小時的時間來提供首次清查報告。如果停用 Create job from manifest (從資訊清單建立任務) 按鈕，則尚未交付第一份清查報告。等到第一份清查報告交付，並且已啟用 Create job from manifest (從資訊清單建立任務) 按鈕，才能在步驟 7 中建立 S3 批次操作任務。
若要檢查 S3 清查報告 (manifest.json)，在 Destination (目的地) 欄位中，選擇您先前為存放清查報告而建立的清查目的地儲存貯體名稱 (例如，tutorial-bucket-3)。
在 Objects (物件) 索引標籤上，選擇具有 S3 來源儲存貯體名稱的現有資料夾 (例如，tutorial-bucket-1)。然後在 Inventory configuration name (清查組態名稱) 中，選擇您先前建立清查組態時所輸入的名稱 (例如，tutorial-inventory-config)。

您可以看到以報告產生日期為名稱的資料夾清單。
若要檢查某個特定日期的每日 S3 清查報告，請選擇具有對應產生日期名稱的資料夾，然後選擇 manifest.json。
若要在特定日期檢查清查報告的詳細資訊，請在 manifest.json 頁面中，選擇 Download (下載) 或 Open (開啟)。

步驟 6：為 S3 Batch 操作建立IAM角色

若要使用 S3 Batch 操作進行 Batch 轉碼，您必須先建立IAM角色，以授與 Amazon S3 執行 S3 批次操作的許可。

子步驟

為 S3 Batch 操作建立IAM政策
建立 S3 Batch 操作IAM角色並連接許可政策

為 S3 Batch 操作建立IAM政策

您必須建立IAM政策，授與 S3 Batch 操作讀取輸入資訊清單、叫用 Lambda 函數，以及撰寫 S3 Batch 操作任務完成報告。

登入 AWS Management Console 並在打開IAM控制台https://console.aws.amazon.com/iam/。
在左側導覽窗格中選擇 Policies (政策)。
選擇 建立政策。
選擇標JSON籤。

在JSON文字欄位中，貼上下列JSON原則。

在JSON原則中，以下列值取代四個範例值：

存放您的輸入影片的來源儲存貯體名稱 (例如，tutorial-bucket-1)。
您在步驟 5 中建立的用於存放 manifest.json 檔案的清查目的地儲存貯體的名稱 (例如，tutorial-bucket-3)。
您在步驟 1 中建立的用於存放輸出媒體檔案的儲存貯體的名稱 (例如，tutorial-bucket-2)。在本教學課程中，我們把任務完成報告放在輸出媒體檔案的目的地儲存貯體。
您在步驟 4 中建立ARN的 Lambda 函數的角色。若要尋找並複製 Lambda 函數ARN的角色，請執行下列動作：
- 在新的瀏覽器標籤中，在 https://console.aws.amazon.com/lambda/home#/functions 上開啟 Lambda 主控台中的 Functions (函數) 頁面。
- 在 Functions (函數) 清單中，選擇您在步驟 4 中建立的 Lambda 函數名稱 (例如，tutorial-lambda-convert)。
- 請選擇 CopyARN (複製)。


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

選擇下一步：標籤。
選擇下一步：檢閱。
在 Name (名稱) 欄位中，輸入 tutorial-s3batch-policy。
選擇 建立政策。

建立 S3 Batch 操作IAM角色並連接許可政策

登入 AWS Management Console 並在打開IAM控制台https://console.aws.amazon.com/iam/。
在左側導覽窗格中，選擇 Roles (角色)，然後選擇 Create role (建立角色)。
選擇 AWS 服務角色類型，然後選擇 S3 服務。
在 Select your use case (選取使用案例) 下，選擇 S3 Batch Operations (S3 批次操作)。
選擇下一步：許可。
在 [附加權限IAM原則] 底下，在搜尋方塊中輸入您先前建立的原則名稱 (例如tutorial-s3batch-policy)，以篩選原則清單。選取政策名稱 (例如，tutorial-s3batch-policy) 旁的核取方塊。
選擇下一步：標籤。
選擇下一步：檢閱。
在角色名稱中，輸入 tutorial-s3batch-role。

選擇建立角色。

建立 S3 Batch 操作的IAM角色後，下列信任政策會自動附加至該角色。此信任政策允許 S3 Batch 操作服務主體擔任該IAM角色。


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

步驟 7：建立並執行 S3 批次操作任務

若要建立 S3 批次操作任務以處理 S3 來源儲存貯體中的輸入影片，您必須指定此特定任務的參數。

注意

在開始建立 S3 批次操作任務之前，請確定 Create job from manifest (從資訊清單建立任務) 按鈕已啟用。如需詳細資訊，請參閱檢查您的 S3 影片來源儲存貯體的清查報告。如果 Create job from manifest (從資訊清單建立任務) 按鈕已停用，則尚未交付第一份清查報告且您必須等到該按鈕啟用為止。在步驟 5 中為 S3 來源儲存貯體設定 Amazon S3 清查後，交付第一份清查報告最多可能需要 48 小時的時間。

子步驟

建立一個 S3 批次操作任務
執行 S3 批次操作任務來叫用 Lambda 函數
(選用) 檢查完成報告
(選用) 監控 Lambda 主控台中的每個 Lambda 叫用
(選擇性) 監控主控台中的每個 MediaConvert 視訊轉碼工作 MediaConvert

建立一個 S3 批次操作任務

登入 AWS Management Console 並打開 Amazon S3 控制台https://console.aws.amazon.com/s3/。
在左側導覽窗格中，選擇 Batch Operations (批次操作)。
選擇建立作業。
針對 AWS 區域」下方，選擇您要建立工作的「區域」。

在本教學課程中，若要使用 S3 批次操作任務來叫用 Lambda 函數，您必須在與資訊清單中參照的物件所在的 S3 影片來源儲存貯體相同的區域中建立任務。
在 Manifest (資訊清單) 區段中，執行下列動作：
1. 針對 Manifest format (資訊清單格式)，選擇 S3 Inventory report (manifest.json) (S3 庫存報告 (manifest.json))。
2. 針對 Manifest object (資訊清單物件)，選擇 Browse S3 (瀏覽 S3)，以查找您在步驟 5 中為存放清查報告而建立的儲存貯體 (例如，tutorial-bucket-3)。在 Manifest object (資訊清單物件) 頁面上，瀏覽物件名稱，直到找到特定日期的 manifest.json 檔案。此檔案會列出您想要批次轉碼的所有影片的相關資訊。當您找到 manifest.json 檔案時，請選擇檔案旁邊的選項按鈕。然後，選擇 Choose path (選擇路徑)。
3. (選用) 對於 Manifest object version ID - optional (資訊清單物件版本 ID - 選用)，如果您想要使用最新版本以外的版本，請輸入資訊清單物件的版本 ID。
選擇 Next (下一步)。
若要使用 Lambda 函數對所選manifest.json檔案中列出的所有物件進行轉碼，請在「作業類型」下選擇 「叫用」 AWS Lambda 功能。
在 Invoke Lambda function (叫用 Lambda 函數) 區段中，執行下列動作：
1. 選擇 Choose from functions in your account (從帳戶中的函數選擇)。
2. 針對 Lambda function (Lambda 函數)，選擇您在步驟 4 中建立的 Lambda 函數 (例如，tutorial-lambda-convert)。
3. 對於 Lambda 函數版本，請保留預設值 $ LATEST。
選擇 Next (下一步)。Configure additional options (設定其他選項) 頁面隨即開啟。
在 Additional options (其他選項) 區段中，保留預設設定。

如需關於這些選項的詳細資訊，請參閱批次操作任務請求元素。
在 Completion report (完成報告) 區段中, 針對 Path to completion report destination (完成報告目的地的路徑)，選擇 Browse S3 (瀏覽 S3)。找出在步驟 1 中您為輸出媒體檔案建立的儲存貯體 (例如，tutorial-bucket-2)。選擇儲存貯體名稱旁的選項按鈕。然後，選擇 Choose path (選擇路徑)。

對於剩餘的 Completion report (完成報告) 設定，請保留預設值。如需完成報告設定的詳細資訊，請參閱批次操作任務請求元素。完成報告會維護任務的詳細資訊和執行的操作的記錄。
在「權限」區段中，選擇「從現有IAM角色中選擇」。針對IAM角色，選擇您在步驟 6 中建立的 S3 Batch 操作任務的IAM角色 (例如tutorial-s3batch-role)。
選擇 Next (下一步)。
請詳閱 Review (檢閱) 頁面上的設定。然後，選擇 Create Job (建立任務)。

在 S3 完成讀取 S3 批次操作任務的資訊清單後，會將任務的 Status (狀態) 設定為 Awaiting your confirmation to run (等待確認執行)。若要查看任務狀態的更新，請重新整理頁面。您無法執行任務，直到其狀態為 Awaiting your confirmation to run (等待確認執行)。

執行 S3 批次操作任務來叫用 Lambda 函數

執行批次操作任務以叫用 Lambda 函數進行影片轉碼。如果您的任務失敗，您可以檢查完成報告，以找出原因。

執行 S3 批次操作任務

登入 AWS Management Console 並打開 Amazon S3 控制台https://console.aws.amazon.com/s3/。
在左側導覽窗格中，選擇 Batch Operations (批次操作)。
從 Jobs (任務) 清單中，選擇第一列的任務的 Job ID (任務 ID)，也就是您先前建立的 S3 批次操作任務。
選擇執行工作。
再次檢閱您的任務參數，並確認 Total objects listed in manifest (資訊清單中列出的物件總數) 的數值與資訊清單中的物件數目相同。接著選擇 Run job (執行任務)。

隨即開啟 S3 批次操作任務頁面。
開始執行任務後，在任務頁面上的 Status (狀態) 下，檢查 S3 批次操作任務的進度，例如 Status (狀態)、% Complete (完成百分比)、Total succeeded (rate) (總成功 (率))、Total failed (rate) (總失敗 (率))、Date terminated (終止日期) 以及 Reason for termination (終止的原因)。

S3 批次操作任務完成時，請檢視任務頁面上的資料，以確認任務是否如預期完成。

如果超過 50% 的 S3 批次操作任務的物件操作在嘗試超過 1,000 次操作後失敗，則任務會自動失敗。若要檢查完成報告以識別失敗的原因，請使用下列選用程序。

(選用) 檢查完成報告

您可以使用完成報告來判斷哪些物件失敗以及失敗的原因。

若要檢查完成報告，以取得失敗物件的詳細資訊

在 S3 批次操作任務的頁面上，向下捲動至 Completion report (完成報告) 區段，然後選擇 Completion report destination (完成報告目的地) 下的連結。

S3 輸出目的地儲存貯體頁面隨即開啟。
在 Objects (物件) 索引標籤上，選擇名稱以您先前建立之 S3 批次操作任務的任務 ID 為結尾的資料夾。
選擇 results/。
選取 .csv 檔案旁的核取方塊。
若要檢視任務報告，請選擇 Open (開啟) 或 Download (下載)。

(選用) 監控 Lambda 主控台中的每個 Lambda 叫用

開始執行 S3 批次操作任務之後，任務會叫用每個輸入影片物件的 Lambda 函數。S3 會將每個 Lambda 叫用的記錄寫入 CloudWatch 日誌。您可以使用 Lambda 主控台的監控儀表板來監控您的 Lambda 函數。

打開 AWS Lambda 控制台位於https://console.aws.amazon.com/lambda/。
在左側導覽窗格中，選擇 Functions (函數)。
在 Functions (函數) 清單中，選擇您在步驟 4 中建立的 Lambda 函數名稱 (例如，tutorial-lambda-convert)。
選擇監控索引標籤。
在 Metrics (指標) 下，請參閱 Lambda 函數的執行時間指標。
在「記錄檔」下，透過日誌深入解析檢視每個 Lambda 叫用的 CloudWatch 日誌資料。

注意
當您搭配 Lambda 函數使用 S3 批次操作時，Lambda 函數會叫用每個物件。如果您的 S3 批次操作任務較大，則可以同時叫用多個 Lambda 函數，會造成 Lambda 並行峰值。
每個 AWS 帳戶每個區域都有 Lambda 並行配額。如需詳細資訊，請參閱 AWS Lambda 中的函數縮放 AWS Lambda 開發人員指南。搭配 S3 批次操作使用 Lambda 函數的最佳實務是設定 Lambda 函數本身的並行限制。設定並行限制可以避免您的任務耗用大部分 Lambda 並行，並可能調節您帳戶中的其他功能。如需詳細資訊，請參閱中的管理 Lambda 保留並行 AWS Lambda 開發人員指南。

(選擇性) 監控主控台中的每個 MediaConvert 視訊轉碼工作 MediaConvert

工作完成對媒體文件進行轉碼的工作。 MediaConvert 當 S3 Batch 操作任務為每個視訊叫用 Lambda 函數時，每個 Lambda 函數呼叫都會為每個輸入視訊建立 MediaConvert 轉碼任務。

登入 AWS Management Console 並在。打開 MediaConvert 控制台https://console.aws.amazon.com/mediaconvert/。
如果出現 MediaConvert 介紹頁面，請選擇 [開始使用]。
從 Jobs (任務) 清單中，檢視每一列，以監控每個輸入影片的轉碼任務。
識別您要檢查的任務列，然後選擇 Job ID (任務 ID) 連結，以開啟任務詳細資訊頁面。
在 [Job 摘要] 頁面的 [輸出] 下，根據瀏覽器支援的內容選擇、或縮圖輸出的連結，以移至輸出媒體檔案的 S3 目標儲存貯體。HLS MP4
在 S3 輸出目標儲存貯體的對應資料夾 (HLS、或縮圖) 中，選擇輸出媒體檔案物件的名稱。MP4

物件詳細資訊頁面隨即開啟。
在物件詳細資訊頁面的 [物件概觀] 底下，選擇 [物件] 下的連結，URL以監視轉碼的輸出媒體檔案。

步驟 8：從 S3 目的地儲存貯體檢查輸出媒體檔案

若要從 S3 目的地儲存貯體檢查輸出媒體檔案

登入 AWS Management Console 並打開 Amazon S3 控制台https://console.aws.amazon.com/s3/。
在左側導覽窗格中，選擇 Buckets (儲存貯體)。
在 Buckets (儲存貯體) 清單中，選擇您在步驟 1 中建立的輸出媒體檔案的 S3 目的地儲存貯體名稱 (例如，tutorial-bucket-2)。
在 Objects (物件) 標籤上，每個輸入影片都有一個具有輸入影片名稱的資料夾。每個資料夾皆包含輸入影片的轉碼後的輸出媒體檔案。

若要檢查輸入影片的輸出媒體檔案，請執行下列動作：
1. 選擇以您要檢查的輸入影片名稱命名的資料夾。
2. 選擇 Default/ 資料夾。
3. 選擇轉碼格式的資料夾 (HLSMP4、或本教學課程中的縮圖)。
4. 選擇輸出媒體檔案的名稱。
5. 若要觀看已轉碼的檔案，請在物件的詳細資訊頁面上，選擇「物件」(Object URL) 下的連結。
  
  HLS格式的輸出媒體文件被分成短段。要播放這些視頻，請將.m3u8文件URL的對象嵌入兼容的播放器中。

步驟 9：清除

如果您使用 S3 Batch 操作 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/。
在左側導覽窗格中，選擇 Buckets (儲存貯體)。
在 Buckets (儲存貯體) 清單中，選擇來源儲存貯體的名稱 (例如，tutorial-bucket-1)。
選擇 Management (管理) 標籤，
在 Inventory configurations (清查組態) 中，選擇您在步驟 5 中建立的清查組態 (例如，tutorial-inventory-config) 旁的選項按鈕。
選擇 Delete (刪除)，然後選擇 Confirm (確認)。

刪除 Lambda 函數

打開 AWS Lambda 控制台位於https://console.aws.amazon.com/lambda/。
在左側導覽窗格中，選擇 Functions (函數)。
選取您在步驟 4 中建立的函數旁的核取方塊 (例如，tutorial-lambda-convert)。
選擇動作，然後選擇刪除。
在 Delete function (刪除函數) 對話方塊中，選擇 Delete (刪除)。

刪除記 CloudWatch 錄群組

在開啟 CloudWatch 主控台https://console.aws.amazon.com/cloudwatch/。
在左側導覽窗格中，選擇 Logs (日誌)，然後選擇 Log groups (日誌群組)。
選取日誌群組旁的核取方塊，該日誌群組的名稱以您在步驟 4 中建立的 Lambda 函數結尾 (例如，tutorial-lambda-convert)。
選擇 Actions (動作)，然後選擇 Delete log group (刪除日誌群組)。
在 刪除日誌群組 對話方塊中，選擇刪除。

刪除IAM角色以及IAM角色的內嵌政策

若要刪除在步驟 2、步驟 3 和步驟 6 中建立的IAM角色，請執行下列操作：

登入 AWS Management Console 並在打開IAM控制台https://console.aws.amazon.com/iam/。
在左側導覽窗格中，選擇 Roles (角色)，然後選取您要刪除之角色名稱旁的核取方塊。
在頁面頂端，選擇 Delete (刪除)。
在確認對話方塊中，根據提示在文字輸入欄位中輸入所需的回應，然後選擇 Delete (刪除)。

刪除客戶管理IAM的政策

若要刪除您在步驟 6 中建立的客戶管理IAM策略，請執行下列動作：

登入 AWS Management Console 並在打開IAM控制台https://console.aws.amazon.com/iam/。
在左側導覽窗格中選擇 Policies (政策)。
選擇您在步驟 6 中建立之政策 (例如，tutorial-s3batch-policy) 旁的選項按鈕。您可以使用搜尋方塊來篩選政策清單。
選擇動作，然後選擇刪除。
在文字欄位中，輸入本政策的名稱，以確認您要刪除此政策，然後選擇 Delete (刪除)。

清空 S3 儲存貯體

若要清空您在先決條件、步驟 1 及步驟 5 中建立的 S3 儲存貯體，請執行下列動作：

登入 AWS Management Console 並打開 Amazon S3 控制台https://console.aws.amazon.com/s3/。
在左側導覽窗格中，選擇 Buckets (儲存貯體)。
在 Bucket (儲存貯體) 清單中，選擇您要清空之儲存貯體名稱旁的選項按鈕，然後選擇 Empty (清空)。
在 Empty bucket (清空儲存貯體) 頁面上，在文字欄位中輸入 permanently delete 以確認您要清空儲存貯體，然後選擇 Empty (清空)。

刪除 S3 儲存貯體

若要刪除您在先決條件、步驟 1 及步驟 5 中建立的 S3 儲存貯體，請執行下列動作：

登入 AWS Management Console 並打開 Amazon S3 控制台https://console.aws.amazon.com/s3/。
在左側導覽窗格中，選擇 Buckets (儲存貯體)。
在 Buckets (儲存貯體) 清單中，選擇您要刪除之儲存貯體名稱旁的選項按鈕。
選擇刪除。
在 Delete bucket (刪除儲存貯體) 頁面上，在文字欄位中輸入儲存貯體名稱以確認您要刪除該儲存貯體，然後選擇 Delete bucket (刪除儲存貯體)。

後續步驟

完成本教學課程後，您可以進一步探索其他相關使用案例：

您可以使用 Amazon CloudFront 將已轉碼的媒體檔案串流給全球的觀眾。如需詳細資訊，請參閱教學課程：使用 Amazon S3、Amazon 和 Amazon Route 53 託管隨選串流視訊 CloudFront。
當您將影片上傳到 S3 來源儲存貯體時，您可以對影片進行轉碼。若要這麼做，您可以設定 Amazon S3 事件觸發器，該觸發器會自動叫用 Lambda 函數，將 S3 中的新物件轉碼為。 MediaConvert如需詳細資訊，請參閱教學課程：使用 Amazon S3 觸發程序叫用中的 Lambda 函數 AWS Lambda 開發人員指南。

您的瀏覽器已停用或無法使用 Javascript。

您必須啟用 Javascript，才能使用 AWS 文件。請參閱您的瀏覽器說明頁以取得說明。

文件慣用形式

託管影片串流

透過多部分上傳來上傳物件，並驗證其資料完整性