Tutorial: Batch-Transcodierung von Videos mit S3- AWS Lambda Batchoperationen und AWS Elemental MediaConvert - Amazon Simple Storage Service
Voraussetzungen Schritt 1: Erstellen Sie einen S3-Bucket für Ausgabe-MediendateienSchritt 2: Erstellen einer IAM-Rolle für MediaConvertSchritt 3: Erstellen Sie eine IAM-Rolle für Ihre Lambda-FunktionSchritt 4: Erstellen einer Lambda-Funktion für die VideotranscodierungSchritt 5: Konfigurieren des Amazon S3-Bestands für Ihren S3-Quell-BucketSchritt 6: Erstellen einer IAM-Rolle für S3-BatchvorgängeSchritt 7: Einrichten und Ausführen eines Auftrags für S3-BatchvorgängeSchritt 8: Überprüfen Sie die Ausgabe-Mediendateien aus Ihrem S3-Ziel-BucketSchritt 9: BereinigenNächste Schritte

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- AWS Lambda Batchoperationen und AWS Elemental MediaConvert

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. Anstatt in einem one-size-fits-all Format zu sein, müssen Videos konvertiert werden, damit sie eine breite Palette von Größen, Formaten und Bitraten umfassen 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 Erstellen einer skalierbaren, verteilten Architektur, die Folgendes tut:

  • 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-Batchoperationen 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 auf, um umfangreiche Videotranskodierungsaufgaben auszuführen. Die konvertierten Ausgabe-Mediendateien werden in einem S3-Ziel-Bucket gespeichert.

Ein Workflow zur Batch-Transcodierungs-Diagramm zeigt den Fluss von den Eingabevideos im S3-Quell-Bucket zu den Ausgabemediendateien im S3-Ziel-Bucket an.
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) adaptiver Bitrate-Stream für die Wiedergabe auf Geräten mit mehreren Größen und unterschiedlichen Bandbreiten

  • Eine MP4-Videodatei

  • In Intervallen gesammelte Miniaturbilder

Voraussetzungen

Bevor Sie mit diesem Lernprogramm beginnen können, benötigen Sie einen Amazon S3-Quell-Bucket (z. B. tutorial-bucket-1) 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 Regeln für die Benennung von Buckets.

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

Weitere Informationen über das Hochladen von Videos in den S3-Quell-Bucket finden Sie unter Objekte hochladen. Wenn Sie ein Video in S3 hochladen, können Sie auch Amazon 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.

Schritt 1: Erstellen Sie einen S3-Bucket für Ausgabe-Mediendateien

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.

Erstellen Sie einen Bucket für die Ausgabe-Mediendateien

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

  2. Wählen Sie im linken Navigationsbereich die Option 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. tutorial-bucket-2).

  5. Wählen Sie für Region die aus, AWS-Region in der 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 transcodierten Mediendateien an Viewer (Endbenutzer) zu übermitteln. 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 Bucket erstellen aus.

So fügen Sie einem S3-Ausgabe-Bucket eine CORS-Konfiguration hinzu:

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-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. tutorial-bucket-2).

  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 CORS-Konfiguration.

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

    }
]

  7. Wählen Sie Änderungen speichern aus.

Schritt 2: Erstellen einer IAM-Rolle für MediaConvert

Um AWS Elemental MediaConvert zum Transcodieren von Eingabevideos zu verwenden, die in Ihrem S3-Bucket gespeichert sind, benötigen Sie eine AWS Identity and Access Management (IAM)-Servicerolle, 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.

So erstellen Sie eine IAM-Rolle 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 Ihrer 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 Liste der Rollen 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 zur Verwendung von ARNs finden Sie unter Amazon-Ressourcennamen (ARNs) in der Allgemeinen AWS -Referenz.

Schritt 3: Erstellen Sie eine IAM-Rolle für Ihre Lambda-Funktion

Um Videos mit MediaConvert und S3-Batchoperationen im Stapel zu transcodieren, verwenden Sie eine Lambda-Funktion, um diese beiden Services zum Konvertieren von Videos zu verbinden. Diese Lambda-Funktion muss über eine IAM-Rolle verfügen, die der Lambda-Funktion Berechtigungen für den Zugriff auf MediaConvert und S3-Batchoperationen gewährt.

Erstellen Sie eine IAM-Rolle für Ihre Lambda-Funktion

  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 AWSLambdaBasicExecutionRole an diese Rolle anzufügen, um Amazon CloudWatch Logs Schreibberechtigungen zu erteilen, aktivieren Sie das Kontrollkästchen neben AWSLambdaBasicExecutionRole.

  6. Wählen Sie Weiter: Markierungen.

  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.

Einbetten einer Inline-Richtlinie für die IAM-Rolle Ihrer Lambda -Funktion

Um Berechtigungen für die MediaConvert Ressource zu erteilen, die für die Ausführung der Lambda-Funktion erforderlich ist, 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 Beispiel-ARN-Wert von durch Resource den Rollen-ARN der IAM-Rolle für , MediaConvert die Sie in Schritt 2 (z. B. tutorial-mediaconvert-role) erstellt haben.

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

In diesem Abschnitt des Tutorials erstellen Sie eine Lambda-Funktion mit dem -SDK für Python zur Integration in S3-Batchoperationen 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.

Schreiben von Lambda-Funktionscode und Erstellen eines Bereitstellungspakets

  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 MP4-Videodatei

    • 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 Aufrufen einer AWS Lambda-Funktion. 

    import json
import os
from urllib.parse import urlparse
import uuid
import boto3

"""
When you run an S3 Batch Operations job, your job  
invokes this Lambda function. Specifically, the Lambda function is 
invoked on each video object listed in the manifest that you specify 
for the S3 Batch Operations job in Step 5.  

Input parameter "event": The S3 Batch Operations event as a request
                         for the Lambda function.

Input parameter "context": Context about the event.

Output: A result structure that Amazon S3 uses to interpret the result 
        of the operation. It is a job response returned back to S3 Batch Operations.
"""
def handler(event, context):

    invocation_schema_version = event['invocationSchemaVersion']
    invocation_id = event['invocationId']
    task_id = event['tasks'][0]['taskId']

    source_s3_key = event['tasks'][0]['s3Key']
    source_s3_bucket = event['tasks'][0]['s3BucketArn'].split(':::')[-1]
    source_s3 = 's3://' + source_s3_bucket + '/' + source_s3_key

    result_list = []
    result_code = 'Succeeded'
    result_string = 'The input video object was converted successfully.'

    # The type of output group determines which media players can play 
    # the files transcoded by MediaConvert.
    # For more information, see Creating outputs with AWS Elemental MediaConvert.
    output_group_type_dict = {
        'HLS_GROUP_SETTINGS': 'HlsGroupSettings',
        'FILE_GROUP_SETTINGS': 'FileGroupSettings',
        'CMAF_GROUP_SETTINGS': 'CmafGroupSettings',
        'DASH_ISO_GROUP_SETTINGS': 'DashIsoGroupSettings',
        'MS_SMOOTH_GROUP_SETTINGS': 'MsSmoothGroupSettings'
    }

    try:
        job_name = 'Default'
        with open('job.json') as file:
            job_settings = json.load(file)

        job_settings['Inputs'][0]['FileInput'] = source_s3

        # The path of each output video is constructed based on the values of 
        # the attributes in each object of OutputGroups in the job.json file. 
        destination_s3 = 's3://{0}/{1}/{2}' \
            .format(os.environ['DestinationBucket'],
                    os.path.splitext(os.path.basename(source_s3_key))[0],
                    os.path.splitext(os.path.basename(job_name))[0])

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

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

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

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

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

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

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

  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.

Stellen Sie Ihre Lambda-Funktion mit ZIP-Dateiarchiven bereit und konfigurieren Sie die Lambda-Funktion (Konsole)

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

  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: tutorial-bucket-2

      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 für MediaConvert , 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 Speichern.

  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.

Schritt 5: Konfigurieren des Amazon S3-Bestands für Ihren S3-Quell-Bucket

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

