チュートリアル: S3 バッチオペレーション、AWS Lambda、および AWS Elemental MediaConvert を使用した動画のバッチトランスコーディング - Amazon Simple Storage Service
前提条件 ステップ 1: 出力メディアファイルの S3 バケットを作成する。ステップ 2: MediaConvert 用に IAM ロールを作成するステップ 3: Lambda 関数の IAM ロールを作成するステップ 4: 動画トランスコーディング用の Lambda 関数の作成ステップ 5: S3 ソースバケットの Amazon S3 インベントリを設定する。ステップ 6: S3 バッチ操作の IAM ロールを作成する。ステップ 7: S3 バッチ操作ジョブを作成して実行する。ステップ 8: S3 宛先バケットから出力メディアファイルを確認する。ステップ 9: クリーンアップする。次のステップ

チュートリアル: S3 バッチオペレーション、AWS Lambda、および AWS Elemental MediaConvert を使用した動画のバッチトランスコーディング

動画消費者は、あらゆる形状、サイズ、ビンテージのデバイスを使用してメディアコンテンツを楽しんでいます。この幅広い一連のデバイスは、コンテンツ作成者やディストリビューターにとって課題となります。動画は、ワンサイズですべてにフィットするフォーマットではなく、幅広いサイズ、フォーマット、ビットレートに変換する必要があります。変換が必要な動画が多数ある場合、この変換タスクはさらに困難になります。

AWS では、以下を実行するスケーラブルな分散アーキテクチャを構築する方法を提供します。

  • 入力動画を取り込みます。

  • さまざまなデバイスで再生するために動画を処理します。

  • トランスコードされたメディアファイルを格納します。

  • 需要に合わせて出力メディアファイルを配信します。

Amazon S3 に広範な動画リポジトリを保存している場合は、これらの動画をソース形式から、特定の動画プレーヤーやデバイスに必要なサイズ、解像度、形式の複数のファイルタイプに変換できます。具体的には、S3 バッチ操作 は、S3 ソースバケット内の既存の入力動画の AWS Lambda 関数を呼び出すためのソリューションを提供します。次に、Lambda 関数は AWS Elemental MediaConvert を呼び出して、広範な動画トランスコーディングタスクを実行します。変換後の出力メディアファイルは S3 保存先バケットに保存されます。

バッチトランスコーディングのワークフロー図
目的

このチュートリアルでは、S3 送信先バケットに保存された動画のバッチトランスコーディング用に Lambda 関数を呼び出すように S3 バッチ操作を設定する方法を学習します。Lambda 関数は MediaConvert を呼び出して、動画をトランスコードします。S3 ソースバケット内の各動画の出力は、次のとおりです。

  • 複数のサイズのデバイスおよびさまざまな帯域幅で再生するための HTTP Live Streaming (HLS) アダプティブビットレートストリーム。

  • MP4 動画ファイル

  • サムネイル画像は、間隔をおいて収集されます。

前提条件

このチュートリアルを開始する前に、トランスコードされる動画がすでにその中に保存されている Amazon S3 ソースバケットが必要です (例、tutorial-bucket-1 )。

必要に応じて、バケットに別の名前を付けることができます。Amazon S3 のバケット命名規則の詳細については、「バケットの名前付け」を参照してください。

S3 ソースバケットの場合、このバケットのブロックパブリックアクセス設定 に関連する設定をデフォルトに設定したままにします (すべて のパブリックアクセスをブロックする が有効)。詳細については、「バケットの作成」を参照してください。

S3 ソースバケットへの動画のアップロードの詳細については、オブジェクトのアップロード を参照してください。S3 に動画ファイルをアップロードするときは、Amazon S3 Transfer Acceleration を使用して、高速かつ安全なファイル転送を設定します。転送アクセラレーションを使用すると、S3 バケットへの動画のアップロードを高速化して、大きな動画の長距離転送を行うことができます。詳細については、「Amazon S3 Transfer Acceleration を使用した高速かつ安全なファイル転送の設定」を参照してください。

ステップ 1: 出力メディアファイルの S3 バケットを作成する。

このステップでは、変換後の出力メディアファイルを保存するための S3 ソースバケットを作成します。また、Cross Origin Resource Sharing (CORS) 設定を作成して、S3 の送信先バケットに保存されているトランスコードされたメディアファイルへのクロスオリジンアクセスを許可します。

出力メディアファイル用のバケットを作成する。

  1. AWS Management Console にサインインし、Amazon S3 コンソール (https://console.aws.amazon.com/s3/) を開きます。

  2. 左側のナビゲーションペインで、[バケット] を選択します。

  3. [Create bucket (バケットの作成)] を選択します。

  4. Bucket Name に、バケットの名前 (例: tutorial-bucket-2) を入力します。

  5. [リージョン] で、バケットを保存する AWS リージョンを選択します。

  6. 出力メディアファイルへのパブリックアクセスを確保するには、Block Public Access settings (パブリックアクセスのブロック設定) で、Block all public access (すべてのパブリックアクセスをブロック) をオフにします。

    警告

    このステップを完了する前に「Amazon S3 ストレージへのパブリックアクセスのブロック」を読んで、パブリックアクセスを許可することに伴うリスクを理解し、了承します。ブロックパブリックアクセス設定をオフにしてバケットをパブリックにすると、インターネット上の誰でもバケットにアクセスできるようになります。バケットへのすべてのパブリックアクセスをブロックすることをお勧めします。

    ブロックパブリックアクセス設定をクリアしたくない場合は、Amazon CloudFront を使用して、トランスコードされたメディアファイルをビューワー (エンドユーザー) に配信できます。詳細については、「チュートリアル: Amazon S3、Amazon CloudFront、Amazon Route 53 を使用したオンデマンドストリーミング動画のホスティング。」を参照してください。

  7. [現在の設定により、このバケットと保存されたオブジェクトがパブリックになる可能性があることを了承します] の横にあるチェックボックスを選択します。

  8. 残りの設定はデフォルト値のままにしておきます。

  9. [バケットを作成] を選択します。

CORS 設定を S3 出力バケットに追加する

JSON CORS 設定は、特定のドメインにロードされたクライアントウェブアプリケーション (このコンテキストでは動画プレーヤー) が、異なるドメインでトランスコードされた出力メディアファイルを再生する方法を定義します。

  1. AWS Management Console にサインインし、Amazon S3 コンソール (https://console.aws.amazon.com/s3/) を開きます。

  2. 左側のナビゲーションペインで、[バケット] を選択します。

  3. バケット リストで、先に作成したバケットの名前を選択します(例: tutorial-bucket-2) 。

  4. [アクセス許可] タブを選択します。

  5. [CORS (クロスオリジンリソース共有)] セクションで、[編集] を選択します。

  6. [CORS 設定] テキストボックスで、次に示す CORS 設定をコピーして貼り付けます。

    CORS 設定は、JSON 形式である必要があります。この例では、AllowedOrigins 属性はワイルドカード文字 (*) を使用して、すべてのオリジンを指定します。特定のオリジンがわかっている場合は、AllowedOrigins 属性を特定のプレーヤーの URL に限定します。この属性およびその他の属性の設定の詳細については、「CORS 設定のエレメント」を参照してください。

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

    }
]

  7. [Save changes] (変更の保存) をクリックします。

ステップ 2: MediaConvert 用に IAM ロールを作成する

AWS Elemental MediaConvert を使用して S3 バケットに保存されている入力動画をトランスコーディングするには、AWS Identity and Access Management (IAM) サービスロールを使用して、S3 ソースバケットおよび宛先バケットから動画ファイルを読み書きするための MediaConvert アクセス許可を付与します。トランスコーディングジョブを実行すると、MediaConvert コンソールはこのロールを使用します。

MediaConvert の IAM ロールを作成するには

  1. 選択したロール名を使用して IAM ロールを作成します (例: tutorial-mediaconvert-role)。このロールを作成するには、「AWS Elemental MediaConvert ユーザーガイド」の「IAM (コンソール) で MediaConvert ロールを作成する」に記載のステップに従ってください。

  2. MediaConvert の IAM ロールを作成した後、ロール のリストで、作成した MediaConvert のロールの名前を選択します (例: tutorial-mediaconvert-role)。

  3. 概要 ページで、arn:aws:iam:: で始まる ロール ARN をコピーし、後で使用できるように ARN を保存します。

    ARN の詳細については、AWS 全般のリファレンスの Amazon リソースネーム (ARN) を参照してください。

ステップ 3: Lambda 関数の IAM ロールを作成する

MediaConvert および S3 バッチ操作で動画をバッチトランスコードするには、これらの 2 つのサービスを接続して動画を変換する Lambda 関数を使用します。この Lambda 関数には、MediaConvert および S3 バッチ操作にアクセスするための許可を Lambda 関数に付与する IAM ロールが必要です。

Lambda 関数の IAM ロールを作成する

  1. AWS Management Console にサインインして、IAM コンソール (https://console.aws.amazon.com/iam/) を開きます。

  2. 左側のナビゲーションペインから、[Roles (ロール)] を選択し、[Create role (ロールの作成)] を選択します。

  3. AWS サービス ロールの種類を選択し、一般的ユースケース で、Lambda を選択します。

  4. [Next: Permissions] (次へ: アクセス許可) を選択します。

  5. [Attach Permissions policies (許可ポリシーのアタッチ) ]ページにあるポリシーのフィルタリング に AWSLambdaBasicExecutionRole を入力します。管理ポリシー AWSLambdaBasicExecutionRole をこのロールにアタッチして、Amazon CloudWatch Logs への書き込み許可を付与するには、AWSLambdaBasicExecutionRole の横にあるチェックボックスを選択します。

  6. [Next: Tags] (次へ: タグ) を選択します。

  7. (オプション) 管理ポリシーにタグを追加します。

  8. [Next: Review (次へ: レビュー)] を選択します。

  9. [ロール名] に「tutorial-lambda-transcode-role」と入力します。

  10. [ロールの作成] を選択します。

Lambda 関数の IAM ロールにインラインポリシーを埋め込む

Lambda 関数の実行に必要な MediaConvert リソースに許可を付与するためには、インラインポリシーを使用する必要があります。

  1. AWS Management Console にサインインして、IAM コンソール (https://console.aws.amazon.com/iam/) を開きます。

  2. 左のナビゲーションペインで、[ロール] を選択します。

  3. ロール のリストで、Lambda 関数用に先に作成した IAM ロールの名前を選択します (例、tutorial-lambda-transcode-role)。

  4. [Permissions] タブを選択します。

  5. [Add inline policy] を選択します。

  6. [JSON] タブを選択し、以下の JSON ポリシーをコピーペーストします。

    JSON ポリシーでは、Resource の例の ARN 値を、ステップ 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"
        }
    ]
}

  7. [ポリシーの確認] を選択します。

  8. [Name] (名前) に tutorial-lambda-policy と入力します。

  9. [ポリシーの作成] を選択します。

    インラインポリシーを作成すると、Lambda 関数の IAM ロールに自動的に埋め込まれます。

ステップ 4: 動画トランスコーディング用の Lambda 関数の作成

チュートリアルの子のセクションでは、S3 バッチ操作および MediaConvert と統合するには、SDK for Python を使用して Lambda 関数を構築します。S3 ソースバケットにすでに保存されている動画のトランスコーディングを開始するには、S3 ソースバケット内の各動画に対して Lambda 関数を直接呼び出す S3 バッチ操作ジョブを実行します。次に、Lambda 関数は、各動画のトランスコーディングジョブを MediaConvert に送信します。

Lambda 関数コードを記述し、デプロイパッケージを作成する

  1. ローカルマシンで、batch-transcode という名前のフォルダを作成します。

  2. batch-transcode フォルダに、JSON ジョブ設定でファイルを作成します。例えば、このセクションで提供されている設定を使用して、ファイル job.json に名前を付けることができます。

    job.json ファイルでは、以下を指定します。

    • トランスコードするファイル

    • 入力動画のトランスコード方法

    • 作成したい出力メディアファイル

    • トランスコードされたファイルの名前

    • トランスコードされたファイルを保存する場所

    • 適用する高度な機能など

    このチュートリアルでは、次の job.json ファイルを使用して、S3 ソースバケットの各動画に対して次の出力を作成します。

    • 複数のサイズのデバイスおよびさまざまな帯域幅で再生するための HTTP Live Streaming (HLS) アダプティブビットレートストリーム。

    • MP4 動画ファイル

    • 間隔を置いて収集されたサムネイル画像

    このサンプル job.json ファイルは、品質が定義された可変ビットレート (QVBR) を使用して動画品質を最適化します。HLS 出力は、Apple に準拠しています (動画からのオーディオの混合、セグメント継続時間 (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"
    }
  ]
}
    表示を増やす表示を減らす

  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['DestinationBucket'],
                    os.path.splitext(os.path.basename(source_s3_key))[0],
                    os.path.splitext(os.path.basename(job_name))[0])

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

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

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

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

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

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

  4. ローカルターミナルで、convert.py および lambda.zip という名前の .zip ファイルとして job.json を使用してデプロイパッケージを作成するには、上記で作成した 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. 左側のナビゲーションペインで、関数 を選択します。

  3. 関数の作成 を選択します。

  4. Author from scratch を選択します。

  5. 基本的な情報 で、以下の作業を行います。

    1. [関数名] に「tutorial-lambda-convert」と入力します。

    2. ランタイム で、Python 3.8 またはそれ以降のバージョンを選択します。

  6. デフォルト実行ロールを変更する を選択し、実行ロール で、既存のロールを使用する を選択します。

  7. 既存のロール で、ステップ 3 で Lambda 関数用に作成した IAM ロールの名前を選択します (例、tutorial-lambda-transcode-role)。

  8. 残りの設定はデフォルトのままにしておきます。

  9. 関数の作成 を選択します。

.zip ファイルアーカイブを使用して Lambda 関数コードをデプロイし、Lambda 関数を設定します (コンソール)。

  1. 上で作成した Lambda 関数のページの [コードソース] セクション (tutorial-lambda-convert など) で、[アップロード元]、[.zip ファイル]の順に選択します。

  2. アップロード を選択して、ローカルの .zip ファイルを選択します。

  3. 前に作成した lambda.zip ファイルを選択し、開く を選択します。

  4. Save を選択します。

  5. ランタイム設定 セクションで、編集 を選択します。

  6. Lambda ランタイムに Lambda 関数コード内のどのハンドラメソッドの呼び出しを指示するには、ハンドラー フィールドに convert.handler を入力します。

    Python で関数を設定するとき、ハンドラー設定の値は、ファイル名と、ハンドラーモジュールの名前を、ドット (.) で区切ったものになります。例えば、convert.handler は、convert.py ファイルで定義された handler メソッドを呼び出します。

  7. Save を選択します。

  8. [Lambda 関数] ページで、設定 タブを選択します。設定 タブの左側のナビゲーションペインで、環境変数 を選択し、編集 を選択します。

  9. 環境変数の追加 を選択します。次に、次の環境変数ごとにキー および値 を入力します。

    • キー : DestinationBucket 値: tutorial-bucket-2

      この値は、ステップ 1 で作成した出力メディアファイルの S3 バケットです。

    • キー : MediaConvertRole 値: arn:aws:iam::111122223333:role/tutorial-mediaconvert-role

      この値は、ステップ 2 で作成した MediaConvert の IAM ロールの ARN です。この ARN を IAM ロールの実際の ARN に置き換えてください。

    • キー : Application 値: Batch-Transcoding

      この値は、アプリケーションの名前です。

  10. Save を選択します。

  11. (オプション) Configuration (設定) タブの左側のナビゲーションペインの General configuration (一般設定) セクションで、Edit (編集) を選択します。[タイムアウト] フィールドに、2 分 0 秒と入力します。次に、保存を選択します。

    タイムアウトは、Lambda で関数が停止するまでに許可される実行時間の長さです。デフォルト値は 3 秒です。料金は、設定されたメモリの量とコードの実行時間に基づいて請求されます。詳細については、「AWS Lambda 料金表」を参照してください。

ステップ 5: S3 ソースバケットの Amazon S3 インベントリを設定する。

トランスコーディング Lambda 関数をセットアップしたら、S3 バッチ操作ジョブを作成して、一連の動画をトランスコードします。まず、S3 バッチ操作で指定したトランスコーディングアクションを実行する入力動画オブジェクトのリストが必要です。入力動画オブジェクトのリストを取得するには、S3 ソースバケットの S3 インベントリレポートを生成できます (例、tutorial-bucket-1)。

入力動画の S3 インベントリレポート用のバケットを作成して設定する

S3 ソースバケットのオブジェクトをリストする S3 インベントリレポートを保存するには、S3 インベントリ宛先バケットを作成し、そのバケットに対してインベントリファイルを S3 ソースバケットに書き込むようにバケットポリシーを設定します。

  1. AWS Management Console にサインインし、Amazon S3 コンソール (https://console.aws.amazon.com/s3/) を開きます。

  2. 左側のナビゲーションペインで、[バケット] を選択します。

  3. [Create bucket (バケットの作成)] を選択します。

  4. Bucket Name に、バケットの名前 (例: tutorial-bucket-3) を入力します。

  5. AWS リージョン で、バケットを保存するAWS リージョン を選択します。

    インベントリ宛先バケットは、S3 インベントリを設定するソースバケットと同じ AWS リージョン である必要があります。インベントリ宛先バケットは、別の AWS アカウント にある場合があります。

  6. このバケットのパブリックアクセス設定をブロック で、デフォルト設定 (ブロックすべてパブリックアクセスが有効) のままであることを確認します。

  7. 残りの設定はデフォルトのままにしておきます。

  8. [バケットを作成] を選択します。

  9. [バケット] リストで、作成したばかりのバケットの名前を選択します(例、tutorial-bucket-3) 。

  10. S3 インベントリレポートのデータを S3 インベントリ送信先バケットに書き込む許可を Amazon S3 に付与するには、許可 タブを選択します。

  11. バケットポリシー セクションまで下にスクロールし、編集 を選択します。バケットポリシー ページが開きます。

  12. S3 インベントリの許可を付与するには、ポリシー フィールドに、次のバケットポリシーを貼り付けます。

    3 つの例の値を、それぞれ次の値に置き換えます。

    • インベントリレポート (例、tutorial-bucket-3) を保存するために作成したバケットの名前。

    • 入力動画を保存するソースバケットの名前 (例、tutorial-bucket-1 )。

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

  13. [Save changes] (変更の保存) をクリックします。

S3 動画ソースバケットの Amazon S3 インベントリを設定します。

動画オブジェクトとメタデータのフラットファイルリストを生成するには、S3 動画ソースバケットの S3 インベントリを設定する必要があります。これらのスケジュールされたレポートには、バケット内のすべてのオブジェクト、または共有プレフィックスでグループ化されたオブジェクトを含めることができます。このチュートリアルでは、S3 インベントリレポートに S3 ソースバケット内のすべての動画オブジェクトが含まれます。

  1. AWS Management Console にサインインし、Amazon S3 コンソール (https://console.aws.amazon.com/s3/) を開きます。

  2. 左側のナビゲーションペインで、[バケット] を選択します。

  3. S3 ソースバケットの入力動画の S3 インベントリレポートを設定するには、バケット リストで、S3 ソースバケットの名前を選択します (例、tutorial-bucket-1)。

  4. [管理] タブを選択します。

  5. インベントリの設定 セクションを下にスクロールし、インベントリ設定を作成する を選択します。

  6. Inventory configuration name (インベントリ設定名) に、名前を入力します (例、tutorial-inventory-config)。

  7. インベントリの範囲 で、オブジェクトバージョン に対して現在のバージョンのみ を選択し、他のインベントリの範囲 設定をこのチュートリアルのデフォルトに設定したままにします。

  8. レポートの詳細 の 宛先バケット で、このアカウント を選択します。

  9. 宛先 で S3 を参照 を選択し、インベントリレポートを保存するために先に作成した宛先バケットを選択します (例、tutorial-bucket-3)。次に、パスの選択 を選択します。

    インベントリ宛先バケットは、S3 インベントリを設定するソースバケットと同じ AWS リージョン である必要があります。宛先バケットは、別の AWS アカウント アカウントにある場合があります。

    [送信先] バケットフィールドの下に、Amazon S3 がそのバケットにデータを入れることを許可するために送信先バケットポリシーに追加される [送信先バケットの許可] が追加されます。詳細については、「ターゲットバケットポリシーの作成」を参照してください。

  10. 頻度 で、1 日 1 回 を選択します。

  11. [Output format] (出力形式) として [CSV] を選択します。

  12. Status (ステータス) で、有効 を選択します。

  13. サーバー側の暗号化 で、このチュートトリアルの 無効 を選択します。

    詳細については、「S3 コンソールを使用したインベントリの設定」および「カスタマーマネージドキーを暗号化に使用するためのアクセス許可を Amazon S3 に付与する」を参照してください。

  14. 追加フィールド - オプション セクションで、サイズ、最終更新日時 および ストレージクラス を選択します。

  15. [Create] (作成) を選択します。

詳細については、「S3 コンソールを使用したインベントリの設定」を参照してください。

S3 動画ソースバケットのインベントリレポートを確認します。

インベントリレポートが発行されると、マニフェストファイルは S3 インベントリ宛先バケットに送信されます。

  1. AWS Management Console にサインインし、Amazon S3 コンソール (https://console.aws.amazon.com/s3/) を開きます。

  2. 左側のナビゲーションペインで、[バケット] を選択します。

  3. Buckets (バケット) リストで、動画送信先バケットの名前を選択します (例、tutorial-bucket-1)。

  4. [Management (管理)] を選択します。

  5. S3 インベントリレポートで S3 バッチ操作ジョブを作成する準備ができているかどうかを確認するには、ステップ 7 の インベントリ設定 で、マニフェストからジョブを作成 ボタンが有効になっているかを確認します。

    注記

    最初のレポートが配信されるまでに最大で 48 時間かかることがあります。Create job from manifest (マニフェストからジョブを作成) ボタンが無効になっている場合、最初のインベントリレポートは配信されていません。ステップ 7 で S3 バッチ操作ジョブを作成するには、最初のインベントリレポートが配信され、マニフェストからジョブを作成 ボタンが有効になるまで待つ必要があります。

  6. S3 インベントリレポート (manifest.json) を確認するには、宛先 列で、インベントリレポートを保存するために先に作成したインベントリ宛先バケットの名前を選択します (例、tutorial-bucket-3)。

  7. オブジェクト タブで、S3 ソースバケットの名前を持つ既存のフォルダ (例、tutorial-bucket-1) を選択します。次に、先にインベントリ設定を作成した際に インベントリの設定名 で入力した名前を選択します (例、tutorial-inventory-config)。

    レポートの生成日を名前として含むフォルダのリストを表示できます。

  8. 特定の日付の日次 S3 インベントリレポートを確認するには、生成日の名前が付いたフォルダを選択して、manifest.json を選択します。

  9. 特定の日付のインベントリレポートの詳細を確認するには、manifest.json ページで、Download (ダウンロード) または Open (開く) を選択します。

ステップ 6: S3 バッチ操作の IAM ロールを作成する。

S3 バッチ操作を使用してバッチトランスコーディングを行うには、最初に IAM ロールを作成して、S3 バッチ操作を実行する許可を Amazon S3 に付与する必要があります。

S3 バッチ操作用の IAM ポリシーを作成する。

S3 バッチ操作に、入力マニフェストを読み取り、Lambda 関数を呼び出し、S3 バッチ操作ジョブ完了レポートに書き込みを行う許可を与える IAM ポリシーを作成する必要があります。

  1. AWS Management Console にサインインして、IAM コンソール (https://console.aws.amazon.com/iam/) を開きます。

  2. 左のナビゲーションペインの [ポリシー] を選択します。

  3. [Create policy (ポリシーの作成)] を選択します。

  4. [JSON] タブを選択します。

  5. JSON テキストフィールドに、次の JSON ポリシーをコピーして貼り付けます。

    JSON ポリシーで、4 つのサンプル値を次の値に置き換えます。

    • 入力動画を保存するソースバケットの名前 (例、tutorial-bucket-1)。

    • manifest.json ファイル (例、tutorial-bucket-3) を保存するためにステップ 5 で作成したインベントリ送信先バケットの名前。

    • 出力メディアファイルを保存するために ステップ 1 で作成したバケットの名前 (例、tutorial-bucket-2)。このチュートリアルでは、出力メディアファイルの送信先バケットにジョブ完了レポートを配置します。

    • ステップ 4 で作成した Lambda 関数のロール ARN。Lambda 関数のロール ARN を検索してコピーするには、次の操作を行います。

      • 新しいブラウザタブで、https://console.aws.amazon.com/lambda/home#/functions にある Lambda コンソールの 関数 ページを開きます。

      • 関数 のリストから、ステップ 4 で作成した Lambda 関数を選択します (例、tutorial-lambda-convert)。

      • [Copy ARN (ARN のコピー)] を選択します。

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

  6. [Next: Tags (次へ: タグ)] を選択します。

  7. [Next: Review (次へ: レビュー)] を選択します。

  8. [Name (名前)] フィールドに tutorial-s3batch-policy を入力します。

  9. [Create policy (ポリシーの作成)] を選択します。

S3 バッチ操作 IAM ロールを作成し、許可ポリシーを割り当てる

  1. AWS Management Console にサインインして、IAM コンソール (https://console.aws.amazon.com/iam/) を開きます。

  2. 左側のナビゲーションペインから、[Roles (ロール)] を選択し、[Create role (ロールの作成)] を選択します。

  3. AWS のサービス ロールタイプを選択し、S3 サービスを選択します。

  4. [ユースケースを選択] で、S3 バッチ操作 を選択します。

  5. [Next: Permissions] (次へ: アクセス許可) を選択します。

  6. 許可ポリシーをアタッチする で、事前に作成した IAM ポリシーの名前 (例、tutorial-s3batch-policy) を検索ボックスに入力し、ポリシーのリストをフィルタリングします。ポリシー名の横にあるチェックボックスを選択します (例、tutorial-s3batch-policy)。

  7. [Next: Tags] (次へ: タグ) を選択します。

  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 バッチ操作ジョブの作成を開始するには、[マニフェストからジョブを作成] ボタンが有効になっていることを確認する必要があります。詳細については、「S3 動画ソースバケットのインベントリレポートを確認します。」を参照してください。マニフェストからジョブを作成 ボタンが無効になっている場合、最初のインベントリレポートは配信されておらず、ボタンが有効になるまで待つ必要があります。ステップ 5 で S3 ソースバケットの Amazon S3 インベントリを設定した後は、最初のインベントリレポートが配信されるまでに最大で 48 時間かかることがあります。

S3 バッチオペレーションジョブを作成します。

  1. AWS Management Console にサインインし、Amazon S3 コンソール (https://console.aws.amazon.com/s3/) を開きます。

  2. 左のナビゲーションペインで、[バッチ操作] を選択します。

  3. [ジョブの作成]を選択します。

  4. AWS リージョン については、ジョブを作成する [Region (リージョン)] を選択します。

    このチュートリアルで、S3 バッチ操作ジョブを使用して Lambda 関数を呼び出すには、マニフェストで参照されるオブジェクトがある S3 動画ソースバケットと同じリージョンにジョブを作成する必要があります。

  5. マニフェスト セクションで、以下を実行します。

    1. Manifest format (マニフェスト形式) で、S3 inventory report (manifest.json) を選択します。

    2. オブジェクトのマニフェスト については、Browse S3 を選択して、インベントリレポートを保存するために ステップ 5 で作成したバケットを見つけます (例、tutorial-bucket-3)。マニフェストオブジェクト ページで、特定の日付の manifest.json ファイルが見つかるまで、オブジェクト名を検索します。このファイルには、バッチトランスコードするすべての動画に関する情報がリストされます。使用する manifest.json ファイルを見つけたら、横にあるオプションボタンを選択します。次に、[パスの選択] を選択します。

    3. （オプション）[マニフェストオブジェクトのバージョン ID-オプション] で、最新版以外のバージョンを使用する場合は、マニフェストオブジェクトのバージョン ID を入力します。

  6. [Next] を選択します。

  7. Lambda 関数を使用して、選択した manifest.json ファイルリストされているすべてのオブジェクトをトランスコードするには、オペレーションタイプ で AWS Lambda 関数を呼び出す を選択します。

  8. Lambda 関数の呼び出し ウィンドウで、次を実行します。

    1. Choose from functions in your account (アカウントの関数を選択する) を選択します。

    2. Lambda 関数 で、ステップ 4 で作成した Lambda 関数を選択します (例、tutorial-lambda-convert)。

    3. Lambda 関数のバージョン で、デフォルト値の $LATEST を維持します。

  9. Next を選択します。追加のオプションの設定 ページが開きます。

  10. 追加のオプション で、デフォルトの設定を維持します。

    これらのパラメータの詳細については、「バッチ操作ジョブのリクエストの要素」を参照してください。

  11. 完了レポート セクションの 完了レポートの送信先へのパス で、S3 をブラウズ を選択します。ステップ 1 で出力メディアファイル用に作成したバケットを見つけます (例、tutorial-bucket-2)。バケット名の横にあるオプションボタンを選択します。次に、パスの選択 を選択します。

    残りの 完了レポート 設定は、デフォルト値のままにしておきます。レポートの設定の完了に関する詳細については、「バッチ操作ジョブのリクエストの要素」を参照してください。完了レポートには、ジョブの詳細と実行された操作のレコードが保持されます。

  12. 許可 で、既存の IAM ロールから選択する を選択します。IAM role (IAM ロール) で、ステップ 6 (例、tutorial-s3batch-role) で作成した S3 バッチ操作ジョブの IAM ロールを選択します。

  13. [Next] を選択します。

  14. Review ページで、設定を確認します。次に、ジョブの作成 を選択します。

    S3 が S3 バッチ操作のジョブのマニフェストの読み取りを終了すると、実行のための確認待ち の ステータス に移行します。ジョブのステータスの更新を表示するには、ページをリフレッシュします。ステータスが 実行のための確認待ち になるまで、ジョブを実行することはできません。

S3 バッチ操作ジョブを実行して Lambda 関数を呼び出します。

バッチ操作ジョブを実行して、動画トランスコーディング用の Lambda 関数を呼び出します。ジョブが失敗した場合は、完了レポートを確認して原因を特定できます。

S3 バッチ操作ジョブを実行するには

  1. AWS Management Console にサインインし、Amazon S3 コンソール (https://console.aws.amazon.com/s3/) を開きます。

  2. 左のナビゲーションペインで、バッチ操作 を選択します。

  3. ジョブ のリストから、最初の行のジョブの ジョブ ID を選択します。これは、上記で作成した S3 バッチ操作ジョブです。

  4. [Run job] (ジョブの実行) を選択します。

  5. ジョブパラメータをもう一度確認し、Total objects listed in manifest (マニフェストにリストされているオブジェクトの総数) の値がマニフェスト内のオブジェクトの数と同じであることを確認します。次に、ジョブの実行 を選択します。

    S3 バッチ操作ジョブページが開きます。

  6. ジョブの実行が開始されたら、ジョブページの Status (ステータス) で、Status (ステータス)、% Complete (% 完了)、Total succeeded (rate) (成功合計) (レート)、Total failed (rate) (失敗合計) (レート)、Date terminated (終了日)、Reason for termination (終了理由) など、S3 バッチ操作ジョブの進行状況を確認します。

    S3 バッチ操作ジョブが完了したら、ジョブページのデータを表示して、ジョブが期待どおりに完了したことを確認します。

    1,000 を超える操作が試行された後、失敗が S3 バッチ操作ジョブのオブジェクト操作の 50% を超えると、ジョブは自動的に失敗します。完了レポートを確認して失敗の原因を特定するには、以下のオプション手順を参照してください。

(オプション) 完了レポートを確認する。

完了レポートを使用して、失敗したオブジェクトと失敗の原因を特定できます。

失敗したオブジェクトの詳細について完了レポートを確認するには

  1. S3 バッチ操作ジョブのページで、完了レポート までスクロールし、完了レポートの宛先 のリンクを選択します。

    S3 出力宛先バケットページが開きます。

  2. オブジェクト タブで、上記で作成した S3 バッチ操作ジョブのジョブ ID で終わる名前のフォルダを選択します。

  3. results/ (結果/) を選択します。

  4. .csv ファイルの横にあるチェックボックスを選択します。

  5. ジョブレポートを表示するには、[オープン] または [ダウンロード ] を選択します。

(オプション) Lambda コンソールで各 Lambda 呼び出しをモニタリングする。

S3 バッチ操作ジョブの実行が開始されると、ジョブは入力動画オブジェクトごとに Lambda 関数の呼び出しを開始します。S3 では、各 Lambda 呼び出しのログを CloudWatch Logs に書き込みます。Lambda コンソールのモニタリングダッシュボードを使用して、Lambda 関数とアプリケーションをモニタリングできます。

  1. AWS Lambda コンソールを https://console.aws.amazon.com/lambda/ で開きます。

  2. 左側のナビゲーションペインで、[関数] を選択します。

  3. 関数 のリストから、ステップ 4 で作成した Lambda 関数 の名前を選択します (例、tutorial-lambda-convert)。

  4. [Monitor] (モニタリング) タブを選択します。

  5. Metrics (メトリクス) で、Lambda 関数のランタイムメトリクスを確認します。

  6. Logs (ログ) で、CloudWatch Logs インサイトを使用して各 Lambda 呼び出しのログデータを表示します。

    注記

    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 入門者向けページが表示される場合は、[Get Started] を選択します。

  3. ジョブのリストから、各行を表示して、各入力動画のトランスコーディングタスクを監視します。

  4. チェックするジョブの行を特定し、ジョブ ID リンクを選択してジョブ詳細ページを開きます。

  5. [Job 概要] ページの [出力] で、ブラウザでサポートされている内容に応じて、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. 左側のナビゲーションペインで、[バケット] を選択します。

  3. バケット のリストから、ステップ 1 で作成した出力メディアファイルの S3 宛先バケットの名前を選択します (例、tutorial-bucket-2)。

  4. [オブジェクト] タブで、各入力動画には、入力動画の名前を持つフォルダがあります。各フォルダには、入力動画のトランスコードされた出力メディアファイルが含まれています。

    入力動画の出力メディアファイルを確認するには、次の操作を行います。

    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. 左側のナビゲーションペインで、[バケット] を選択します。

  3. バケット] リストで、送信先バケットの名前を選択します (例、tutorial-bucket-1)。

  4. [管理] タブを選択します。

  5. [インベントリ設定] セクションで、ステップ 5 で作成したインベントリ設定の横のオプションボタンを選択します (例、tutorial-inventory-config)。

  6. [削除]、[確認] の順に選択します。

Lambda 関数を削除する

  1. AWS Lambda コンソールを https://console.aws.amazon.com/lambda/ で開きます。

  2. 左側のナビゲーションペインで、[関数] を選択します。

  3. ステップ 4 で作成した関数の横にあるチェックボックスを選択します (例、tutorial-lambda-convert)。

  4. [アクション] を選択し、[削除] を選択します。

  5. [関数の削除] ダイアログボックスで、[削除] を選択します。

CloudWatch Logs グループを削除する

  1. CloudWatch コンソール (https://console.aws.amazon.com/cloudwatch/) を開きます。

  2. 左のナビゲーションペインで、[ログ] 、[ロググループ] の順に選択します。

  3. ステップ 4 で作成した Lambda 関数で終わる名前を持つロググループの横にあるチェックボックスを選択します (例、tutorial-lambda-convert)。

  4. [アクション] を選択してから、[ロググループの削除] を選択します。

  5. [ロググループの削除] ダイアログボックスで、[削除] をクリックします。

IAM ロールのインラインポリシーとともに IAM ロールを削除する

ステップ 2、ステップ 3、およびステップ 6] で作成した IAM ロールを削除するには、次の作業を行います。

  1. AWS Management Console にサインインして、IAM コンソール (https://console.aws.amazon.com/iam/) を開きます。

  2. ナビゲーションペインで、[ロール] を選択し、削除するロール名の隣にあるチェックボックスを選択します。

  3. ページの上部で、[削除] を選択します。

  4. 確認ダイアログボックスで、プロンプトに基づいてテキスト入力フィールドに必要な応答を入力し、[削除] を選択します。

カスタマー管理の IAM ポリシーを削除する。

ステップ 6 で作成したカスタマー管理の IAM ポリシーを削除するには、次の作業を行います。

  1. AWS Management Console にサインインして、IAM コンソール (https://console.aws.amazon.com/iam/) を開きます。

  2. 左のナビゲーションペインの [ポリシー] を選択します。

  3. ステップ 6 で作成したポリシーの横にあるオプションボタンを選択します (例、tutorial-s3batch-policy)。検索ボックスを使用して、グループのリストをフィルタリングできます。

  4. [アクション] を選択し、[削除] を選択します。

  5. テキストフィールドにポリシーの名前を入力して、このポリシーを削除することを確認し、[削除] を選択します。

S3 バケットを空にする

前提条件 、ステップ 1、および ステップ 5 で作成した S3 バケットを空にするには、次の作業を行います。

  1. AWS Management Console にサインインし、Amazon S3 コンソール (https://console.aws.amazon.com/s3/) を開きます。

  2. 左側のナビゲーションペインで、[バケット] を選択します。

  3. [バケット名] リストで、空にするバケットの名前の横にあるバケットアイコンを選択し、[バケットを空にする] を選択します。

  4. [バケットを空にする] ページで、テキストフィールドに permanently delete を入力することでバケットを空にすることを確定し、[空にする] を選択します。

S3 バケットの削除

前提条件 、ステップ 1 およびステップ 5 で作成した S3 バケットを削除するには、次の作業を行います。

  1. AWS Management Console にサインインし、Amazon S3 コンソール (https://console.aws.amazon.com/s3/) を開きます。

  2. 左側のナビゲーションペインで、[バケット] を選択します。

  3. [バケット] リストで、削除するバケット名の横にあるオプションボタンを選択します。

  4. [削除] を選択します。

  5. [バケットの削除] ページで、テキストフィールドにバケット名を入力することでバケットを削除することを確認し、[バケットを削除] を選択します。

次のステップ

このチュートリアルを完了すると、他の関連するユースケースをさらに詳しく調べることができます。