Tutorial: Batch-Transcodierung von Videos mit S3 Batch Operations, und AWS LambdaAWS Elemental MediaConvert - Amazon Simple Storage Service
Voraussetzungen Schritt 1: Erstellen Sie einen S3-Bucket für Ausgabe-MediendateienSchritt 2: Erstelle eine 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: Eine IAM Rolle für S3 Batch Operations erstellenSchritt 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 Batch Operations, und AWS LambdaAWS 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. 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 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-Diagramm für die Batch-Transcodierung.
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 transkodieren. Die Ausgänge für jedes Video im S3-Quell-Bucket sind wie folgt:

  • Ein HTTPLive-Streaming-Stream (HLS) mit adaptiver Bitrate für die Wiedergabe auf Geräten verschiedener Größen und unterschiedlicher Bandbreiten

  • Eine Videodatei MP4

  • 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. Sie erstellen auch eine Cross-Origin-Konfiguration für die gemeinsame Nutzung von Ressourcen (CORS), um den ursprungsübergreifenden Zugriff auf die transkodierten 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 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 unter Region den AWS-Region Ort aus, an dem sich der Bucket befinden soll.

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

    Warnung

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

    Wenn Sie die Einstellungen 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.

  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.

Fügen Sie dem S3-Ausgabe-Bucket eine CORS Konfiguration hinzu

Eine JSON CORS Konfiguration definiert eine Methode für Client-Webanwendungen (in diesem Kontext Videoplayer), die in eine Domain geladen werden, transkodierte Ausgabemediendateien in einer anderen Domain abzuspielen.

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

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

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

  4. Wählen Sie die Registerkarte Berechtigungen.

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

  6. Kopieren Sie die folgende CORS Konfiguration und fügen Sie sie in das Textfeld für die CORS Konfiguration ein.

    Die CORS Konfiguration muss im JSON Format vorliegen. In diesem Beispiel verwendet das AllowedOrigins-Attribut das Platzhalterzeichen (*) um alle Ursprünge anzugeben. Wenn du deine spezifische Herkunft kennst, kannst du das AllowedOrigins Attribut auf deinen spezifischen Spieler beschränkenURL. Weitere Informationen zum Konfigurieren von diesem und anderen Attributen finden Sie unter Elemente einer CORS Konfiguration.

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

    }
]

  7. Wählen Sie Änderungen speichern aus.

Schritt 2: Erstelle eine IAM Rolle für MediaConvert

Um die in Ihrem S3-Bucket gespeicherten Eingabevideos AWS Elemental MediaConvert zu transkodieren, 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.

Um eine IAM Rolle zu erstellen für MediaConvert

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

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

  3. Kopieren Sie auf der Übersichtsseite die Rolle ARN (die mit beginntarn:aws:iam::) und speichern Sie sie ARN zur späteren Verwendung.

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

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

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.

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

  6. Wählen Sie Weiter: 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.

Betten Sie eine Inline-Richtlinie für die IAM Rolle Ihrer Lambda-Funktion ein

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

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

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

  3. Wählen Sie in der Liste Rollen den Namen der IAM Rolle aus, die Sie zuvor 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 JSONRegisterkarte aus, kopieren Sie dann die folgende JSON Richtlinie und fügen Sie sie ein.

    Ersetzen Sie in der JSON Richtlinie den ARN Beispielwert von Resource durch die Rolle ARN der IAM Rolle MediaConvert , für die Sie in Schritt 2 erstellt haben (z. B.tutorial-mediaconvert-role).

    {
    "Version": "2012-10-17",
    "Statement": [
        {
            "Action": [
                "logs:CreateLogGroup",
                "logs:CreateLogStream",
                "logs:PutLogEvents"
            ],
            "Resource": "*",
            "Effect": "Allow",
            "Sid": "Logging"
        },
        {
            "Action": [
                "iam:PassRole"
            ],
            "Resource": [
                "arn:aws:iam::111122223333:role/tutorial-mediaconvert-role"
            ],
            "Effect": "Allow",
            "Sid": "PassRole"
        },
        {
            "Action": [
                "mediaconvert:*"
            ],
            "Resource": [
                "*"
            ],
            "Effect": "Allow",
            "Sid": "MediaConvertService"
        },
        {
            "Action": [
                "s3:*"
            ],
            "Resource": [
                "*"
            ],
            "Effect": "Allow",
            "Sid": "S3Service"
        }
    ]
}

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

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

  9. Wählen Sie Richtlinie erstellen aus.

    Nachdem Sie eine Inline-Richtlinie erstellt haben, wird sie automatisch in die 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 mithilfe von SDK for 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

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 den 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-Stream (HLS) mit adaptiver Bitrate für die Wiedergabe auf mehreren Geräten unterschiedlicher Größe und Bandbreite

    • Eine Videodatei MP4

    • In Intervallen gesammelte Miniaturbilder

    Diese job.json Beispieldatei verwendet die qualitätsdefinierte variable Bitrate (QVBR), um die Videoqualität zu optimieren. Die HLS Ausgabe ist Apple-kompatibel (Audio ohne Mischung aus Video, Segmentdauer von 6 Sekunden und optimierte Videoqualität durch Auto). 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 JSONim Benutzerhandbuch unter AWS Elemental MediaConvert Beispieljobeinstellungen.AWS Elemental MediaConvert 

    {
  "OutputGroups": [
    {
      "CustomName": "HLS",
      "Name": "Apple HLS",
      "Outputs": [
        {
          "ContainerSettings": {
            "Container": "M3U8",
            "M3u8Settings": {
              "AudioFramesPerPes": 4,
              "PcrControl": "PCR_EVERY_PES_PACKET",
              "PmtPid": 480,
              "PrivateMetadataPid": 503,
              "ProgramNumber": 1,
              "PatInterval": 0,
              "PmtInterval": 0,
              "TimedMetadata": "NONE",
              "VideoPid": 481,
              "AudioPids": [
                482,
                483,
                484,
                485,
                486,
                487,
                488,
                489,
                490,
                491,
                492
              ]
            }
          },
          "VideoDescription": {
            "Width": 640,
            "ScalingBehavior": "DEFAULT",
            "Height": 360,
            "TimecodeInsertion": "DISABLED",
            "AntiAlias": "ENABLED",
            "Sharpness": 50,
            "CodecSettings": {
              "Codec": "H_264",
              "H264Settings": {
                "InterlaceMode": "PROGRESSIVE",
                "NumberReferenceFrames": 3,
                "Syntax": "DEFAULT",
                "Softness": 0,
                "GopClosedCadence": 1,
                "GopSize": 2,
                "Slices": 1,
                "GopBReference": "DISABLED",
                "MaxBitrate": 1200000,
                "SlowPal": "DISABLED",
                "SpatialAdaptiveQuantization": "ENABLED",
                "TemporalAdaptiveQuantization": "ENABLED",
                "FlickerAdaptiveQuantization": "DISABLED",
                "EntropyEncoding": "CABAC",
                "FramerateControl": "INITIALIZE_FROM_SOURCE",
                "RateControlMode": "QVBR",
                "CodecProfile": "MAIN",
                "Telecine": "NONE",
                "MinIInterval": 0,
                "AdaptiveQuantization": "HIGH",
                "CodecLevel": "AUTO",
                "FieldEncoding": "PAFF",
                "SceneChangeDetect": "TRANSITION_DETECTION",
                "QualityTuningLevel": "SINGLE_PASS_HQ",
                "FramerateConversionAlgorithm": "DUPLICATE_DROP",
                "UnregisteredSeiTimecode": "DISABLED",
                "GopSizeUnits": "SECONDS",
                "ParControl": "INITIALIZE_FROM_SOURCE",
                "NumberBFramesBetweenReferenceFrames": 2,
                "RepeatPps": "DISABLED"
              }
            },
            "AfdSignaling": "NONE",
            "DropFrameTimecode": "ENABLED",
            "RespondToAfd": "NONE",
            "ColorMetadata": "INSERT"
          },
          "OutputSettings": {
            "HlsSettings": {
              "AudioGroupId": "program_audio",
              "AudioRenditionSets": "program_audio",
              "SegmentModifier": "$dt$",
              "IFrameOnlyManifest": "EXCLUDE"
            }
          },
          "NameModifier": "_360"
        },
        {
          "ContainerSettings": {
            "Container": "M3U8",
            "M3u8Settings": {
              "AudioFramesPerPes": 4,
              "PcrControl": "PCR_EVERY_PES_PACKET",
              "PmtPid": 480,
              "PrivateMetadataPid": 503,
              "ProgramNumber": 1,
              "PatInterval": 0,
              "PmtInterval": 0,
              "TimedMetadata": "NONE",
              "TimedMetadataPid": 502,
              "VideoPid": 481,
              "AudioPids": [
                482,
                483,
                484,
                485,
                486,
                487,
                488,
                489,
                490,
                491,
                492
              ]
            }
          },
          "VideoDescription": {
            "Width": 960,
            "ScalingBehavior": "DEFAULT",
            "Height": 540,
            "TimecodeInsertion": "DISABLED",
            "AntiAlias": "ENABLED",
            "Sharpness": 50,
            "CodecSettings": {
              "Codec": "H_264",
              "H264Settings": {
                "InterlaceMode": "PROGRESSIVE",
                "NumberReferenceFrames": 3,
                "Syntax": "DEFAULT",
                "Softness": 0,
                "GopClosedCadence": 1,
                "GopSize": 2,
                "Slices": 1,
                "GopBReference": "DISABLED",
                "MaxBitrate": 3500000,
                "SlowPal": "DISABLED",
                "SpatialAdaptiveQuantization": "ENABLED",
                "TemporalAdaptiveQuantization": "ENABLED",
                "FlickerAdaptiveQuantization": "DISABLED",
                "EntropyEncoding": "CABAC",
                "FramerateControl": "INITIALIZE_FROM_SOURCE",
                "RateControlMode": "QVBR",
                "CodecProfile": "MAIN",
                "Telecine": "NONE",
                "MinIInterval": 0,
                "AdaptiveQuantization": "HIGH",
                "CodecLevel": "AUTO",
                "FieldEncoding": "PAFF",
                "SceneChangeDetect": "TRANSITION_DETECTION",
                "QualityTuningLevel": "SINGLE_PASS_HQ",
                "FramerateConversionAlgorithm": "DUPLICATE_DROP",
                "UnregisteredSeiTimecode": "DISABLED",
                "GopSizeUnits": "SECONDS",
                "ParControl": "INITIALIZE_FROM_SOURCE",
                "NumberBFramesBetweenReferenceFrames": 2,
                "RepeatPps": "DISABLED"
              }
            },
            "AfdSignaling": "NONE",
            "DropFrameTimecode": "ENABLED",
            "RespondToAfd": "NONE",
            "ColorMetadata": "INSERT"
          },
          "OutputSettings": {
            "HlsSettings": {
              "AudioGroupId": "program_audio",
              "AudioRenditionSets": "program_audio",
              "SegmentModifier": "$dt$",
              "IFrameOnlyManifest": "EXCLUDE"
            }
          },
          "NameModifier": "_540"
        },
        {
          "ContainerSettings": {
            "Container": "M3U8",
            "M3u8Settings": {
              "AudioFramesPerPes": 4,
              "PcrControl": "PCR_EVERY_PES_PACKET",
              "PmtPid": 480,
              "PrivateMetadataPid": 503,
              "ProgramNumber": 1,
              "PatInterval": 0,
              "PmtInterval": 0,
              "TimedMetadata": "NONE",
              "VideoPid": 481,
              "AudioPids": [
                482,
                483,
                484,
                485,
                486,
                487,
                488,
                489,
                490,
                491,
                492
              ]
            }
          },
          "VideoDescription": {
            "Width": 1280,
            "ScalingBehavior": "DEFAULT",
            "Height": 720,
            "TimecodeInsertion": "DISABLED",
            "AntiAlias": "ENABLED",
            "Sharpness": 50,
            "CodecSettings": {
              "Codec": "H_264",
              "H264Settings": {
                "InterlaceMode": "PROGRESSIVE",
                "NumberReferenceFrames": 3,
                "Syntax": "DEFAULT",
                "Softness": 0,
                "GopClosedCadence": 1,
                "GopSize": 2,
                "Slices": 1,
                "GopBReference": "DISABLED",
                "MaxBitrate": 5000000,
                "SlowPal": "DISABLED",
                "SpatialAdaptiveQuantization": "ENABLED",
                "TemporalAdaptiveQuantization": "ENABLED",
                "FlickerAdaptiveQuantization": "DISABLED",
                "EntropyEncoding": "CABAC",
                "FramerateControl": "INITIALIZE_FROM_SOURCE",
                "RateControlMode": "QVBR",
                "CodecProfile": "MAIN",
                "Telecine": "NONE",
                "MinIInterval": 0,
                "AdaptiveQuantization": "HIGH",
                "CodecLevel": "AUTO",
                "FieldEncoding": "PAFF",
                "SceneChangeDetect": "TRANSITION_DETECTION",
                "QualityTuningLevel": "SINGLE_PASS_HQ",
                "FramerateConversionAlgorithm": "DUPLICATE_DROP",
                "UnregisteredSeiTimecode": "DISABLED",
                "GopSizeUnits": "SECONDS",
                "ParControl": "INITIALIZE_FROM_SOURCE",
                "NumberBFramesBetweenReferenceFrames": 2,
                "RepeatPps": "DISABLED"
              }
            },
            "AfdSignaling": "NONE",
            "DropFrameTimecode": "ENABLED",
            "RespondToAfd": "NONE",
            "ColorMetadata": "INSERT"
          },
          "OutputSettings": {
            "HlsSettings": {
              "AudioGroupId": "program_audio",
              "AudioRenditionSets": "program_audio",
              "SegmentModifier": "$dt$",
              "IFrameOnlyManifest": "EXCLUDE"
            }
          },
          "NameModifier": "_720"
        },
        {
          "ContainerSettings": {
            "Container": "M3U8",
            "M3u8Settings": {}
          },
          "AudioDescriptions": [
            {
              "AudioSourceName": "Audio Selector 1",
              "CodecSettings": {
                "Codec": "AAC",
                "AacSettings": {
                  "Bitrate": 96000,
                  "CodingMode": "CODING_MODE_2_0",
                  "SampleRate": 48000
                }
              }
            }
          ],
          "OutputSettings": {
            "HlsSettings": {
              "AudioGroupId": "program_audio",
              "AudioTrackType": "ALTERNATE_AUDIO_AUTO_SELECT_DEFAULT"
            }
          },
          "NameModifier": "_audio"
        }
      ],
      "OutputGroupSettings": {
        "Type": "HLS_GROUP_SETTINGS",
        "HlsGroupSettings": {
          "ManifestDurationFormat": "INTEGER",
          "SegmentLength": 6,
          "TimedMetadataId3Period": 10,
          "CaptionLanguageSetting": "OMIT",
          "Destination": "s3://EXAMPLE-BUCKET/HLS/",
          "DestinationSettings": {
            "S3Settings": {
              "AccessControl": {
                "CannedAcl": "PUBLIC_READ"
              }
            }
          },
          "TimedMetadataId3Frame": "PRIV",
          "CodecSpecification": "RFC_4281",
          "OutputSelection": "MANIFESTS_AND_SEGMENTS",
          "ProgramDateTimePeriod": 600,
          "MinSegmentLength": 0,
          "DirectoryStructure": "SINGLE_DIRECTORY",
          "ProgramDateTime": "EXCLUDE",
          "SegmentControl": "SEGMENTED_FILES",
          "ManifestCompression": "NONE",
          "ClientCache": "ENABLED",
          "StreamInfResolution": "INCLUDE"
        }
      }
    },
    {
      "CustomName": "MP4",
      "Name": "File Group",
      "Outputs": [
        {
          "ContainerSettings": {
            "Container": "MP4",
            "Mp4Settings": {
              "CslgAtom": "INCLUDE",
              "FreeSpaceBox": "EXCLUDE",
              "MoovPlacement": "PROGRESSIVE_DOWNLOAD"
            }
          },
          "VideoDescription": {
            "Width": 1280,
            "ScalingBehavior": "DEFAULT",
            "Height": 720,
            "TimecodeInsertion": "DISABLED",
            "AntiAlias": "ENABLED",
            "Sharpness": 100,
            "CodecSettings": {
              "Codec": "H_264",
              "H264Settings": {
                "InterlaceMode": "PROGRESSIVE",
                "ParNumerator": 1,
                "NumberReferenceFrames": 3,
                "Syntax": "DEFAULT",
                "Softness": 0,
                "GopClosedCadence": 1,
                "HrdBufferInitialFillPercentage": 90,
                "GopSize": 2,
                "Slices": 2,
                "GopBReference": "ENABLED",
                "HrdBufferSize": 10000000,
                "MaxBitrate": 5000000,
                "ParDenominator": 1,
                "EntropyEncoding": "CABAC",
                "RateControlMode": "QVBR",
                "CodecProfile": "HIGH",
                "MinIInterval": 0,
                "AdaptiveQuantization": "AUTO",
                "CodecLevel": "AUTO",
                "FieldEncoding": "PAFF",
                "SceneChangeDetect": "ENABLED",
                "QualityTuningLevel": "SINGLE_PASS_HQ",
                "UnregisteredSeiTimecode": "DISABLED",
                "GopSizeUnits": "SECONDS",
                "ParControl": "SPECIFIED",
                "NumberBFramesBetweenReferenceFrames": 3,
                "RepeatPps": "DISABLED",
                "DynamicSubGop": "ADAPTIVE"
              }
            },
            "AfdSignaling": "NONE",
            "DropFrameTimecode": "ENABLED",
            "RespondToAfd": "NONE",
            "ColorMetadata": "INSERT"
          },
          "AudioDescriptions": [
            {
              "AudioTypeControl": "FOLLOW_INPUT",
              "AudioSourceName": "Audio Selector 1",
              "CodecSettings": {
                "Codec": "AAC",
                "AacSettings": {
                  "AudioDescriptionBroadcasterMix": "NORMAL",
                  "Bitrate": 160000,
                  "RateControlMode": "CBR",
                  "CodecProfile": "LC",
                  "CodingMode": "CODING_MODE_2_0",
                  "RawFormat": "NONE",
                  "SampleRate": 48000,
                  "Specification": "MPEG4"
                }
              },
              "LanguageCodeControl": "FOLLOW_INPUT",
              "AudioType": 0
            }
          ]
        }
      ],
      "OutputGroupSettings": {
        "Type": "FILE_GROUP_SETTINGS",
        "FileGroupSettings": {
          "Destination": "s3://EXAMPLE-BUCKET/MP4/",
          "DestinationSettings": {
            "S3Settings": {
              "AccessControl": {
                "CannedAcl": "PUBLIC_READ"
              }
            }
          }
        }
      }
    },
    {
      "CustomName": "Thumbnails",
      "Name": "File Group",
      "Outputs": [
        {
          "ContainerSettings": {
            "Container": "RAW"
          },
          "VideoDescription": {
            "Width": 1280,
            "ScalingBehavior": "DEFAULT",
            "Height": 720,
            "TimecodeInsertion": "DISABLED",
            "AntiAlias": "ENABLED",
            "Sharpness": 50,
            "CodecSettings": {
              "Codec": "FRAME_CAPTURE",
              "FrameCaptureSettings": {
                "FramerateNumerator": 1,
                "FramerateDenominator": 5,
                "MaxCaptures": 500,
                "Quality": 80
              }
            },
            "AfdSignaling": "NONE",
            "DropFrameTimecode": "ENABLED",
            "RespondToAfd": "NONE",
            "ColorMetadata": "INSERT"
          }
        }
      ],
      "OutputGroupSettings": {
        "Type": "FILE_GROUP_SETTINGS",
        "FileGroupSettings": {
          "Destination": "s3://EXAMPLE-BUCKET/Thumbnails/",
          "DestinationSettings": {
            "S3Settings": {
              "AccessControl": {
                "CannedAcl": "PUBLIC_READ"
              }
            }
          }
        }
      }
    }
  ],
  "AdAvailOffset": 0,
  "Inputs": [
    {
      "AudioSelectors": {
        "Audio Selector 1": {
          "Offset": 0,
          "DefaultSelection": "DEFAULT",
          "ProgramSelection": 1
        }
      },
      "VideoSelector": {
        "ColorSpace": "FOLLOW"
      },
      "FilterEnable": "AUTO",
      "PsiControl": "USE_PSI",
      "FilterStrength": 0,
      "DeblockFilter": "DISABLED",
      "DenoiseFilter": "DISABLED",
      "TimecodeSource": "EMBEDDED",
      "FileInput": "s3://EXAMPLE-INPUT-BUCKET/input.mp4"
    }
  ]
}
    Mehr anzeigenWeniger anzeigen

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

    S3-Batchvorgänge sendet bestimmte Aufgabendaten an eine Lambda-Funktion und erfordert Ergebnisdaten zurück. Anforderungs- und Antwortbeispielen für die Lambda-Funktion, Informationen über Antwort- und Ergebniscodes sowie Beispiel-Lambda-Funktionen für S3-Batchvorgänge finden Sie unter Funktion aufrufen AWS Lambda. 

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

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

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

Input parameter "context": Context about the event.

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

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

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

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

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

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

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

        # The path of each output video is constructed based on the values of 
        # the attributes in each object of OutputGroups in the job.json file. 
        destination_s3 = 's3://{0}/{1}/{2}' \
            .format(os.environ['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 Existierende Rolle den Namen der IAM Rolle aus, die Sie in Schritt 3 für Ihre Lambda-Funktion erstellt haben (z. B.tutorial-lambda-transcode-role).

  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 entspricht ARN der IAM Rolle MediaConvert , für die Sie in Schritt 2 erstellt haben. Stellen Sie sicher, dass Sie diesen ARN Wert durch den tatsächlichen ARN Wert 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 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 den AWS-Region Ort aus AWS-Region, an dem sich der Bucket befinden soll.

    Der Inventarziel-Bucket muss sich in demselben Bereich 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, mit der Sie den S3-Videoquellen-Bucket erstellt haben (z. 111122223333 B.

    {
  "Version":"2012-10-17",
  "Statement":[
    {
      "Sid":"InventoryAndAnalyticsExamplePolicy",
      "Effect":"Allow",
      "Principal": {"Service": "s3.amazonaws.com"},
      "Action":"s3:PutObject",
      "Resource":["arn:aws:s3:::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 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 Ziel-Bucket für das Inventar muss sich im selben Bucket befinden AWS-Region wie der Quell-Bucket, in dem Sie S3 Inventory einrichten. Der Bestands-Ziel-Bucket kann sich in einem anderem AWS-Konto befinden.

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

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

  11. Wählen Sie als Ausgabeformat die Option 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 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: Eine IAM Rolle für S3 Batch Operations erstellen

Um S3 Batch Operations für die Batch-Transcodierung zu verwenden, müssen Sie zunächst eine IAM Rolle erstellen, um Amazon S3 Berechtigungen zur Durchführung von S3-Batch-Vorgängen zu erteilen.

Erstellen Sie eine IAM Richtlinie für S3 Batch Operations

Sie müssen eine IAM Richtlinie erstellen, die S3 Batch Operations die Erlaubnis erteilt, das Eingabemanifest zu lesen, die Lambda-Funktion aufzurufen und den Bericht zum Abschluss des S3 Batch Operations-Jobs zu schreiben.

  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 die Registerkarte JSON aus.

  5. Fügen Sie die folgende JSON Richtlinie in das JSONTextfeld 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 Rolle ARN der Lambda-Funktion, die Sie in Schritt 4 erstellt haben. Gehen Sie wie folgt vor, um die Rolle ARN der Lambda-Funktion zu finden und zu kopieren:

      • Ö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.

      • Wählen Sie die Option KopierenARN aus.

    {
    "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 IAM S3-Rolle für Batch Operations und fügen Sie Berechtigungsrichtlinien hinzu

  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 Zugriffsrichtlinien anhängen 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).

  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 Batch Operations erstellt haben, wird die folgende Vertrauensrichtlinie automatisch an die Rolle angehängt. Diese Vertrauensrichtlinie ermöglicht es dem Dienstprinzipal von S3 Batch Operations, 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 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 die Lambda-Funktionsversion 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 die Option Aus vorhandenen IAM Rollen auswählen aus. Wählen Sie unter IAMRolle die IAM Rolle für Ihren S3 Batch Operations-Job aus, den Sie in Schritt 6 erstellt haben (z. B.tutorial-s3batch-role).

  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 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 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/

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

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

  4. Wählen Sie den Tab Überwachung.

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

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

    Anmerkung

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

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

(Optional) Überwachen Sie jeden MediaConvert Video-Transcodierungsauftrag in der Konsole MediaConvert

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

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

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

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

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

  6. Wählen Sie im entsprechenden Ordner (HLSMP4, oder Miniaturansichten) Ihres Ziel-Buckets für die S3-Ausgabe den Namen des Objekts der Ausgabemediendatei aus.

    Die Detailseite des Objekts wird geöffnet.

  7. Wählen Sie auf der Detailseite des Objekts unter Objektübersicht den Link unter Objekt aus, URL um die transkodierte Ausgabemediendatei 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 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 transkodiertes Format (HLS,MP4, oder Miniaturansichten in diesem Tutorial).

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

    5. Um die transkodierte Datei anzusehen, klicken Sie auf der Detailseite des Objekts auf den Link unter Objekt. URL

      Ausgabemediendateien in diesem HLS Format sind in kurze Segmente aufgeteilt. Um diese Videos abzuspielen, betten Sie das Objekt URL der .m3u8 Datei in einen kompatiblen Player ein.

Schritt 9: Bereinigen

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.

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 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 Sie die 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

Gehen Sie wie folgt vor, um die IAM Rollen zu löschen, die Sie in Schritt 2, Schritt 3 und Schritt 6 erstellt haben:

  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 vom Kunden verwaltete Richtlinie IAM

Gehen Sie wie folgt vor, um die vom Kunden verwaltete IAM Richtlinie zu löschen, die Sie in Schritt 6 erstellt haben:

  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 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 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: