

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Tutorial: Batch-Transcodierung von Videos mit S3 Batch Operations
<a name="tutorial-s3-batchops-lambda-mediaconvert-video"></a>

Videokonsumenten nutzen Geräte aller Formen, Größen und Jahrgänge, um Medieninhalte zu genießen. Diese breite Palette an Geräten stellt eine Herausforderung für Content-Ersteller und -Distributoren dar. Videos müssen nicht in einem one-size-fits-all Format vorliegen, sondern müssen so konvertiert werden, dass sie ein breites Spektrum an Größen, Formaten und Bitraten abdecken können. Diese Konvertierungsaufgabe ist noch schwieriger, wenn Sie eine große Anzahl von Videos haben, die konvertiert werden müssen.

AWS bietet Ihnen eine Methode zum Aufbau einer skalierbaren, verteilten Architektur mit folgenden Funktionen: 
+ Greift Eingabevideos auf
+ Verarbeitet die Videos zur Wiedergabe auf einer Vielzahl von Geräten
+ Speichert die transcodierten Mediendateien
+ Liefert die Ausgabemediendateien und befriedigt Ansprüche

Wenn Sie umfangreiche Video-Repositories in Amazon S3 gespeichert haben, können Sie diese Videos aus ihren Quellformaten in mehrere Dateitypen in der Größe, Auflösung und Format transkodieren, die von einem bestimmten Videoplayer oder Gerät benötigt werden. Insbesondere bietet Ihnen [S3 Batch Operations](https://aws.amazon.com/s3/features/batch-operations) eine Lösung zum Aufrufen von AWS Lambda Funktionen für vorhandene Eingabevideos in einem S3-Quell-Bucket. Dann rufen die Lambda-Funktionen [AWS Elemental MediaConvert](https://aws.amazon.com/mediaconvert/) auf, um umfangreiche Videotranskodierungsaufgaben auszuführen. Die konvertierten Ausgabe-Mediendateien werden in einem S3-Ziel-Bucket gespeichert. 

![\[Ein Workflow-Diagramm für Batch-Transcodierung.\]](http://docs.aws.amazon.com/de_de/AmazonS3/latest/userguide/images/batchops-example-image-global.png)


**Ziel**  
In diesem Lernprogramm erfahren Sie, wie Sie S3-Batch-Vorgänge einrichten, um eine Lambda-Funktion zum Batch-Transcodieren von Videos aufzurufen, die in einem S3-Quell-Bucket gespeichert sind. Die Lambda Funktion ruft MediaConvert auf, um die Videos zu transcodieren. Die Ausgänge für jedes Video im S3-Quell-Bucket sind wie folgt:
+ Ein [HTTP Live Streaming (HLS)](http://wikipedia.org/wiki/HTTP_Live_Streaming) adaptiver Bitrate-Stream für die Wiedergabe auf Geräten mit mehreren Größen und unterschiedlichen Bandbreiten
+ Eine MP4 Videodatei
+ In Intervallen gesammelte Miniaturbilder

**Topics**
+ [

## Voraussetzungen
](#batchops-s3-prerequisites)
+ [

## Schritt 1: Erstellen Sie einen S3-Bucket für Ausgabe-Mediendateien
](#batchops-s3-step1)
+ [

## Schritt 2: Erstellen Sie eine IAM-Rolle für MediaConvert
](#batchops-s3-step2)
+ [

## Schritt 3: Erstellen Sie eine IAM-Rolle für Ihre Lambda-Funktion
](#batchops-s3-step3)
+ [

## Schritt 4: Erstellen einer Lambda-Funktion für die Videotranscodierung
](#batchops-s3-step4)
+ [

## Schritt 5: Konfigurieren des Amazon S3-Bestands für Ihren S3-Quell-Bucket
](#batchops-s3-step5)
+ [

## Schritt 6: Erstellen einer IAM-Rolle für S3-Batchvorgänge
](#batchops-s3-step6)
+ [

## Schritt 7: Einrichten und Ausführen eines Auftrags für S3-Batchvorgänge
](#batchops-s3-step7)
+ [

## Schritt 8: Überprüfen Sie die Ausgabe-Mediendateien aus Ihrem S3-Ziel-Bucket
](#batchops-s3-step8)
+ [

## Schritt 9: Bereinigen
](#batchops-s3-step9)
+ [

## Nächste Schritte
](#batchops-s3-next-steps)

## Voraussetzungen
<a name="batchops-s3-prerequisites"></a>

Bevor Sie mit diesem Lernprogramm beginnen können, benötigen Sie einen Amazon S3-Quell-Bucket (z. B. `amzn-s3-demo-source-bucket`) mit Videos, die bereits darin transcodiert werden sollen.

Sie können dem Bucket einen anderen Namen geben, wenn Sie möchten. Weitere Informationen zu Amazon S3 Bucket-Namen finden Sie unter [Benennungsregeln für Allzweck-Buckets](bucketnamingrules.md).

Lassen Sie für den S3-Quell-Bucket die **Einstellungen für öffentlichen Zugriff für diesen Bucket blockieren** auf die Standardeinstellungen festlegen (***Alle* öffentlichen Zugriffe blockieren** ist aktiviert). Weitere Informationen finden Sie unter [Erstellen eines Allzweck-Buckets](create-bucket-overview.md). 

Weitere Informationen über das Hochladen von Videos in den S3-Quell-Bucket finden Sie unter [Objekte hochladen](upload-objects.md). Wenn Sie ein Video in S3 hochladen, können Sie auch [Amazon S3 Transfer Acceleration](https://aws.amazon.com/s3/transfer-acceleration) nutzen, um schnelle und sichere Dateiübertragungen zu konfigurieren. Transfer Acceleration kann das Hochladen von Videos zu Ihrem S3-Bucket zur Übertragung größerer Videos über große Entfernungen beschleunigen. Weitere Informationen finden Sie unter [Konfigurieren schneller, sicherer Dateiübertragungen mit Amazon S3 Transfer Acceleration](transfer-acceleration.md). 

## Schritt 1: Erstellen Sie einen S3-Bucket für Ausgabe-Mediendateien
<a name="batchops-s3-step1"></a>

In diesem Schritt erstellen Sie einen S3-Ziel-Bucket, um die konvertierten Ausgabe-Mediendateien zu speichern. Außerdem erstellen Sie eine CORS-Konfiguration (Cross Origin Resource Sharing), um den ursprungsübergreifenden Zugriff auf die transcodierten Mediendateien zu ermöglichen, die in Ihrem S3-Ziel-Bucket gespeichert sind. 

**Topics**
+ [

### Erstellen Sie einen Bucket für die Ausgabe-Mediendateien
](#batchops-s3-step1-create-bucket)
+ [

### So fügen Sie einem S3-Ausgabe-Bucket eine CORS-Konfiguration hinzu:
](#batchops-s3-step1-cors)

### Erstellen Sie einen Bucket für die Ausgabe-Mediendateien
<a name="batchops-s3-step1-create-bucket"></a>



1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon S3 S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

1. Wählen Sie im linken Navigationsbereich **Buckets** aus.

1. Wählen Sie **Create Bucket** (Bucket erstellen) aus. 

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

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

1. 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](access-control-block-public-access.md), 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 für den Block Public Access 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](tutorial-s3-cloudfront-route53-video-streaming.md). 

1. 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)**.

1. Lassen Sie die restlichen Einstellungen bei den Standardwerten. 

1. Wählen Sie **Create Bucket** (Bucket erstellen) aus.

### So fügen Sie einem S3-Ausgabe-Bucket eine CORS-Konfiguration hinzu:
<a name="batchops-s3-step1-cors"></a>

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-Managementkonsole und öffnen Sie die Amazon S3 S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

1. Wählen Sie im linken Navigationsbereich **Buckets** aus.

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

1. Wählen Sie die Registerkarte **Berechtigungen**.

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

1. 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](ManageCorsUsing.md).

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

1. Wählen Sie **Änderungen speichern ** aus.

## Schritt 2: Erstellen Sie eine IAM-Rolle für MediaConvert
<a name="batchops-s3-step2"></a>

Um die in Ihrem S3-Bucket gespeicherten Eingabevideos AWS Elemental MediaConvert zu transkodieren, benötigen Sie eine AWS Identity and Access Management (IAM-) Dienstrolle, um MediaConvert Berechtigungen zum Lesen und Schreiben von Videodateien aus und in Ihre S3-Quell- und Ziel-Buckets zu erteilen. Wenn Sie Transcodierungsaufträge ausführen, verwendet die MediaConvert Konsole diese Rolle. 

**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)](https://docs.aws.amazon.com/mediaconvert/latest/ug/creating-the-iam-role-in-iam.html) im *AWS Elemental MediaConvert Benutzerhandbuch*.

1. 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**).

1. 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)](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) in der *AWS Allgemeinen Referenz*. 

## Schritt 3: Erstellen Sie eine IAM-Rolle für Ihre Lambda-Funktion
<a name="batchops-s3-step3"></a>

Um Videos mit MediaConvert und S3 Batch Operations stapelweise zu transkodieren, verwenden Sie eine Lambda-Funktion, um diese beiden Dienste zu verbinden, um Videos zu konvertieren. Diese Lambda-Funktion muss über eine IAM-Rolle verfügen, die der Lambda-Funktion Zugriffsberechtigungen MediaConvert und S3-Stapeloperationen gewährt. 

**Topics**
+ [

### Erstellen Sie eine IAM-Rolle für Ihre Lambda-Funktion
](#batchops-s3-step3-role)
+ [

### Einbetten einer Inline-Richtlinie für die IAM-Rolle Ihrer Lambda -Funktion
](#batchops-s3-step3-inline-policy)

### Erstellen Sie eine IAM-Rolle für Ihre Lambda-Funktion
<a name="batchops-s3-step3-role"></a>

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)

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

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

1. Wählen Sie **Weiter: Berechtigungen** aus. 

1. 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 **AWSLambdaBasicExecutionRole**an diese Rolle anzuhängen, um Schreibberechtigungen für Amazon CloudWatch Logs zu gewähren, aktivieren Sie das Kontrollkästchen neben **AWSLambdaBasicExecutionRole**.

1. Wählen Sie **Weiter** aus.

1. Geben Sie für **Rollenname** den Namen **tutorial-lambda-transcode-role** ein.

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

1. Wählen Sie **Rolle erstellen** aus.

### Einbetten einer Inline-Richtlinie für die IAM-Rolle Ihrer Lambda -Funktion
<a name="batchops-s3-step3-inline-policy"></a>

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-Managementkonsole und öffnen Sie die IAM-Konsole unter. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)

1. Wählen Sie im linken Navigationsbereich **Roles** aus. 

1. 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**).

1. Wählen Sie den Tab **Permissions (Berechtigungen)**.

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

1. 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](#batchops-s3-step2) erstellt haben (z. B.**tutorial-mediaconvert-role**).

------
#### [ JSON ]

****  

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

------

1. Wählen Sie **Review policy** (Richtlinie überprüfen) aus.

1. Geben Sie unter **Name** **tutorial-lambda-policy** ein.

1. Wählen Sie **Richtlinie erstellen** aus.

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

## Schritt 4: Erstellen einer Lambda-Funktion für die Videotranscodierung
<a name="batchops-s3-step4"></a>

In diesem Abschnitt des Tutorials erstellen Sie eine Lambda-Funktion mithilfe des SDK für Python zur Integration mit S3 Batch Operations und MediaConvert. Um mit der Transcodierung der Videos zu beginnen, die bereits in Ihrem S3-Quell-Bucket gespeichert sind, führen Sie einen S3-Batchvorgang-Auftrag aus, der direkt die Lambda-Funktion für jedes Video im S3-Quell-Bucket aufruft. Anschließend sendet die Lambda-Funktion einen Transcodierungsauftrag für jedes Video an. MediaConvert

**Topics**
+ [

### Schreiben von Lambda-Funktionscode und Erstellen eines Bereitstellungspakets
](#batchops-s3-step4-write-function)
+ [

### Erstellen einer Lambda-Funktion mit einer Ausführungsrolle (Konsole)
](#batchops-s3-step4-create-function)
+ [

### Stellen Sie Ihre Lambda-Funktion mit ZIP-Dateiarchiven bereit und konfigurieren Sie die Lambda-Funktion (Konsole)
](#batchops-s3-step4-deploy-function)

### Schreiben von Lambda-Funktionscode und Erstellen eines Bereitstellungspakets
<a name="batchops-s3-step4-write-function"></a>

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

1. 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](https://docs.aws.amazon.com/mediaconvert/latest/ug/example-job-settings.html). 

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

1. 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](batch-ops-invoke-lambda.md). 

   ```
   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](https://docs.aws.amazon.com/mediaconvert/latest/ug/creating-streaming-and-file-outputs.html).
       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](https://docs.aws.amazon.com/mediaconvert/latest/ug/mediaconvert_error_codes.html). 
           # 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
       }
   ```

1. 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                
   ```

### Erstellen einer Lambda-Funktion mit einer Ausführungsrolle (Konsole)
<a name="batchops-s3-step4-create-function"></a>

1. 

   Öffnen Sie die AWS Lambda Konsole unter [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).

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

1. Wählen Sie **Create function** (Funktion erstellen).

1. Wählen Sie **Author from scratch** aus.

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

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

   1. Wählen Sie für **Runtime** **Python 3.13**.

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

1. Wählen Sie unter **Bestehende Rolle** den Namen der IAM-Rolle aus, die Sie für Ihre Lambda-Funktion in [Schritt 3](#batchops-s3-step3) (zum Beispiel **tutorial-lambda-transcode-role**) erstellt haben.

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

1. Wählen Sie **Funktion erstellen** aus.

### Stellen Sie Ihre Lambda-Funktion mit ZIP-Dateiarchiven bereit und konfigurieren Sie die Lambda-Funktion (Konsole)
<a name="batchops-s3-step4-deploy-function"></a>

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.

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

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

1. Wählen Sie **Speichern** aus.

1. Wählen Sie im Abschnitt **Runtime settings** (Laufzeiteinstellungen) die Option**Bearbeiten** aus. 

1. 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.

1. Wählen Sie **Speichern**.

1. 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.

1. 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](#batchops-s3-step1) 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](#batchops-s3-step2) 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.

1. Wählen Sie **Speichern**.

1. (Optional) Wählen Sie im Tab **Konfiguration**im 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](https://aws.amazon.com/lambda/pricing/?icmpid=docs_console_unmapped).

## Schritt 5: Konfigurieren des Amazon S3-Bestands für Ihren S3-Quell-Bucket
<a name="batchops-s3-step5"></a>

Nachdem Sie die Transcodierungs-Lambda-Funktion eingerichtet haben, erstellen Sie einen S3-Batchvorgangsauftrag, um eine Reihe von Videos zu transcodieren. Zuerst benötigen Sie eine Liste von Eingabe-Videoobjekten, für die S3-Batch-Vorgänge die angegebene Transcodierungsaktion ausführen soll. Um eine Liste von Eingabe-Videoobjekten abzurufen, können Sie einen S3-Inventarbericht für Ihren S3-Quell-Bucket erstellen (z. B. `amzn-s3-demo-source-bucket`). 

**Topics**
+ [

### Erstellen und Konfigurieren eines Buckets für S3-Inventarberichte für Eingabevideos
](#batchops-s3-step5-bucket)
+ [

### Konfigurieren des Amazon S3-Bestands für Ihren S3-Quell-Bucket
](#batchops-s3-step5-inventory)
+ [

### Überprüfen Sie den Lagerbestandsbericht für Ihren S3-Videoquellen-Bucket
](#batchops-s3-step5-manifest)

### Erstellen und Konfigurieren eines Buckets für S3-Inventarberichte für Eingabevideos
<a name="batchops-s3-step5-bucket"></a>

Um einen S3-Bestandslistenbericht zu speichern, der die Objekte des S3-Quell-Buckets auflistet, erstellen Sie einen S3-Inventarziel-Bucket und konfigurieren Sie dann eine Bucket-Richtlinie, damit der Bucket Inventardateien in den S3-Quell-Bucket schreibt.

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon S3 S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

1. Wählen Sie im linken Navigationsbereich **Buckets** aus.

1. Wählen Sie **Create Bucket** (Bucket erstellen) aus. 

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

1. Wählen Sie für **AWS-Region**, AWS-Region wo 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. 

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

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

1. Wählen Sie **Create Bucket** (Bucket erstellen) aus.

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

1. 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.

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

1. 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.

------
#### [ JSON ]

****  

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

------

1. Wählen Sie **Änderungen speichern ** aus.

### Konfigurieren des Amazon S3-Bestands für Ihren S3-Quell-Bucket
<a name="batchops-s3-step5-inventory"></a>

Sie müssen S3-Inventar für Ihren S3-Videoquellen-Bucket konfigurieren, um eine flache Dateiliste mit Videoobjekten und Metadaten zu generieren. Diese geplanten Bestandsberichte können alle Objekte im Bucket oder Objekte enthalten, die nach einem gemeinsamen Präfix gruppiert sind. In diesem Tutorial enthält der S3-Bestandsbericht alle Video-Objekte in Ihrem S3-Quell-Bucket.

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon S3 S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

1. Wählen Sie im linken Navigationsbereich **Buckets** aus.

1. 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`).

1. Wählen Sie den Tab **Management**.

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

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

1. 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. 

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

1. 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](configure-inventory.md#configure-inventory-destination-bucket-policy).

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

1. Für das **Ausgabeformat** wählen Sie **CSV**. 

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

1. 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](configure-inventory.md#configure-inventory-console) und [Erteilen der Berechtigung an Amazon S3 zur Verwendung Ihres vom Kunden verwalteten Schlüssels für die Verschlüsselung](configure-inventory.md#configure-inventory-kms-key-policy). 

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

1. Wählen Sie **Erstellen** aus.

Weitere Informationen finden Sie unter [Konfigurieren des Bestands mit der S3-Konsole](configure-inventory.md#configure-inventory-console).

### Überprüfen Sie den Lagerbestandsbericht für Ihren S3-Videoquellen-Bucket
<a name="batchops-s3-step5-manifest"></a>

Wenn ein Bestandsbericht veröffentlicht wird, werden die Manifestdateien an den S3-Bestands-Ziel-Bucket gesendet.

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon S3 S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

1. Wählen Sie im linken Navigationsbereich **Buckets** aus.

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

1. Wählen Sie **Management (Verwaltung)** aus.

1. Um zu sehen, ob Ihr S3-Bestandsbericht für das Erstellen eines S3-Batchvorgänge-Auftrags in [Schritt 7](#batchops-s3-step7) 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 erstellen**deaktiviert 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](#batchops-s3-step7) erstellen. 

1. 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`).

1. 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. 

1. 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. 

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

## Schritt 6: Erstellen einer IAM-Rolle für S3-Batchvorgänge
<a name="batchops-s3-step6"></a>

Um S3-Batchvorgänge für die Batch-Transcodierung verwenden zu können, müssen Sie zunächst eine IAM-Rolle erstellen, um Amazon S3 Berechtigungen zum Ausführen von S3-Batchvorgängen zu geben. 

**Topics**
+ [

### Erstellen einer IAM-Richtlinie für S3-Batchvorgänge
](#batchops-s3-step6-policy)
+ [

### Erstellen Sie eine S3-Batchvorgänge-IAM-Rolle und fügen Sie Berechtigungsrichtlinien an
](#batchops-s3-step6-role)

### Erstellen einer IAM-Richtlinie für S3-Batchvorgänge
<a name="batchops-s3-step6-policy"></a>

Sie müssen eine IAM-Richtlinie erstellen, die S3-Batchvorgängen die Berechtigung zum Lesen des Eingabemanifests, zum Aufrufen der Lambda-Funktion und zum Schreiben desAbschlussberichts des S3-Batchvorgänge-Auftrags erteilt. 

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Wählen Sie im linken Navigationsbereich **Richtlinien** aus.

1. Wählen Sie **Richtlinie erstellen** aus.

1. Wählen Sie den Tab **JSON**.

1. 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](#batchops-s3-step5) erstellt haben, um `manifest.json`-Dateien (z. B. `amzn-s3-demo-destination-bucket2`) zu speichern.
   + Der Name des Buckets, den Sie in [Schritt 1](#batchops-s3-step1) 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 Abschnitt[Schritt 4](#batchops-s3-step4) 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](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](#batchops-s3-step4) (zum Beispiel **tutorial-lambda-convert**) erstellt haben.
     + Klicken Sie auf **Copy ARN** (ARN kopieren).

------
#### [ JSON ]

****  

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

------

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

1. Klicken Sie auf **Weiter: Prüfen**.

1. Geben Sie im Feld **Name** **tutorial-s3batch-policy** ein.

1. Wählen Sie **Richtlinie erstellen** aus.

### Erstellen Sie eine S3-Batchvorgänge-IAM-Rolle und fügen Sie Berechtigungsrichtlinien an
<a name="batchops-s3-step6-role"></a>

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)

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

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

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

1. Wählen Sie **Weiter** aus.

1. Geben Sie unter **Berechtigungen zuweisen**den Namen der IAM-Richtlinie, die Sie zuvor erstellt haben (z. B. **tutorial-s3batch-policy**), in das Suchfeld ein, um die Liste der Richtlinien zu filtern. Aktivieren Sie das Kontrollkästchen neben dem Namen der Richtlinie (z. B. **tutorial-s3batch-policy**). 

1. Wählen Sie **Weiter** aus.

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

1. 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.

------
#### [ JSON ]

****  

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

------

## Schritt 7: Einrichten und Ausführen eines Auftrags für S3-Batchvorgänge
<a name="batchops-s3-step7"></a>

Um einen S3-Batchvorgänge-Auftrag zu erstellen, um die Eingabevideos in Ihrem S3-Quell-Bucket zu verarbeiten, müssen Sie Parameter für diesen bestimmten Auftrag angeben.

**Anmerkung**  
Um mit der Erstellung eines S3-Batchvorgänge-Auftrags zu beginnen, stellen Sie sicher, dass die Schaltfläche **Auftrag aus Manifest erstellen** aktiviert ist. Weitere Informationen finden Sie unter [Überprüfen Sie den Lagerbestandsbericht für Ihren S3-Videoquellen-Bucket](#batchops-s3-step5-manifest). Wenn die Schaltfläche **Auftrag aus Manifest erstellen** deaktiviert ist, wurde der erste Inventarbericht nicht übermittelt und Sie müssen warten, bis die Schaltfläche aktiviert ist. Nachdem Sie Amazon S3-Bestand für Ihren S3-Quell-Bucket in [Schritt 5](#batchops-s3-step5) konfiguriert haben, kann es bis zu 48 Stunden dauern, bis der erste Bestandsbericht übermittelt wird.

**Topics**
+ [

### Erstellen eines S3-Batchvorgangsauftrags
](#batchops-s3-step7-create-job)
+ [

### Führen Sie den S3-Batchvorgänge-Auftrag aus, um Ihre Lambda-Funktion aufzurufen.
](#batchops-s3-step7-run-job)
+ [

### (Optional) Prüfen Sie Ihren Abschlussbericht
](#batchops-s3-step7-check-report)
+ [

### (Optional) Überwachen Sie jeden Lambda-Aufruf in der Lambda-Konsole
](#batchops-s3-step7-monitor-lambda)
+ [

### (Optional) Überwachen Sie jeden MediaConvert Video-Transcodierungsauftrag in der Konsole MediaConvert
](#batchops-s3-step7-monitor-mediaconvert)

### Erstellen eines S3-Batchvorgangsauftrags
<a name="batchops-s3-step7-create-job"></a>

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon S3 S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

1. Klicken Sie im linken Navigationsbereich auf **Batchvorgänge**.

1. Wählen Sie **Job erstellen** aus.

1. 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.

1. Gehen Sie im Abschnitt **Manifest** wie folgt vor:

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

   1. Wählen Sie für **Manifest-Objekt** **S3 durchsuchen**, um den Bucket zu finden, den Sie in [Schritt 5](#batchops-s3-step5) 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.

   1. (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.

1. Wählen Sie **Next** (Weiter).

1. 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.

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

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

   1. Wählen Sie für **Lambda-Funktion** die Lambda-Funktion aus, die Sie in [Schritt 4](#batchops-s3-step4) (zum Beispiel **tutorial-lambda-convert**) erstellt haben.

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

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

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

   Weitere Informationen zu diesen Optionen finden Sie unter [Batch-Vorgangsauftrag-Anforderungselemente](batch-ops-create-job.md#batch-ops-create-job-request-elements).

1. 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](#batchops-s3-step1) 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](batch-ops-create-job.md#batch-ops-create-job-request-elements). Ein Abschlussbericht führt eine Aufzeichnung der Details des Auftrags und der ausgeführten Vorgänge.

1. 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](#batchops-s3-step6) (z. B. **tutorial-s3batch-role**) erstellt haben.

1. Wählen Sie **Weiter** aus.

1. Ü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**.

### Führen Sie den S3-Batchvorgänge-Auftrag aus, um Ihre Lambda-Funktion aufzurufen.
<a name="batchops-s3-step7-run-job"></a>

Führen Sie Ihren Batchvorgänge-Auftrag aus, um Ihre Lambda-Funktion für die Videotranscodierung aufzurufen. Wenn Ihr Auftrag fehlschlägt, können Sie den Abschlussbericht überprüfen, um die Ursache zu ermitteln.

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

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon S3 S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

1. Klicken Sie im linken Navigationsbereich auf **Batchvorgänge**.

1. 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.

1. Wählen Sie **Auftrag ausführen** aus. 

1. Ü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.

1. 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.

### (Optional) Prüfen Sie Ihren Abschlussbericht
<a name="batchops-s3-step7-check-report"></a>

Sie können Ihren Abschlussbericht verwenden, um festzustellen, welche Objekte fehlgeschlagen sind und welche Ursache der Fehler sind.

**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.

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

1. Klicken Sie auf **Ergebnis/se**.

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

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

### (Optional) Überwachen Sie jeden Lambda-Aufruf in der Lambda-Konsole
<a name="batchops-s3-step7-monitor-lambda"></a>

Nachdem der S3-Batchvorgänge-Auftrag gestartet wurde, ruft der Auftrag, die Lambda-Funktion für jedes Eingabe-Video-Objekt auf. S3 schreibt Protokolle jedes Lambda-Aufrufs in Logs. CloudWatch Sie können das Monitoring-Dashboard der Lambda-Konsole verwenden, um Ihre Lambda-Funktion zu überwachen. 

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

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

1. Wählen Sie in der Liste **Funktionen** den Namen der Lambda-Funktion aus, die Sie in [Schritt 4](#batchops-s3-step4) (zum Beispiel **tutorial-lambda-convert**) erstellt haben.

1. Wählen Sie den Tab **Überwachung**.

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

1. 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](https://docs.aws.amazon.com/lambda/latest/dg/invocation-scaling.html) 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](https://docs.aws.amazon.com/lambda/latest/dg/configuration-concurrency.html) im *AWS Lambda -Entwicklerhandbuch*.

### (Optional) Überwachen Sie jeden MediaConvert Video-Transcodierungsauftrag in der Konsole MediaConvert
<a name="batchops-s3-step7-monitor-mediaconvert"></a>

Ein MediaConvert Job erledigt die Transcodierung einer Mediendatei. Wenn Ihr S3 Batch Operations-Job Ihre Lambda-Funktion für jedes Video aufruft, erstellt jeder Lambda-Funktionsaufruf einen MediaConvert Transcodierungsauftrag für jedes Eingabevideo. 

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Konsole unter. MediaConvert [https://console.aws.amazon.com/mediaconvert/](https://console.aws.amazon.com/mediaconvert/)

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

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

1. 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.

1. 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.

1. 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.

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

## Schritt 8: Überprüfen Sie die Ausgabe-Mediendateien aus Ihrem S3-Ziel-Bucket
<a name="batchops-s3-step8"></a>

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

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon S3 S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

1. Wählen Sie im linken Navigationsbereich **Buckets** aus.

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

1. 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.

   1. Wählen Sie den Ordner **Standard/** aus.

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

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

   1. 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.

## Schritt 9: Bereinigen
<a name="batchops-s3-step9"></a>

Wenn Sie Videos mit S3 Batch Operations, Lambda und MediaConvert nur zu Lernzwecken transkodiert haben, löschen Sie die AWS Ressourcen, die Sie zugewiesen haben, sodass keine Gebühren mehr anfallen. 

**Topics**
+ [

### Löschen der S3-Bestandskonfiguration für Ihren S3-Quell-Bucket
](#batchops-s3-step9-delete-inventory)
+ [

### Löschen Sie die Lambda-Funktion
](#batchops-s3-step9-delete-lambda)
+ [

### Löschen Sie die CloudWatch Protokollgruppe
](#batchops-s3-step9-delete-cw)
+ [

### Löschen Sie die IAM-Rollen zusammen mit den Inline-Richtlinien für die IAM-Rollen
](#batchops-s3-step9-delete-role)
+ [

### Löschen Sie die kundenverwaltete IAM-Richtlinie
](#batchops-s3-step9-delete-policy)
+ [

### Leeren Sie die S3-Buckets
](#batchops-s3-step9-empty-bucket)
+ [

### Löschen der S3-Buckets
](#batchops-s3-step9-delete-bucket)

### Löschen der S3-Bestandskonfiguration für Ihren S3-Quell-Bucket
<a name="batchops-s3-step9-delete-inventory"></a>

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon S3 S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

1. Wählen Sie im linken Navigationsbereich **Buckets** aus.

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

1. Wählen Sie den Tab **Management**.

1. Wählen Sie im Abschnitt **Bestandskonfigurationen** die Optionsschaltfläche neben der Bestandskonfiguration aus, die Sie in [Schritt 5](#batchops-s3-step5) (zum Beispiel **tutorial-inventory-config**) erstellt haben.

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

### Löschen Sie die Lambda-Funktion
<a name="batchops-s3-step9-delete-lambda"></a>

1. 

   Öffnen Sie die AWS Lambda Konsole unter [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).

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

1. Aktivieren Sie das Kontrollkästchen neben der Funktion, die Sie im Abschnitt [Schritt 4](#batchops-s3-step4) (zum Beispiel **tutorial-lambda-convert**) erstellt haben.

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

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

### Löschen Sie die CloudWatch Protokollgruppe
<a name="batchops-s3-step9-delete-cw"></a>

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

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

1. Aktivieren Sie das Kontrollkästchen neben der Protokollgruppe, deren Name mit der Lambda-Funktion endet, die Sie im Abschnitt [Schritt 4](#batchops-s3-step4) (zum Beispiel **tutorial-lambda-convert**) erstellt haben.

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

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

### Löschen Sie die IAM-Rollen zusammen mit den Inline-Richtlinien für die IAM-Rollen
<a name="batchops-s3-step9-delete-role"></a>

Um die IAM-Rollen zu löschen, die Sie in [Schritt 2](#batchops-s3-step2), [Schritt 3](#batchops-s3-step3), und [Schritt 6](#batchops-s3-step6) erstellt haben, tun Sie Folgendes: 

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

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

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

1. 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. 

### Löschen Sie die kundenverwaltete IAM-Richtlinie
<a name="batchops-s3-step9-delete-policy"></a>

Um die vom Kunden verwaltete IAM-Richtlinie zu löschen, die Sie in [Schritt 6](#batchops-s3-step6) erstellt haben, tun Sie Folgendes:

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)

1. Wählen Sie im linken Navigationsbereich **Richtlinien** aus.

1. Wählen Sie das Optionsfeld neben der Richtlinie aus, die Sie in [Schritt 6](#batchops-s3-step6) (zum Beispiel **tutorial-s3batch-policy**) erstellt haben. Sie können über das Suchfeld die Liste der Richtlinien filtern.

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

1. 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. 

### Leeren Sie die S3-Buckets
<a name="batchops-s3-step9-empty-bucket"></a>

Um die S3-Buckets zu leeren, die Sie in [Voraussetzungen](#batchops-s3-prerequisites), [Schritt 1](#batchops-s3-step1) und [Schritt 5](#batchops-s3-step5) erstellt haben, tun Sie Folgendes: 

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon S3 S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

1. Wählen Sie im linken Navigationsbereich **Buckets** aus.

1. 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.

1. 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.

### Löschen der S3-Buckets
<a name="batchops-s3-step9-delete-bucket"></a>

Um die S3-Buckets zu löschen, die Sie in [Voraussetzungen](#batchops-s3-prerequisites), [Schritt 1](#batchops-s3-step1) und [Schritt 5](#batchops-s3-step5) erstellt haben, tun Sie Folgendes: 

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon S3 S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

1. Wählen Sie im linken Navigationsbereich **Buckets** aus.

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

1. Wählen Sie **Löschen** aus.

1. 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).

## Nächste Schritte
<a name="batchops-s3-next-steps"></a>

Nachdem Sie dieses Tutorial abgeschlossen haben, können Sie weitere relevante Anwendungsfälle untersuchen:
+ Sie können Amazon verwenden CloudFront , um die transkodierten Mediendateien an Zuschauer auf der ganzen Welt zu streamen. Weitere Informationen finden Sie unter [Tutorial: Hosten von On-Demand-Streaming-Videos mit Amazon S3 CloudFront, Amazon und Amazon Route 53](tutorial-s3-cloudfront-route53-video-streaming.md).
+ Sie können Videos in dem Moment transcodieren, indem Sie sie in den S3-Quell-Bucket hochladen. Dazu können Sie einen Amazon S3 S3-Event-Trigger konfigurieren, der automatisch die Lambda-Funktion aufruft, mit der neue Objekte in S3 transkodiert werden. MediaConvert Weitere Informationen finden Sie unter [Tutorial: Verwenden eines Amazon S3-Auslösers zum Aufrufen einer Lambda-Funktion](https://docs.aws.amazon.com/lambda/latest/dg/with-s3-example.html) im *AWS Lambda -Entwicklerhandbuch*. 