Tutoriel : Transcodage par lots de vidéos avec S3 Batch Operations, et AWS LambdaAWS Elemental MediaConvert - Amazon Simple Storage Service
Prérequis Étape 1 : Créer un compartiment S3 pour les fichiers multimédias de sortieÉtape 2 : créer un rôle IAM pour MediaConvertÉtape 3 : Créer un rôle IAM pour votre fonction LambdaÉtape 4 : Créer une fonction Lambda pour le transcodage vidéoÉtape 5 : Configurer un inventaire Amazon S3 pour votre compartiment source S3Étape 6 : Créer un rôle IAM pour S3 Batch OperationsÉtape 7 : Configurer et exécuter une tâche S3 Batch OperationsÉtape 8 : Vérifier les fichiers multimédias de sortie à partir de votre compartiment de destination S3Étape 9 : NettoyerÉtapes suivantes

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Tutoriel : Transcodage par lots de vidéos avec S3 Batch Operations, et AWS LambdaAWS Elemental MediaConvert

Les consommateurs de vidéos utilisent des appareils de toutes formes, tailles et millésimes pour profiter des contenus multimédia. Ce large éventail de services représente un défi pour les créateurs et distributeurs de contenus. Au lieu d'être dans un one-size-fits-all format, les vidéos doivent être converties afin qu'elles puissent couvrir une large gamme de tailles, de formats et de débits. Cette tâche de conversion est encore plus difficile lorsque vous avez un grand nombre de vidéos à convertir.

AWS vous propose une méthode pour créer une architecture distribuée évolutive qui effectue les opérations suivantes :

  • Intégrer les vidéos d'entrée

  • Traiter les vidéos en vue de leur lecture sur un large éventail d'appareils

  • Stocker les fichiers multimédias transcodés

  • Fournir les fichiers multimédias de sortie pour répondre à la demande

Si vous disposez de référentiels vidéo étendus stockés dans Amazon S3, vous pouvez transcoder ces vidéos à partir de leurs formats source en plusieurs types de fichiers dans la taille, la résolution et le format requis par un lecteur vidéo ou un appareil particulier. Plus précisément, S3 Batch Operations vous fournit une solution pour invoquer AWS Lambda des fonctions pour les vidéos d'entrée existantes dans un compartiment source S3. Ensuite, les fonctions Lambda appellent AWS Elemental MediaConvert pour effectuer des tâches de transcodage de vidéos à grande échelle. Les fichiers multimédias de sortie convertis sont stockés dans un compartiment de destination S3.

Schéma de flux de travail de transcodage par lots.
Objectif

Dans ce didacticiel, vous apprendrez à configurer S3 Batch Operations pour appeler une fonction Lambda pour le transcodage par lots de vidéos stockées dans un compartiment source S3. La fonction Lambda appelle MediaConvert pour transcoder les vidéos. Les sorties de chaque vidéo dans le compartiment source S3 se présentent comme suit :

  • Un flux à débit adaptatif HTTP Live Streaming (HLS) pour lecture sur des appareils de diverses tailles et des largeurs de bande passante variables

  • Un fichier vidéo MP4

  • Images miniatures collectées à intervalles

Prérequis

Avant de commencer à suivre ce didacticiel, vous devez disposer d'un compartiment source Amazon S3 (par exemple tutorial-bucket-1) avec des vidéos à transcoder déjà stockées.

Vous pouvez donner un autre nom au compartiment si vous le souhaitez. Pour en savoir plus sur les règles d'attribution de noms de compartiment dans Amazon S3, consultez Règles de dénomination de compartiment.

Pour le compartiment source S3, conservez les paramètres associés aux Paramètres de blocage de l'accès public à ce compartiment définis pour les valeurs par défaut (Block all public access (Bloquer tous les accès publics) est activé). Pour plus d’informations, consultez Créer un compartiment.

Pour en savoir plus sur le téléchargement de vidéos vers le compartiment source S3, veuillez consulter Chargement d'objets. Lorsque vous téléchargez de nombreux fichiers vidéo volumineux sur S3, vous pouvez également utiliser Amazon S3 Transfer Acceleration pour configurer des transferts de fichiers rapides et sécurisés. Transfer Acceleration peut accélérer le chargement de vidéos vers votre compartiment S3 pour le transfert à longue distance de vidéos plus volumineuses. Pour plus d’informations, consultez Configuration de transferts de fichiers rapides et sécurisés à l'aide d'Amazon S3 Transfer Acceleration.

Étape 1 : Créer un compartiment S3 pour les fichiers multimédias de sortie

Dans cette étape, vous créez un compartiment de destination S3 pour stocker les fichiers multimédias de sortie convertis. Vous créez également une configuration CORS (Cross Origin Resource Sharing) pour autoriser l'accès croisé aux fichiers multimédias transcodés stockés dans votre compartiment de destination S3.

Créer un compartiment pour les fichiers multimédias de sortie

  1. Connectez-vous à la console Amazon S3 AWS Management Console et ouvrez-la à l'adresse https://console.aws.amazon.com/s3/.

  2. Dans le panneau de navigation de gauche, choisissez Compartiments.

  3. Choisissez Créer un compartiment.

  4. Pour Bucket Name (Nom du compartiment), indiquez le nom de votre compartiment, (par exemple, tutorial-bucket-2).

  5. Pour Région, choisissez l' Région AWS endroit où vous souhaitez que le compartiment réside.

  6. Pour garantir l'accès public à vos fichiers multimédias de sortie, dans Paramètres de blocage de l'accès public à ce compartiment, désactivez Bloquer tous les accès publics.

    Avertissement

    Avant de terminer cette étape, revoyez Blocage de l'accès public à votre stockage Amazon S3 pour vous assurer que vous comprenez et acceptez les risques liés à l'autorisation d'accès public. Lorsque vous désactivez les paramètres de blocage de l'accès public pour rendre votre compartiment public, toute personne sur Internet peut accéder à votre compartiment. Nous vous recommandons de bloquer tous les accès publics à vos compartiments.

    Si vous ne souhaitez pas effacer les paramètres de blocage de l'accès public, vous pouvez utiliser Amazon CloudFront pour transmettre les fichiers multimédia transcodés aux spectateurs (utilisateurs finaux). Pour plus d’informations, consultez Tutoriel : Hébergement de vidéos en streaming à la demande avec Amazon S3 CloudFront, Amazon et Amazon Route 53.

  7. Cochez la case pour Je reconnais que les paramètres actuels pourraient rendre ce compartiment et les objets qu'il contient accessibles publiquement.

  8. Conservez les paramètres restants définis sur les valeurs par défaut.

  9. Choisissez Créer un compartiment.

Ajouter une configuration CORS à un compartiment de sortie S3

Une configuration JSON CORS définit un moyen pour les applications Web clientes (lecteurs vidéo dans ce contexte) chargées dans un domaine particulier de lire des fichiers multimédias de sortie transcodés dans un autre domaine.

  1. Connectez-vous à la console Amazon S3 AWS Management Console et ouvrez-la à l'adresse https://console.aws.amazon.com/s3/.

  2. Dans le panneau de navigation de gauche, choisissez Compartiments.

  3. Dans la liste Buckets (Compartiments), choisissez le nom du compartiment que vous avez créé précédemment (par ex., tutorial-bucket-2).

  4. Choisissez l’onglet Permissions (Autorisations).

  5. Dans la section Partage des ressources cross-origin (CORS), choisissez Modifier.

  6. Dans la zone de texte de configuration CORS, copiez-collez la configuration CORS ci-dessous.

    La configuration CORS doit être au format JSON. Dans cet exemple, l'attribut AllowedOrigins utilise le caractère générique (*) pour spécifier toutes les origines. Si vous connaissez votre origine précise, vous pouvez restreindre l'attribut AllowedOrigins à l'URL de votre lecteur spécifique. Pour plus d'informations sur la configuration de cet attribut et d'autres, veuillez consulter Configuration CORS.

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

    }
]

  7. Sélectionnez Enregistrer les modifications.

Étape 2 : créer un rôle IAM pour MediaConvert

AWS Elemental MediaConvert Pour pouvoir transcoder des vidéos d'entrée stockées dans votre compartiment S3, vous devez disposer d'un rôle de service AWS Identity and Access Management (IAM) qui octroie MediaConvert les autorisations de lecture et d'écriture de fichiers vidéo depuis et vers vos compartiments source et destination S3. Lorsque vous exécutez des tâches de transcodage, la MediaConvert console utilise ce rôle.

Pour créer un rôle IAM pour MediaConvert

  1. Créez un rôle IAM avec un nom de rôle que vous choisissez (par exemple, tutorial-mediaconvert-role). Pour créer ce rôle, suivez les étapes décrites dans la section Créer votre MediaConvert rôle dans IAM (console) dans le guide de l'AWS Elemental MediaConvert utilisateur.

  2. Après avoir créé le rôle IAM pour MediaConvert, dans la liste des rôles, choisissez le nom du rôle pour MediaConvert lequel vous avez créé (par exemple,tutorial-mediaconvert-role).

  3. Dans la page Summary (Récapitulatif), copiez l'ARN du rôle (commençant par arn:aws:iam::), puis enregistrez l'ARN en vue d'une utilisation ultérieure.

    Pour en savoir plus sur les ARN, consultez la section Amazon Resource Names (ARN) dans les Références générales AWS .

Étape 3 : Créer un rôle IAM pour votre fonction Lambda

Pour transcoder des vidéos par lots avec MediaConvert S3 Batch Operations, vous utilisez une fonction Lambda pour connecter ces deux services afin de convertir des vidéos. Cette fonction Lambda doit avoir un rôle IAM qui accorde à la fonction Lambda des autorisations d'accès et MediaConvert des opérations de traitement par lots S3.

Créer un rôle IAM pour votre fonction Lambda

  1. Connectez-vous à la console IAM AWS Management Console et ouvrez-la à l'adresse https://console.aws.amazon.com/iam/.

  2. Dans le panneau de navigation de gauche, choisissez Roles (Rôles), puis Create role (Créer un rôle).

  3. Cliquez sur le type de rôle de service AWS , puis, sous Common use cases (Cas d'utilisation courants), choisissez Lambda.

  4. Sélectionnez Next: Permissions (Étape suivante : autorisations).

  5. Sur la page Attach Permissions policies (Attacher les stratégies d'autorisations), saisissez AWSLambdaBasicExecutionRole dans la case Filter policies (Politiques de filtrage). Pour associer la politique gérée AWSLambdaBasicExecutionRoleà ce rôle afin d'accorder des autorisations d'écriture à Amazon CloudWatch Logs, cochez la case à côté de AWSLambdaBasicExecutionRole.

  6. Choisissez Suivant : Balises.

  7. (Facultatif) Ajoutez des balises à la stratégie gérée.

  8. Choisissez Next: Review (Suivant : Vérification).

  9. Pour le Nom du rôle, saisissez tutorial-lambda-transcode-role.

  10. Choisissez Créer un rôle.

Intégrez une politique en ligne pour le rôle IAM de votre fonction Lambda

Pour accorder des autorisations à la MediaConvert ressource nécessaire à l'exécution de la fonction Lambda, vous devez utiliser une politique intégrée.

  1. Connectez-vous à la console IAM AWS Management Console et ouvrez-la à l'adresse https://console.aws.amazon.com/iam/.

  2. Dans le panneau de navigation de gauche, choisissez Rôles.

  3. Dans la liste Roles (Rôles), choisissez le nom du rôle IAM que vous avez créé précédemment pour votre fonction Lambda (par exemple, tutorial-lambda-transcode-role).

  4. Sélectionnez l'onglet Autorisations.

  5. Sélectionnez Ajouter une politique en ligne.

  6. Choisissez l'onglet JSON, puis copiez et collez la stratégie JSON suivante.

    Dans la politique JSON, remplacez l'exemple de valeur Resource d'ARN de par le rôle ARN du rôle IAM MediaConvert que vous avez créé à l'étape 2 (par exemple,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. Choisissez Examiner une politique.

  8. Pour Name (Nom), saisissez tutorial-lambda-policy.

  9. Choisissez Créer une politique.

    Lorsque vous aurez créé une politique en ligne, elle sera automatiquement intégrée au rôle IAM de votre fonction Lambda.

Étape 4 : Créer une fonction Lambda pour le transcodage vidéo

Dans cette section du didacticiel, vous allez créer une fonction Lambda à l'aide du SDK pour Python afin de l'intégrer à S3 Batch Operations et. MediaConvert Pour commencer à transcoder les vidéos déjà stockées dans votre compartiment source S3, vous exécutez une tâche S3 Batch Operations qui appelle directement la fonction Lambda pour chaque vidéo du compartiment source S3. Ensuite, la fonction Lambda soumet une tâche de transcodage pour chaque vidéo à. MediaConvert

Écrire le code de la fonction Lambda et créer un package de déploiement

  1. Sur votre ordinateur local, créez un dossier nommé batch-transcode.

  2. Dans le dossier batch-transcode, créez un fichier contenant les paramètres de la tâche JSON. Par exemple, vous pouvez utiliser les paramètres fournis dans cette section et nommer le fichier job.json.

    Un fichier job.json spécifie les éléments suivants :

    • Quels fichiers transcoder

    • Comment transcoder vos vidéos d'entrée

    • Quels fichiers multimédias de sortie vous souhaitez créer

    • Quel nom à attribuer aux fichiers transcodés

    • Où enregistrer les fichiers transcodés

    • Quelles fonctions avancées appliquer, et ainsi de suite

    Dans ce didacticiel, nous utiliserons le fichier job.json suivant pour créer les sorties suivantes pour chaque vidéo dans le compartiment source S3 :

    • Un flux à débit adaptatif HTTP Live Streaming (HLS) pour lecture sur plusieurs appareils de diverses tailles et des largeurs de bande passante variables

    • Un fichier vidéo MP4

    • Images miniatures collectées à intervalles

    Ce fichier d'exemple job.json utilise le débit variable selon la qualité (QVCR) pour optimiser la qualité de la vidéo. La sortie HLS est conforme aux applications d'Apple (fichier audio séparé du fichier vidéo, durée de segment de 6 secondes et qualité vidéo optimisée via QVBR automatique).

    Si vous ne souhaitez pas utiliser les exemples de paramètres fournis ici, vous pouvez générer une spécification job.json basée sur votre cas d'utilisation. Pour assurer la cohérence entre vos sorties, vérifiez que vos fichiers d'entrée ont des configurations vidéo et audio similaires. Créez des automatisations distinctes (paramètres job.json uniques) pour tous les fichiers d'entrée avec différentes configurations vidéo et audio. Pour en savoir plus, consultez Exemples de paramètres de tâche AWS Elemental MediaConvert en JSON dans le Guide de l'utilisateur 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"
    }
  ]
}
    Afficher plusAfficher moins

  3. Dans le dossier batch-transcode, créez un fichier avec une fonction Lambda. Vous pouvez utiliser l'exemple Python suivant et nommer le fichier convert.py.

    S3 Batch Operations envoie des données propres à la tâche à une fonction Lambda et demande des données de résultat en retour. Pour consulter des exemples de requête et de réponse pour la fonction Lambda, des informations sur les codes de réponse et de résultat, ainsi que des exemples de fonctions Lambda pour S3 Batch Operations, veuillez consulter AWS Lambda Fonction Invoke. 

    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. Pour créer un package de déploiement avec convert.py et job.json sous forme de fichier .zip nommé lambda.zip, dans votre terminal local, ouvrez le dossier batch-transcode que vous avez créé précédemment et exécutez la commande suivante.

    Pour les utilisateurs macOS, exécutez la commande suivante :

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

    Pour les utilisateurs Windows, exécutez les commandes suivantes :

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

Créer une fonction Lambda à l'aide d'un rôle d'exécution (console)

  1. Ouvrez la AWS Lambda console à l'adresse https://console.aws.amazon.com/lambda/.

  2. Dans le panneau de navigation de gauche, choisissez Fonctions.

  3. Choisissez Créer une fonction.

  4. Choisissez Créer à partir de zéro.

  5. Sous Informations de base, procédez comme suit :

    1. Sous Nom de la fonction, saisissez tutorial-lambda-convert.

    2. Pour Runtime (Exécution), choisissez Python 3.8 ou version ultérieure de Python.

  6. Choisissez Modifier le rôle d'exécution par défaut et, sous Rôle d'exécution, choisissez Utiliser un rôle existant.

  7. Sous Existing role (Rôle existant), choisissez le nom du rôle IAM que vous avez créé pour votre fonction Lambda à l'étape 3(par exemple, tutorial-lambda-transcode-role).

  8. Pour les paramètres restants, conservez les paramètres par défaut.

  9. Choisissez Créer une fonction.

Déployez votre fonction Lambda avec les archives de fichiers .zip, puis configurez la fonction Lambda (console)

  1. Dans la section Code Source (Source du code) de la page de la fonction Lambda que vous avez créée (par exemple, tutorial-lambda-convert), choisissez Upload from (Télécharger à partir de), puis le fichier .zip.

  2. Choisissez Charger pour sélectionner votre fichier .zip local.

  3. Choisissez le fichier lambda.zip que vous avez créé précédemment, puis choisissez Open (Ouvrir).

  4. Choisissez Enregistrer.

  5. Dans la section Paramètres d'exécution, choisissez Modifier.

  6. Pour indiquer à l'exécution Lambda la méthode de gestionnaire dans votre code de fonction Lambda à appeler, saisissez convert.handler dans le champ Handler (Gestionnaire).

    Quand vous configurez une fonction dans Python, la valeur du paramètre de gestionnaire correspond au nom de fichier et au nom de module de gestionnaire, séparés par un point (.). Par exemple, convert.handler appelle la méthode handler définie dans le fichier convert.py.

  7. Choisissez Enregistrer.

  8. Dans la page de la fonction Lambda, choisissez l'onglet Configuration. Dans le panneau de navigation de gauche de l'onglet Configuration, choisissez Environment variables (Variables d'environnement), puis Edit (Modifier).

  9. Choisissez Ajouter une variable d'environnement. Ensuite, saisissez la clé et la valeur spécifiées pour chacune des variables d'environnement suivantes :

    • Clé : Valeur DestinationBucket : tutorial-bucket-2

      Cette valeur est le compartiment S3 pour les fichiers multimédias de sortie que vous avez créés à l'étape 1.

    • Clé : Valeur MediaConvertRole : arn:aws:iam::111122223333:role/tutorial-mediaconvert-role

      Cette valeur est l'ARN du rôle IAM MediaConvert que vous avez créé à l'étape 2. Assurez-vous de remplacer cet ARN par le véritable ARN de votre rôle IAM.

    • Clé : Valeur Application : Batch-Transcoding

      Cette valeur est le nom de l'application.

  10. Choisissez Enregistrer.

  11. (Facultatif) Dans l'onglet Configuration, dans la section Configuration générale du panneau de navigation de gauche, choisissez Modifier. Dans le champ Délai d'expiration, saisissez 2 min 0 sec. Ensuite, choisissez Enregistrer.

    Le Délai d'expiration est le temps que Lambda autorise pour l'exécution d'une fonction avant de l'arrêter. Le durée par défaut est de 3 secondes. La tarification est basée sur la quantité de mémoire configurée et la durée pendant laquelle votre code s'exécute. Pour en savoir plus, consultez AWS Lambda Tarification.

Étape 5 : Configurer un inventaire Amazon S3 pour votre compartiment source S3

Après avoir configuré la fonction Lambda de transcodage, créez une tâche S3 Batch Operations pour transcoder un jeu de vidéos. Tout d'abord, vous avez besoin d'une liste d'objets vidéo d'entrée sur lesquels S3 Batch Operations devra exécuter l'action de transcodage indiquée. Pour obtenir une liste d'objets vidéo d'entrée, vous pouvez générer un rapport d'inventaire S3 pour votre compartiment source S3 (par exemple, tutorial-bucket-1).

Créer et configurer un compartiment pour les rapports d'inventaire S3 des vidéos d'entrée

Pour stocker un rapport d'inventaire S3 qui répertorie les objets du compartiment source S3, créez un compartiment de destination d'inventaire S3, puis configurez une politique de compartiment pour que le compartiment puisse écrire des fichiers d'inventaire dans le compartiment source S3.

  1. Connectez-vous à la console Amazon S3 AWS Management Console et ouvrez-la à l'adresse https://console.aws.amazon.com/s3/.

  2. Dans le panneau de navigation de gauche, choisissez Compartiments.

  3. Choisissez Créer un compartiment.

  4. Pour Bucket Name (Nom du compartiment), indiquez le nom de votre compartiment, (par exemple, tutorial-bucket-3).

  5. Pour Région AWS, choisissez l' Région AWS endroit où vous souhaitez que le compartiment réside.

    Le compartiment de destination de l'inventaire doit se trouver dans le même compartiment Région AWS que le compartiment source dans lequel vous configurez S3 Inventory. Le compartiment de destination d'inventaire peut être dans un autre Compte AWS.

  6. Dans Block Public Access settings for this bucket (Bloquer les paramètres d'accès public pour ce compartiment), conservez les paramètres par défaut (Block all public access Bloquer tous les accès publics) est activé).

  7. Pour les paramètres restants, conservez les paramètres par défaut.

  8. Choisissez Créer un compartiment.

  9. Dans la liste Compartiments, choisissez le nom du compartiment que vous venez de créer (par exemple, tutorial-bucket-3).

  10. Pour accorder à Amazon S3 l'autorisation d'écrire des données pour les rapports d'inventaire dans le compartiment de destination d'inventaire S3, choisissez l'onglet Permissions (Autorisations).

  11. Faites défiler jusqu'à la section Bucket policy (Stratégie de compartiment), puis choisissez Edit (Modifier). La page Bucket policy (Stratégie de compartiment) s'ouvre.

  12. Pour accorder des autorisations pour l'inventaire S3, dans le champ Policy (Stratégie), collez la stratégie de compartiment suivante.

    Remplacez les trois exemples de valeurs par les valeurs suivantes :

    • Le nom du compartiment que vous avez créé pour stocker les rapports d'inventaire (par exemple, tutorial-bucket-3).

    • Le nom du compartiment source qui stocke les vidéos d'entrée (par exemple, tutorial-bucket-1).

    • L' Compte AWS ID que vous avez utilisé pour créer le compartiment de source vidéo S3 (par exemple,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. Choisissez Enregistrer les modifications.

Configurer l'inventaire Amazon S3 pour votre compartiment source S3 des vidéos

Pour générer une liste de fichiers plats d'objets vidéo et de métadonnées, vous devez configurer l'inventaire S3 pour votre compartiment source S3 des vidéos. Ces rapports d'inventaire planifiés peuvent inclure tous les objets du compartiment ou les objets regroupés par un préfixe partagé. Dans ce didacticiel, le rapport d'inventaire S3 inclut tous les objets vidéo de votre compartiment source S3.

  1. Connectez-vous à la console Amazon S3 AWS Management Console et ouvrez-la à l'adresse https://console.aws.amazon.com/s3/.

  2. Dans le panneau de navigation de gauche, choisissez Compartiments.

  3. Pour configurer un rapport d'inventaire S3 des vidéos d'entrée dans votre compartiment source S3, dans la liste Buckets (Compartiments), choisissez le nom du compartiment source S3 (par exemple, tutorial-bucket-1).

  4. Choisissez l'onglet Gestion.

  5. Faites défiler jusqu'à la section Inventory configurations (Configurations d'inventaire) et choisissez Create inventory configuration (Créer une configuration d'inventaire).

  6. Pour le Nom de la configuration d'inventaire, saisissez un nom (par exemple, tutorial-inventory-config).

  7. Sous Inventory scope (Portée de l'inventaire), choisissez Current version only (Version actuelle uniquement pour Object versions (Versions d'un objet) et conservez les autres paramètres Inventory scope (Portée de l'inventaire) définis pour les valeurs par défaut de ce didacticiel.

  8. Dans la section Report details (Détails du rapport), pour Destination bucket (Compartiment de destination), choisissez This account (Ce compte).

  9. Pour Destination, choisissez Browse S3 (Parcourir S3), puis choisissez le compartiment de destination que vous avez créé précédemment pour enregistrer les rapports d'inventaire (par exemple, tutorial-bucket-3). Ensuite, choisissez Choose path (Choisir un chemin).

    Le compartiment de destination de l'inventaire doit se trouver dans le même compartiment Région AWS que le compartiment source dans lequel vous configurez S3 Inventory. Le compartiment de destination d'inventaire peut être dans un autre Compte AWS.

    Sous le champ du compartiment Destination, l'autorisation du compartiment de destination est ajoutée à la politique du compartiment de destination afin de permettre à Amazon S3 de placer des données dans le compartiment de destination d'inventaire. Pour plus d’informations, consultez Création d'une stratégie de compartiment de destination.

  10. Pour Frequency (Fréquence), choisissez Daily (Quotidiennement).

  11. Pour Output format (Format de sortie), choisissez CSV.

  12. Pour Status (Statut), choisissez Enabled (Activé).

  13. Dans la section Server-side encryption (Chiffrement côté serveur), choisissez Disable (Désactiver) pour ce didacticiel.

    Pour plus d’informations, consultez Configuration de l'inventaire à l'aide de la console S3 et Octroi à Amazon S3 d'utiliser votre clé gérée par le client pour le chiffrement.

  14. Dans la section Additional fields - optional (Champs supplémentaires – facultatif), sélectionnez Size (Taille) Last modified (Dernière modification) et Storage class (Classe de stockage).

  15. Sélectionnez Créer.

Pour plus d’informations, consultez Configuration de l'inventaire à l'aide de la console S3.

Consultez le rapport d'inventaire pour votre compartiment source S3 de vidéos

Lorsqu'un rapport d'inventaire est publié, les fichiers manifestes sont envoyés au compartiment de destination d'inventaire S3.

  1. Connectez-vous à la console Amazon S3 AWS Management Console et ouvrez-la à l'adresse https://console.aws.amazon.com/s3/.

  2. Dans le panneau de navigation de gauche, choisissez Compartiments.

  3. Dans la liste des Compartiments, choisissez le nom du compartiment source des vidéos (par exemple, tutorial-bucket-1).

  4. Choisissez Gestion.

  5. Pour savoir si votre rapport d'inventaire S3 est prêt afin que vous puissiez créer une tâche S3 Batch Operations à l'étape 7, sous Inventory configurations (Configurations d'inventaire), vérifiez si le bouton Create job from manifest (Créer une tâche à partir du manifeste) est activé.

    Note

    La distribution du premier rapport d'inventaire peut prendre jusqu'à 48 heures. Si l'icône Créer une tâche à partir du manifeste est désactivé, cela signifie que le premier rapport d'inventaire n'a pas été remis. Attendez que le premier rapport d'inventaire soit livré et que le bouton Create job from manifest (Créer une tâche à partir du manifeste) soit activé pour créer une tâche S3 Batch Operations à l'étape 7.

  6. Pour vérifier un rapport d'inventaire S3 (manifest.json), dans la colonne Destination, choisissez le nom du compartiment de destination d'inventaire que vous avez créé précédemment pour stocker les rapports d'inventaire (par exemple, tutorial-bucket-3).

  7. Dans l'onglet Objects (Objets), choisissez le dossier existant portant le nom de votre compartiment source S3 (par exemple, tutorial-bucket-1). Choisissez ensuite le nom dans lequel vous avez saisi dans Inventory configuration name (Nom de configuration d'inventaire) lorsque vous avez créé la configuration d'inventaire précédemment (par exemple, tutorial-inventory-config).

    Vous pouvez afficher une liste de dossiers avec les dates de génération des rapports en guise de noms.

  8. Pour vérifier le rapport d'inventaire quotidien S3 à une date donnée, choisissez le dossier avec le nom de date de génération correspondant, puis choisissez manifest.json.

  9. Pour vérifier les détails du rapport d'inventaire à une date précise, dans la page manifest.json, choisissez Télécharger ou Ouvrir.

Étape 6 : Créer un rôle IAM pour S3 Batch Operations

Pour utiliser S3 Batch Operations à des fins de transcodage par lots, vous devez d'abord créer un rôle IAM pour permettre à Amazon S3 d'exécuter S3 Batch Operations.

Créer une politique IAM pour S3 Batch Operations

Vous devez créer une stratégie IAM qui autorise lS3 Batch Operations à lire le manifeste d'entrée, appeler la fonction Lambda et écrire le rapport de fin de tâche S3 Batch Operations.

  1. Connectez-vous à la console IAM AWS Management Console et ouvrez-la à l'adresse https://console.aws.amazon.com/iam/.

  2. Dans le panneau de navigation de gauche, choisissez Politiques.

  3. Sélectionnez Créer une politique.

  4. Choisissez l'onglet JSON.

  5. Dans le champ JSON, collez la politique JSON suivante.

    Dans la stratégie JSON, remplacez les quatre valeurs d'exemple par les valeurs suivantes :

    • Le nom du compartiment source qui stocke vos vidéos d'entrée (par exemple, tutorial-bucket-1).

    • Le nom du compartiment de destination d'inventaire que vous avez créé à l'étape 5 pour stocker des fichiers manifest.json (par exemple, tutorial-bucket-3).

    • Le nom du compartiment que vous avez créé à l'étape 1 pour stocker des fichiers multimédias de sortie (par exemple, tutorial-bucket-2). Dans ce didacticiel, nous mettons les rapports de fin de tâche dans le compartiment de destination des fichiers multimédias de sortie.

    • L'ARN du rôle de la fonction Lambda que vous avez créée à l'étape 4. Pour rechercher et copier l'ARN de rôle de la fonction Lambda, procédez comme suit :

      • Dans un nouvel onglet du navigateur, ouvrez la page Functions (Fonctions) de la console Lambda à l'adresse https://console.aws.amazon.com/lambda/home#/functions.

      • Dans la liste Functions (Fonctions), choisissez le nom de la fonction Lambda que vous avez créée à l'étape 4 (par exemple, tutorial-lambda-convert).

      • Choisissez Copier l'ARN.

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

  6. Choisissez Étape suivante : balises.

  7. Choisissez Étape suivante : vérification).

  8. Dans le champ Nom, saisissez tutorial-s3batch-policy.

  9. Choisissez Créer une politique.

Créez un rôle IAM S3 Batch Operations et attachez les politiques d'autorisations

  1. Connectez-vous à la console IAM AWS Management Console et ouvrez-la à l'adresse https://console.aws.amazon.com/iam/.

  2. Dans le panneau de navigation de gauche, choisissez Roles (Rôles), puis Create role (Créer un rôle).

  3. Choisissez le type de rôle Service AWS, puis le service S3.

  4. Sous Sélectionner votre cas d'utilisation, choisissez S3 Batch Operations.

  5. Choisissez Étape suivante : autorisations.

  6. Sous Attach permissions policies (Attacher des stratégies d'autorisation), saisissez le nom de la stratégie IAM que vous avez créée précédemment (par exemple, tutorial-s3batch-policy) dans la zone de recherche pour filtrer la liste de stratégies. Cochez la case en regard du nom de la stratégie (par exemple, tutorial-s3batch-policy).

  7. Choisissez Suivant : Balises.

  8. Choisissez Next: Review (Suivant : Vérification).

  9. Pour le Nom du rôle, saisissez tutorial-s3batch-role.

  10. Choisissez Créer un rôle.

    Après avoir créé le rôle IAM pour S3 Batch Operations, la politique de confiance suivante sera automatiquement attachée au rôle. Cette stratégie d'approbation permet au principal du service S3 Batch Operations d'assumer le rôle IAM.

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

Étape 7 : Configurer et exécuter une tâche S3 Batch Operations

Pour créer une tâche S3 Batch Operations aux fins de traiter les vidéos d'entrée dans votre compartiment source S3, vous devez préciser des paramètres pour cette tâche particulière.

Note

Avant de commencer à créer une tâche S3 Batch Operations, vérifiez que le bouton Create job from manifest (Créer une tâche à partir du manifeste) est activé. Pour plus d’informations, consultez Consultez le rapport d'inventaire pour votre compartiment source S3 de vidéos. Si le bouton Create job from manifest (Créer une tâche à partir du manifeste) est désactivé, cela signifie que le premier rapport d'inventaire n'a pas été livré et vous devez attendre que le bouton soit activé. Après avoir configuré l'inventaire Amazon S3 pour votre compartiment source S3 à l'étape 5, la livraison du premier rapport d'inventaire peut prendre jusqu'à 48 heures.

Créer une tâche S3 Batch Operations

  1. Connectez-vous à la console Amazon S3 AWS Management Console et ouvrez-la à l'adresse https://console.aws.amazon.com/s3/.

  2. Dans le panneau de navigation de gauche, choisissez Batch Operations (Opérations par lot).

  3. Choisissez Créer une tâche.

  4. Pour Région AWS, choisissez la Région dans laquelle vous souhaitez créer votre tâche.

    Dans ce didacticiel, pour utiliser la tâche S3 Batch Operations aux fins d'appeler une fonction Lambda, vous devez créer la tâche dans la même Région que le compartiment de source S3 des vidéos où se trouvent les objets référencés dans le manifeste.

  5. Dans la section Manifest (Manifeste), procédez comme suit :

    1. Pour Manifest format (Format du manifeste), choisissez S3 Inventory report (manifest.json) (Rapport d'inventaire S3 [manifest.json]).

    2. Pour Manifest object (Objet du manifeste), choisissez Browse S3 (Parcourir S3) pour chercher le compartiment que vous avez créé à l'étape 5 pour stocker des rapports d'inventaire (par exemple, tutorial-bucket-3). Sur la page Manifest object (Objet manifeste), parcourez les noms des objets jusqu'à ce que vous trouviez un fichier manifest.json pour une date spécifique. Ce fichier répertorie les informations sur toutes les vidéos que vous souhaitez transcoder par lots. Lorsque vous avez trouvé le fichier manifest.json que vous souhaitez utiliser, choisissez le bouton d'option en regard de celui-ci. Ensuite, choisissez Choose path (Choisir un chemin).

    3. (Facultatif) Pour Manifest object version ID - optional (ID de version de l'objet manifeste) - facultatif), saisissez l'ID de version de l'objet manifeste si vous souhaitez utiliser une autre version que la plus récente.

  6. Choisissez Suivant.

  7. Pour utiliser la fonction Lambda afin de transcoder tous les objets répertoriés dans le fichier manifest.json sélectionné, sous Operation type (Type d'opération), choisissez Invoke AWS Lambda function (Appeler une fonction Lambda).

  8. Dans la section Invoke Lambda function (Appeler une fonction Lambda), procédez comme suit :

    1. Choisissez Choisir parmi les fonctions dans votre compte.

    2. Pour Lambda function (Fonction Lambda), choisissez la fonction Lambda que vous avez créée à l'étape 4 (par exemple, tutorial-lambda-convert).

    3. Pour Lambda function version (Version de la fonction Lambda), conservez la valeur par défaut $LATEST.

  9. Choisissez Suivant. La page Configure additional options (Configurer des options supplémentaires) s'ouvre.

  10. Dans la section Additional options (Options supplémentaires), conservez les paramètres par défaut.

    Pour plus d’informations sur ces options, consultez Éléments d'une demande de tâche d'opération par lot.

  11. Dans la section Completion report (Rapport d'achèvement), pour Path to completion report destination (Chemin vers la destination du rapport d'achèvement), choisissez Browse S3 (Parcourir S3). Recherchez le compartiment que vous avez créé à l'étape 1 pour des fichiers multimédias de sortie (par exemple, tutorial-bucket-2). Choisissez le bouton d'option en regard du nom de ce compartiment. Ensuite, choisissez Choose path (Choisir un chemin).

    Pour les paramètres de rapport d'achèvement restants, conservez les paramètres par défaut. Pour en savoir plus sur les paramètres des rapports d'achèvement, consultez Éléments d'une demande de tâche d'opération par lot. Un rapport d'achèvement conserve un enregistrement des détails de la tâche et des opérations exécutées.

  12. Dans la section Permissions (Autorisations), choisissez Choose from existing IAM roles (Choisir parmi les rôles IAM existants). Pour Rôle IAM, choisissez le rôle IAM pour votre tâche S3 Batch Operations job que vous avez créée à l'étape 6 (par exemple, tutorial-s3batch-role).

  13. Choisissez Suivant.

  14. Sur la page Review (Vérification), vérifiez les paramètres. Ensuite, choisissez Create job (Créer une tâche).

    Lorsque S3 termine la lecture du manifeste de votre tâche S3 Batch Operations, la tâche passe à l'état Awaiting your confirmation to run (En attente de confirmation). Pour afficher les mises à jour de l'état de la tâche, actualisez la page. Vous ne pouvez pas exécuter votre tâche tant que son statut n'est pas Awaiting your confirmation to run (En attente de confirmation).

Exécutez la tâche S3 Batch Operations pour appeler votre fonction Lambda

Exécutez votre tâche d'opérations par lots pour appeler votre fonction Lambda aux fins de transcodage vidéo. Si votre tâche échoue, vous pouvez vérifier votre rapport d'achèvement pour identifier la cause.

Pour exécuter la tâche S3 Batch Operations

  1. Connectez-vous à la console Amazon S3 AWS Management Console et ouvrez-la à l'adresse https://console.aws.amazon.com/s3/.

  2. Dans le panneau de navigation de gauche, choisissez Batch Operations (Opérations par lot).

  3. Dans la liste Jobs (Tâches), choisissez l'ID de tâche de la tâche sur la première ligne, qui est la tâche S3 Batch Operations que vous avez créée précédemment.

  4. Choisissez Exécuter la tâche.

  5. Vérifiez à nouveau les paramètres de votre tâche et confirmez que la valeur du Nombre total d'objets répertoriés dans le manifeste est le même que le nombre d'objets indiqué dans le manifeste. Ensuite, choisissez Run job (Exécuter la tâche).

    La page de votre tâche S3 Batch Operations s'ouvre.

  6. Lorsque la tâche aura commencé à s'exécuter, dans la page de votre tâche, sous État, vérifiez la progression de votre tâche S3 Batch Operations, par exemple État,  % Terminé, Total réussi (débit),Total échoué (débit), Date de la résiliation, et Raison de la résiliation.

    Lorsque la tâche S3 Batch Operations sera terminée, affichez les données dans la page de votre tâche pour confirmer qu'elle s'est achevée comme prévu.

    Si plus de 50 % des opérations objet d'une tâche S3 Batch Operations échouent après que plus de 1 000 opérations aient été tentées, la tâche échouera automatiquement. Pour vérifier votre rapport d'achèvement afin d'identifier la cause des échecs, utilisez la procédure facultative ci-dessous.

(Facultatif) Vérifiez votre rapport d'achèvement

Vous pouvez utiliser votre rapport d'achèvement pour déterminer quels objets ont échoué et la cause des échecs.

Pour vérifier votre rapport d'achèvement afin d'obtenir plus de détails sur les objets qui ont échoué

  1. Dans la page de votre tâche S3 Batch Operations, faites défiler jusqu'à la section Completion report (Rapport d'achèvement), puis cliquez sur le lien sous Completion report destination (Destination du rapport d'achèvement).

    La page du compartiment de destination de sortie S3 s'ouvre.

  2. Dans l'onglet Objects (Objets), choisissez le dossier dont le nom se termine par l'ID de tâche de la tâche S3 Batch Operations que vous avez créée précédemment.

  3. Choisissez résultats/.

  4. Cochez la case en regard du fichier .csv.

  5. Pour afficher le rapport de la tâche, choisissez Open (Ouvrir) ou Download (Télécharger).

(Facultatif) Contrôlez chaque appel Lambda dans la console Lambda

Lorsque la tâche S3 Batch Operations commence à s'exécuter, la tâche appelle la fonction Lambda pour chaque objet d'entrée vidéo. S3 écrit les journaux de chaque appel Lambda dans Logs. CloudWatch Vous pouvez utiliser le tableau de bord de surveillance de la console Lambda pour surveiller votre fonction Lambda.

  1. Ouvrez la AWS Lambda console à l'adresse https://console.aws.amazon.com/lambda/.

  2. Dans le panneau de navigation de gauche, choisissez Fonctions.

  3. Dans la liste Functions (Fonctions), choisissez le nom de la fonction Lambda que vous avez créée à l'étape 4 (par exemple, tutorial-lambda-convert).

  4. Choisissez l'onglet Surveiller.

  5. Sous Métriques, consultez les mesures de l'environnement d'exécution de votre fonction Lambda.

  6. Sous Logs, consultez les données du journal pour chaque appel Lambda via CloudWatch Logs Insights.

    Note

    Si vous utilisez des opérations de lots S3 avec une fonction Lambda, la fonction Lambda sera appelée sur chaque objet. Si votre tâche S3 Batch Operations est volumineuse, elle pourra appeler plusieurs fonctions Lambda en même temps, provoquant un pic dans la simultanéité Lambda.

    Chacune Compte AWS dispose d'un quota de simultanéité Lambda par région. Pour plus d'informations, veuillez consulter AWS Lambda Function Scaling (Mise à l'échelle de fonction Lambda) dans le Guide du développeur AWS Lambda . Une bonne pratique pour utiliser les fonctions Lambda avec les opérations par lots S3 consiste à définir une limite de simultanéité sur la fonction Lambda elle-même. La définition d'une limite de simultanéité empêche votre tâche de consommer la majeure partie de votre simultanéité Lambda et de limiter éventuellement d'autres fonctions de votre compte. Pour plus d’informations, consultez Gestion de la simultanéité réservée Lambda dans le Guide du développeur AWS Lambda .

(Facultatif) Surveillez chaque tâche de MediaConvert transcodage vidéo dans la console MediaConvert

Une MediaConvert tâche consiste à transcoder un fichier multimédia. Lorsque votre tâche S3 Batch Operations appelle votre fonction Lambda pour chaque vidéo, chaque appel de fonction Lambda crée MediaConvert une tâche de transcodage pour chaque vidéo en entrée.

  1. Connectez-vous à la MediaConvert console AWS Management Console et ouvrez-la à l'adresse https://console.aws.amazon.com/mediaconvert/.

  2. Si la page MediaConvert d'introduction apparaît, choisissez Commencer.

  3. Dans la liste des Tâches, affichez chaque ligne pour contrôler la tâche de transcodage pour chaque vidéo d'entrée.

  4. Identifiez la ligne d'une tâche à vérifier, puis cliquez sur le lien Job ID (ID de tâche) pour ouvrir la page de détails de la tâche.

  5. Dans la page Résumé de la tâche, sous Sorties, cliquez sur le lien de la sortie HLS, MP4 ou Miniatures, en fonction de ce qui est pris en charge par votre navigateur, pour accéder au compartiment de destination S3 des fichiers multimédias de sortie.

  6. Dans le dossier correspondant (HLS, MP4 ou Miniatures) de votre compartiment de destination de sortie S3, choisissez le nom de l'objet fichier multimédia de sortie.

    La page de détails de l'objet s'ouvre.

  7. Dans la page de détails de l'objet, sous Object overview (Présentation de l'objet), choisissez le lien sous la rubrique Object URL (URL de l'objet) pour regarder le fichier multimédia de sortie transcodé.

Étape 8 : Vérifier les fichiers multimédias de sortie à partir de votre compartiment de destination S3

Vérifier les fichiers multimédias de sortie à partir de votre compartiment de destination S3

  1. Connectez-vous à la console Amazon S3 AWS Management Console et ouvrez-la à l'adresse https://console.aws.amazon.com/s3/.

  2. Dans le panneau de navigation de gauche, choisissez Compartiments.

  3. Dans la liste Buckets (Compartiments), choisissez le nom du compartiment de destination S3 pour les fichiers multimédias de sortie que vous avez créés à l'étape 1 (par exemple, tutorial-bucket-2).

  4. Dans l'onglet Objets, chaque vidéo d'entrée possède un dossier portant le nom de la vidéo d'entrée. Chaque dossier contient les fichiers multimédias de sortie transcodés d'une vidéo d'entrée.

    Pour vérifier les fichiers multimédias de sortie d'une vidéo d'entrée, procédez comme suit :

    1. Choisissez le dossier portant le nom de la vidéo d'entrée que vous souhaitez vérifier.

    2. Choisissez le dossier Par défaut/.

    3. Choisissez le dossier d'un format transcodé (HLS, MP4 ou vignettes dans ce didacticiel).

    4. Choisissez le nom du fichier multimédia de sortie.

    5. Pour regarder le fichier transcodé, choisissez le lien sous URL de l'objet dans la page de détails de l'objet.

      Les fichiers multimédia de sortie au format HLS sont divisés en segments courts. Pour lire ces vidéos, intégrez l'URL de l'objet du fichier .m3u8 dans un lecteur compatible.

Étape 9 : Nettoyer

Si vous avez transcodé des vidéos à l'aide de S3 Batch Operations, Lambda, MediaConvert et uniquement dans le cadre d'un exercice d'apprentissage, supprimez AWS les ressources que vous avez allouées afin de ne plus payer de frais.

Supprimer la configuration d'inventaire S3 de votre compartiment source S3

  1. Connectez-vous à la console Amazon S3 AWS Management Console et ouvrez-la à l'adresse https://console.aws.amazon.com/s3/.

  2. Dans le panneau de navigation de gauche, choisissez Compartiments.

  3. Dans Compartiments, choisissez le nom de votre compartiment source (par exemple, tutorial-bucket-1).

  4. Choisissez l'onglet Gestion.

  5. Sous Inventory configurations (Configurations d'inventaire), choisissez le bouton radio en regard de la configuration d'inventaire que vous avez créée à l'étape 5 (par exemple, tutorial-inventory-config).

  6. Choisissez Supprimer, puis choisissez Confirmer.

Supprimer la fonction Lambda

  1. Ouvrez la AWS Lambda console à l'adresse https://console.aws.amazon.com/lambda/.

  2. Dans le panneau de navigation de gauche, choisissez Fonctions.

  3. Cochez la case en regard de la fonction que vous avez créée à l'étape 4 (par exemple, tutorial-lambda-convert).

  4. Choisissez Actions, puis Supprimer.

  5. Dans la boîte de dialogue Supprimer une fonction, choisissez Supprimer.

Supprimer le groupe de CloudWatch journaux

  1. Ouvrez la CloudWatch console à l'adresse https://console.aws.amazon.com/cloudwatch/.

  2. Dans le panneau de navigation de gauche, choisissez Logs (Journaux), puis Log groups (Groupes de journaux).

  3. Cochez la case en regard du groupe de journaux dont le nom se termine par la fonction Lambda que vous avez créée à l'étape 4 (par exemple, tutorial-lambda-convert).

  4. Choisissez Actions, puis Supprimer le ou les groupes de journaux.

  5. Dans la boîte de dialogue Supprimer le ou les groupes de journaux), choisissez Supprimer.

Supprimer les rôles IAM en même temps que les politiques en ligne des rôles IAM

Pour supprimer les rôles IAM que vous avez créés à l'étape 2, à l'étape 3 et à l'étape 6, procédez comme suit :

  1. Connectez-vous à la console IAM AWS Management Console et ouvrez-la à l'adresse https://console.aws.amazon.com/iam/.

  2. Dans le panneau de navigation, choisissez Roles (Rôles), puis cochez les cases en regard des noms que vous souhaitez supprimer.

  3. En haut de la page, choisissez Supprimer.

  4. Dans la boîte de dialogue de confirmation, saisissez la réponse requise dans la zone de saisie de texte en fonction de l'invite, puis choisissez Supprimer.

Supprimer la stratégie IAM gérée par le client

Pour supprimer la stratégie IAM gérée par le client que vous avez créée à l'étape 6, procédez comme suit :

  1. Connectez-vous à la console IAM AWS Management Console et ouvrez-la à l'adresse https://console.aws.amazon.com/iam/.

  2. Dans le panneau de navigation de gauche, choisissez Politiques.

  3. Choisissez le bouton radio en regard de la stratégie que vous avez créée à l'étape 6 (par exemple, tutorial-s3batch-policy). Vous pouvez utiliser la zone de recherche pour filtrer la liste des politiques.

  4. Choisissez Actions, puis choisissez Supprimer.

  5. Confirmez que vous souhaitez supprimer cette stratégie en saisissant son nom dans le champ de texte, puis choisissez Delete (Supprimer).

Vider les compartiments S3

Pour vider les compartiments S3 que vous avez créés dans Prerequisites (Prérequis), à l'étape 1 et à l'étape 5, procédez comme suit :

  1. Connectez-vous à la console Amazon S3 AWS Management Console et ouvrez-la à l'adresse https://console.aws.amazon.com/s3/.

  2. Dans le panneau de navigation de gauche, choisissez Compartiments.

  3. Dans la liste Buckets (Compartiments), choisissez le bouton radio en regard du nom du compartiment à vider, puis choisissez Empty (Vider).

  4. Dans la page Empty bucket (Vider le compartiment), confirmez que vous souhaitez vider le compartiment en saisissant permanently delete dans le champ de texte, puis choisissez Empty (Vider).

Supprimer les compartiments S3

Pour supprimer les compartiments S3 que vous avez créés dans Prerequisites (Prérequis), à l'étape 1 et à l'étape 5, procédez comme suit :

  1. Connectez-vous à la console Amazon S3 AWS Management Console et ouvrez-la à l'adresse https://console.aws.amazon.com/s3/.

  2. Dans le panneau de navigation de gauche, choisissez Compartiments.

  3. Dans la liste Buckets (Compartiments), choisissez le bouton radio en regard du nom du compartiment que vous souhaitez supprimer.

  4. Choisissez Supprimer.

  5. Dans la page Supprimer le compartiment, confirmez que vous souhaitez supprimer le compartiment en saisissant le nom de ce dernier dans le champ de texte, puis choisissez Supprimer le compartiment.

Étapes suivantes

Après avoir terminé ce didacticiel, vous pourrez explorer d'autres cas d'utilisation pertinents :