Tutorial: transcodifica in batch di video con S3 Batch Operations e AWS LambdaAWS Elemental MediaConvert - Amazon Simple Storage Service
Prerequisiti Fase 1: Creazione di un bucket S3 per i file multimediali di outputFase 2: Creare un ruolo IAM per MediaConvertFase 3: creazione di un ruolo IAM per la funzione LambdaFase 4: Creazione di una funzione Lambda per la transcodifica dei videoFase 5: Configurazione dell'inventario Amazon S3 per il bucket S3 di origineFase 6: creazione di un ruolo IAM per le operazioni in batch S3Fase 7: creazione ed esecuzione di un processo di operazioni in batch S3Fase 8: Controllo dei file multimediali di output dal bucket S3 di destinazioneFase 9: PuliziaPassaggi successivi

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Tutorial: transcodifica in batch di video con S3 Batch Operations e AWS LambdaAWS Elemental MediaConvert

I consumatori di video utilizzano dispositivi di tutte le forme, dimensioni ed età per godere dei contenuti multimediali. Questa vasta gamma di dispositivi rappresenta una sfida per i creatori e i distributori di contenuti. Invece di essere in un one-size-fits-all formato, i video devono essere convertiti in modo che possano coprire un'ampia gamma di dimensioni, formati e bitrate. Questa operazione di conversione è ancora più difficile quando si dispone di un numero elevato di video che devono essere convertiti.

AWS offre un metodo per creare un'architettura scalabile e distribuita che esegue le seguenti operazioni:

  • Importa video di input

  • Elabora i video per la riproduzione su un'ampia gamma di dispositivi

  • Memorizza i file multimediali transcodificati

  • Fornisce i file multimediali di output per soddisfare la domanda

Quando hai repository video di grandi dimensioni archiviati in Amazon S3, puoi transcodificare questi video dal loro formato di origine in più tipi di file nelle dimensioni, nella risoluzione o nel formato necessario per un determinato lettore video o dispositivo. In particolare, S3 Batch Operations offre una soluzione per richiamare AWS Lambda funzioni per i video di input esistenti in un bucket sorgente S3. Quindi, le funzioni Lambda richiamano AWS Elemental MediaConvert perché esegua processi di transcodifica di video su larga scala. I file multimediali di output convertiti sono archiviati in un bucket di destinazione S3.

Un diagramma del flusso di lavoro di transcodifica batch che mostra il flusso dai video di input nel bucket sorgente S3 ai file multimediali di output nel bucket di destinazione S3.
Obiettivo

In questa esercitazione imparerai a impostare le operazioni in batch S3 per richiamare una funzione Lambda per la transcodificazione in batch di video memorizzati in un bucket S3 di origine. La funzione Lambda chiama MediaConvert per transcodificare i video. Gli output per ogni video nel bucket S3 di origine hanno le caratteristiche mostrate di seguito:

  • Un flusso di bitrate adattivo HTTP Live Streaming (HLS) per la riproduzione su dispositivi di dimensioni multiple e con larghezza di banda variabile.

  • Un file video MP4

  • Immagini in miniatura raccolte a intervalli

Prerequisiti

Prima di iniziare questo tutorial, devi disporre di un bucket Amazon S3 di origine (ad esempio, tutorial-bucket-1) dove siano già archiviati video da transcodificare.

Se lo desideri, puoi assegnare al bucket un altro nome. Per ulteriori informazioni sulle regole di denominazione dei bucket in Amazon S3, consulta Regole di denominazione dei bucket.

Per il bucket S3 di origine, mantieni le impostazioni relative a Impostazioni di blocco dell'accesso pubblico per questo bucket sui valori di default (l'opzione Blocca tutto l'accesso pubblico è abilitata). Per ulteriori informazioni, consulta Creazione di un bucket.

Per ulteriori informazioni sul caricamento di video nel bucket S3 di origine, consulta Caricamento degli oggetti. Quando carichi un video in S3, puoi anche possibile utilizzare Amazon S3 Transfer Acceleration per configurare trasferimenti di file veloci e sicuri. Transfer Acceleration può velocizzare il caricamento dei video nel bucket S3 per il trasferimento a lunga distanza di video di grandi dimensioni. Per ulteriori informazioni, consulta Configurazione di trasferimenti veloci e sicuri di file con Amazon S3 Transfer Acceleration.

Fase 1: Creazione di un bucket S3 per i file multimediali di output

In questa fase, viene creato un bucket S3 di destinazione per archiviare i file multimediali di output convertiti. Puoi inoltre creare una configurazione per l'abilitazione della condivisione di risorse multiorigine (CORS, Cross Origin Resource Sharing) per permettere l'accesso tra origini ai file multimediali transcodificati archiviati nel bucket S3 di destinazione.

Creazione di un bucket per i file multimediali di output

  1. Accedi AWS Management Console e apri la console Amazon S3 all'indirizzo https://console.aws.amazon.com/s3/.

  2. Nel pannello di navigazione a sinistra, scegli Buckets (Bucket).

  3. Seleziona Crea bucket.

  4. Per Nome bucket, specifica un nome per il bucket, ad esempio tutorial-bucket-2.

  5. Per Regione, scegli Regione AWS dove vuoi che risieda il bucket.

  6. Per garantire l'accesso pubblico ai file multimediali di output, in Block Public Access settings for this bucket (Impostazioni di blocco dell'accesso pubblico per questo bucket), deseleziona Block all public access (Blocca tutto l'accesso pubblico).

    avvertimento

    Prima di completare questa fase, consulta Blocco dell'accesso pubblico allo storage Amazon S3 per confermare di avere compreso e accettato i rischi connessi alla concessione di un accesso pubblico. Quando si disattivano le impostazioni di blocco dell'accesso pubblico per rendere pubblico il bucket, chiunque su Internet può accedere al bucket. Consigliamo di bloccare tutti gli accessi pubblici ai bucket.

    Se non desideri cancellare le impostazioni Block Public Access, puoi utilizzare Amazon CloudFront per distribuire i file multimediali transcodificati agli spettatori (utenti finali). Per ulteriori informazioni, consulta Tutorial: hosting di video in streaming su richiesta con Amazon S3, Amazon e CloudFront Amazon Route 53.

  7. Seleziona la casella di controllo accanto a I acknowledge that the current settings might result in this bucket and the objects within becoming public. (Riconosco che le impostazioni correnti possono portare il bucket e gli oggetti all'interno a diventare pubblici).

  8. Mantieni le impostazioni rimanenti impostate sui valori predefiniti.

  9. Seleziona Crea bucket.

Aggiunta di una configurazione CORS a un bucket S3 di output

Una configurazione JSON CORS definisce un metodo con cui le applicazioni Web client (lettori video in questo contesto) caricate in un dominio possono riprodurre file multimediali di output transcodificati in un dominio differente.

  1. Accedi AWS Management Console e apri la console Amazon S3 all'indirizzo https://console.aws.amazon.com/s3/.

  2. Nel pannello di navigazione a sinistra, scegli Buckets (Bucket).

  3. Nell'elenco Bucket scegli il nome del bucket creato in precedenza (ad esempio, tutorial-bucket-2).

  4. Scegli la scheda Permissions (Autorizzazioni).

  5. Nella sezione Cross-Origin Resource Sharing (CORS) scegliere Edit (Modifica).

  6. Nella casella di testo della configurazione CORS, copia e incolla la nuova configurazione CORS mostrata di seguito.

    La configurazione CORS deve essere in formato JSON. In questo esempio, l'attributo AllowedOrigins utilizza il carattere jolly (*) per specificare tutte le origini. Se conosci la tua origine specifica, puoi limitare l'attributo AllowedOrigins all'URL del lettore specifico. Per ulteriori informazioni sulla configurazione di questo e altri attributi, consulta Configurazione CORS.

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

    }
]

  7. Seleziona Salvataggio delle modifiche.

Fase 2: Creare un ruolo IAM per MediaConvert

Per poter AWS Elemental MediaConvert transcodificare i video di input archiviati nel bucket S3, devi avere un ruolo di servizio AWS Identity and Access Management (IAM) che conceda MediaConvert le autorizzazioni per leggere e scrivere file video da e verso i bucket di origine e destinazione S3. Quando esegui lavori di transcodifica, la console utilizza questo ruolo. MediaConvert

Per creare un ruolo IAM per MediaConvert

  1. Crea un ruolo IAM scegliendo un nome di ruolo (ad esempio, tutorial-mediaconvert-role). Per creare questo ruolo, segui i passaggi in Crea il tuo MediaConvert ruolo in IAM (console) nella Guida per l'AWS Elemental MediaConvert utente.

  2. Dopo aver creato il ruolo IAM per MediaConvert, nell'elenco dei ruoli, scegli il nome del ruolo per MediaConvert cui hai creato (ad esempio,tutorial-mediaconvert-role).

  3. Nella pagina Riepilogo, copia l'ARN ruolo (che inizia con arn:aws:iam::) e salva l'ARN per utilizzarlo in un secondo momento.

    Per ulteriori informazioni sull'utilizzo degli ARN, consulta Amazon Resource Name (ARN) in Riferimenti generali di AWS .

Fase 3: creazione di un ruolo IAM per la funzione Lambda

Per transcodificare in batch i video con e MediaConvert S3 Batch Operations, usi una funzione Lambda per connettere questi due servizi e convertire i video. Questa funzione Lambda deve avere un ruolo IAM che conceda alla funzione Lambda le autorizzazioni di accesso e le operazioni in batch di S3. MediaConvert

Creazione di un ruolo IAM per la funzione Lambda

  1. Accedi AWS Management Console e apri la console IAM all'indirizzo https://console.aws.amazon.com/iam/.

  2. Nel pannello di navigazione a sinistra, scegli Ruoli, quindi Crea ruolo.

  3. Scegli il tipo di ruolo Servizio AWS dopodiché in Casi d'uso comuni scegli Lambda.

  4. Scegli Successivo: Autorizzazioni.

  5. Sulla pagina Collega policy di autorizzazioni, immetti AWSLambdaBasicExecutionRole nella casella Filtra policy. Per allegare la policy gestita AWSLambdaBasicExecutionRolea questo ruolo per concedere le autorizzazioni di scrittura ad Amazon CloudWatch Logs, seleziona la casella di controllo accanto a. AWSLambdaBasicExecutionRole

  6. Scegliere Successivo: Tag.

  7. (Facoltativo) Aggiungi i tag alla policy gestita.

  8. Seleziona Successivo: Revisione.

  9. Per Nome ruolo, inserisci tutorial-lambda-transcode-role.

  10. Scegli Crea ruolo.

Incorporazione di una policy inline per il ruolo IAM della funzione Lambda

Per concedere le autorizzazioni alla MediaConvert risorsa necessaria per l'esecuzione della funzione Lambda, è necessario utilizzare una policy in linea.

  1. Accedi AWS Management Console e apri la console IAM all'indirizzo https://console.aws.amazon.com/iam/.

  2. Nel pannello di navigazione a sinistra, seleziona Ruoli.

  3. Nell'elenco Ruoli scegli il nome del ruolo IAM creato in precedenza per la funzione Lambda (ad esempio, tutorial-lambda-transcode-role).

  4. Scegliere la scheda Permissions (Autorizzazioni).

  5. Scegliere Add inline policy (Aggiungi policy inline).

  6. Scegli la scheda JSON e copia e incolla la seguente policy JSON.

    Nella policy JSON, sostituisci il valore ARN di esempio Resource di con il ruolo ARN del ruolo IAM MediaConvert per il quale hai creato nella Fase 2 (ad esempio,). 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. Scegliere Review policy (Esamina policy).

  8. In Nome, inserisci tutorial-lambda-policy.

  9. Scegliere Create Policy (Crea policy).

    Una volta creata, la policy inline viene automaticamente incorporata nel ruolo IAM della funzione Lambda.

Fase 4: Creazione di una funzione Lambda per la transcodifica dei video

In questa sezione del tutorial, crei una funzione Lambda utilizzando l'SDK per Python per l'integrazione con S3 Batch Operations e. MediaConvert Per iniziare a transcodificare i video già archiviati nel bucket S3 di origine, esegui un processo di operazioni in batch S3 che richiama direttamente la funzione Lambda per ogni video nel bucket S3 di origine. Quindi, la funzione Lambda invia un processo di transcodifica per ogni video a. MediaConvert

Scrittura del codice della funzione Lambda e creazione di un pacchetto di implementazione

  1. Nel computer locale, crea un cartella denominata batch-transcode.

  2. Nella cartella batch-transcode, crea un file con le impostazioni del processo JSON. Ad esempio, è possibile utilizzare le impostazioni fornite in questa sezione e denominare il file job.json.

    Un file job.json specifica le seguenti informazioni:

    • Quali file transcodificare

    • Come transcodificare i tuoi video di input

    • Quali file multimediali di output si desidera creare

    • Come denominare i file transcodificati

    • Dove salvare i file transcodificati

    • Le funzioni avanzate da applicare e così via.

    In questo tutorial utilizziamo il seguente file job.json per creare i seguenti output per ogni video del bucket S3 di origine:

    • Un flusso di bitrate adattivo HTTP Live Streaming (HLS) per la riproduzione su dispositivi di dimensioni differenti e con larghezza di banda variabile.

    • Un file video MP4

    • Immagini in miniatura raccolte a intervalli

    Questo file job.json di esempio utilizza il bitrate della variabile definita dalla qualità (QVCR, Quality-Defined Variable Bitrate) per ottimizzare la qualità del video. L'output HTTP Live Streaming (HLS) è conforme a Apple (audio non mixato al video, durata del segmento corretta di 6 secondi e qualità video ottimizzata tramite QVBR automatico).

    Se non si desidera utilizzare le impostazioni di esempio fornite qui, è possibile generare una specifica job.json basata sul proprio caso d'uso. Per garantire la coerenza tra gli output, assicurati che i file di input abbiano configurazioni video e audio simili. Per tutti i file di input con configurazioni video e audio diverse, è consigliabile creare automazioni separate (impostazioni job.json univoche). Per ulteriori informazioni, consulta Example AWS Elemental MediaConvert job settings in JSON nella Guida per l'utente di 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"
    }
  ]
}
    Mostra piùMostra meno

  3. Nella cartella batch-transcode, crea un file con una funzione Lambda. Puoi utilizzare il seguente esempio Python e denominare il file convert.py.

    Le operazioni in batch S3 inviano dati di processi specifici a una funzione Lambda e richiedono i dati dei risultati. Per gli esempi di richiesta e risposta per la funzione Lambda, le informazioni sui codici di risposta e dei risultati e le funzioni Lambda di esempio per le operazioni in batch S3, consulta Invoca funzione 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. Per creare un pacchetto di implementazione con convert.py e job.json come file .zip denominato lambda.zip, nel computer locale, apri la cartella batch-transcode creata in precedenza ed emetti il comando seguente.

    Per utenti macOS, eseguire il seguente comando:

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

    Per utenti Windows, esegui questi comandi:

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

Creare una funzione Lambda con un ruolo di esecuzione (console)

  1. Apri la console all'indirizzo https://console.aws.amazon.com/lambda/ AWS Lambda .

  2. Nel pannello di navigazione a sinistra, scegli Functions (Funzioni).

  3. Selezionare Create function (Crea funzione).

  4. Scegli Author from scratch (Crea da zero).

  5. In Basic information (Informazioni di base) eseguire queste operazioni:

    1. Nel campo Function name (Nome funzione), immettere tutorial-lambda-convert.

    2. In Runtime, scegli Python 3.8 o una versione successiva.

  6. Scegli Change default execution role (Cambia ruolo di esecuzione predefinito) e in Execution role (Ruolo di esecuzione) scegli Use an existing role (Utilizza un ruolo esistente).

  7. In Ruolo esistente, scegli il nome del ruolo IAM creato per la funzione Lambda nella Fase 3 (ad esempio, tutorial-lambda-transcode-role).

  8. Mantieni le impostazioni rimanenti impostate sui valori di default.

  9. Scegli Crea funzione.

Implementa la tua funzione Lambda con gli archivi in file .zip e configura la funzione Lambda (console)

  1. Nel riquadro Origine codice della pagina della funzione Lambda creata in precedenza (ad esempio, tutorial-lambda-convert), scegli Carica da e poi File .zip.

  2. Scegli Upload (Carica) per selezionare il file .zip locale.

  3. Scegli il file lambda.zip creato in precedenza, quindi scegli Apri.

  4. Selezionare Salva.

  5. Nel pannello Runtime settings (Impostazioni runtime), scegli Edit (Modifica).

  6. Per indicare al runtime Lambda quale metodo gestore richiamare nel codice della funzione Lambda, inserisci convert.handler nel campo Gestore.

    Quando si configura una funzione in Python, il valore dell'impostazione del gestore è costituito dal nome del file e dal nome del modulo del gestore, separati da un punto (.). Ad esempio, convert.handler richiama il metodo handler definito nel file convert.py.

  7. Selezionare Salva.

  8. Nella pagina della funzione Lambda, scegli la scheda Configuration (Configurazione). Nel pannello di navigazione a sinistra nella scheda Configurazione, scegli Variabili di ambiente, quindi scegli Modifica.

  9. Scegli Add environment variable (Aggiungi variabile d'ambiente). Quindi, inserisci Chiave e Valore per ciascuna delle variabili di ambiente elencate di seguito.

    • Chiave: DestinationBucket Valore: tutorial-bucket-2

      Questo valore è il bucket S3 per i file multimediali di output creati nella Fase 1.

    • Chiave: MediaConvertRole Valore: arn:aws:iam::111122223333:role/tutorial-mediaconvert-role

      Questo valore è l'ARN del ruolo IAM per MediaConvert il quale hai creato nel passaggio 2. Assicurati di sostituire questo ARN con l'ARN effettivo del tuo ruolo IAM.

    • Chiave: Application Valore: Batch-Transcoding

      Questo valore è il nome dell'applicazione.

  10. Selezionare Salva.

  11. (Facoltativo) Nella scheda Configuration (Configurazione), nella sezione General configuration (Configurazione generale) del pannello di navigazione a sinistra, seleziona Edit (Modifica). Nel campo Timeout inserisci 2 min 0 sec. Quindi, scegliere Save (Salva).

    Il Timeout è la quantità di tempo consentita da Lambda per l'esecuzione di una funzione per una chiamata prima di arrestarla. Il valore predefinito è 3 secondi. I prezzi si basano sulla quantità di memoria configurata e sulla quantità di tempo di esecuzione del codice. Per ulteriori informazioni, consultare Prezzi di AWS Lambda.

Fase 5: Configurazione dell'inventario Amazon S3 per il bucket S3 di origine

Dopo aver impostato la funzione di transcodifica Lambda, devi creare un processo di operazioni in batch S3 per transcodificare una serie di video. Innanzitutto, devi disporre di un elenco degli oggetti video di input sui quali desideri che le operazioni in Batch S3 eseguano l'azione di transcodifica specificata. Per ottenere un elenco di oggetti video di input, puoi generare un report di inventario S3 per il bucket S3 di origine (ad esempio, tutorial-bucket-1).

Creazione e configurazione di un bucket per i report di inventario S3 dei video di input

Per archiviare un report di inventario S3 che elenca gli oggetti del bucket S3 di origine, devi creare un bucket di destinazione dell'inventario S3 e configurare una policy perché il bucket possa scrivere i file di inventario nel bucket S3 di origine.

  1. Accedi AWS Management Console e apri la console Amazon S3 all'indirizzo https://console.aws.amazon.com/s3/.

  2. Nel pannello di navigazione a sinistra, scegli Buckets (Bucket).

  3. Seleziona Crea bucket.

  4. Per Nome bucket, specifica un nome per il bucket, ad esempio tutorial-bucket-3.

  5. Per Regione AWS, scegli Regione AWS dove vuoi che risieda il bucket.

    Il bucket di destinazione dell'inventario deve trovarsi nello stesso Regione AWS del bucket di origine in cui stai configurando S3 Inventory. Il bucket di destinazione dell'inventario può trovarsi in un diverso Account AWS.

  6. In Impostazioni di blocco dell'accesso pubblico per questo bucket, mantieni le impostazioni di default (l'opzione Blocca tutto l'accesso pubblico è abilitata).

  7. Mantieni le impostazioni rimanenti impostate sui valori di default.

  8. Seleziona Crea bucket.

  9. Nell'elenco Buckets (Bucket) scegli il nome del bucket appena creato (ad esempio, tutorial-bucket-3).

  10. Per concedere ad Amazon S3 l'autorizzazione a scrivere dati per i report di inventario nel bucket di destinazione dell'inventario S3, seleziona la scheda Autorizzazioni.

  11. Scorri verso il basso fino alla sezione Policy di bucket e scegli Modifica. Viene visualizzata la pagina Policy del bucket.

  12. Per concedere le autorizzazioni per l'inventario S3, nel campo Policy copia la seguente policy del bucket.

    Sostituisci i tre valori di esempio rispettivamente con i seguenti valori:

    • Il nome del bucket creato per archiviare i rapporti di inventario (ad esempio, tutorial-bucket-3).

    • Il nome del bucket di origine che archivia i video di input (ad esempio, tutorial-bucket-1).

    • L' Account AWS ID che hai usato per creare il bucket di sorgenti video S3 (ad esempio,. 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. Seleziona Salvataggio delle modifiche.

Configurazione dell'inventario Amazon S3 per il bucket S3 di origine dei video

Per generare un elenco di file flat di oggetti video e metadati, devi configurare l'inventario S3 per il bucket S3 di origine dei video. Questi report pianificati possono includere tutti gli oggetti del bucket oppure oggetti raggruppati in base a un prefisso condiviso. In questo tutorial, il report di inventario S3 include tutti gli oggetti video nel bucket S3 di origine.

  1. Accedi AWS Management Console e apri la console Amazon S3 all'indirizzo https://console.aws.amazon.com/s3/.

  2. Nel pannello di navigazione a sinistra, scegli Buckets (Bucket).

  3. Per configurare un report di inventario S3 dei video di input nel bucket S3 di origine, nell'elenco Bucket scegli il nome del bucket S3 di origine (ad esempio, tutorial-bucket-1).

  4. Scegliere la scheda Management (Gestione),

  5. Scorri fino alla sezione Configurazione dell'inventario e scegli Crea configurazione dell'inventario.

  6. Nel campo Inventory configuration name (Nome configurazione inventario) inserisci un nome (ad esempio, tutorial-inventory-config).

  7. In Ambito inventario, scegli Solo versione corrente per Versioni oggetto e mantieni le altre impostazioni di Ambito inventario sui valori di default per questo tutorial.

  8. Nella sezione Dettagli report, per Bucket di destinazione, scegli Questo account.

  9. In Destinazione, scegli Sfoglia S3 e scegli il bucket di destinazione creato in precedenza per salvare i report di inventario (ad esempio, tutorial-bucket-3). Quindi, scegli Seleziona percorso.

    Il bucket di destinazione dell'inventario deve trovarsi nello stesso bucket Regione AWS di origine in cui stai configurando S3 Inventory. Il bucket di destinazione dell'inventario può trovarsi in un diverso Account AWS.

    Nel campo Destination bucket (Bucket di destinazione) la Destination bucket permission (Autorizzazione per il bucket di destinazione) viene aggiunta alla policy del bucket di destinazione dell'inventario per consentire ad Amazon S3 di inserirvi i dati. Per ulteriori informazioni, consulta Creazione di una policy di bucket di destinazione.

  10. In Frequenza, seleziona Giornaliero.

  11. Per Formato di output, seleziona CSV.

  12. In Stato, scegli Abilitato.

  13. In Crittografia lato server, scegli Disabilita per questo tutorial.

    Per ulteriori informazioni, consultare Configurazione dell'inventario utilizzando la console S3 e Concessione ad Amazon S3 dell'autorizzazione per l'utilizzo della chiave gestita dal cliente per la crittografia.

  14. Nella sezione Campi aggiuntivi - facoltativo, seleziona Dimensioni, Ultima modifica e Classe di archiviazione.

  15. Scegli Create (Crea).

Per ulteriori informazioni, consulta Configurazione dell'inventario utilizzando la console S3.

Controllo del report di inventario per il bucket S3 di origine dei video

Quando viene pubblicato un elenco di inventario, i file manifesto vengono inviati al bucket di destinazione dell'inventario S3.

  1. Accedi AWS Management Console e apri la console Amazon S3 all'indirizzo https://console.aws.amazon.com/s3/.

  2. Nel pannello di navigazione a sinistra, scegli Buckets (Bucket).

  3. Nell'elenco Buckets (Bucket) scegli il nome del bucket di origine dei video (ad esempio, tutorial-bucket-1).

  4. Seleziona Gestione.

  5. Per verificare se il report di inventario S3 è pronto per la creazione di un processo di operazioni in batch S3 nella Fase 7, in Configurazioni di inventario, verifica se il pulsante Create processo dal manifesto è abilitato.

    Nota

    La consegna del primo report di inventario può richiedere fino a 48 ore. Se il pulsante Create job from manifest (Crea processo dal manifesto) è disattivato, il primo report di inventario non è stato consegnato. Devi attendere che venga consegnato il primo report di inventario e che il pulsante Crea processo dal manifesto sia abilitato per creare un processo di operazioni in batch S3 nella Fase 7.

  6. Per controllare un report di inventario S3 (manifest.json), nella colonna Destinazione, scegli il nome del bucket di destinazione dell'inventario creato in precedenza per l'archiviazione dei report di inventario (ad esempio, tutorial-bucket-3).

  7. Nella scheda Oggetti, scegli la cartella esistente con il nome del bucket di origine S3 (ad esempio, tutorial-bucket-1). Quindi scegli il nome che hai inserito in Nome configurazione inventario quando hai creato la configurazione dell'inventario (ad esempio, tutorial-inventory-config).

    Puoi visualizzare un elenco di cartelle denominate con la data di generazione dei report.

  8. Per controllare il report di inventario S3 giornaliero di una certa data, scegli una cartella denominata con una data di generazione, quindi scegli manifest.json.

  9. Per controllare i dettagli del report di inventario in una data specifica, nella pagina manifest.json, scegli Download (Scarica) o Open (Apri).

Fase 6: creazione di un ruolo IAM per le operazioni in batch S3

Per utilizzare le operazioni in batch S3 per eseguire la transcodifica in batch, per prima cosa devi creare un ruolo IAM per consentire ad Amazon S3 di disporre delle autorizzazioni per eseguire le operazioni in batch S3.

Creazione di una policy IAM per le operazioni in batch S3

Devi creare una policy IAM che fornisca alle operazioni in batch S3 l'autorizzazione per leggere il manifesto di input, richiamare la funzione Lambda e scrivere il report di completamento del processo di operazioni in batch S3.

  1. Accedi AWS Management Console e apri la console IAM all'indirizzo https://console.aws.amazon.com/iam/.

  2. Nel pannello di navigazione a sinistra, seleziona Policy.

  3. Scegli Crea policy.

  4. Scegliere la scheda JSON.

  5. Nel campo di testo JSON incolla la seguente policy JSON.

    Nella policy JSON, sostituisci i quattro valori di esempio con i seguenti valori:

    • Il nome del bucket di origine che archivia i video di input (ad esempio, tutorial-bucket-1).

    • Il nome del bucket di destinazione dell'inventario creato nella Fase 5 per archiviare i file manifest.json (ad esempio, tutorial-bucket-3).

    • Il nome del bucket creato nella Fase 1 per archiviare i file multimediali di output (ad esempio, tutorial-bucket-2). In questo tutorial, abbiamo messo i report di completamento del processo nel bucket di destinazione per i file multimediali di output.

    • L'ARN del ruolo della funzione Lambda creato nella Fase 4. Per trovare e copiare l'ARN del ruolo della funzione Lambda, completa le seguenti operazioni: 

    {
    "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. Scegliere Next: Tags (Successivo: Tag).

  7. Scegliere Next:Review (Successivo: Rivedi).

  8. Nel campo Name (Nome), inserire tutorial-s3batch-policy.

  9. Scegli Crea policy.

Creare un ruolo IAM per le operazioni in batch S3 e assegna le policy di autorizzazione

  1. Accedi AWS Management Console e apri la console IAM all'indirizzo https://console.aws.amazon.com/iam/.

  2. Nel pannello di navigazione a sinistra, scegli Ruoli, quindi Crea ruolo.

  3. Scegli il tipo di ruolo Servizio AWS, quindi seleziona il servizio S3.

  4. In Select your use case (Seleziona il tuo caso d'uso), scegli S3 Batch Operations (Operazioni in batch S3).

  5. Scegliere Next: Permissions (Successivo: Autorizzazioni).

  6. In Collega policy di autorizzazioni, immettere il nome della policy IAM creata in precedenza (ad esempio, tutorial-s3batch-policy) nella casella di ricerca per filtrare l'elenco di policy. Seleziona la casella di controllo accanto al nome della policy (ad esempio, tutorial-s3batch-policy).

  7. Scegliere Next: Tags (Successivo: Tag).

  8. Scegliere Next:Review (Successivo: Rivedi).

  9. Per Nome ruolo, inserisci tutorial-s3batch-role.

  10. Scegli Crea ruolo.

    Dopo aver creato il ruolo IAM per le operazioni in batch S3, la seguente policy di attendibilità viene automaticamente associata al ruolo per permettere all'entità del servizio delle operazioni in batch S3 di assumere il ruolo IAM. Questa policy di attendibilità consente al principale del servizio di operazioni in batch S3 di assumere il ruolo IAM.

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

Fase 7: creazione ed esecuzione di un processo di operazioni in batch S3

Per creare un processo di operazioni in batch S3 per elaborare i video di input nel bucket S3 di origine, devi specificare i parametri per questo particolare processo.

Nota

Per iniziare a creare un processo di operazioni in batch S3, devi assicurarti che il pulsante Crea processo dal manifesto sia abilitato. Per ulteriori informazioni, consulta Controllo del report di inventario per il bucket S3 di origine dei video. Se il pulsante Crea processo dal manifesto è disabilitato, il primo report di inventario non è stato consegnato e devi attendere che il pulsante sia abilitato. Dopo aver configurato l'inventario Amazon S3 per il bucket S3 di origine nella Fase 5, la consegna del primo report dell'inventario può richiedere fino a 48 ore.

Creare un processo di operazioni in batch S3

  1. Accedi AWS Management Console e apri la console Amazon S3 all'indirizzo https://console.aws.amazon.com/s3/.

  2. Nel pannello di navigazione a sinistra, scegli Operazioni in batch.

  3. Scegli Crea processo.

  4. Per Regione AWS, scegli la regione in cui creare il processo.

    In questo tutorial, al fine di utilizzare il processo di operazioni in batch S3 per richiamare una funzione Lambda, devi creare il processo nella stessa regione del bucket S3 di origine dei video in cui si trovano gli oggetti a cui fa riferimento il manifesto.

  5. Nella sezione Manifesto, procedi nel seguente modo:

    1. Per Manifest format (Formato manifesto), scegliere S3 inventory report (manifest.json) (Report inventario S3 (manifest.json)).

    2. In Oggetto manifesto scegli Sfoglia S3 per trovare il bucket creato nella Fase 5 per l'archiviazione dei report di inventario (ad esempio, tutorial-bucket-3). Nella pagina Oggetto manifesto, naviga tra i nomi degli oggetti fino a trovare un file manifest.json per una data specifica. Questo file elenca le informazioni su tutti i video che vuoi transcodificare in batch. Una volta trovato il file manifest.json da utilizzare, scegli il pulsante di opzione accanto ad esso. Quindi, scegli Seleziona percorso.

    3. (Facoltativo) In ID versione oggetto manifesto - facoltativo, inserisci l'ID versione dell'oggetto manifesto se desideri utilizzare una versione diversa da quella più recente.

  6. Seleziona Avanti.

  7. Per utilizzare la funzione Lambda per transcodificare tutti gli oggetti elencati nel file manifest.json selezionato, in Tipo di operazione, scegli Invoca funzione AWS Lambda .

  8. Nella sezione Chiamare una funzione Lambda completa le operazioni seguenti:

    1. Scegli Choose from functions in your account (Scegli tra le funzioni del tuo account).

    2. In Funzione Lambda, scegli la funzione Lambda creata nella Fase 4 (ad esempio, tutorial-lambda-convert).

    3. In Versione della funzione Lambda mantieni il valore di default $LATEST.

  9. Seleziona Avanti. Viene visualizzata la pagina Configura opzioni aggiuntive.

  10. In Opzioni aggiuntive mantieni le impostazioni predefinite.

    Per ulteriori informazioni su queste opzioni, consulta Elementi della richiesta di un processo di operazioni in batch.

  11. Nella sezione Report di completamento, per Percorso di destinazione del report di completamento, scegli Sfoglia S3. Individua il bucket creato per i file multimediali di output nella Fase 1 (ad esempio, tutorial-bucket-2). Scegli il pulsante di opzione accanto al nome del bucket. Quindi, scegli Seleziona percorso.

    Mantieni le impostazioni rimanenti di Report di completamento impostate sui valori di default. Per ulteriori informazioni sulla configurazione dei report di completamento, consulta Elementi della richiesta di un processo di operazioni in batch. Un report di completamento mantiene un registro dei dettagli del processo e delle operazioni eseguite.

  12. Nella sezione Autorizzazioni, seleziona Scegli tra ruoli IAM esistenti. In IAM role (Ruolo IAM) scegli il ruolo IAM per il processo di operazioni in batch S3 creato nella Fase 6 (ad esempio, tutorial-s3batch-role).

  13. Seleziona Avanti.

  14. Nella pagina Revisione, rivedi le impostazioni. Quindi seleziona Crea processo.

    Dopo che S3 ha terminato la lettura del manifesto del processo di operazioni in batch S3, il processo imposta lo stato del processo su In attesa di conferma dell'esecuzione. Per visualizzare gli aggiornamenti dello stato del processo, aggiorna la pagina. Non sarà possibile eseguire il processo finché lo stato non sarà In attesa di esecuzione della conferma.

Esecuzione del processo di operazioni in batch di S3 per richiamare la funzione Lambda

Esegui il processo di operazioni in batch per richiamare la funzione Lambda per la transcodifica dei video. Se il processo non riesce, puoi controllare il report di completamento per identificare la causa.

Per eseguire il processo di operazioni in batch S3

  1. Accedi AWS Management Console e apri la console Amazon S3 all'indirizzo https://console.aws.amazon.com/s3/.

  2. Nel pannello di navigazione a sinistra, scegli Operazioni in batch.

  3. Nell'elenco Processi, scegli l'ID processo del processo nella prima riga, ovvero il processo di operazioni in batch S3 creato in precedenza.

  4. Scegliere Run job (Esegui processo).

  5. Riesamina i parametri del processo e conferma che il valore di Total objects listed in manifest (Totale oggetti elencati nel manifesto) corrisponda al numero di oggetti nel manifesto. Seleziona quindi Esegui processo.

    Viene visualizzata la pagina del processo di operazioni in batch S3.

  6. Dopo l'inizio dell'esecuzione del processo, nella pagina del processo, in Status (Stato) controlla lo stato di avanzamento del processo di operazioni in batch S3, ad esempio Status (Stato), % Complete (% completamento), Total succeeded (rate) (Totale riusciti (tasso)), Total failed (rate) (Totale non riusciti (tasso)), Date terminated (Data di terminazione) e Reason for termination (Motivo della terminazione).

    Al termine del processo di operazioni in batch S3, visualizza i dati nella pagina del processo per confermare che è stato completato come previsto.

    Se oltre il 50% delle operazioni sugli oggetti di un processo di operazione in batch S3 ha esito negativo dopo aver tentato più di 1.000 operazioni, il processo ha automaticamente esito negativo. Per controllare il report di completamento per identificare la causa degli errori, consulta la procedura facoltativa riportata di seguito.

(Facoltativo) Controllo del report di completamento

Puoi utilizzare il report di completamento per determinare quali oggetti non sono riusciti e la causa degli errori.

Come controllare il report di completamento con i dettagli sugli oggetti non eseguiti correttamente

  1. Nella pagina del processo di operazioni in batch S3, in Report di completamento, scegli il collegamento per Destinazione del report di completamento.

    Viene aperta la pagina del bucket di destinazione dell'output S3.

  2. Nella scheda Oggetti, scegli la cartella che ha il nome che termina con l'ID del processo di operazioni in batch S3 creato in precedenza.

  3. Scegli results/ (risultati/).

  4. Seleziona la casella di controllo accanto al file .csv.

  5. Per visualizzare il report del processo, scegli Apri o Scarica.

(Facoltativo) Monitoraggio di ogni chiamata Lambda nella console Lambda

Dopo l'avvio del processo di operazioni in batch S3, il processo richiama la funzione Lambda per ogni oggetto video di input. S3 scrive i log di ogni chiamata Lambda in Logs. CloudWatch Puoi utilizzare il pannello di controllo di monitoraggio della console Lambda per monitorare la funzione Lambda.

  1. Apri la console all'indirizzo https://console.aws.amazon.com/lambda/. AWS Lambda

  2. Nel pannello di navigazione a sinistra, scegli Functions (Funzioni).

  3. Nell'elenco Funzioni, scegli la funzione Lambda creata nella Fase 4 (ad esempio, tutorial-lambda-convert).

  4. Selezionare la scheda Monitor (Monitora).

  5. In Metrics (Parametri), visualizza i parametri di runtime per la funzione Lambda.

  6. In Logs, visualizza i dati di log per ogni chiamata CloudWatch Lambda tramite Logs Insights.

    Nota

    Quando utilizzi le operazioni in batch S3 con una funzione Lambda, la funzione Lambda viene richiamata su ciascun oggetto. Se il tuo processo di operazioni in batch S3 è grande, può richiamare più funzioni Lambda contemporaneamente, causando un picco nella simultaneità Lambda.

    Ciascuno Account AWS ha una quota di concorrenza Lambda per regione. Per ulteriori informazioni, consulta Dimensionamento della funzione AWS Lambda nella Guida per gli sviluppatori di AWS Lambda . Una best practice per l'utilizzo delle funzioni Lambda con le operazioni in batch S3 è impostare un limite di simultaneità sulla funzione Lambda stessa. Ciò impedisce al tuo processo di consumare la maggior parte della simultaneità Lambda e potenzialmente di limitare altre funzioni nel tuo account. Per ulteriori informazioni, consulta Gestione della simultaneità riservata Lambda nella Guida per gli sviluppatori di AWS Lambda .

(Facoltativo) Monitora ogni processo di MediaConvert transcodifica video nella console MediaConvert

Un MediaConvert job svolge il lavoro di transcodifica di un file multimediale. Quando il job S3 Batch Operations richiama la funzione Lambda per ogni video, ogni chiamata alla funzione Lambda crea un processo di transcodifica per ogni video in ingresso. MediaConvert

  1. Accedi e apri la console all'indirizzo https://console.aws.amazon.com/mediaconvert/. AWS Management Console MediaConvert

  2. Se viene visualizzata la pagina MediaConvert introduttiva, scegli Inizia.

  3. Nell'elenco Processi, visualizza ogni riga per monitorare l'attività di transcodifica per ogni video di input.

  4. Identifica la riga del processo che desideri controllare e scegli il collegamento ID processo per aprire la pagina dei dettagli.

  5. Nella pagina Job summary (Riepilogo del processo), in Output, scegli il collegamento per l'output HLS, MP4 o miniature, a seconda di cosa supporta il browser in uso, per passare al bucket S3 di destinazione per i file multimediali di output.

  6. Nella cartella corrispondente (HLS, MP4 o Miniature) del bucket S3 di destinazione dell'output, scegli il nome dell'oggetto file multimediale di output.

    Viene aperta la pagina dei dettagli dell'oggetto.

  7. Nella pagina dell'oggetto, in Panoramica oggetto, scegli il link in URL oggetto per esaminare il file multimediale di output transcodificato.

Fase 8: Controllo dei file multimediali di output dal bucket S3 di destinazione

Come controllare i file multimediali di output dal bucket S3 di destinazione

  1. Accedi AWS Management Console e apri la console Amazon S3 all'indirizzo https://console.aws.amazon.com/s3/.

  2. Nel pannello di navigazione a sinistra, scegli Buckets (Bucket).

  3. Nell'elenco Bucket scegli il nome del bucket S3 di destinazione per i file multimediali di output creati nella Fase 1 (ad esempio, tutorial-bucket-2).

  4. Nella scheda Objecets (Oggetti), ogni video di input ha una cartella con il nome del video di input. Ogni cartella contiene i file multimediali di output transcodificati di un video di input.

    Per controllare i file multimediali di output di un video di input, esegui le seguenti operazioni:

    1. Scegli la cartella con il nome del video di input che desideri controllare.

    2. Scegli la cartella Default/ (Predefinito/).

    3. Scegli la cartella di un formato transcodificato (HLS, MP4 o miniature in questo tutorial).

    4. Scegli il nome del file multimediale di output.

    5. Per esaminare il file transcodificato, nella pagina dell'oggetto scegli il link in URL oggetto.

      I file multimediali di output in formato HLS vengono suddivisi in segmenti brevi. Per riprodurre questi video, incorpora l'URL oggetto del file .m3u8 in un lettore compatibile.

Fase 9: Pulizia

Se hai transcodificato i video utilizzando S3 Batch Operations, Lambda MediaConvert e solo come esercizio di apprendimento, elimina AWS le risorse che hai allocato in modo da non addebitare più addebiti.

Eliminazione della configurazione di inventario S3 per il bucket S3 di origine

  1. Accedi AWS Management Console e apri la console Amazon S3 all'indirizzo https://console.aws.amazon.com/s3/.

  2. Nel pannello di navigazione a sinistra, scegli Buckets (Bucket).

  3. Nell'elenco Buckets (Bucket) scegli il nome del bucket di origine (ad esempio, tutorial-bucket-1).

  4. Scegliere la scheda Management (Gestione),

  5. Nella sezione Configurazioni inventario scegli la configurazione di inventario creata nella Fase 5 (ad esempio, tutorial-inventory-config).

  6. Scegli Elimina e poi Conferma.

Eliminazione della funzione Lambda

  1. Apri la AWS Lambda console all'indirizzo https://console.aws.amazon.com/lambda/.

  2. Nel pannello di navigazione a sinistra, scegli Functions (Funzioni).

  3. Seleziona la casella di controllo accanto alla funzione creata nella Fase 4 (ad esempio, tutorial-lambda-convert).

  4. Scegli Actions (Operazioni), quindi Delete (Elimina).

  5. Nella finestra di dialogo Delete function (Elimina funzione), scegli Delete (Elimina).

Eliminare il gruppo di CloudWatch log

  1. Apri la CloudWatch console all'indirizzo https://console.aws.amazon.com/cloudwatch/.

  2. Nel pannello di navigazione a sinistra scegli Log, quindi Gruppi di log.

  3. Seleziona la casella di controllo accanto al gruppo di log dal nome che termina con la funzione Lambda creata nella Fase 4 (ad esempio, tutorial-lambda-convert).

  4. Scegli Actions (Operazioni), quindi scegli Delete log group(s) (Elimina gruppi di registri).

  5. Nella finestra di dialogo Delete log group(s) (Elimina gruppo/i di log) scegli Delete (Elimina).

Eliminazione dei ruoli IAM e delle policy inline per i ruoli IAM

Per eliminare i ruoli IAM creati nella Fase 2, nella Fase 3, e nella Fase 6 esegui invece le seguenti operazioni:

  1. Accedi AWS Management Console e apri la console IAM all'indirizzo https://console.aws.amazon.com/iam/.

  2. Nel pannello di navigazione, scegli Ruoli, quindi seleziona la casella di controllo accanto al nome del ruolo che desideri eliminare.

  3. Nella parte superiore della pagina, scegli Delete (Elimina).

  4. Nella finestra di dialogo di conferma inserisci la risposta richiesta nel campo di inserimento di testo in base al comando e scegli Delete (Elimina).

Eliminazione della policy IAM gestita dal cliente

Per eliminare la policy IAM gestita dal cliente creata nella Fase 6, completa le seguenti operazioni:

  1. Accedi AWS Management Console e apri la console IAM all'indirizzo https://console.aws.amazon.com/iam/.

  2. Nel pannello di navigazione a sinistra, seleziona Policy.

  3. Scegli il pulsante di opzione accanto alla policy creata nella Fase 6 (ad esempio, tutorial-s3batch-policy). Puoi utilizzare la casella di ricerca per filtrare l'elenco di policy.

  4. Scegli Actions (Operazioni), quindi Delete (Elimina).

  5. Conferma di voler eliminare questa policy inserendone il nome nel campo di testo, quindi scegli Elimina.

Svuotare i bucket S3

Per svuotare i bucket S3 creati nei Prerequisiti, nella Fase 1 e nella Fase 5, completa le seguenti operazioni:

  1. Accedi AWS Management Console e apri la console Amazon S3 all'indirizzo https://console.aws.amazon.com/s3/.

  2. Nel pannello di navigazione a sinistra, scegli Buckets (Bucket).

  3. Nell'elenco Bucket scegli il pulsante di opzione accanto al nome del bucket che desideri svuotare, quindi scegli Svuota.

  4. Nella pagina Svuota bucket conferma che desideri svuotare il bucket inserendo permanently delete nel campo di testo e quindi scegli Svuota.

Eliminazione dei bucket S3

Per eliminare i bucket S3 creati nei Prerequisiti, nella Fase 1 e nella Fase 5, completa invece le seguenti operazioni:

  1. Accedi AWS Management Console e apri la console Amazon S3 all'indirizzo https://console.aws.amazon.com/s3/.

  2. Nel pannello di navigazione a sinistra, scegli Buckets (Bucket).

  3. Nell'elenco Bucket, scegli il pulsante di opzione accanto al nome del bucket che desideri eliminare.

  4. Scegli Elimina.

  5. Nella pagina Delete bucket (Elimina bucket) conferma che desideri eliminare il bucket inserendone il nome nel campo di testo e quindi scegli Delete bucket (Elimina bucket).

Passaggi successivi

Dopo aver completato questo tutorial, puoi esplorare altri casi d'uso rilevanti: