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

本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。

教學課程：使用 S3 批次操作進行批次轉碼影片

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

AWS 提供您建立可擴展、分散式架構的方法，其執行下列動作：

  • 擷取輸入影片

  • 處理影片，以在各種裝置上播放

  • 存放轉碼後的媒體檔案

  • 交付輸出媒體檔案，以滿足需求

當您在 Amazon S3 中存放了大量的影片儲存庫時，您可以將這些影片從其來源格式轉碼為特定影片播放器或裝置所需的大小、解析度和格式各異的多種檔案類型。具體而言，S3 Batch Operations 為您提供解決方案，以叫用 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 來源儲存貯體，請將與 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 目的地儲存貯體中的轉碼媒體檔案。

為您的輸出媒體檔案建立儲存貯體

  1. 登入 AWS Management Console 並在 開啟 Amazon S3 主控台https://console.aws.amazon.com/s3/。

  2. 在左側導覽窗格中，選擇 Buckets (儲存貯體)。

  3. 選擇建立儲存貯體。

  4. 針對 Bucket name (儲存貯體名稱)，輸入儲存貯體的名稱 (例如 amzn-s3-demo-destination-bucket1)。

  5. 針對區域 ，選擇您要儲存貯體所在的 AWS 區域 。

  6. 若要確保公開存取您的輸出媒體檔案，請在 Block Public Access settings for this bucket (此儲存貯體的封鎖公開存取設定) 中，清除 Block all public access (封鎖所有公開存取)。

    警告

    在完成此步驟之前，請檢閱 封鎖對 Amazon S3 儲存體的公開存取權 以確保您了解並接受允許公開存取所涉及的風險。當您關閉 Block Public Access (封鎖公開存取) 設定以公開儲存貯體時，網際網路上的任何人都可以存取您的儲存貯體。我們建議您封鎖對儲存貯體的所有公用存取權。

    如果您不想清除封鎖公開存取設定，您可以使用 Amazon CloudFront 將轉碼媒體檔案交付給檢視器 （最終使用者）。如需詳細資訊，請參閱教學課程：使用 Amazon S3、Amazon CloudFront和 Amazon Route 53 託管隨需串流影片。

  7. 選取 I acknowledge that the current settings might result in this bucket and the objects within becoming public (我確認目前的設定可能會導致此儲存貯體及其中的物件變為公開) 旁的核取方塊。

  8. 將其餘設定保持為預設值。

  9. 選擇建立儲存貯體。

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

JSON CORS 組態定義了載入一個網域的用戶端 Web 應用程式 （此內容中的影片播放器），以在不同網域中播放轉碼輸出媒體檔案的方式。

  1. 登入 AWS Management Console 並在 開啟 Amazon S3 主控台https://console.aws.amazon.com/s3/。

  2. 在左側導覽窗格中，選擇 Buckets (儲存貯體)。

  3. 在 Buckets (儲存貯體) 清單中，選擇您先前建立的儲存貯體名稱 (例如，amzn-s3-demo-destination-bucket1)。

  4. 選擇許可索引標籤標籤。

  5. 在跨來源資源共用 （CORS） 區段中，選擇編輯 。

  6. 在CORS組態文字方塊中，複製並貼上下列CORS組態。

    CORS 組態必須是 JSON 格式。在此範例中，AllowedOrigins 屬性使用萬用字元 (*) 來指定所有來源伺服器。如果您知道您的特定原始伺服器，您可以將AllowedOrigins屬性限制為特定播放器 URL。如需有關設定此屬性和其他屬性的詳細資訊，請參閱 CORS 組態的元素。

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

    }
]

  7. 選擇 Save changes (儲存變更)。

步驟 2：建立 IAM的角色 MediaConvert

若要使用 AWS Elemental MediaConvert 來轉碼儲存在 S3 儲存貯體中的輸入影片，您必須具有 AWS Identity and Access Management （IAM） 服務角色，以授予 MediaConvert 許可，將影片檔案從 S3 來源和目的地儲存貯體讀取和寫入。當您執行轉碼任務時， MediaConvert 主控台會使用此角色。

為 建立IAM角色 MediaConvert

  1. 使用您選擇的IAM角色名稱建立角色 （例如 tutorial-mediaconvert-role）。若要建立此角色，請遵循 AWS Elemental MediaConvert 使用者指南 中的在 IAM（主控台） 中建立 MediaConvert 角色中的步驟。

  2. 為 建立IAM角色後 MediaConvert，在角色 清單中，選擇 MediaConvert 您建立的角色名稱 （例如 tutorial-mediaconvert-role）。

  3. 在摘要頁面上，複製角色 ARN （以 開頭arn:aws:iam::），並儲存 ARN以供稍後使用。

    如需 的詳細資訊ARNs，請參閱AWS 一般參考 中的 Amazon Resource Names （ARNs）。

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

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

為您的 Lambda 函數建立IAM角色

  1. 登入 AWS Management Console 並在 開啟IAM主控台https://console.aws.amazon.com/iam/。

  2. 在左側導覽窗格中，選擇 Roles (角色)，然後選擇 Create role (建立角色)。

  3. 選擇 AWS service (AWS 服務) 角色類型，然後在 Common use cases (常用使用案例) 下，選擇 Lambda。

  4. 選擇下一步：許可。

  5. 在 Attach Permissions policies (連接許可政策) 頁面上，於 Filter policies (篩選政策) 方塊中輸入 AWSLambdaBasicExecutionRole。若要將受管政策連接至AWSLambdaBasicExecutionRole此角色，以授予 Amazon CloudWatch Logs 寫入許可，請選取 旁邊的核取方塊AWSLambdaBasicExecutionRole。

  6. 選擇下一步：標籤。

  7. (選用) 新增標籤至受管政策。

  8. 選擇下一步：檢閱。

  9. 在角色名稱中，輸入 tutorial-lambda-transcode-role。

  10. 選擇建立角色。

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

若要授予許可給 Lambda 函數執行所需的 MediaConvert 資源，您必須使用內嵌政策。

  1. 登入 AWS Management Console 並在 開啟IAM主控台https://console.aws.amazon.com/iam/。

  2. 在左側導覽窗格中，選擇 Roles (角色)。

  3. 在角色清單中，選擇您先前為 Lambda 函數建立IAM的角色名稱 （例如 tutorial-lambda-transcode-role）。

  4. 選擇 Permissions (許可) 標籤。

  5. 選擇 Add inline policy (新增內嵌政策)。

  6. 選擇 JSON索引標籤，然後複製並貼上下列JSON政策。

    在JSON政策中，將 的範例ARN值取代Resource為您在步驟 2 中IAM MediaConvert 建立ARN的角色角色 （例如 tutorial-mediaconvert-role）。 步驟 2：建立 IAM的角色 MediaConvert

    {
    "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. 選擇檢閱政策。

  8. 對於 Name (名稱)，輸入 tutorial-lambda-policy。

  9. 選擇 建立政策 。

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

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

在教學課程的本節中，您可以使用 SDK for Python 與 S3 批次操作 和 整合，建置 Lambda 函數 MediaConvert。若要開始轉碼已存放在 S3 來源儲存貯體中的影片，您需要執行 S3 批次操作任務，該任務會直接為 S3 來源儲存貯體中的每個影片叫用 Lambda 函數。然後，Lambda 函數會將每個影片的轉碼任務提交給 MediaConvert。

撰寫 Lambda 函數程式碼並建立部署套件

  1. 在本機電腦上，建立名為 batch-transcode 的資料夾。

  2. 在 batch-transcode 資料夾中，使用JSON任務設定建立檔案。例如，您可以使用本區段提供的設定，並將檔案命名為 job.json。

    指定下列項目的 job.json 檔案：

    • 要轉碼的檔案

    • 您想要如何轉碼輸入影片

    • 您想要建立的輸出媒體檔案

    • 如何命名轉碼後的檔案

    • 轉碼後的檔案的儲存位置

    • 要套用的進階功能等等

    在此教學課程中，我們使用下列 job.json 檔案為 S3 來源儲存貯體中的每個影片建立以下輸出：

    • HTTP 即時串流 （HLS） 適應性位元速率串流，可在不同大小和不同頻寬的多個裝置上播放

    • MP4 影片檔案

    • 每隔一段時間收集的縮圖影像

    此範例job.json檔案使用 Quality-Defined Variable Bitrate （QVBR） 來最佳化影片品質。HLS 輸出符合 Apple 標準 （音訊從影片中未混合、區段持續時間為 6 秒，以及透過自動 最佳化的影片品質QVBR）。

    如果想要不使用此處提供的範例設定，您可以根據您的使用案例產生 job.json 規格。為了確保輸出的一致性，請確定您的輸入檔案具有類似的影片和音訊組態。針對任何具有不同影片和音訊組態的輸入檔案，建立單獨的自動化 (唯一的 job.json 設定)。如需詳細資訊，請參閱 AWS Elemental MediaConvert 使用者指南 中的任務設定範例 AWS Elemental MediaConvert JSON。

    {
  "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"
    }
  ]
}
    顯示較多顯示較少

  3. 在 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['amzn-s3-demo-destination-bucket'],
                    os.path.splitext(os.path.basename(source_s3_key))[0],
                    os.path.splitext(os.path.basename(job_name))[0])

        for output_group in job_settings['OutputGroups']:
            output_group_type = output_group['OutputGroupSettings']['Type']
            if output_group_type in output_group_type_dict.keys():
                output_group_type = output_group_type_dict[output_group_type]
                output_group['OutputGroupSettings'][output_group_type]['Destination'] = \
                    "{0}{1}".format(destination_s3,
                                    urlparse(output_group['OutputGroupSettings'][output_group_type]['Destination']).path)
            else:
                raise ValueError("Exception: Unknown Output Group Type {}."
                                 .format(output_group_type))

        job_metadata_dict = {
            'assetID': str(uuid.uuid4()),
            'application': os.environ['Application'],
            'input': source_s3,
            'settings': job_name
        }

        region = os.environ['AWS_DEFAULT_REGION']
        endpoints = boto3.client('mediaconvert', region_name=region) \
            .describe_endpoints()
        client = boto3.client('mediaconvert', region_name=region, 
                               endpoint_url=endpoints['Endpoints'][0]['Url'], 
                               verify=False)

        try:
            client.create_job(Role=os.environ['MediaConvertRole'], 
                              UserMetadata=job_metadata_dict, 
                              Settings=job_settings)
        # You can customize error handling based on different error codes that 
        # MediaConvert can return.
        # For more information, see MediaConvert error codes. 
        # When the result_code is TemporaryFailure, S3 Batch Operations retries 
        # the task before the job is completed. If this is the final retry, 
        # the error message is included in the final report.
        except Exception as error:
            result_code = 'TemporaryFailure'
            raise
    
    except Exception as error:
        if result_code != 'TemporaryFailure':
            result_code = 'PermanentFailure'
        result_string = str(error)

    finally:
        result_list.append({
            'taskId': task_id,
            'resultCode': result_code,
            'resultString': result_string,
        })

    return {
        'invocationSchemaVersion': invocation_schema_version,
        'treatMissingKeyAs': 'PermanentFailure',
        'invocationId': invocation_id,
        'results': result_list
    }

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

  1. 在 開啟 AWS Lambda 主控台https://console.aws.amazon.com/lambda/。

  2. 在左側導覽窗格中，選擇 Functions (函數)。

  3. 選擇建立函數。

  4. 選擇 Author from scratch (從頭開始撰寫)。

  5. 在基本資訊下，請執行下列動作：

    1. 針對 函數名稱 ，請輸入 tutorial-lambda-convert。

    2. 針對 Runtime (執行時間)，選擇 Python 3.8 或更新的 Python 版本。

  6. 選擇 Change default execution role (變更預設執行角色)，並在 Execution role (執行角色) 下，選擇 Use an existing role (使用現有角色)。

  7. 在現有角色 下，選擇您在步驟 3 中為 Lambda 函數建立IAM的角色名稱 （例如 tutorial-lambda-transcode-role）。 步驟 3：為您的 Lambda 函數建立IAM角色

  8. 對於其他設定，請保留預設值。

  9. 選擇建立函數。

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

  1. 在頁面的 Code Source (程式碼來源) 區段中，為您先前建立的 Lambda 函數 (例如，tutorial-lambda-convert)，依次選擇 Upload from (上傳來源) 和 .zip 檔案。

  2. 選擇 Upload (上傳) 以選取您的本機 .zip 檔案。

  3. 選擇您之前建立的 lambda.zip 檔案，然後選擇 Open (開啟)。

  4. 選擇 Save (儲存)。

  5. 在 Runtime settings (執行時間設定) 區段中，選擇 Edit (編輯)。

  6. 若要告知 Lambda 執行時間要叫用 Lambda 函數程式碼中的處理常式方法，請在 Handler (處理常式) 欄位中輸入 convert.handler。

    當您設定 Python 函式時，處理常式的設定值就是檔案名稱加上處理常式模組名稱，並且以點 (.) 分隔。例如，convert.handler 會呼叫 convert.py 檔案中定義的 handler 方法。

  7. 選擇 Save (儲存)。

  8. 在 Lambda 函數頁面上，選擇 Configuration (組態) 標籤。在 Configuration (組態) 索引標籤的左側導覽窗格中，選擇 Environment variables (環境變數)，然後選擇 Edit (編輯)。

  9. 選擇 Add environment variable (新增環境變數)。然後，為以下每個環境變數輸入指定的 Key (索引鍵) 和 Value (數值)：

    • Key (索引鍵)：DestinationBucket Value (數值)：amzn-s3-demo-destination-bucket1

      該數值是您在步驟 1 中建立的輸出媒體檔案的 S3 儲存貯體。

    • Key (索引鍵)：MediaConvertRole Value (數值)：arn:aws:iam::111122223333:role/tutorial-mediaconvert-role

      此值是IAM MediaConvert 您在步驟 2 中建立ARN的角色的 。 步驟 2：建立 IAM的角色 MediaConvert請務必ARN以IAM角色ARN的實際 取代。

    • Key (索引鍵)：Application Value (數值)：Batch-Transcoding

      這是應用程式名稱的值。

  10. 選擇 Save (儲存)。

  11. (選用) 在 Configuration (組態) 標籤上，在左側導覽窗格的 General configuration (一般組態) 區段中，選擇 Edit (編輯)。在 Timeout (逾時) 欄位中，輸入 2 分 0 秒。然後選擇 Save (儲存)。

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

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

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

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

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

  1. 登入 AWS Management Console 並在 開啟 Amazon S3 主控台https://console.aws.amazon.com/s3/。

  2. 在左側導覽窗格中，選擇 Buckets (儲存貯體)。

  3. 選擇建立儲存貯體。

  4. 針對 Bucket name (儲存貯體名稱)，輸入儲存貯體的名稱 (例如 amzn-s3-demo-destination-bucket2)。

  5. 針對 AWS 區域，選擇您要儲存貯體所在的 AWS 區域 。

    庫存目的地儲存貯體必須與您要設定 S3 庫存的 AWS 區域 來源儲存貯體位於相同位置。清查目的地儲存貯體可位於不同的 AWS 帳戶之中。

  6. 在 Block Public Access settings for this bucket (此儲存貯體的封鎖公開存取設定) 中，保留預設設定 (已啟用 Block all public access (封鎖所有公開存取))。

  7. 對於其他設定，請保留預設值。

  8. 選擇建立儲存貯體。

  9. 在 Buckets (儲存貯體) 清單中，選擇您剛剛建立的儲存貯體名稱 (例如，amzn-s3-demo-destination-bucket2)。

  10. 若要授予 Amazon S3 將清查報告的資料寫入 S3 清查目的地儲存貯體的許可，請選擇 Permissions (許可) 標籤。

  11. 向下捲動到 Bucket policy (儲存貯體政策) 區段，然後選擇 Edit (編輯)。Bucket policy (儲存貯體政策) 頁面隨即開啟。

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

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

    • 您為存放清查報告而建立的儲存貯體名稱 (例如，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"
          }
       }
    }
  ]
}

  13. 選擇 Save changes (儲存變更)。

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

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

  1. 登入 AWS Management Console 並在 開啟 Amazon S3 主控台https://console.aws.amazon.com/s3/。

  2. 在左側導覽窗格中，選擇 Buckets (儲存貯體)。

  3. 若要在 S3 來源儲存貯體中設定輸入影片的 S3 清查報告，請在 Buckets (儲存貯體) 清單中，選擇 S3 來源儲存貯體的名稱 (例如，amzn-s3-demo-source-bucket)。

  4. 選擇 Management (管理) 標籤，

  5. 向下捲動至 Inventory configurations (清查組態) 區段，然後選擇 Create inventory configuration (建立清查組態)。

  6. 在 Inventory configuration name (清查組態名稱) 中，輸入一個名稱 (例如，tutorial-inventory-config)。

  7. 在 Inventory scope (清查範圍) 下，針對 Object versions (物件版本) 選擇 Current version only (僅限目前版本)，並將其他 Inventory scope (清查範圍) 設定為本教學課程保留預設值。

  8. 在 Report details (報告詳細資訊) 區段中，針對 Destination bucket (目的地儲存貯體)，選擇 This account (此帳戶)。

  9. 針對 Destination (目的地)，選擇 Browse S3 (瀏覽 S3)，然後選擇您先前建立的目的地儲存貯體，以儲存清查報告 (例如，amzn-s3-demo-destination-bucket2)。然後，選擇 Choose path (選擇路徑)。

    庫存目的地儲存貯體必須與您要設定 S3 庫存的 AWS 區域 來源儲存貯體位於相同位置。清查目的地儲存貯體可位於不同的 AWS 帳戶之中。

    在 Destination bucket (目的地儲存貯體) 欄位下，您會看到 Destination bucket permission (目的地儲存貯體許可)，這會新增至清查目的地儲存貯體政策，以允許 Amazon S3 將資料放入清查目的地儲存貯體中。如需詳細資訊，請參閱建立目的地儲存貯體政策。

  10. 針對 Frequency (頻率)，請選擇 Daily (每日)。

  11. 針對輸出格式 ，選擇 CSV。

  12. 針對 Status (狀態)，請選擇 Enable (啟用)。

  13. 在 Server-side encryption (伺服器端加密) 區段中，為此教學課程選擇 Disable (停用)。

    如需詳細資訊，請參閱 使用 S3 主控台設定清查 和 對 Amazon S3 授予許可使用您的客戶受管金鑰進行加密。

  14. 在 Additional fields - optional (其他欄位 - 選用) 區段中，選取 Size (大小)、Last modified (上次修改) 及 Storage class (儲存方案)。

  15. 選擇 Create (建立)。

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

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

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

  1. 登入 AWS Management Console 並在 開啟 Amazon S3 主控台https://console.aws.amazon.com/s3/。

  2. 在左側導覽窗格中，選擇 Buckets (儲存貯體)。

  3. 在 Buckets (儲存貯體) 清單中，選擇影片來源儲存貯體的名稱 (例如，amzn-s3-demo-source-bucket)。

  4. 選擇 Management (管理)。

  5. 若要查看 S3 清查報告是否準備好讓您在步驟 7 中建立 S3 批次操作任務，則在 Inventory configurations (清查組態) 下，檢查是否已啟用 Create job from manifest (從資訊清單建立任務) 按鈕。

    注意

    最多可能需要 48 小時的時間來提供首次清查報告。如果停用 Create job from manifest (從資訊清單建立任務) 按鈕，則尚未交付第一份清查報告。等到第一份清查報告交付，並且已啟用 Create job from manifest (從資訊清單建立任務) 按鈕，才能在步驟 7 中建立 S3 批次操作任務。

  6. 若要檢查 S3 清查報告 (manifest.json)，在 Destination (目的地) 欄位中，選擇您先前為存放清查報告而建立的清查目的地儲存貯體名稱 (例如，amzn-s3-demo-destination-bucket2)。

  7. 在 Objects (物件) 索引標籤上，選擇具有 S3 來源儲存貯體名稱的現有資料夾 (例如，amzn-s3-demo-source-bucket)。然後在 Inventory configuration name (清查組態名稱) 中，選擇您先前建立清查組態時所輸入的名稱 (例如，tutorial-inventory-config)。

    您可以看到以報告產生日期為名稱的資料夾清單。

  8. 若要檢查某個特定日期的每日 S3 清查報告，請選擇具有對應產生日期名稱的資料夾，然後選擇 manifest.json。

  9. 若要在特定日期檢查清查報告的詳細資訊，請在 manifest.json 頁面中，選擇 Download (下載) 或 Open (開啟)。

步驟 6：建立 S3 批次操作IAM的角色

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

建立 S3 批次操作IAM的政策

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

  1. 登入 AWS Management Console 並在 開啟IAM主控台https://console.aws.amazon.com/iam/。

  2. 在左側導覽窗格中選擇 Policies (政策)。

  3. 選擇 建立政策。

  4. 選擇 JSON 索引標籤。

  5. 在JSON文字欄位中，貼上下列JSON政策。

    在JSON政策中，將四個範例值取代為下列值：

    • 存放您的輸入影片的來源儲存貯體名稱 (例如，amzn-s3-demo-source-bucket)。

    • 您在步驟 5 中建立的用於存放 manifest.json 檔案的清查目的地儲存貯體的名稱 (例如，amzn-s3-demo-destination-bucket2)。

    • 您在步驟 1 中建立的用於存放輸出媒體檔案的儲存貯體的名稱 (例如，amzn-s3-demo-destination-bucket1)。在本教學課程中，我們把任務完成報告放在輸出媒體檔案的目的地儲存貯體。

    • 您在步驟 4 中建立ARN的 Lambda 函數角色。 步驟 4：為影片轉碼建立 Lambda 函數若要尋找和複製 Lambda 函數ARN的角色，請執行下列動作：

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

  6. 選擇下一步：標籤。

  7. 選擇下一步：檢閱。

  8. 在 Name (名稱) 欄位中，輸入 tutorial-s3batch-policy。

  9. 選擇 建立政策。

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

  1. 登入 AWS Management Console 並在 開啟IAM主控台https://console.aws.amazon.com/iam/。

  2. 在左側導覽窗格中，選擇 Roles (角色)，然後選擇 Create role (建立角色)。

  3. 選擇 AWS 服務 角色類型，然後選擇 S3 服務。

  4. 在 Select your use case (選取使用案例) 下，選擇 S3 Batch Operations (S3 批次操作)。

  5. 選擇下一步：許可。

  6. 在連接許可政策 下，在搜尋方塊中輸入您先前建立IAM的政策名稱 （例如 tutorial-s3batch-policy），以篩選政策清單。選取政策名稱 (例如，tutorial-s3batch-policy) 旁的核取方塊。

  7. 選擇下一步：標籤。

  8. 選擇下一步：檢閱。

  9. 在角色名稱中，輸入 tutorial-s3batch-role。

  10. 選擇建立角色。

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

建立一個 S3 批次操作任務

  1. 登入 AWS Management Console 並在 開啟 Amazon S3 主控台https://console.aws.amazon.com/s3/。

  2. 在左側導覽窗格中，選擇 Batch Operations (批次操作)。

  3. 選擇建立作業。

  4. 針對 AWS 區域，​選擇要在其中建立任務的區域。

    在本教學課程中，若要使用 S3 批次操作任務來叫用 Lambda 函數，您必須在與資訊清單中參照的物件所在的 S3 影片來源儲存貯體相同的區域中建立任務。

  5. 在 Manifest (資訊清單) 區段中，執行下列動作：

    1. 針對 Manifest format (資訊清單格式)，選擇 S3 Inventory report (manifest.json) (S3 庫存報告 (manifest.json))。

    2. 針對 Manifest object (資訊清單物件)，選擇 Browse S3 (瀏覽 S3)，以查找您在步驟 5 中為存放清查報告而建立的儲存貯體 (例如，amzn-s3-demo-destination-bucket2)。在 Manifest object (資訊清單物件) 頁面上，瀏覽物件名稱，直到找到特定日期的 manifest.json 檔案。此檔案會列出您想要批次轉碼的所有影片的相關資訊。當您找到 manifest.json 檔案時，請選擇檔案旁邊的選項按鈕。然後，選擇 Choose path (選擇路徑)。

    3. (選用) 對於 Manifest object version ID - optional (資訊清單物件版本 ID - 選用)，如果您想要使用最新版本以外的版本，請輸入資訊清單物件的版本 ID。

  6. 選擇 Next (下一步)。

  7. 若要使用 Lambda 函數轉碼選定的 manifest.json 檔案中列出的所有物件，請在 Operation type (操作類型) 下，選擇 Invoke AWS Lambda function (叫用 AWS Lambda 函數)。

  8. 在 Invoke Lambda function (叫用 Lambda 函數) 區段中，執行下列動作：

    1. 選擇 Choose from functions in your account (從帳戶中的函數選擇)。

    2. 針對 Lambda function (Lambda 函數)，選擇您在步驟 4 中建立的 Lambda 函數 (例如，tutorial-lambda-convert)。

    3. 對於 Lambda 函數版本 ，請保留預設值 $LATEST。

  9. 選擇 Next (下一步)。Configure additional options (設定其他選項) 頁面隨即開啟。

  10. 在 Additional options (其他選項) 區段中，保留預設設定。

    如需關於這些選項的詳細資訊，請參閱 批次操作任務請求元素。

  11. 在 Completion report (完成報告) 區段中, 針對 Path to completion report destination (完成報告目的地的路徑)，選擇 Browse S3 (瀏覽 S3)。找出在步驟 1 中您為輸出媒體檔案建立的儲存貯體 (例如，amzn-s3-demo-destination-bucket1)。選擇儲存貯體名稱旁的選項按鈕。然後，選擇 Choose path (選擇路徑)。

    對於剩餘的 Completion report (完成報告) 設定，請保留預設值。如需完成報告設定的詳細資訊，請參閱 批次操作任務請求元素。完成報告會維護任務的詳細資訊和執行的操作的記錄。

  12. 在許可區段中，選擇從現有IAM角色中選擇 。針對IAM角色 ，選擇您在步驟 6 中建立的 S3 批次操作任務IAM角色 （例如 tutorial-s3batch-role）。 步驟 6：建立 S3 批次操作IAM的角色

  13. 選擇 Next (下一步)。

  14. 請詳閱 Review (檢閱) 頁面上的設定。然後，選擇 Create Job (建立任務)。

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

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

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

執行 S3 批次操作任務

  1. 登入 AWS Management Console 並在 開啟 Amazon S3 主控台https://console.aws.amazon.com/s3/。

  2. 在左側導覽窗格中，選擇 Batch Operations (批次操作)。

  3. 從 Jobs (任務) 清單中，選擇第一列的任務的 Job ID (任務 ID)，也就是您先前建立的 S3 批次操作任務。

  4. 選擇執行工作。

  5. 再次檢閱您的任務參數，並確認 Total objects listed in manifest (資訊清單中列出的物件總數) 的數值與資訊清單中的物件數目相同。接著選擇 Run job (執行任務)。

    隨即開啟 S3 批次操作任務頁面。

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

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

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

(選用) 檢查完成報告

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

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

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

    S3 輸出目的地儲存貯體頁面隨即開啟。

  2. 在 Objects (物件) 索引標籤上，選擇名稱以您先前建立之 S3 批次操作任務的任務 ID 為結尾的資料夾。

  3. 選擇 results/。

  4. 選取 .csv 檔案旁的核取方塊。

  5. 若要檢視任務報告，請選擇 Open (開啟) 或 Download (下載)。

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

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

  1. 在 開啟 AWS Lambda 主控台https://console.aws.amazon.com/lambda/。

  2. 在左側導覽窗格中，選擇 Functions (函數)。

  3. 在 Functions (函數) 清單中，選擇您在步驟 4 中建立的 Lambda 函數名稱 (例如，tutorial-lambda-convert)。

  4. 選擇 監控 索引標籤。

  5. 在 Metrics (指標) 下，請參閱 Lambda 函數的執行時間指標。

  6. 在日誌 下，透過 Logs Insights 檢視每個 Lambda 調用的 CloudWatch 日誌資料。

    注意

    當您搭配 Lambda 函數使用 S3 批次操作時，Lambda 函數會叫用每個物件。如果您的 S3 批次操作任務較大，則可以同時叫用多個 Lambda 函數，會造成 Lambda 並行峰值。

    每個區域 AWS 帳戶 都有 Lambda 並行配額。如需詳細資訊，請參閱《AWS Lambda 開發人員指南》中的 AWS Lambda 函數擴展。搭配 S3 批次操作使用 Lambda 函數的最佳實務是設定 Lambda 函數本身的並行限制。設定並行限制可以避免您的任務耗用大部分 Lambda 並行，並可能調節您帳戶中的其他功能。如需詳細資訊，請參閱中的《AWS Lambda 開發人員指南》中的管理 Lambda 預留並行。

（選用） 在 MediaConvert 主控台中監控每個 MediaConvert 影片轉碼任務

MediaConvert 任務會執行轉碼媒體檔案的工作。當您的 S3 批次操作任務叫用每個影片的 Lambda 函數時，每個 Lambda 函數叫用都會為每個輸入影片建立 MediaConvert 轉碼任務。

  1. 登入 AWS Management Console 並在 開啟 MediaConvert 主控台https://console.aws.amazon.com/mediaconvert/。

  2. 如果出現 MediaConvert 簡介頁面，請選擇開始使用 。

  3. 從 Jobs (任務) 清單中，檢視每一列，以監控每個輸入影片的轉碼任務。

  4. 識別您要檢查的任務列，然後選擇 Job ID (任務 ID) 連結，以開啟任務詳細資訊頁面。

  5. 在工作摘要頁面的輸出 下，根據瀏覽器支援的內容，選擇 HLS、 MP4或縮圖輸出的連結，以前往輸出媒體檔案的 S3 目的地儲存貯體。

  6. 在 S3 HLS輸出目的地儲存貯體的對應資料夾 （MP4、 或縮圖） 中，選擇輸出媒體檔案物件的名稱。

    物件詳細資訊頁面隨即開啟。

  7. 在物件詳細資訊頁面的物件概觀 下，選擇物件URL下方的連結來觀看轉碼輸出媒體檔案。

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

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

  1. 登入 AWS Management Console 並在 開啟 Amazon S3 主控台https://console.aws.amazon.com/s3/。

  2. 在左側導覽窗格中，選擇 Buckets (儲存貯體)。

  3. 在 Buckets (儲存貯體) 清單中，選擇您在步驟 1 中建立的輸出媒體檔案的 S3 目的地儲存貯體名稱 (例如，amzn-s3-demo-destination-bucket1)。

  4. 在 Objects (物件) 標籤上，每個輸入影片都有一個具有輸入影片名稱的資料夾。每個資料夾皆包含輸入影片的轉碼後的輸出媒體檔案。

    若要檢查輸入影片的輸出媒體檔案，請執行下列動作：

    1. 選擇以您要檢查的輸入影片名稱命名的資料夾。

    2. 選擇 Default/ 資料夾。

    3. 選擇本教學課程中轉碼格式 （HLS、 MP4或 縮圖） 的資料夾。

    4. 選擇輸出媒體檔案的名稱。

    5. 若要觀看轉碼檔案，請在物件的詳細資訊頁面上，選擇物件 URL下方的連結。

      HLS 格式的輸出媒體檔案會分割為短區段。若要播放這些影片，請將.m3u8檔案URL的物件內嵌在相容的播放器中。

步驟 9：清除

如果您使用 S3 批次操作、Lambda 轉碼影片，且 MediaConvert 僅將 轉碼為學習練習，請刪除您配置 AWS 的資源，這樣您就不會再產生費用。

刪除 S3 來源儲存貯體的 S3 清查組態

  1. 登入 AWS Management Console 並在 開啟 Amazon S3 主控台https://console.aws.amazon.com/s3/。

  2. 在左側導覽窗格中，選擇 Buckets (儲存貯體)。

  3. 在 Buckets (儲存貯體) 清單中，選擇來源儲存貯體的名稱 (例如，amzn-s3-demo-source-bucket)。

  4. 選擇 Management (管理) 標籤，

  5. 在 Inventory configurations (清查組態) 中，選擇您在步驟 5 中建立的清查組態 (例如，tutorial-inventory-config) 旁的選項按鈕。

  6. 選擇 Delete (刪除)，然後選擇 Confirm (確認)。

刪除 Lambda 函數

  1. 在 開啟 AWS Lambda 主控台https://console.aws.amazon.com/lambda/。

  2. 在左側導覽窗格中，選擇 Functions (函數)。

  3. 選取您在步驟 4 中建立的函數旁的核取方塊 (例如，tutorial-lambda-convert)。

  4. 選擇動作，然後選擇刪除。

  5. 在 Delete function (刪除函數) 對話方塊中，選擇 Delete (刪除)。

刪除 CloudWatch 日誌群組

  1. 在 開啟 CloudWatch 主控台https://console.aws.amazon.com/cloudwatch/。

  2. 在左側導覽窗格中，選擇 Logs (日誌)，然後選擇 Log groups (日誌群組)。

  3. 選取日誌群組旁的核取方塊，該日誌群組的名稱以您在步驟 4 中建立的 Lambda 函數結尾 (例如，tutorial-lambda-convert)。

  4. 選擇 Actions (動作)，然後選擇 Delete log group (刪除日誌群組)。

  5. 在 刪除日誌群組 對話方塊中，選擇 刪除 。

將IAM角色與IAM角色的內嵌政策一起刪除

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

  1. 登入 AWS Management Console 並在 開啟IAM主控台https://console.aws.amazon.com/iam/。

  2. 在左側導覽窗格中，選擇 Roles (角色)，然後選取您要刪除之角色名稱旁的核取方塊。

  3. 在頁面頂端，選擇 Delete (刪除)。

  4. 在確認對話方塊中，根據提示在文字輸入欄位中輸入所需的回應，然後選擇 Delete (刪除)。

刪除客戶受管IAM政策

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

  1. 登入 AWS Management Console 並在 開啟IAM主控台https://console.aws.amazon.com/iam/。

  2. 在左側導覽窗格中選擇 Policies (政策)。

  3. 選擇您在步驟 6 中建立之政策 (例如，tutorial-s3batch-policy) 旁的選項按鈕。您可以使用搜尋方塊來篩選政策清單。

  4. 選擇 動作，然後選擇 刪除。

  5. 在文字欄位中，輸入本政策的名稱，以確認您要刪除此政策，然後選擇 Delete (刪除)。

清空 S3 儲存貯體

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

  1. 登入 AWS Management Console 並在 開啟 Amazon S3 主控台https://console.aws.amazon.com/s3/。

  2. 在左側導覽窗格中，選擇 Buckets (儲存貯體)。

  3. 在 Bucket (儲存貯體) 清單中，選擇您要清空之儲存貯體名稱旁的選項按鈕，然後選擇 Empty (清空)。

  4. 在 Empty bucket (清空儲存貯體) 頁面上，在文字欄位中輸入 permanently delete 以確認您要清空儲存貯體，然後選擇 Empty (清空)。

刪除 S3 儲存貯體

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

  1. 登入 AWS Management Console 並在 開啟 Amazon S3 主控台https://console.aws.amazon.com/s3/。

  2. 在左側導覽窗格中，選擇 Buckets (儲存貯體)。

  3. 在 Buckets (儲存貯體) 清單中，選擇您要刪除之儲存貯體名稱旁的選項按鈕。

  4. 選擇 刪除 。

  5. 在 Delete bucket (刪除儲存貯體) 頁面上，在文字欄位中輸入儲存貯體名稱以確認您要刪除該儲存貯體，然後選擇 Delete bucket (刪除儲存貯體)。

後續步驟

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