Erstellen und Konfigurieren eines Buckets für S3-Inventarberichte für Eingabevideos

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 Management Console und öffnen Sie die Amazon S3-Konsole unter https://console.aws.amazon.com/s3/.

  2. Wählen Sie im linken Navigationsbereich die Option 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. tutorial-bucket-3).

  5. Wählen Sie für die ausAWS-Region, AWS-Region in der sich der Bucket befinden soll.

    Der Bestandsziel-Bucket muss sich in derselben 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 Bucket erstellen aus.

  9. Wählen Sie in der Liste der Buckets den Namen des Buckets, den Sie gearde erstellt haben (z. B. tutorial-bucket-3).

  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. tutorial-bucket-3).

    • Der Name des Quell-Buckets, in dem die Eingabe-Videos gespeichert werden (z. B. tutorial-bucket-1).

    • Die AWS-Konto ID, die Sie zum Erstellen des S3-Videoquellen-Buckets verwendet haben (z. B. 111122223333.

    {
  "Version":"2012-10-17",
  "Statement":[
    {
      "Sid":"InventoryAndAnalyticsExamplePolicy",
      "Effect":"Allow",
      "Principal": {"Service": "s3.amazonaws.com"},
      "Action":"s3:PutObject",
      "Resource":["arn:aws:s3:::tutorial-bucket-3/*"],
      "Condition": {
          "ArnLike": {
              "aws:SourceArn": "arn:aws:s3:::tutorial-bucket-1"
           },
         "StringEquals": {
             "aws:SourceAccount": "111122223333",
             "s3:x-amz-acl": "bucket-owner-full-control"
          }
       }
    }
  ]
}

  13. Wählen Sie Änderungen speichern aus.

Konfigurieren des Amazon S3-Bestands für Ihren S3-Quell-Bucket

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 Management Console und öffnen Sie die Amazon 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. tutorial-bucket-1).

  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 .tutorial-bucket-3). Wählen Sie dann Pfad wählen aus.

    Der Bestandsziel-Bucket muss sich in derselben 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 finden 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 Create (Erstellen) aus.

Weitere Informationen finden Sie unter Konfigurieren des Bestands mit der S3-Konsole.

Überprüfen Sie den Lagerbestandsbericht für Ihren S3-Videoquellen-Bucket

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

  1. Melden Sie sich bei der an AWS Management Console und öffnen Sie die Amazon 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. tutorial-bucket-1).

  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. tutorial-bucket-3).

  7. Wählen Sie auf der Registerkarte Objekte den vorhandenen Ordner mit dem Namen Ihres S3-Quell-Buckets (z. B. tutorial-bucket-1). 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.

Schritt 6: Erstellen einer IAM-Rolle für S3-Batchvorgänge

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.

Erstellen einer IAM-Richtlinie für S3-Batchvorgänge

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 Management Console und öffnen Sie die IAM-Konsole unter https://console.aws.amazon.com/iam/.

  2. Wählen Sie im linken Navigationsbereich die Option Policies (Richtlinien) aus.

  3. Wählen Sie 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. tutorial-bucket-1).

    • Der Name des Bestands-Ziel-Buckets, den Sie in Schritt 5 erstellt haben, um manifest.json-Dateien (z. B. tutorial-bucket-3) zu speichern.

    • Der Name des Buckets, den Sie in Schritt 1 erstellt haben, um Ausgabe-Mediendateien zu speichern (z. B. tutorial-bucket-2). 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:::tutorial-bucket-1/*",
                "arn:aws:s3:::tutorial-bucket-3/*"
            ]
        },
        {
            "Sid": "S3PutJobCompletionReport",
            "Effect": "Allow",
            "Action": "s3:PutObject",
            "Resource": "arn:aws:s3:::tutorial-bucket-2/*"
        },
        {
            "Sid": "S3BatchOperationsInvokeLambda",
            "Effect": "Allow",
            "Action": [
                "lambda:InvokeFunction"
            ],
            "Resource": [
                "arn:aws:lambda:us-west-2:111122223333:function:tutorial-lambda-convert"
            ]
        }
    ]
}

  6. 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 Richtlinie erstellen aus.

Erstellen Sie eine S3-Batchvorgänge-IAM-Rolle und fügen Sie Berechtigungsrichtlinien an

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

Schritt 7: Einrichten und Ausführen eines Auftrags für S3-Batchvorgänge

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. 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 konfiguriert haben, kann es bis zu 48 Stunden dauern, bis der erste Bestandsbericht übermittelt wird.

Erstellen eines S3-Batchvorgangsauftrags

  1. Melden Sie sich bei der an AWS Management Console und öffnen Sie die Amazon 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. tutorial-bucket-3) 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 aus. 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. tutorial-bucket-2). 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 aus.

  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.

Führen Sie den S3-Batchvorgänge-Auftrag aus, um Ihre Lambda-Funktion aufzurufen.

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 Management Console und öffnen Sie die Amazon 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 Auftragaseite 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

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.

  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.

(Optional) Überwachen Sie jeden Lambda-Aufruf in der Lambda-Konsole

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 CloudWatch Protokolle. 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/.

  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. Zeigen Sie unter Protokolle 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 ein Lambda-Kontingent für Gleichzeitigkeit 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.

(Optional) Überwachen Sie jeden MediaConvert Videotranscodierungsauftrag in der MediaConvert Konsole

Ein MediaConvert Auftrag übernimmt die Transcodierung einer Mediendatei. Wenn Ihr S3-Batchoperationenauftrag 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 Management Console und öffnen Sie die - MediaConvert Konsole unter https://console.aws.amazon.com/mediaconvert/.

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

  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. Klicken Sie auf der Seite Auftragszusammenfassung unter Ausgaben auf den Link für die Ausgabe HLS, MP4 oder Miniaturansichten, je nachdem, was von Ihrem Browser unterstützt wird, um zum S3-Ziel-Bucket für die Ausgabe-Mediendateien zu wechseln.

  6. Wählen Sie im entsprechenden Ordner (HLS, MP4 oder Thumbnails) Ihres S3-Ausgabe-Ziel-Buckets den Namen des Ausgabe-Mediendateiobjekts aus.

    Die Detailseite des Objekts wird geöffnet.

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

Schritt 8: Überprüfen Sie die Ausgabe-Mediendateien aus Ihrem S3-Ziel-Bucket

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-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 tutorial-bucket-2) 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 transcodiertes Format aus (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.

Schritt 9: Bereinigen

Wenn Sie Videos mit S3 Batch Operations, Lambda und MediaConvert nur als Lernübung transcodiert haben, löschen Sie die AWS Ressourcen, die Sie zugewiesen haben, damit keine Gebühren mehr anfallen.

Löschen der S3-Bestandskonfiguration für Ihren S3-Quell-Bucket

  1. Melden Sie sich bei der an AWS Management Console und öffnen Sie die Amazon 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. tutorial-bucket-1).

  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.

Löschen Sie die Lambda-Funktion

  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.

Löschen der CloudWatch Protokollgruppe

  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.

Löschen Sie die IAM-Rollen zusammen mit den Inline-Richtlinien für die IAM-Rollen

Um die IAM-Rollen zu löschen, die Sie in Schritt 2, Schritt 3, und Schritt 6 erstellt haben, tun Sie Folgendes:

  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.

Löschen Sie die kundenverwaltete IAM-Richtlinie

Um die vom Kunden verwaltete IAM-Richtlinie zu löschen, die Sie in Schritt 6 erstellt haben, tun Sie Folgendes:

  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.

Leeren Sie die S3-Buckets

Um die S3-Buckets zu leeren, die Sie in Voraussetzungen, Schritt 1 und Schritt 5 erstellt haben, tun Sie Folgendes:

  1. Melden Sie sich bei der an AWS Management Console und öffnen Sie die Amazon 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.

Löschen der S3-Buckets

Um die S3-Buckets zu löschen, die Sie in Voraussetzungen, Schritt 1 und Schritt 5 erstellt haben, tun Sie Folgendes:

  1. Melden Sie sich bei der an AWS Management Console und öffnen Sie die Amazon 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 aus.

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

Nächste Schritte

Nachdem Sie dieses Tutorial abgeschlossen haben, können Sie weitere relevante Anwendungsfälle untersuchen: