Tutorial: Batch-Transcodierung von Videos mit S3 Batch Operations

1. Melden Sie sich bei der an AWS Management Console und öffnen Sie die Amazon S3 S3-Konsole unter https://console.aws.amazon.com/s3/.

2. Wählen Sie im linken Navigationsbereich Buckets aus.

3. Wählen Sie Create Bucket (Bucket erstellen) aus.

4. Geben Sie im Feld Bucket Name einen Namen für Ihren Bucket ein (z. B. amzn-s3-demo-destination-bucket1).

5. Wählen Sie unter Region den AWS-Region Ort aus, an dem sich der Bucket befinden soll.

6. Um den öffentlichen Zugriff auf Ihre Ausgabemediendateien zu gewährleisten, deaktivieren Sie unter Einstellungen für den öffentlichen Zugriff für diesen Bucket blockieren Alle öffentlichen Zugriffe blockieren.

   Warnung

   Bevor Sie diesen Schritt ausführen, lesen Sie den Abschnitt Blockieren des öffentlichen Zugriffs auf Ihren Amazon-S3-Speicher, um sicherzustellen, dass Sie die mit dem Zulassen eines öffentlichen Zugriffs verbundenen Risiken kennen und akzeptieren. Wenn Sie die Einstellungen für Block Public Access deaktivieren, um Ihren Bucket öffentlich zu machen, kann jeder im Internet auf Ihren Bucket zugreifen. Wir empfehlen Ihnen, den gesamten öffentlichen Zugriff auf Ihre Buckets zu blockieren.

   Wenn Sie die Einstellungen zum Blockieren des öffentlichen Zugriffs nicht löschen möchten, können Sie Amazon verwenden, CloudFront um die transkodierten Mediendateien an Zuschauer (Endbenutzer) zu senden. Weitere Informationen finden Sie unter Tutorial: Hosten von On-Demand-Streaming-Videos mit Amazon S3 CloudFront, Amazon und Amazon Route 53.

7. Aktivieren Sie das Kontrollkästchen neben I acknowledge that the current settings may result in this bucket and the objects within becoming public (Ich bestätige, dass die aktuellen Einstellungen dazu führen können, dass dieser Bucket und die darin enthaltenen Objekte öffentlich werden).

8. Lassen Sie die restlichen Einstellungen bei den Standardwerten.

9. Wählen Sie Create Bucket (Bucket erstellen) aus.

Die JSON-CORS-Konfiguration definiert für Client-Webanwendungen (Videoplayer in diesem Kontext), die in einer Domain geladen sind, eine Möglichkeit zur Wiedergabe transcodierter Ausgabemediendateien in einer anderen Domain.

1. Melden Sie sich bei der an AWS Management Console und öffnen Sie die Amazon S3 S3-Konsole unter https://console.aws.amazon.com/s3/.

2. Wählen Sie im linken Navigationsbereich Buckets aus.

3. Wählen Sie in der Liste der Buckets den Namen des Buckets, den Sie zuvor erstellt haben (z. B. amzn-s3-demo-destination-bucket1).

4. Wählen Sie die Registerkarte Berechtigungen.

5. Wählen Sie im Abschnitt Cross-Origin Resource Sharing (CORS) die Option Edit (Bearbeiten) aus.

6. Kopieren Sie im Textfeld CORS-Konfiguration die folgende CORS-Konfiguration und fügen Sie sie ein.

   Die CORS-Konfiguration muss im JSON-Format vorliegen. In diesem Beispiel verwendet das AllowedOrigins-Attribut das Platzhalterzeichen (*) um alle Ursprünge anzugeben. Wenn Sie Ihren spezifischen Ursprung kennen, können Sie das AllowedOrigins-Attribut auf Ihre spezifische Player-URL beschränken. Weitere Informationen zum Konfigurieren von diesem und anderen Attributen finden Sie unter Elemente einer CORS-Konfiguration.

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

7. Wählen Sie Änderungen speichern.

Um eine IAM-Rolle zu erstellen für MediaConvert

1. Erstellen Sie eine IAM-Rolle mit einem von Ihnen ausgewählten Rollennamen (z. B. tutorial-mediaconvert-role). Um diese Rolle zu erstellen, folgen Sie den Schritten unter Erstellen Sie Ihre MediaConvert Rolle in IAM (Konsole) im AWS Elemental MediaConvert Benutzerhandbuch.

2. Nachdem Sie die IAM-Rolle für erstellt haben MediaConvert, wählen Sie in der Rollenliste den Namen der Rolle aus, für MediaConvert die Sie erstellt haben (z. B.tutorial-mediaconvert-role).

3. Kopieren Sie auf der Seite Übersicht die ARN der Rolle (die mit arn:aws:iam:: beginnt) und speichern Sie den ARN für die spätere Verwendung.

   Weitere Informationen zu ARNs finden Sie unter Amazon Resource Names (ARNs) in der AWS Allgemeinen Referenz.

1. Melden Sie sich bei der an AWS Management Console und öffnen Sie die IAM-Konsole unter. https://console.aws.amazon.com/iam/

2. Wählen Sie im linken Navigationsbereich Roles (Rollen) und dann Create Role (Rolle erstellen) aus.

3. Wählen Sie den AWS -Service-Rollentyp und wählen Sie dann unter Häufige Anwendungsfälle Lambda aus.

4. Wählen Sie Weiter: Berechtigungen aus.

5. Geben Sie auf der Seite Attach permissions (Berechtigungen anfügen) AWSLambdaBasicExecutionRole in das Suchfeld ein, um die Liste der Richtlinien zu filtern. Um die verwaltete Richtlinie AWSLambdaBasicExecutionRolean diese Rolle anzuhängen, um Schreibberechtigungen für Amazon CloudWatch Logs zu gewähren, aktivieren Sie das Kontrollkästchen neben AWSLambdaBasicExecutionRole.

6. Wählen Sie Weiter: Tags aus.

7. (Optional) Fügen Sie der verwalteten Richtlinie Tags hinzu.

8. Wählen Sie Weiter: Prüfen aus.

9. Geben Sie für Role name (Rollenname) den Namen tutorial-lambda-transcode-role ein.

10. Wählen Sie Create role (Rolle erstellen) aus.

Um der MediaConvert Ressource, die für die Ausführung der Lambda-Funktion benötigt wird, Berechtigungen zu gewähren, müssen Sie eine Inline-Richtlinie verwenden.

1. Melden Sie sich bei der an AWS Management Console und öffnen Sie die IAM-Konsole unter. https://console.aws.amazon.com/iam/

2. Wählen Sie im linken Navigationsbereich Roles aus.

3. Wählen Sie in der Liste der Rollen den Namen der IAM-Rolle aus, die Sie vorher für Ihre Lambda-Funktion erstellt haben (z. B. tutorial-lambda-transcode-role).

4. Wählen Sie den Tab Permissions (Berechtigungen).

5. Wählen Sie Add inline Policy (Inline-Richtlinie auswählen).

6. Wählen Sie die Registerkarte JSON aus, kopieren und fügen Sie dann die folgende JSON-Richtlinie ein:

   Ersetzen Sie in der JSON-Richtlinie den ARN-Beispielwert von Resource durch den Rollen-ARN der IAM-Rolle MediaConvert , für die Sie in Schritt 2 erstellt haben (z. B.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. Wählen Sie Review policy (Richtlinie überprüfen) aus.

8. Geben Sie unter Name tutorial-lambda-policy ein.

9. Wählen Sie Create Policy (Richtlinie erstellen) aus.

   Nachdem Sie eine Inline-Richtlinie erstellt haben, wird sie automatisch in Ihre IAM-Rolle Ihrer Lambda-Funktion eingebettet.

1. Erstellen Sie auf Ihrem lokalen Computer einen Ordner mit dem Namen batch-transcode.

2. Erstellen Sie im batch-transcode-Ordner eine Datei mit JSON-Auftragseinstellungen. Sie können z. B. die Einstellungen in diesem Abschnitt verwenden und die Datei job.json benennen.

   Eine job.json-Datei gibt Folgendes an:

   • Welche Dateien transcodiert werden sollen

   • Wie Sie Ihre Eingabevideos transcodieren möchten

   • Welche Ausgabemediendateien Sie erstellen möchten

   • Wie die transcodierten Dateien benannt werden sollen

   • Wo die transcodierten Dateien gespeichert werden sollen

   • Welche fortschrittlichen Funktionen angewendet werden sollen und so weiter

   In diesem Tutorial wird die folgende job.json-Datei verwendet, um die folgenden Ausgaben für jedes Video im S3-Quell-Bucket zu erstellen:

   • Ein HTTP Live Streaming (HLS) adaptiver Bitrate-Stream für die Wiedergabe auf mehreren Geräten mit verschiedenen Größen und unterschiedlichen Bandbreiten

   • Eine Videodatei MP4

   • In Intervallen gesammelte Miniaturbilder

   Diese Beispiel-Datei job.json verwendet Quality-Defined Variable Bitrate (QVBR), um die Videoqualität zu optimieren. Die HLS-Ausgabe ist Apple-kompatibel (Audio ungemischt vom Video, Segmentdauer von 6 Sekunden und optimierte Videoqualität durch automatisches QVBR).

   Wenn Sie die hier bereitgestellten Beispieleinstellungen nicht verwenden möchten, können Sie eine job.json-Spezifikation basierend auf Ihrem Anwendungsfall erstellen. Stellen Sie sicher, dass die Eingabedateien ähnliche Video- und Audiokonfigurationen aufweisen, um die Konsistenz Ihrer Ausgänge zu gewährleisten. Für beliebige Eingabedateien mit unterschiedlichen Video- und Audiokonfigurationen erstellen Sie getrennte Automatisierungen (eindeutige job.json-Einstellungen). Weitere Informationen finden Sie im AWS Elemental MediaConvert -Benutzerhandbuch unter Beispiel für AWS Elemental MediaConvert -Jobeinstellungen in 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"
       }
     ]
   }

   Mehr anzeigenWeniger anzeigen

3. Erstellen Sie im batch-transcode-Ordner eine Datei mit einer Lambda-Funktion. Sie können das folgende Python-Beispiel verwenden und die Datei convert.py nennen.

   S3-Batchvorgänge sendet bestimmte Aufgabendaten an eine Lambda-Funktion und erfordert Ergebnisdaten zurück. Anforderungs- und Antwortbeispielen für die Lambda-Funktion, Informationen über Antwort- und Ergebniscodes sowie Beispiel-Lambda-Funktionen für S3-Batchvorgänge finden Sie unter Funktion aufrufen 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. Um ein Bereitstellungspaket mit convert.py und job.json als .zip-Datei mit dem Namen lambda.zip zu erstellen, öffnen Sie in Ihrem lokalen Terminal den batch-transcode-Ordner, den Sie bereits erstellt haben, und führen Sie den folgenden Befehl aus.

   Führen Sie für macOS-Benutzer den folgenden Befehl aus:

   zip -r lambda.zip convert.py job.json                

   Führen Sie für Windows-Benutzer die folgenden Befehle aus:

   powershell Compress-Archive convert.py lambda.zip

   powershell Compress-Archive -update job.json lambda.zip                

1. Öffnen Sie die AWS Lambda Konsole unter https://console.aws.amazon.com/lambda/.

2. Wählen Sie im linken Navigationsbereich die Option Functions (Funktionen) aus.

3. Wählen Sie Create function (Funktion erstellen).

4. Wählen Sie Author from scratch aus.

5. Führen Sie unter Basic information (Grundlegende Informationen) die folgenden Schritte aus:

   1. Geben Sie für Function name (Funktionsname) tutorial-lambda-convert ein.

   2. Wählen Sie für Laufzeit Python 3.8 oder eine höhere Version von Python aus.

6. Wählen Sie Ändern der standardmäßigen Ausführungsrolle und wählen Sie unter Ausführungsrolle Verwenden einer vorhandenen Rolle.

7. Wählen Sie unter Bestehende Rolle den Namen der IAM-Rolle aus, die Sie für Ihre Lambda-Funktion in Schritt 3 (zum Beispiel tutorial-lambda-transcode-role) erstellt haben.

8. Lassen Sie die restlichen Einstellungen auf die Standardwerte eingestellt.

9. Wählen Sie Funktion erstellen aus.

1. Wählen Sie im Abschnitt Code-Quelle der Seite für die Lambda-Funktion, die Sie erstellt haben (z. B. tutorial-lambda-convert), Hochladen von und dann ZIP-Datei aus.

2. Wählen Sie Upload (Hochladen) aus, um Ihre lokale .zip-Datei auszuwählen.

3. Wählen Sie die zuvor erstellte lambda.zip-Datei und klicken Sie auf Öffnen.

4. Wählen Sie Speichern aus.

5. Wählen Sie im Abschnitt Runtime settings (Laufzeiteinstellungen) die OptionBearbeiten aus.

6. Um der Lambda-Laufzeit mitzuteilen, welche Handler-Methode in Ihrem Lambda-Funktionscode aufgerufen werden soll, geben Sie convert.handler in das Feld Handler ein.

   Wenn Sie eine Funktion in Python konfigurieren, besteht der Wert der Handler-Einstellung aus dem Dateinamen und dem Namen des Handler-Moduls, getrennt durch einen Punkt (.). Beispielsweise ruft convert.handler die Methode handler auf, die in der Datei convert.py definiert ist.

7. Wählen Sie Save (Speichern) aus.

8. Wählen Sie auf der Seite der Lambda-Funktion den Tab Konfiguration. Im linken Navigationsbereich auf der Registerkarte Konfiguration wählen Sie Umgebungsvariablen und wählen dann Bearbeiten aus.

9. Wählen Sie Umgebungsvariablen hinzufügen aus. Geben Sie dann den angegebenen Schlüssel und Wert für jede der folgenden Umgebungsvariablen ein:

   • Schlüssel: DestinationBucket Wert: amzn-s3-demo-destination-bucket1

     Dieser Wert ist der S3 Bucket für Ausgabe-Mediendateien, die Sie in Schritt 1 erstellt haben.

   • Schlüssel: MediaConvertRole Wert: arn:aws:iam::111122223333:role/tutorial-mediaconvert-role

     Dieser Wert ist der ARN der IAM-Rolle MediaConvert , für die Sie in Schritt 2 erstellt haben. Stellen Sie sicher, dass Sie diesen ARN durch den tatsächlichen ARN Ihrer IAM-Rolle ersetzen.

   • Schlüssel: Application Wert: Batch-Transcoding

     Dieser Wert ist der Name der Anwendung.

10. Wählen Sie Save (Speichern) aus.

11. (Optional) Wählen Sie im Tab Konfigurationim Abschnitt Allgemeine Konfiguration des linken Navigationsbereichs Bearbeiten aus. Geben Sie im Timeout-Feld 2 m 0 s ein. Wählen Sie dann Save (Speichern) aus.

    Timeout ist die Zeitspanne, die Lambda einer Funktion für einen Aufruf zulässt, bevor diese gestoppt wird. Der Standardwert ist 3 Sekunden. Die Preise basieren auf dem konfigurierten Arbeitsspeicher und der Zeit, für die der Code ausgeführt wird. Weitere Informationen finden Sie unter AWS Lambda Preise.

1. Melden Sie sich bei der an AWS Management Console und öffnen Sie die Amazon S3 S3-Konsole unter https://console.aws.amazon.com/s3/.

2. Wählen Sie im linken Navigationsbereich Buckets aus.

3. Wählen Sie Create Bucket (Bucket erstellen) aus.

4. Geben Sie im Feld Bucket Name einen Namen für Ihren Bucket ein (z. B. amzn-s3-demo-destination-bucket2).

5. Wählen Sie für den AWS-Region Ort aus AWS-Region, an dem sich der Bucket befinden soll.

   Der Ziel-Bucket für das Inventar muss sich im selben Bucket befinden AWS-Region wie der Quell-Bucket, in dem Sie S3 Inventory einrichten. Der Bestands-Ziel-Bucket kann sich in einem anderem AWS-Konto befinden.

6. Behalten Sie die Einstellungen für öffentlichen Zugriff für diesen Bucket blockieren auf die Standardeinstellungen gestellt (Alle öffentlichen Zugriffe blockieren ist aktiviert).

7. Lassen Sie die restlichen Einstellungen auf die Standardwerte eingestellt.

8. Wählen Sie Create Bucket (Bucket erstellen) aus.

9. Wählen Sie in der Liste der Buckets den Namen des Buckets, den Sie gerade erstellt haben (z. B. amzn-s3-demo-destination-bucket2).

10. Um Amazon S3 die Berechtigung zu erteilen, Daten für die Bestandsberichte in den S3-Basisziel-Bucket zu schreiben, wählen Sie das Tab Berechtigungen aus.

11. Scrollen Sie nach unten zum Abschnitt Bucket-Richtlinie und wählen Sie Bearbeiten aus. Die Seite Bucket-Richtlinie wird geöffnet.

12. Um Berechtigungen für S3-Inventar zu erteilen, fügen Sie im Feld Richtlinie die folgende Bucket-Richtlinie ein.

    Ersetzen Sie die drei Beispielwerte durch die folgenden Werte:

    • Der Name des Buckets, den Sie erstellt haben, um die Bestandsberichte zu speichern (z. B. amzn-s3-demo-destination-bucket2).

    • Der Name des Quell-Buckets, in dem die Eingabe-Videos gespeichert werden (z. B. amzn-s3-demo-source-bucket).

    • Die AWS-Konto ID, mit der Sie den S3-Videoquellen-Bucket erstellt haben (z. 111122223333 B.

    {
      "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. Wählen Sie Änderungen speichern.

1. Melden Sie sich bei der an AWS Management Console und öffnen Sie die Amazon S3 S3-Konsole unter https://console.aws.amazon.com/s3/.

2. Wählen Sie im linken Navigationsbereich Buckets aus.

3. Um einen S3-Inventarbericht der Eingabe-Videos in Ihrem S3-Quell-Bucket zu konfigurieren, wählen Sie in der Liste Buckets zum Beispiel den Namen des S3-Quell-Buckets aus (z. B. amzn-s3-demo-source-bucket).

4. Wählen Sie den Tab Management.

5. Blättern Sie nach unten bis zur Konfigurationen für Bestandserfassung und wählen Sie Erstellen der Bestandskonfiguration aus.

6. Geben Sie für Name der Bestandserfassung z. B. einen Namen ein (z. B. tutorial-inventory-config).

7. Wählen Sie unter Bestandserfassung Nur aktuelle Version für Objekt-Versionen und lassen Sie andere Einstellungen der Bestandserfassung auf die Standardwerte für dieses Tutorial eingestellt.

8. Wählen Sie im Abschnitt Berichtsdetails für Ziel-Bucket Dieses Konto aus.

9. Wählen Sie für Ziel S3 durchsuchen und wählen Sie den Ziel-Bucket aus, den Sie bereits erstellt haben, um die Lagerbestandsberichte zu speichern (z. B .amzn-s3-demo-destination-bucket2). Wählen Sie dann Pfad wählen aus.

   Der Ziel-Bucket für das Inventar muss sich im selben Bucket befinden AWS-Region wie der Quell-Bucket, in dem Sie S3 Inventory einrichten. Der Bestands-Ziel-Bucket kann sich in einem anderem AWS-Konto befinden.

   Unter dem Bucket-Feld Destination (Ziel) wird die Destination bucket permission (Ziel-Bucket-Berechtigung) der Bestands-Ziel-Bucket-Richtlinie hinzugefügt, damit Amazon S3 Daten in diesen Bestands-Ziel-Bucket platzieren kann. Weitere Informationen finden Sie unter Erstellen einer Ziel-Bucket-Richtlinie.

10. Wählen Sie für Häufigkeit Täglich aus.

11. Für das Ausgabeformat wählen Sie CSV.

12. Wählen Sie für Status die Option Aktiviert.

13. Wählen Sie im Abschnitt Serverseitige Verschlüsselung Deaktivieren für dieses Tutorial.

    Weitere Informationen erhalten Sie unter Konfigurieren des Bestands mit der S3-Konsole und Erteilen der Berechtigung an Amazon S3 zur Verwendung Ihres vom Kunden verwalteten Schlüssels für die Verschlüsselung.

14. Wählen Sie unter Zusätzliche Felder – optional Größe, Letzte Änderung, und Speicherklasse aus.

15. Wählen Sie Erstellen aus.

1. Melden Sie sich bei der an AWS Management Console und öffnen Sie die Amazon S3 S3-Konsole unter https://console.aws.amazon.com/s3/.

2. Wählen Sie im linken Navigationsbereich Buckets aus.

3. Wählen Sie in der Liste Buckets den Namen des Video-Quell-Buckets (z. B. amzn-s3-demo-source-bucket).

4. Wählen Sie Management (Verwaltung) aus.

5. Um zu sehen, ob Ihr S3-Bestandsbericht für das Erstellen eines S3-Batchvorgänge-Auftrags in Schritt 7 bereit ist, überprüfen Sie unter Bestandskonfigurationen, ob die Schaltfläche Auftrag aus Manifest erstellen aktiviert ist.

   Anmerkung

   Es kann bis zu 48 Stunden dauern, bis der erste Bestandsbericht bereitgestellt wird. Wenn die Schaltfläche Auftrag aus Manifest erstellendeaktiviert ist, wurde der erste Bestandsbericht nicht zugestellt. Warten Sie, bis der erste Bestandsbericht zugestellt wurde und die Schaltfläche Auftrag aus Manifest erstellen aktiviert ist, bevor Sie einen S3-Batchvorgänge-Auftrag in Schritt 7 erstellen.

6. Um einen S3-Bestandsbericht (manifest.json) in der die Spalte Ziel zu überprüfen, wählen Sie den Namen des Bestandsziels aus, den Sie bereits zum Speichern von Bestandsberichten erstellt haben (z. B. amzn-s3-demo-destination-bucket2).

7. Wählen Sie auf der Registerkarte Objekte den vorhandenen Ordner mit dem Namen Ihres S3-Quell-Buckets (z. B. amzn-s3-demo-source-bucket). Wählen Sie dann den Namen aus, den Sie in Name der Bestandserfassung eingegeben haben, als Sie die Inventarkonfiguration früher erstellt haben (z. B. tutorial-inventory-config).

   Sie können eine Liste von Ordnern mit den Generierungsdaten der Berichte als Namen sehen.

8. Um den täglichen S3-Bestandsbericht an einem bestimmten Datum zu überprüfen, wählen Sie den Ordner mit dem entsprechenden Namen des Generierungsdatums aus und wählen Sie dann manifest.json aus.

9. Um die Details des Bestandsberichts zu einem bestimmten Datum zu überprüfen, wählen Sie auf der Seite manifest.json Herunterladen oder Öffnen aus.

1. Melden Sie sich bei der an AWS Management Console und öffnen Sie die IAM-Konsole unter https://console.aws.amazon.com/iam/.

2. Wählen Sie im linken Navigationsbereich Richtlinien aus.

3. Wählen Sie Create Policy (Richtlinie erstellen) aus.

4. Wählen Sie den Tab JSON.

5. Fügen Sie die folgende JSON-Richtlinie in das JSON-Textfeld ein.

   Ersetzen Sie in der JSON-Richtlinie die vier Beispielwerte durch die folgenden Werte:

   • Der Name des Quell-Buckets, in dem Ihre Eingabe-Videos gespeichert werden (z. B. amzn-s3-demo-source-bucket).

   • Der Name des Bestands-Ziel-Buckets, den Sie in Schritt 5 erstellt haben, um manifest.json-Dateien (z. B. amzn-s3-demo-destination-bucket2) zu speichern.

   • Der Name des Buckets, den Sie in Schritt 1 erstellt haben, um Ausgabe-Mediendateien zu speichern (z. B. amzn-s3-demo-destination-bucket1). In diesem Tutorial legen wir Auftragsvervollständigungsberichte in den Ziel-Bucket für Ausgabe-Mediendateien.

   • Die Rollen-ARN der Lambda -Funktion, die Sie im AbschnittSchritt 4 erstellt haben. Um die Rolle ARN der Lambda-Funktion zu finden und zu kopieren, gehen Sie wie folgt vor:

     • Öffnen Sie in einem neuen Browser-Tab die Seite Funktionen der Lambda-Konsole bei https://console.aws.amazon.com/lambda/home#/functions.

     • Wählen Sie in der Liste Funktionen den Namen der Lambda-Funktion aus, die Sie in Schritt 4 (zum Beispiel tutorial-lambda-convert) erstellt haben.

     • Klicken Sie auf Copy ARN (ARN kopieren).

   {
       "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. Wählen Sie Next: Tags (Weiter: Tags) aus.

7. Klicken Sie auf Weiter: Prüfen.

8. Geben Sie im Feld Name tutorial-s3batch-policy ein.

9. Wählen Sie Create Policy (Richtlinie erstellen) aus.

1. Melden Sie sich bei der an AWS Management Console und öffnen Sie die IAM-Konsole unter. https://console.aws.amazon.com/iam/

2. Wählen Sie im linken Navigationsbereich Roles (Rollen) und dann Create Role (Rolle erstellen) aus.

3. Wählen Sie den AWS-Service-Rollentyp und danach den Service S3 aus.

4. Wählen Sie unter Ihren Anwendungsfall auswählen S3-Batch-Vorgänge.

5. Wählen Sie Weiter: Berechtigungen aus.

6. Geben Sie unter Anfügen von Berechtigungsrichtlinien den Namen der vorher erstellten IAM-Richtlinie ein (z. B.tutorial-s3batch-policy), um die Liste der Richtlinien zu filtern. Aktivieren Sie das Kontrollkästchen neben dem Namen der Richtlinie (z. B. tutorial-s3batch-policy).

7. Wählen Sie Next: Tags (Weiter: Tags) aus.

8. Wählen Sie Weiter: Prüfen aus.

9. Geben Sie für Role name (Rollenname) den Namen tutorial-s3batch-role ein.

10. Wählen Sie Create role (Rolle erstellen) aus.

    Nachdem Sie die IAM-Rolle für S3-Batchvorgänge erstellt haben, wird die folgende Vertrauensrichtlinie automatisch an die Rolle angefügt. Diese Vertrauensrichtlinie ermöglicht dem S3-Batchoperationen-Service-Prinzipal, die IAM-Rolle zu übernehmen.

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

1. Melden Sie sich bei der an AWS Management Console und öffnen Sie die Amazon S3 S3-Konsole unter https://console.aws.amazon.com/s3/.

2. Klicken Sie im linken Navigationsbereich auf Batchvorgänge.

3. Wählen Sie Job erstellen aus.

4. Wählen Sie für AWS-Region die Region aus, in der Sie Ihren Auftrag erstellen möchten.

   In diesem Tutorial müssen Sie den S3-Batchvorgänge-Auftrag zum Aufrufen einer Lambda-Funktion in derselben Region wie den S3-Videoquellen-Bucket erstellen, in dem sich die im Manifest referenzierten Objekte befinden.

5. Gehen Sie im Abschnitt Manifest wie folgt vor:

   1. Wählen Sie für Manifestformat S3-Inventory-Bericht (manifest.json) aus.

   2. Wählen Sie für Manifest-Objekt S3 durchsuchen, um den Bucket zu finden, den Sie in Schritt 5 zum Speichern von Bestandsberichten (z. B. amzn-s3-demo-destination-bucket2) erstellt haben. Navigieren Sie auf der Seite Manifest-Objekt durch die Objektnamen, bis Sie eine manifest.json-Datei für ein bestimmtes Datum finden. Diese Datei listet die Informationen zu allen Videos auf, die Sie Batch-Transcodieren möchten. Wenn Sie die manifest.json-Datei gefunden haben, die Sie verwenden möchten, wählen Sie die Optionsschaltfläche daneben. Wählen Sie dann Pfad wählen aus.

   3. (Optional) Geben Sie für Versions-ID des Manifestobjekts – optional die Versions-ID des Manifestobjekts ein, wenn Sie eine andere Version als die aktuelle verwenden möchten.

6. Wählen Sie Next (Weiter).

7. Um die Lambda-Funktion zum Transcodieren aller Objekte zu verwenden, die in der ausgewählten manifest.json-Datei aufgelistet sind, wählen Sie unter Vorgangstyp AWS Lambda -Funktion aufrufen aus.

8. Führen Sie im Abschnitt Aufrufen einer Lambda-Funktion Folgendes aus:

   1. Klicken Sie auf Wählen Sie aus den Funktionen Ihres Kontos aus.

   2. Wählen Sie für Lambda-Funktion die Lambda-Funktion aus, die Sie in Schritt 4 (zum Beispiel tutorial-lambda-convert) erstellt haben.

   3. Behalten Sie für Version der Lambda-Funktion den Standardwert $LATEST bei.

9. Wählen Sie Weiter. Die Seite Konfigurieren zusätzlicher Optionen wird geöffnet.

10. Behalten Sie im Abschnitt Zusätzliche Optionen die Standardeinstellungen bei.

    Weitere Informationen zu diesen Optionen finden Sie unter Batch-Vorgangsauftrag-Anforderungselemente.

11. Wählen Sie im Abschnitt Abschlussbericht für Pfad zum Ziel des Abschlussberichts S3 durchsuchen aus. Finden Sie den Bucket, den Sie in Schritt 1 für die Ausgabe-Mediendateien erstellte haben (z. B. amzn-s3-demo-destination-bucket1). Wählen Sie das Optionsfeld neben dem Namen dieses Buckets aus. Wählen Sie dann Pfad wählen aus.

    Lassen Sie die restlichen Einstellungen des Abschlussberichts auf die Standardwerte eingestellt. Weitere Informationen zu den Einstellungen des Fertigstellungsberichts finden Sie unter Batch-Vorgangsauftrag-Anforderungselemente. Ein Abschlussbericht führt eine Aufzeichnung der Details des Auftrags und der ausgeführten Vorgänge.

12. Wählen Sie im Abschnitt Berechtigungen Wählen Sie aus vorhandenen IAM-Rollen aus. Wählen Sie für IAM-Rolle die IAM-Rolle für Ihren S3-Batch-Vorgänge-Auftrag aus, den Sie im Abschnitt Schritt 6 (z. B. tutorial-s3batch-role) erstellt haben.

13. Wählen Sie Weiter.

14. Überprüfen Sie die Einstellungen auf der Seite Review. Wählen Sie dann Auftrag erstellen aus.

    Nachdem S3 das Manifest Ihres S3-Batchvorgänge-Auftrags gelesen hat, wechselt es den Auftrag in den Zustand Awaiting your confirmation to run (Wartet auf Ihre Bestätigung zur Ausführung). Um Aktualisierungen des Auftragsstatus anzuzeigen, aktualisieren Sie die Seite. Sie können Ihren Job erst ausführen, wenn der Status lautet Wartet auf Ihre Bestätigung zur Ausführung.

So führen Sie den S3-Batchvorgänge-Auftrag aus

1. Melden Sie sich bei der an AWS Management Console und öffnen Sie die Amazon S3 S3-Konsole unter https://console.aws.amazon.com/s3/.

2. Klicken Sie im linken Navigationsbereich auf Batchvorgänge.

3. Wählen Sie aus der Liste Aufträge die Auftrags-ID des Auftrags in der ersten Zeile aus, bei der es sich um den vorher erstellten S3-Batchvorgänge-Auftrag handelt.

4. Wählen Sie Auftrag ausführen aus.

5. Überprüfen Sie die Auftrags-Parameter erneut, und bestätigen Sie, dass der Wert für Insgesamt im Manifest aufgelistete Objekte mit der Anzahl der Objekte im Manifest identisch ist. Wählen Sie dann Auftrag ausführen.

   Ihre Seite des S3-Batchvorgänge-Auftrags wird geöffnet.

6. Nachdem der Auftrag gestartet wurde, kontrollieren Sie unter Status den Fortschritt Ihres S3-Batchvorgänge-Auftrags, wie z. B. Status, % abgeschlossen, Gesamt erfolgreich (Rate), Gesamt fehlgeschlagen (Rate), Beendigungsdatum, und Grund für die Beendigung.

   Wenn der S3-Batchvorgänge-Auftrag abgeschlossen ist, zeigen Sie die Daten auf Ihrer Auftragsseite an, um zu bestätigen, dass der Auftrag wie erwartet abgeschlossen wurde.

   Wenn mehr als 50 Prozent der Objektvorgänge eines S3-Batchvorgänge-Auftrags fehlschlagen, nachdem mehr als 1000 Vorgänge versucht wurden, schlägt der Auftrag automatisch fehl. Um Ihren Abschlussbericht zu überprüfen, um die Ursache der Fehler zu ermitteln, verwenden Sie das folgenden optionale Verfahren.

Um Ihren Abschlussbericht auf Details zu fehlgeschlagenen Objekten zu überprüfen:

1. Blättern Sie auf der Seite Ihres S3-Batchvorgänge-Auftrags zum Abschnitt Abschlussbericht und wählen Sie den Link unter Ziel des Abschlussberichts aus.

   Die Seite des S3-Ausgabe-Ziel-Buckets wird geöffnet.

2. Wählen Sie auf der Registerkarte Objekte auf den Ordner, dessen Name mit der Auftrags-ID des vorher erstellten S3-Batchvorgänge-Auftrags endet.

3. Klicken Sie auf Ergebnis/se.

4. Aktivieren Sie das Kontrollkästchen neben der .csv-Datei.

5. Wählen Sie Öffnen oder Herunterladen, um den Auftragsbericht anzuzeigen.

1. Öffnen Sie die AWS Lambda Konsole unter. https://console.aws.amazon.com/lambda/

2. Wählen Sie im linken Navigationsbereich die Option Functions (Funktionen) aus.

3. Wählen Sie in der Liste Funktionen den Namen der Lambda-Funktion aus, die Sie in Schritt 4 (zum Beispiel tutorial-lambda-convert) erstellt haben.

4. Wählen Sie den Tab Überwachung.

5. Finden Sie unter Metriken die Laufzeitmetriken für Ihre Lambda-Funktion.

6. Sehen Sie sich unter Logs die Protokolldaten für jeden Lambda-Aufruf über CloudWatch Logs Insights an.

   Anmerkung

   Wenn Sie S3-Batch-Vorgänge mit einer Lambda-Funktion verwenden, wird die Lambda-Funktion für jedes Objekt aufgerufen. Wenn Ihr S3-Batchvorgänge-Auftrag groß ist, kann er mehrere Lambda-Funktionen gleichzeitig aufrufen, was zu einer Spitze der Lambda-Gleichzeitigkeit führt.

   Jedes AWS-Konto hat eine Lambda-Parallelitätsquote pro Region. Weitere Informationen finden Sie unter Funktionsskalierung AWS Lambda im AWS Lambda -Entwicklerhandbuch. Eine bewährte Methode für die Verwendung von Lambda-Funktionen mit S3-Batchvorgängen besteht darin, eine Gleichzeitigkeitsgrenze für die Lambda-Funktion selbst festzulegen. Ein Parallelitäts-Limit aufzustellen verhindert, dass Ihr Auftrag den größten Teil Ihrer Lambda-Parallelität verbraucht und möglicherweise andere Funktionen in Ihrem Konto drosselt. Weitere Informationen finden Sie unter Verwalten reservierter Parallelität von Lambda im AWS Lambda -Entwicklerhandbuch.

1. Melden Sie sich bei der an AWS Management Console und öffnen Sie die Konsole unter. MediaConvert https://console.aws.amazon.com/mediaconvert/

2. Wenn die MediaConvert Einführungsseite angezeigt wird, wählen Sie Erste Schritte.

3. Zeige Sie aus der Liste Aufträge jede Zeile an, um die Transcodierungsaufgabe für jedes Eingabe-Video zu überwachen.

4. Geben Sie die Zeile eines Auftrags an, den Sie überprüfen möchten, und wählen Sie den Auftrags-ID-Link, um die Seite Auftrags-Details zu öffnen.

5. Wählen Sie auf der Seite mit der Jobübersicht unter Outputs den Link für die HLS- MP4, oder Thumbnails-Ausgabe aus, je nachdem, was von Ihrem Browser unterstützt wird, um zum S3-Ziel-Bucket für die Ausgabemediendateien zu gelangen.

6. Wählen Sie im entsprechenden Ordner (HLS oder Thumbnails) Ihres S3-Ausgabeziel-Buckets den Namen des Objekts der Ausgabemediendatei aus. MP4

   Die Detailseite des Objekts wird geöffnet.

7. Klicken Sie auf der Detailseite des Objekts unter Objekt-Übersicht auf den Link unter Objekt-URL, um die transcodierte Ausgabe-Mediendatei anzusehen.

So überprüfen Sie die Ausgabe-Mediendateien aus Ihrem S3-Ziel-Bucket

1. Melden Sie sich bei der an AWS Management Console und öffnen Sie die Amazon S3 S3-Konsole unter https://console.aws.amazon.com/s3/.

2. Wählen Sie im linken Navigationsbereich Buckets aus.

3. Wählen Sie aus der Liste Buckets den Namen des S3-Ziel-Buckets für Ausgabe-Mediendateien aus, die Sie im Abschnitt Schritt 1 (zum Beispiel amzn-s3-demo-destination-bucket1) erstellt haben.

4. Im Tab Objekte enthält jedes Eingabe-Video einen Ordner mit dem Namen des Eingabe-Videos. Jeder Ordner enthält die transcodierten Ausgabe-Mediendateien für ein Eingabe-Video.

   Gehen Sie wie folgt vor, um die Ausgabe-Mediendateien für ein Eingabe-Video zu überprüfen:

   1. Wählen Sie den Ordner mit dem Namen des Eingabe-Videos, das Sie überprüfen möchten.

   2. Wählen Sie den Ordner Standard/ aus.

   3. Wählen Sie den Ordner für ein transkodiertes Format (HLS, MP4, oder Miniaturansichten in diesem Tutorial).

   4. Wählen Sie den Namen der Ausgabemediendatei aus.

   5. Um die transcodierte Datei anzusehen, wählen Sie auf der Detailseite des Objekts den Link unter der Objekt-URL aus.

      Ausgabemediendateien im HLS-Format werden in kurze Segmente aufgeteilt. Um diese Videos abzuspielen, betten Sie die Objekt-URL der .m3u8-Datei in einem kompatiblen Player ein.

1. Melden Sie sich bei der an AWS Management Console und öffnen Sie die Amazon S3 S3-Konsole unter https://console.aws.amazon.com/s3/.

2. Wählen Sie im linken Navigationsbereich Buckets aus.

3. Wählen Sie in der Liste Buckets den Namen Ihres Quell-Buckets (z. B. amzn-s3-demo-source-bucket).

4. Wählen Sie den Tab Management.

5. Wählen Sie im Abschnitt Bestandskonfigurationen die Optionsschaltfläche neben der Bestandskonfiguration aus, die Sie in Schritt 5 (zum Beispiel tutorial-inventory-config) erstellt haben.

6. Wählen Sie Löschen und dann Bestätigen aus.

1. Öffnen Sie die AWS Lambda Konsole unter https://console.aws.amazon.com/lambda/.

2. Wählen Sie im linken Navigationsbereich die Option Functions (Funktionen) aus.

3. Aktivieren Sie das Kontrollkästchen neben der Funktion, die Sie im Abschnitt Schritt 4 (zum Beispiel tutorial-lambda-convert) erstellt haben.

4. Wählen Sie Aktionen und anschließend Löschen aus.

5. Wählen Sie im Bestätigungsdialogfeld Delete (Löschen) die Option Delete (Löschen) aus.

1. Öffnen Sie die CloudWatch Konsole unter https://console.aws.amazon.com/cloudwatch/.

2. Wählen Sie im linken Navigationsbereich Protokolle und dann Protokollgruppen aus.

3. Aktivieren Sie das Kontrollkästchen neben der Protokollgruppe, deren Name mit der Lambda-Funktion endet, die Sie im Abschnitt Schritt 4 (zum Beispiel tutorial-lambda-convert) erstellt haben.

4. Wählen Sie Actions (Aktionen) und dann Delete log group(s) (Protokollgruppe(n) löschen) aus.

5. Wählen Sie im Dialogfeld Delete log group(s) (Protokollgruppe(n) löschen) die Option Delete (Löschen) aus.

1. Melden Sie sich bei der an AWS Management Console und öffnen Sie die IAM-Konsole unter https://console.aws.amazon.com/iam/.

2. Wählen Sie im linken Navigationsbereich Roles (Rollen), und aktivieren Sie dann die Kontrollkästchen neben den Rollennamen, die Sie löschen möchten.

3. Wählen Sie oben auf der Seite Delete (Löschen) aus.

4. Geben Sie in das Bestätigungsfeld die erforderliche Antwort basierend auf der Eingabeaufforderung in das Texteingabefeld ein, und wählen Sie dann Löschen aus.

1. Melden Sie sich bei der an AWS Management Console und öffnen Sie die IAM-Konsole unter. https://console.aws.amazon.com/iam/

2. Wählen Sie im linken Navigationsbereich Richtlinien aus.

3. Wählen Sie das Optionsfeld neben der Richtlinie aus, die Sie in Schritt 6 (zum Beispiel tutorial-s3batch-policy) erstellt haben. Sie können über das Suchfeld die Liste der Richtlinien filtern.

4. Wählen Sie Aktionen und anschließend Löschen.

5. Bestätigen Sie, dass Sie diese Richtlinie löschen möchten, indem Sie den Namen in das angezeigte Textfeld eingeben und dann Delete (Löschen) wählen.

1. Melden Sie sich bei der an AWS Management Console und öffnen Sie die Amazon S3 S3-Konsole unter https://console.aws.amazon.com/s3/.

2. Wählen Sie im linken Navigationsbereich Buckets aus.

3. Wählen Sie in der Liste Buckets das Optionsfeld neben dem Namen des Buckets aus, den Sie leeren möchten. Wählen Sie anschließend Empty (Leeren) aus.

4. Bestätigen Sie auf der Seite Empty bucket (Bucket leeren), dass Sie den Bucket leeren möchten, indem Sie permanently delete in das Textfeld eingeben und dann Empty (Leeren) auswählen.

1. Melden Sie sich bei der an AWS Management Console und öffnen Sie die Amazon S3 S3-Konsole unter https://console.aws.amazon.com/s3/.

2. Wählen Sie im linken Navigationsbereich Buckets aus.

3. Wählen Sie in der Liste Buckets das Optionsfeld neben dem Namen des Buckets aus, den Sie löschen möchten.

4. Wählen Sie Löschen.

5. Bestätigen Sie auf der Seite Delete bucket (Bucket löschen), dass Sie den Bucket löschen möchten. Geben Sie dazu den Bucket-Namen in das Textfeld ein und wählen Sie Delete bucket (Bucket löschen).