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. # MediaTailor variables publicitaires dynamiques pour les demandes ADS AWS Elemental MediaTailor utilise des variables publicitaires dynamiques pour transmettre les informations de votre session de visionnage au serveur de décision publicitaire (ADS). Ces informations aident l'ADS à sélectionner les annonces les plus pertinentes pour vos spectateurs. Cette section fournit une vue d'ensemble des variables publicitaires dynamiques et des liens vers des guides de mise en œuvre spécifiques. Pour les instructions de step-by-step configuration, consultez les rubriques individuelles ci-dessous. **Types de variables dynamiques** MediaTailor prend en charge quatre types de variables dynamiques : + **Variables de session** : valeurs générées automatiquement, telles que l'ID de session et les données SCTE-35. Consultez [MediaTailor variables de session pour les requêtes ADS](variables-session.md). + **Variables du lecteur** : paramètres personnalisés envoyés par votre lecteur vidéo. Consultez [MediaTailor variables du joueur pour les requêtes ADS](variables-player.md). + **Variables de domaine** avec **alias de configuration** : domaines URL dynamiques pour les configurations à origines multiples. + **Alias de configuration** : mappages prédéfinis pour le remplacement dynamique des variables. Consultez [Alias de configuration](configuration-aliases-overview.md). **Cas d’utilisation courants** Utilisez des variables publicitaires dynamiques pour : + Transmettez les données démographiques et les préférences des utilisateurs à vos ADS + Acheminer les demandes vers différentes origines en fonction de la situation géographique + Activez l'affichage décalé dans le temps grâce à l'intégration MediaPackage + Mettre en œuvre A/B des scénarios de test et de basculement Les sections suivantes fournissent des informations supplémentaires sur l'utilisation de variables publicitaires dynamiques avec MediaTailor. **Topics** + [Variables de session](variables-session.md) + [Variables du joueur](variables-player.md) + [Variables de domaine](variables-domains.md) + [Alias de configuration](configuration-aliases-overview.md) + [Transmission des paramètres ADS](passing-paramters-to-the-ads.md) + [Routage des paramètres](parameter-routing-behavior.md) + [intégration d’MediaPackage](mediapackage-integration-param.md) + [Comportement de session](parameter-session-behavior.md) + [Référence des paramètres](parameter-comprehensive-reference.md) + [Dépannage des paramètres](parameter-troubleshooting.md) + [Dépannage des alias](configuration-aliases-troubleshooting.md) Pour connaître les exigences relatives au formatage des paramètres et la résolution des problèmes, reportez-vous [MediaTailor référence et limites des paramètres](parameter-comprehensive-reference.md) aux sections et[MediaTailor guide de résolution des problèmes de paramètres](parameter-troubleshooting.md). # MediaTailor variables de session pour les requêtes ADS AWS Elemental MediaTailor envoie les données de session au serveur de décision publicitaire (ADS) lorsque vous configurez AWS Elemental MediaTailor pour spécifier une ou plusieurs des variables répertoriées dans cette section dans l'URL du modèle ADS. Vous pouvez utiliser des variables individuelles et vous pouvez concaténer plusieurs variables pour créer une valeur unique. MediaTailor génère certaines valeurs et obtient le reste à partir de sources telles que le manifeste et la demande d'initialisation de session du joueur. Le tableau suivant décrit les variables de données de session que vous pouvez utiliser dans la configuration de l'URL de votre modèle de demande ADS. Les numéros de section indiqués dans le tableau correspondent à la version 2019a de la spécification 35 de la Society of Cable Telecommunications Engineers (SCTE), [Digital Program Insertion Gueing Message](https://account.scte.org/standards/library/catalog/scte-35-digital-program-insertion-cueing-message/). Pour plus de détails sur le préchargement des publicités, voir. [Publicités de prélecture](prefetching-ads.md) | Nom | Disponible pour la prélecture des annonces | Section de spécification SCTE-35 | Description | | --- | --- | --- | --- | | [avail.index] | Oui | | Nombre qui représente la position d'une annonce dans un index. Au début d'une session de diffusion, MediaTailor crée un index de toutes les publicités disponibles dans un manifeste et stocke l'index pour le reste de la session. Lorsque vous MediaTailor faites une demande à l'ADS pour remplir le fichier, celui-ci inclut le numéro d'index de disponibilité des annonces. Ce paramètre permet au serveur ADS d'améliorer la sélection des publicités en utilisant des fonctionnalités telles que l'exclusion concurrentielle et le plafonnement des fréquences. | | [avail.random] | Oui | | Un nombre aléatoire compris entre 0 et 10 000 000 000, sous forme de nombre long, MediaTailor généré pour chaque demande adressée à l'ADS. Certains serveurs publicitaires utilisent ce paramètre pour activer des fonctionnalités telles que la séparation de publicités d'entreprises concurrentes. | | [scte.archive\$1allowed\$1flag] | Oui | 10.3.3.1 | Valeur booléenne facultative. Lorsque cette valeur est égale à 0, des restrictions d'enregistrement sont imposées au segment. Lorsque cette valeur est égale à 1, aucune restriction d'enregistrement n'est imposée au segment. | | [scte.avail\$1num] | Oui | 9.7.2.1 | La valeur analysée MediaTailor à partir du champ SCTE-35avail\$1num, sous forme de nombre long. MediaTailor peut utiliser cette valeur pour désigner des numéros de publicité linéaires.La valeur doit être un entier. | | [scte.avails\$1expected] | Oui | 9,7.2.1 | Une valeur longue facultative qui indique le nombre attendu d'essais dans le cadre de l'événement en cours. | | [scte.delivery\$1not\$1restricted\$1flag] | Oui | 10.3.3.1 | Valeur booléenne facultative. Lorsque cette valeur est égale à 0, les cinq bits suivants sont réservés. Lorsque cette valeur est égale à 1, les cinq bits suivants prennent la signification décrite dans la spécification SCTE-35. | | [scte.device\$1restrictions] | Oui | 10.3.3.1 | Valeur entière facultative qui indique trois groupes de périphériques prédéfinis, indépendants et non hiérarchiques. Pour plus d'informations sur cette variable, consultez la description segments\$1expected dans la spécification SCTE-35. | | [scte.event\$1id] | Oui | 9.1 et 9.7.2.1 | La valeur analysée MediaTailor à partir du champ SCTE-35splice\$1event\$1id, sous forme de nombre long. MediaTailor utilise cette valeur pour désigner les numéros linéaires de disponibilité des publicités ou pour renseigner les chaînes de requête du serveur publicitaire, telles que les positions des espaces publicitaires.La valeur doit être un entier. | | [scte.no\$1regional\$1blackout\$1flag] | Oui | 10.3.3.1 | Valeur booléenne facultative. Lorsque cette valeur est égale à 0, les restrictions d'interdiction régionales s'appliquent au segment. Lorsque cette valeur est égale à 1, les restrictions d'interdiction régionales ne s'appliquent pas au segment. | | [scte.segment\$1num] | Oui | 10.3.3.1 | Valeur entière facultative qui numérote les segments au sein d'une collection de segments. Pour plus d'informations sur cette variable, consultez la description de segment\$1num dans la spécification SCTE-35. | | [scte.segmentation\$1event\$1id] | Oui | 10.3.3.1 | MediaTailor expose cette variable sous la forme[scte.event_id](#scte.event_id). | | [scte.segmentation\$1type\$1id] | Oui | 10.3.3.1 | Une valeur entière optionnelle de 8 bits qui indique le type de segmentation. Pour plus d'informations sur cette variable, consultez la description de segmentation\$1type\$1id dans la spécification SCTE-35. | | [scte.segmentation\$1upid] | `segmentation_upid_type` : Oui `private_data` : Oui | **segmentation\$1upid** : 10.3.3.1 UPID privé géré : 10.3.3.3 | Correspond à l'élément SCTE-35`segmentation_upid`. L'`segmentation_upid`élément contient `segmentation_upid_type` et`segmentation_upid_length`. MediaTailor prend en charge les `segmentation_upid` types suivants : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/mediatailor/latest/ug/variables-session.html) | | [scte.segmentation\$1upid.assetId] | Oui | | Utilisé conjointement avec le Managed Private UPID (0xC) segmentation\$1 upid\$1type pour les flux de travail de podbuster. MediaTailordérive cette valeur du assetId paramètre dans la structure private\$1data JSON du MPU. Pour de plus amples informations, veuillez consulter [Managed Private UPID JSON structure for a podbuster workflow](#podbuster-workflow). | | [scte.segmentation\$1upid.cueData.key] | Oui | | Utilisé conjointement avec le Managed Private UPID (0xC) segmentation\$1 upid\$1type pour les flux de travail de podbuster. MediaTailordérive cette valeur du cueData.key paramètre dans la structure private\$1data JSON du MPU. Pour de plus amples informations, veuillez consulter [Managed Private UPID JSON structure for a podbuster workflow](#podbuster-workflow). | | [scte.segmentation\$1upid.cueData.value] | Oui | | Utilisé conjointement avec le Managed Private UPID (0xC) segmentation\$1 upid\$1type pour les flux de travail de podbuster. MediaTailordérive cette valeur du cueData.key paramètre dans la structure private\$1data JSON du MPU. Pour de plus amples informations, veuillez consulter [Managed Private UPID JSON structure for a podbuster workflow](#podbuster-workflow).La valeur peut être une chaîne. | | [scte.segmentation\$1upid.private\$1data.\$1index\$1] | Oui | | Utilisé conjointement avec le Managed Private UPID (0xC) segmentation\$1upid\$1type pour des flux de travail publicitaires ciblés. MediaTailor divise les jetons UPID de segmentation délimités par des deux-points et crée des variables de session indexées. L'index correspond à la position dans la liste délimitée par des deux-points, sans tenir compte des espaces blancs situés en tête à partir des deux points initiaux. Par exemple`segmentation_upid = ":3213214:2313321/5:3943"`, si : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/mediatailor/latest/ug/variables-session.html) La valeur peut être une chaîne. | | [scte.segments\$1expected] | Oui | 10.3.3.1 | Valeur entière facultative qui indique le nombre attendu de segments individuels au sein d'une collection de segments. Pour plus d'informations sur cette variable, consultez la description segments\$1expected dans la spécification SCTE-35. | | [scte.sub\$1segment\$1num] | Oui | 10.3.3.1 | Valeur entière facultative qui identifie un sous-segment particulier au sein d'un ensemble de sous-segments. Pour plus d'informations sur cette variable, consultez la description de sub\$1segment\$1num dans la spécification SCTE-35. | | [scte.sub\$1segments\$1expected] | Oui | 10.3.3.1 | Valeur entière facultative qui indique le nombre attendu de sous-segments individuels au sein d'une collection de sous-segments. Pour plus d'informations sur cette variable, consultez la description sub\$1segments\$1expected dans la spécification SCTE-35. | | [scte.unique\$1program\$1id] | Oui | 9.7.2.1 | La valeur entière analysée MediaTailor à partir du champ SCTE-35splice\$1insert. unique\$1program\$1id L'ADS utilise l'ID de programme unique (UPID) pour fournir un ciblage publicitaire au niveau du programme pour les flux linéaires en direct. Si la commande SCTE-35 n'est pas Splice Insert, lui MediaTailor attribue une valeur vide.La valeur doit être un entier. | | [session.avail\$1duration\$1ms] | Oui | | Durée en millisecondes du créneau de disponibilité des annonces. La valeur par défaut est de 300 000 ms. AWS Elemental MediaTailor obtient la valeur de durée à partir du manifeste d'entrée comme suit : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/mediatailor/latest/ug/variables-session.html) | | [session.avail\$1duration\$1secs] | Oui | | Durée en secondes du créneau de disponibilité publicitaire, ou disponibilité publicitaire, arrondie à la seconde la plus proche. MediaTailor détermine cette valeur de la même manière qu'elle le fait[session.avail\$1duration\$1ms]. | | [session.client\$1ip] | Non | | Adresse IP distante d'où provient la MediaTailor demande. Si l'en-tête X-forwarded-for est défini, cette valeur est ce que MediaTailor utilise pour client\$1ip. | | [session.id] | Non | | Identifiant numérique unique pour la session de lecture en cours. Toutes les demandes adressées par un joueur pour une session ont le même ID et, par conséquent, il peut être utilisé pour les champs ADS destinés à établir une corrélation entre les demandes d'une même visualisation. | | [session.referer] | Non | | Il s'agit généralement de l'URL de la page hébergeant le lecteur vidéo. MediaTailor définit cette variable sur la valeur de l'Refereren-tête que le joueur a utilisé dans sa demande MediaTailor. Si le lecteur ne fournit pas cet en-tête, MediaTailor laisse vide [session.referer]. Si vous utilisez un réseau de diffusion de contenu (CDN) ou un proxy devant le point de terminaison du manifeste et que vous souhaitez que cette variable apparaisse, utilisez le proxy pour l'en-tête correct depuis le lecteur ici. | | [session.user\$1agent] | Non | | User-AgentEn-tête MediaTailor reçu de la demande d'initialisation de session du joueur. Si vous utilisez un réseau de diffusion de contenu (CDN) ou un proxy devant le point de terminaison du manifeste, utilisez comme proxy l'en-tête correct du lecteur ici. | | [session.uuid] | Non | | Alternative à**[session.id]**. Il s'agit d'un identifiant unique pour la session courante de lecture, tel que le suivant : 
e039fd39-09f0-46b2-aca9-9871cc116cde
| | [avail.source\$1content\$1time\$1epoch\$1ms] | Non | | Pour HLS, la valeur est le PDT du segment d'origine qui a démarré l'utilisation. Pour DASH, la valeur est ` urn:scte:dash:utc-time` celle `` qui contient le``. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/mediatailor/latest/ug/variables-session.html) | **Example** Si le serveur ADS nécessite un paramètre de requête nommé `deviceSession` pour le transmettre avec l'identificateur de session unique, le modèle d'URL du serveur ADS dans AWS Elemental MediaTailor peut se présenter comme suit : ``` https://my.ads.server.com/path?deviceSession=[session.id] ``` AWS Elemental MediaTailor génère automatiquement un identifiant unique pour chaque flux et saisit l'identifiant à la place de`session.id`. Si l'identifiant est le cas`1234567`, la demande finale MediaTailor envoyée à l'ADS ressemblera à ceci : ``` https://my.ads.server.com/path?deviceSession=1234567 ``` Si l'ADS nécessite la transmission de plusieurs paramètres de requête, l'URL ADS du modèle AWS Elemental MediaTailor peut se présenter comme suit : ``` https://my.ads.server.com/sample?e=[scte.avails_expected]&f=[scte.segment_num]&g=[scte.segments_expected]&h=[scte.sub_segment_num]&j=[scte.sub_segments_expected]&k=[scte.segmentation_type_id] ``` Le fragment XML d'exemple de marqueur DASH suivant montre comment utiliser `scte35:SpliceInsert` : ``` ``` Le fragment XML d'exemple de marqueur DASH suivant montre comment utiliser `scte35:TimeSignal` : ``` 0100 ``` Le fragment XML d'exemple de marqueur DASH suivant montre comment utiliser `scte35:Binary` : ``` /DAhAAAAAAAAAP/wEAUAAAHAf+9/fgAg9YDAAAAAAAA25aoh QW5vdGhlciB0ZXN0IHN0cmluZyBmb3IgZW5jb2RpbmcgdG8gQmFzZTY0IGVuY29kZWQgYmluYXJ5Lg== ``` L'exemple de balise HLS suivant montre comment utiliser `EXT-X-DATERANGE` : ``` #EXT-X-DATERANGE:ID="splice-6FFFFFF0",START-DATE="2014-03-05T11: 15:00Z",PLANNED-DURATION=59.993,SCTE35-OUT=0xFC002F0000000000FF0 00014056FFFFFF000E011622DCAFF000052636200000000000A0008029896F50 000008700000000 ``` L'exemple de balise HLS suivant montre comment utiliser `EXT-X-CUE-OUT` : ``` #EXT-OATCLS-SCTE35:/DA0AAAAAAAAAAAABQb+ADAQ6QAeAhxDVUVJQAAAO3/PAAEUrEoICAAAAAAg+2UBNAAANvrtoQ== #EXT-X-ASSET:CAID=0x0000000020FB6501 #EXT-X-CUE-OUT:201.467 ``` L'exemple de balise HLS suivant montre comment utiliser `EXT-X-SPLICEPOINT-SCTE35` : ``` #EXT-X-SPLICEPOINT-SCTE35:/DA9AAAAAAAAAP/wBQb+uYbZqwAnAiVDVUVJAAAKqX//AAEjW4AMEU1EU05CMDAxMTMyMjE5M19ONAAAmXz5JA== ``` L'exemple suivant montre comment utiliser le `scte35:Binary` décodage : ``` { "table_id": 252, "section_syntax_indicator": false, "private_indicator": false, "section_length": 33, "protocol_version": 0, "encrypted_packet": false, "encryption_algorithm": 0, "pts_adjustment": 0, "cw_index": 0, "tier": "0xFFF", "splice_command_length": 16, "splice_command_type": 5, "splice_command": { "splice_event_id": 448, "splice_event_cancel_indicator": false, "out_of_network_indicator": true, "program_splice_flag": true, "duration_flag": true, "splice_immediate_flag": false, "utc_splice_time": { "time_specified_flag": false, "pts_time": null }, "component_count": 0, "components": null, "break_duration": { "auto_return": false, "duration": { "pts_time": 2160000, "wall_clock_seconds": 24.0, "wall_clock_time": "00:00:24:00000" } }, "unique_program_id": 49152, "avail_num": 0, "avails_expected": 0 "segment_num": 0, "segments_expected": 0, "sub_segment_num": 0, "sub_segments_expected": 0 }, "splice_descriptor_loop_length": 0, "splice_descriptors": null, "Scte35Exception": { "parse_status": "SCTE-35 cue parsing completed with 0 errors.", "error_messages": [], "table_id": 252, "splice_command_type": 5 } } ``` # MediaTailor variables du joueur pour les requêtes ADS AWS Elemental MediaTailor envoie les données reçues du joueur à l'ADS lorsque vous configurez AWS Elemental MediaTailor pour spécifier `player_params.` des variables dans l'URL du modèle ADS. Par exemple, si le joueur envoie un paramètre de requête nommé `user_id` dans sa demande à MediaTailor, pour transmettre ces données dans la demande ADS, incluez-le `[player_params.user_id]` dans la configuration de l'URL ADS. Cela vous permet de contrôler les paramètres de la requête qui sont inclus dans la demande ADS. En général, vous ajoutez un paramètre de requête particulier que le serveur ADS reconnaît à l'URL de demande du serveur ADS et fournissez les paires clé-valeur comme la valeur du paramètre. Les exemples utilisés dans la procédure suivante utilisent les paires clé-valeur suivantes : + *param1* avec une valeur *valeur1 :* + *param2* avec une valeur *valeur2 :* **Pour ajouter les paramètres de requête en tant que paires clé-valeur** 1. Dans AWS Elemental MediaTailor, configurez l'URL du modèle de demande ADS pour référencer les paramètres. L'URL suivante affiche l'inclusion des exemples de paramètres : ``` https://my.ads.com/path?param1=[player_params.param1]¶m2=[player_params.param2] ``` 1. (Facultatif) Pour le reporting du suivi publicitaire côté serveur, encodez dans l'URL les paires clé-valeur du lecteur. Lorsqu'il MediaTailor reçoit la demande d'initialisation de session, il décode les valeurs une fois avant de les substituer dans l'URL de la demande ADS. **Note** Si votre ADS nécessite une valeur codée comme URL, codez comme URL la valeur deux fois sur le lecteur. De cette façon, le décodage effectué par produit MediaTailor une valeur codée une fois pour l'ADS. Par exemple, si la représentation décodée des valeurs envoyées au serveur ADS est `param1=value1:¶m2=value2:`, la représentation codée en URL est `param1=value1%3A¶m2=value2%3A`. 1. Dans l'appel d'initialisation de session lancé par le joueur, transmettez les paires clé-valeur à MediaTailor en tant que valeur d'un seul paramètre de requête. Les exemples d'appels suivants fournissent les exemples de paires clé-valeur pour le reporting du suivi publicitaire côté serveur et côté client. + Exemple de demandes pour le reporting de suivi publicitaire côté serveur - avec les paires encodées en URL HLS : ``` .m3u8?ads.param1=value1%3A&ads.param2=value2%3A ``` DASH : ``` .mpd?ads.param1=value1%3A&ads.param2=value2%3A ``` + Exemple de demande de reporting de suivi publicitaire côté client – sans encodage de l'URL HLS : ``` POST .m3u8 { "adsParams": { "param1": "value1:", "param2": "value2:" } } ``` DASH : ``` POST .mpd { "adsParams": { "param1": "value1:", "param2": "value2:" } } ``` Pour les rapports côté serveur, MediaTailor décode les paramètres lorsque la demande du joueur est reçue. Pour les rapports côté client, cela ne modifie pas les paramètres reçus dans la charge utile JSON. MediaTailor envoie la demande suivante à l'ADS : ``` https://my.ads.com/?param1=value1:¶m2=value2: ``` De cette manière, les paires clé-valeur `param1` et `param2` sont incluses en tant que paramètres de requête de première classe dans la demande ADS. # MediaTailor variables de domaine pour plusieurs sources de contenu AWS Elemental MediaTailor les variables de domaine dynamiques vous permettent d'utiliser plusieurs domaines, tels que la partie **my-ads-server.com** de l'URL http ://my-ads-server.com, avec les paramètres du lecteur dans votre configuration. Cela vous permet d'utiliser plusieurs sources de contenu ou plusieurs serveurs de décision publicitaire (ADS) dans une seule configuration. Vous pouvez utiliser des variables de domaine avec n'importe quel paramètre contenant un URI : + `AdDecisionServerUrl` + `AdSegmentUrlPrefix` + `ContentSegmentUrlPrefix` + `LivePreroll.AdDecisionServerUrl` + `VideoContentSourceUrl` Les variables de domaine sont utilisées conjointement avec les *alias de configuration* pour effectuer le remplacement dynamique des variables. Les alias de configuration associent un ensemble d'alias et de valeurs aux paramètres du joueur utilisés pour la configuration dynamique du domaine. Pour les procédures de configuration, voir[Création et utilisation d'alias de configuration avec MediaTailor](creating-configuration-aliases.md). Pour des informations de référence détaillées, voir[MediaTailor vue d'ensemble des alias de configuration](configuration-aliases-overview.md). # MediaTailor vue d'ensemble des alias de configuration AWS Elemental MediaTailor les alias de configuration permettent le remplacement dynamique des variables dans les domaines URL et autres champs pris en charge. Utilisez cette fonctionnalité pour utiliser plusieurs domaines et effectuer une configuration dynamique URLs lors de l'initialisation de la session. ## Cas d’utilisation Les alias de configuration permettent d'utiliser des architectures multiconfigurations sophistiquées pour les scénarios suivants : + **Routage géographique : acheminez** les demandes vers différentes origines ou vers différents serveurs publicitaires en fonction de la localisation des internautes à l'aide d'alias spécifiques à la région. Pour obtenir des conseils de mise en œuvre, consultez [CloudFront Origin Failover](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/high_availability_origin_failover.html). + **Routage basé sur le contenu : Dirigez** les différents types de contenu vers des origines ou des pipelines de traitement spécialisés. Pour la configuration du comportement de routage, voir[Configurer les comportements de routage du CDN pour MediaTailor](cdn-routing-behaviors.md). + **Scénarios de basculement :** implémentez les origines de sauvegarde et les serveurs publicitaires avec un basculement automatique à l'aide du changement d'alias. Pour une mise en œuvre détaillée, voir [Mettre en œuvre la résilience multirégionale MediaTailor avec MQAR](media-quality-resiliency.md) et[Planifiez votre intégration au CDN pour AWS Elemental MediaTailor](planning-cdn-integration.md). + **Tests A/B :** testez différents serveurs publicitaires, origines ou configurations en acheminant le trafic en fonction des paramètres du joueur. Pour obtenir des conseils sur les tests de charge, consultez [Préparer et exécuter des tests de performance pour Amazon CloudFront avec une véritable surveillance des utilisateurs](https://aws.amazon.com/blogs/networking-and-content-delivery/prepare-and-run-performance-tests-for-amazon-cloudfront-with-real-user-monitoring/). + **Optimisation spécifique à l'appareil :** optimisez la diffusion de contenu et la diffusion d'annonces pour différents types d'appareils ou fonctionnalités. Pour des conseils complets, voir[Configurer le filtrage des manifestes avec MediaTailor MediaPackage, et le CDN](cdn-emp-manifest-filtering.md). + **Équilibrage de charge :** répartissez la charge entre plusieurs origines ou serveurs publicitaires à l'aide du routage dynamique. Pour des conseils de mise en œuvre, voir [Mettre en œuvre la résilience multirégionale MediaTailor avec MQAR](media-quality-resiliency.md) et[Planifiez votre intégration au CDN pour AWS Elemental MediaTailor](planning-cdn-integration.md). ## Champs pris en charge Vous pouvez utiliser des variables dynamiques dans les champs de configuration suivants : + `VideoContentSourceUrl` + `AdDecisionServerUrl` + `LivePreroll.AdDecisionServerUrl` + `AdSegmentUrlPrefix` + `ContentSegmentUrlPrefix` + `TranscodeProfileName` + `SlateAdUrl` + `StartUrl` + `EndUrl` Les sections suivantes décrivent comment utiliser les alias de configuration. **Topics** + [Cas d’utilisation](#configuration-aliases-use-cases) + [Champs pris en charge](#configuration-aliases-supported) + [Création et utilisation](creating-configuration-aliases.md) + [Exemple de flux](configuration-aliases-examples.md) # Création et utilisation d'alias de configuration avec MediaTailor Avant de commencer à utiliser des variables de domaine, vous devez créer des alias de configuration pour votre configuration. Vous utilisez les alias de configuration comme variables de remplacement de domaine au moment de l'initialisation de la session. **Restrictions** Notez les restrictions suivantes lorsque vous utilisez des alias de configuration : + Toutes les variables dynamiques utilisées dans le domaine doivent être définies en tant que variables `ConfigurationAliases` dynamiques. + Les variables des paramètres du joueur doivent être préfixées par`player_params.`. Par exemple, `player_params.origin_domain`. + La liste des valeurs aliasées doit être exhaustive pour les variables de domaine dans critical URLs (`VideoContentSourceUrl`,`AdSegmentUrlPrefix`,`ContentSegmentUrlPrefix`). + Si une demande est faite pour une variable de domaine critique URLs qui ne spécifie pas la variable dynamique ou utilise un alias non valide, la demande échouera avec un code d'`400`état HTTP. Les champs non critiques (`SlateAdUrl`,`TranscodeProfileName`, bumper URLs) enregistreront les avertissements mais ne feront pas échouer la demande. **Comportement de secours en cas d'alias manquants** Lorsque les alias de configuration sont introuvables ou ne sont pas valides, MediaTailor implémente le comportement de secours suivant : + **Variables de domaine :** si un alias de variable de domaine est manquant ou non valide, la demande échoue avec le code d'état HTTP 400. Des alias valides doivent être définis pour toutes les variables de domaine. + **Variables non liées au domaine :** pour les variables utilisées dans des parties non liées au domaine de URLs (telles que les éléments de chemin ou les paramètres de requête), les alias manquants entraînent le remplacement de chaînes vides. + **Validation de la configuration :** MediaTailor vérifie que tous les alias requis sont présents lors des opérations de création et de mise à jour de la configuration. ## Étape 1 : créer des alias de configuration Pour créer des alias de configuration à utiliser pour le remplacement de domaines à l'aide de la MediaTailor console, effectuez la procédure suivante. ------ #### [ Console ] **Pour créer des alias de configuration à l'aide de la console** 1. Ouvrez la MediaTailor console à l'adresse [https://console.aws.amazon.com/mediatailor/](https://console.aws.amazon.com/mediatailor/). 1. Dans la section **Alias de configuration** de la page **Configurations**, choisissez **Ajouter un paramètre de joueur**. 1. Dans **Paramètre du joueur**, entrez le nom du paramètre du joueur que vous souhaitez utiliser comme variable dynamique. Par exemple, `player_params.origin_domain`. 1. **Dans Alias**, entrez les alias et leurs valeurs que vous souhaitez utiliser pour le paramètre du joueur. 1. Choisissez **OK**. AWS Elemental MediaTailor affiche le nouveau paramètre dans le tableau de la section **Alias de configuration**. 1. Répétez les étapes précédentes pour ajouter d'autres paramètres au joueur. 1. Choisissez **Enregistrer**. ------ #### [ API ] **Pour créer des alias de configuration à l'aide de l'API** Lorsque vous créez ou mettez à jour une MediaTailor configuration, utilisez le `ConfigurationAliases` paramètre avec la structure JSON suivante : ``` { "ConfigurationAliases": { "player_params.origin_domain": { "pdx": "abc.mediapackage.us-west-2.amazonaws.com", "iad": "xyz.mediapackage.us-east-1.amazonaws.com" }, "player_params.ad_type": { "customized": "abc12345", "default": "defaultAdType" } } } ``` ------ ## Étape 2 : Utiliser des alias de configuration lors de l'initialisation de session Après avoir configuré les alias de configuration, vous pouvez les utiliser comme variables de remplacement pour les domaines dans votre demande d'initialisation de session. Cela vous permet de configurer dynamiquement les domaines de votre session. **Example Exemple d'alias de configuration de base** Voici un exemple de configuration de base qui inclut des alias de configuration et des variables de domaine dynamiques : ``` PUT /playbackConfiguration { "Name": "aliasedConfig", "AdDecisionServerUrl": "https://abc.execute-api.us-west-2.amazonaws.com/ads?sid=[session.id]&ad_type=[player_params.ad_type]", "VideoContentSourceUrl": "https://[player_params.origin_domain].mediapackage.[player_params.region].amazonaws.com/out/v1/[player_params.endpoint_id]", "ConfigurationAliases": { "player_params.origin_domain": { "pdx": "abc", "iad": "xyz" }, "player_params.region": { "pdx": "us-west-2", "iad": "us-east-1" }, "player_params.endpoint_id": { "pdx": "abcd", "iad": "wxyz" }, "player_params.ad_type": { "customized": "abc12345", "default": "defaultAdType" } } } ``` **Example Initialisation de session avec des alias** En utilisant la configuration précédente, une demande d'initialisation de session utilisant les variables et les alias du lecteur ressemblerait à ce qui suit : ``` POST index.m3u8 { "playerParams": { "origin_domain": "pdx", "region": "pdx", "endpoint_id": "pdx", "ad_type": "customized" } } ``` MediaTailor remplace les chaînes d'alias par les valeurs mappées dans la configuration des alias de configuration. La demande adressée à l'ADS ressemblera à ce qui suit : ``` https://abc.execute-api.us-west-2.amazonaws.com/ads?sid=[session.id]&ad_type=abc12345 ``` La demande adressée à l'origine pour les manifestes ressemblera à ce qui suit : ``` https://abc.mediapackage.us-west-2.amazonaws.com/out/v1/abcd ``` # Alias de configuration avec exemple MediaTailor d'utilisation Les exemples suivants illustrent une MediaTailor configuration complète avec des alias de configuration, une demande d'initialisation de session avec des alias et le flux de traitement des alias. **Example Configuration complète avec alias** L'exemple suivant montre une configuration complète qui inclut des alias de configuration et des variables de domaine dynamiques : ``` PUT /playbackConfiguration { "Name": "aliasedConfig", "AdDecisionServerUrl": "https://abc.execute-api.us-west-2.amazonaws.com/ads?sid=[session.id]&ad_type=[player_params.ad_type]", "VideoContentSourceUrl": "https://[player_params.origin_domain].mediapackage.[player_params.region].amazonaws.com/out/v1/[player_params.endpoint_id]", "AdSegmentUrlPrefix": "https://[player_params.ad_cdn_domain]/ads/", "ContentSegmentUrlPrefix": "https://[player_params.content_cdn_domain]/content/", "TranscodeProfileName": "[player_params.transcode_profile]", "SlateAdUrl": "https://[player_params.slate_domain]/slate/[player_params.slate_type].mp4", "StartUrl": "https://[player_params.tracking_domain]/start?session=[session.id]", "EndUrl": "https://[player_params.tracking_domain]/end?session=[session.id]", "ConfigurationAliases": { "player_params.origin_domain": { "pdx": "abc", "iad": "xyz" }, "player_params.region": { "pdx": "us-west-2", "iad": "us-east-1" }, "player_params.endpoint_id": { "pdx": "abcd", "iad": "wxyz" }, "player_params.ad_type": { "customized": "abc12345", "default": "defaultAdType" }, "player_params.ad_cdn_domain": { "pdx": "ads-west.cdn.example.com", "iad": "ads-east.cdn.example.com" }, "player_params.content_cdn_domain": { "pdx": "content-west.cdn.example.com", "iad": "content-east.cdn.example.com" }, "player_params.transcode_profile": { "mobile": "mobile_optimized", "desktop": "high_quality", "tv": "4k_profile" }, "player_params.slate_domain": { "pdx": "slate-west.example.com", "iad": "slate-east.example.com" }, "player_params.slate_type": { "standard": "default_slate", "branded": "brand_slate" }, "player_params.tracking_domain": { "pdx": "tracking-west.example.com", "iad": "tracking-east.example.com" } } } ``` **Example Initialisation de session avec des alias** L'exemple suivant montre une demande d'initialisation de session qui spécifie les variables et alias du joueur : ``` POST master.m3u8 { "playerParams": { "origin_domain": "pdx", "region": "pdx", "endpoint_id": "pdx", "ad_type": "customized", "ad_cdn_domain": "pdx", "content_cdn_domain": "pdx", "transcode_profile": "mobile", "slate_domain": "pdx", "slate_type": "branded", "tracking_domain": "pdx" } } ``` **Example Flux de traitement des paramètres** Dans l'exemple suivant, MediaTailor remplace les chaînes d'alias par les valeurs mappées dans les alias de configuration. Le traitement donne lieu aux demandes suivantes : + Demande ADS : ``` https://abc.execute-api.us-west-2.amazonaws.com/ads?sid=[session.id]&ad_type=abc12345 ``` + VideoContentSource demande : ``` https://abc.mediapackage.us-west-2.amazonaws.com/out/v1/abcd ``` + AdSegmentUrlPrefix: ``` https://ads-west.cdn.example.com/ads/ ``` + ContentSegmentUrlPrefix: ``` https://content-west.cdn.example.com/content/ ``` + TranscodeProfileName: ``` mobile_optimized ``` + SlateAdUrl: ``` https://slate-west.example.com/slate/brand_slate.mp4 ``` + StartUrl: ``` https://tracking-west.example.com/start?session=[session.id] ``` + EndUrl: ``` https://tracking-west.example.com/end?session=[session.id] ``` # MediaTailor transmission de paramètres à ADS AWS Elemental MediaTailor prend en charge la configuration de variables dynamiques dans les MediaTailor demandes adressées à l'ADS en suivant les étapes suivantes. + Pour plus d'informations sur le formatage pris en charge pour les paramètres de requête, consultez[MediaTailor référence et limites des paramètres](parameter-comprehensive-reference.md). + Pour les alias de configuration et les variables de domaine, consultez[MediaTailor vue d'ensemble des alias de configuration](configuration-aliases-overview.md). + Pour des personnalisations supplémentaires de la demande ADS, voir[Utilisation avancée](#variables-advanced-usage). **Méthodes d'initialisation de session** MediaTailor prend en charge plusieurs méthodes d'initialisation de session et de transmission de paramètres : 1. **POST avec le corps de la requête :** ``` POST .m3u8 { "adsParams": {"param1": "value1", "param2": "value2"}, "playerParams": {"param3": "value3"} } ``` 1. **Paramètres de requête dans l'URL :** ``` GET .m3u8?ads.param1=value1&ads.param2=value2&playerParams.param3=value3 ``` **Important** Vous ne pouvez spécifier les paramètres qu'une seule fois, au moment de l'initialisation. Les alias de configuration sont résolus en valeurs réelles avant le transfert. **Pour transmettre les informations de session et de lecteur au serveur ADS** 1. Collaborez avec l'ADS pour déterminer les informations dont il a besoin pour répondre à une requête publicitaire provenant de celui-ci AWS Elemental MediaTailor. 1. Créez une configuration MediaTailor qui utilise un modèle d'URL de demande ADS qui répond aux exigences ADS. Dans l'URL, incluez les paramètres statiques et les espaces réservés correspondant aux paramètres dynamiques. Entrez l'URL de votre modèle dans le champ **Ad decision server (Serveur ADS)** de la configuration. Dans l'exemple suivant d'URL du modèle `correlation` fournit les données de session et `deviceType` fournit des données de lecteur : ``` https://my.ads.server.com/path?correlation=[session.id]&deviceType=[player_params.deviceType] ``` 1. Sur le joueur, configurez la demande d'initiation de session pour que AWS Elemental MediaTailor fournisse les paramètres pour les données de lecteur. Incluez vos paramètres dans la demande d'initiation de session et omettez-les des demandes suivantes pour la session. Le type d'appel effectué par le joueur pour initialiser la session détermine si le joueur (client) ou MediaTailor (serveur) fournit des rapports de suivi publicitaire pour la session. Pour plus d'informations sur ces deux options, consultez la section [Signalement des données de suivi et](ad-reporting.md). Effectuez l'une des types suivants d'appels, selon que vous voulez un rapport de suivi publicitaire côté serveur ou côté client. Dans les deux exemples d'appels, `userID` est destiné au serveur ADS et `auth_token` à l'origine : + (Option) Demandez des rapports de suivi des publicités côté serveur — Préfixez les paramètres que vous souhaitez envoyer MediaTailor à l'ADS. `ads` Conservez le préfixe désactivé pour les paramètres que MediaTailor doit envoyer au serveur d'origine : Les exemples suivants montrent les demandes entrantes adressées à HLS et DASH à AWS Elemental MediaTailor. MediaTailor utilise le `deviceType` dans sa demande à l'ADS et `auth_token` dans sa demande au serveur d'origine. Exemple HLS : ``` GET master.m3u8?ads.deviceType=ipad&auth_token=kjhdsaf7gh ``` Exemple DASH : ``` GET manifest.mpd?ads.deviceType=ipad&auth_token=kjhdsaf7gh ``` + (Option) Demandez des rapports de suivi des publicités côté client — Fournissez les paramètres de l'ADS à l'intérieur d'un objet. `adsParams` Exemple HLS : ``` POST master.m3u8 { "adsParams": { "deviceType": "ipad" } } ``` Exemple DASH : ``` POST manifest.mpd { "adsParams": { "deviceType": "ipad" } } ``` Lorsque le joueur lance une session, il AWS Elemental MediaTailor remplace les variables du modèle d'URL de demande ADS par les données de session et les `ads` paramètres du joueur. Il transmet les paramètres restants du lecteur au serveur d'origine. **Example MediaTailor demandes avec variables publicitaires** Les exemples suivants illustrent les appels à l'ADS et au serveur d'origine provenant d' AWS Elemental MediaTailor qui correspondent aux exemples d'appel d'initialisation de session de lecteur précédents : + MediaTailor appelle l'ADS avec les données de session et le type d'appareil du joueur : ``` https://my.ads.server.com/path?correlation=896976764&deviceType=ipad ``` + MediaTailor appelle le serveur d'origine avec le jeton d'autorisation du joueur. + Exemple HLS : ``` https://my.origin.server.com/master.m3u8?auth_token=kjhdsaf7gh ``` + Exemple DASH : ``` https://my.origin.server.com/manifest.mpd?auth_token=kjhdsaf7gh ``` ## Utilisation avancée Vous pouvez personnaliser la demande ADS de multiples façons avec les données du lecteur et les données de session. Il vous suffit d'inclure le nom d'hôte ADS. Les exemples suivants illustrent certaines façons de personnaliser votre demande : + Concaténez les paramètres du lecteur et les paramètres de session pour créer de nouveaux paramètres. Exemple : ``` https://my.ads.com?key1=[player_params.value1][session.id] ``` + Utilisez un paramètre du lecteur comme partie intégrante d'un élément du chemin. Exemple : ``` https://my.ads.com/[player_params.path]?key=value ``` + Utilisez les paramètres du lecteur pour transmettre les éléments du chemin d'accès et les clés elles-mêmes, plutôt que les seules valeurs. Exemple : ``` https://my.ads.com/[player_params.path]?[player_params.key1]=[player_params.value1] ``` # MediaTailor routage des paramètres pour ADS et origines AWS Elemental MediaTailor achemine les paramètres de requête vers différentes destinations en fonction de leur préfixe et de leur objectif. Comprendre le routage des paramètres est essentiel pour implémenter des fonctionnalités spécifiques à l'origine, telles que la visualisation décalée dans le temps avec. MediaPackage **Règles de routage des paramètres** MediaTailor utilise les règles de routage suivantes pour les paramètres de requête : + **Paramètres d'origine (pas de préfixe) :** les paramètres sans préfixe spécifique sont transmis au serveur d'origine pour des fonctionnalités spécifiques à l'origine + **Paramètres ADS (`ads.`préfixe) :** les paramètres préfixés par `ads.` sont envoyés au serveur Ad Decision + **Paramètres du manifeste (`manifest.`préfixe) :** les paramètres préfixés par `manifest.` sont utilisés pour le routage et l'autorisation du CDN **Example Exemple de routage de paramètres** L'initialisation de session suivante illustre le routage des paramètres : ``` POST /v1/session/123456789/originId/index.m3u8 { "adsParams": { "param1": "value1", "param2": "value2" }, "manifestParams": { "auth_token": "abc123" } } ``` Dans cet exemple : + `param1`et `param2` sont envoyés à l'ADS + `auth_token`est utilisé pour le routage et l'autorisation du CDN + Les paramètres sans préfixes seraient transmis au serveur d'origine ## Comportement des paramètres du serveur Origin Les paramètres transmis aux serveurs d'origine activent des fonctionnalités spécifiques à l'origine, telles que l'affichage décalé dans le temps, le filtrage du contenu et l'authentification. **Cas d'utilisation courants des paramètres d'origine** Les paramètres d'origine sont couramment utilisés pour : + **Affichage décalé dans le temps :** `start` et `end` paramètres pour le contenu décalé MediaPackage dans le temps + **Authentification du contenu :** jetons d'authentification requis par le serveur d'origine + **Filtrage du contenu :** paramètres qui contrôlent les variantes de contenu renvoyées + **Fonctionnalités spécifiques à l'origine :** tous les paramètres utilisés par le serveur d'origine pour le traitement du contenu **Important** Les paramètres sont traités lors de l'initialisation de la session et conservés tout au long de la session. Pour modifier des paramètres tels que les fenêtres de décalage temporel, vous devez créer une nouvelle session avec des valeurs mises à jour. # MediaTailor et intégration de la visualisation MediaPackage décalée dans le temps AWS Elemental MediaTailor peut transmettre des paramètres d'affichage décalés dans le temps aux MediaPackage origines pour activer les fonctionnalités de visualisation de démarrage et de rattrapage. Cette intégration permet aux spectateurs de commencer à regarder du contenu en direct à des moments antérieurs. **MediaPackage paramètres de visualisation décalés dans le temps** MediaPackage prend en charge les paramètres d'affichage décalés dans le temps suivants qui peuvent être transmis MediaTailor : + `start`: Epoch ou horodatage ISO 8601 définissant le début du manifeste décalé dans le temps + `end`: horodatage Epoch ou ISO 8601 définissant la fin du manifeste décalé dans le temps + `time_delay`: retarde la disponibilité du contenu de quelques secondes + `manifest_window_seconds`: demande un manifeste plus court que la fenêtre configurée **Example MediaTailor initialisation de session avec paramètres décalés MediaPackage dans le temps** L'exemple suivant montre comment initialiser une session avec des paramètres d'affichage décalés dans le temps : ``` GET /v1/master/123456789/originId/index.m3u8?start=2024-08-26T10:00:00Z&end=2024-08-26T11:00:00Z ``` Ou en utilisant une initialisation de session explicite : ``` POST /v1/session/123456789/originId/index.m3u8 { "adsParams": { "param1": "value1" } } ``` Avec des paramètres de requête supplémentaires : ``` ?start=2024-08-26T10:00:00Z&end=2024-08-26T11:00:00Z ``` **Comportement des paramètres pendant les sessions** Les paramètres de visualisation décalés dans le temps présentent des caractéristiques de comportement spécifiques : + **Initialisation de session :** les paramètres sont traités lors de la création de la session + **Persistance des paramètres :** les paramètres restent associés à la session pendant toute la durée de la lecture + **Immuable après l'initialisation :** les paramètres ne peuvent pas être modifiés pendant une session active + **Nouvelle session requise :** pour modifier les fenêtres de décalage horaire, créez une nouvelle session avec des valeurs de paramètres mises à jour **MediaPackage exigences relatives à la fenêtre de démarrage** Pour que l'affichage décalé dans le temps fonctionne MediaPackage, assurez-vous de ce qui suit : 1. Configurez une fenêtre de démarrage sur votre MediaPackage terminal (jusqu'à 24 heures) 1. Assurez-vous que votre CDN transmet les paramètres de requête nécessaires à MediaPackage 1. Utilisez des fenêtres de lecture cohérentes entre les sessions de lecteur pour une meilleure mise en cache du CDN 1. Vérifiez que les heures de début et de fin se situent dans la fenêtre de démarrage configurée **Important** Lorsque vous utilisez l'affichage décalé dans le temps, utilisez des fenêtres de lecture cohérentes entre les sessions de lecteur plutôt que de générer des heures de début ou de fin uniques pour chaque spectateur. Cela permet une meilleure mise en cache sur le CDN et évite un éventuel ralentissement. Pour des informations complètes sur la configuration et les paramètres de l'affichage MediaPackage décalé dans le temps, voir [Affichage décalé](https://docs.aws.amazon.com/mediapackage/latest/ug/time-shifted.html) dans le temps AWS Elemental MediaPackage dans le guide de l'*AWS Elemental MediaPackage utilisateur*. # MediaTailor comportement et persistance de la session de paramètres AWS Elemental MediaTailor traite les paramètres lors de l'initialisation de la session et les gère tout au long du cycle de vie de la session. Il est essentiel de comprendre le comportement des sessions pour implémenter des scénarios de paramètres dynamiques. **Méthodes d'initialisation de session** MediaTailor prend en charge plusieurs méthodes d'initialisation de session avec des paramètres : 1. **Initialisation implicite de session :** paramètres inclus dans la demande de manifeste initiale ``` GET /v1/master/123456789/originId/index.m3u8?manifest.auth_token=abc123&start=2024-08-26T10:00:00Z ``` 1. **Initialisation explicite de session (POST) :** paramètres fournis dans le corps de la requête ``` POST /v1/session/123456789/originId/index.m3u8 { "adsParams": {"param1": "value1"}, "manifestParams": {"auth_token": "abc123"} } ``` 1. **Initialisation explicite de session (GET) :** paramètres fournis sous forme de paramètres de requête ``` GET /v1/session/123456789/originId/index.m3u8?ads.param1=value1&manifestParams.auth_token=abc123 ``` **Persistance et immuabilité des paramètres** MediaTailor le comportement des paramètres suit les règles suivantes : + **Spécification unique :** les paramètres ne peuvent être spécifiés qu'une seule fois, lors de l'initialisation de la session + **Persistance à l'échelle de la session :** les paramètres sont conservés tout au long de la session + **Immuable après l'initialisation :** les paramètres ne peuvent pas être modifiés après la création de la session + **Résolution des alias de configuration :** les alias sont résolus à leurs valeurs réelles avant d'être transférés vers les destinations **Scénarios de modification de paramètres** Pour modifier les paramètres pendant la lecture : + **Créer une nouvelle session :** initialise une nouvelle session avec des valeurs de paramètres mises à jour + **Transition de joueur :** faites passer facilement le joueur à la nouvelle session + **Héritage des paramètres :** reportez les paramètres inchangés pour maintenir la cohérence **Example Modification des paramètres de décalage horaire** Pour passer d'une fenêtre d'une heure à une fenêtre de 2 heures : 1. Session en cours : `start=2024-08-26T10:00:00Z&end=2024-08-26T11:00:00Z` 1. Créez une nouvelle session : `start=2024-08-26T10:00:00Z&end=2024-08-26T12:00:00Z` 1. Faire passer le lecteur à l'URL de la nouvelle session **Important** Plusieurs demandes de playlist multivariantes pour une même session ne mettent pas à jour les paramètres après la première demande. Les paramètres restent immuables pendant toute la durée de la session. # MediaTailor référence et limites des paramètres Avant de configurer des variables publicitaires dynamiques, prenez connaissance des exigences et des limites de mise en forme des paramètres qui s'appliquent à toutes les MediaTailor configurations. AWS Elemental MediaTailor fournit des informations complètes sur les restrictions de caractères des paramètres, les limites de longueur et les formats pris en charge pour les paramètres de requête du manifeste et les paramètres ADS. ## Restrictions relatives aux caractères des paramètres de requête manifeste Les paramètres de requête du manifeste prennent en charge des caractères spécifiques et ont des limites de longueur définies. **Caractères pris en charge (sans codage d'URL)** Vous pouvez utiliser les caractères suivants directement dans les paramètres de requête du manifeste : + Caractères alphanumériques (A-Z, a-z, 0-9) + Périodes (.) + Tirets (-) + Soulignements (\$1) + Barres obliques inversées (\$1) **Caractères pris en charge avec encodage URL** Les caractères spéciaux suivants sont pris en charge lorsqu'ils sont codés en URL : + période (.) = %2E + tiret (-) = %2D + trait de soulignement (\$1) = %5F + pourcentage (%) = %25 + tilde (\$1) = %7E + barre oblique (/) = %2F + astérisque (\$1) = %2A + est égal à (=) = %3D + une question (?) = 3 %F **Support du codage d'URL** MediaTailor prend en charge le signe du pourcentage (%) lorsque vous l'utilisez dans le codage d'URL (par exemple, hello%20world = hello world). Vous pouvez utiliser n'importe quel caractère codé en URL, à condition qu'il s'agisse d'encodages d'URL valides conformément à la spécification HTTP. **Personnages non pris en charge** Vous ne pouvez pas utiliser les caractères suivants dans les paramètres de requête du manifeste sans codage URL :`:`,`?`,,`&`, `=``%`, `/` (barre oblique). **Important** MediaTailor ne prend pas en charge les caractères doubles tels que%%% ou ==. Vous ne pouvez pas utiliser la valeur complète URLs comme valeur de paramètre de requête manifeste en raison des restrictions de caractères. **Limites de longueur** La longueur totale de tous les paramètres de requête du manifeste (clés et valeurs combinées) ne doit pas dépasser 2 000 caractères. ## Limites de longueur des paramètres ADS Les limites de longueur suivantes s'appliquent aux paramètres utilisés dans les demandes adressées à l'ADS : + **Nom du paramètre ADS** : 10 000 caractères maximum + **Valeur du paramètre ADS** : 25 000 caractères maximum + **URL ADS** : 25 000 caractères maximum # MediaTailor guide de résolution des problèmes de paramètres AWS Elemental MediaTailor fournit des conseils pour résoudre les problèmes courants liés aux paramètres, notamment les restrictions de caractères MediaTailor, les problèmes d'encodage d'URL et les erreurs d'alias de configuration. ## Erreurs de restriction de caractères Les valeurs de paramètres contenant des caractères non pris en charge peuvent provoquer des erreurs ou des comportements inattendus. **Symptômes courants** Les symptômes suivants peuvent indiquer des problèmes de restriction de caractères : + Les paramètres n'apparaissent pas dans le manifeste URLs + Erreurs HTTP 400 lors de l'initialisation de la session + Valeurs de paramètres tronquées ou endommagées + Les requêtes ADS échouent en raison d'une malformation URLs **Étapes de résolution** Pour résoudre les erreurs de restriction de caractères : 1. Vérifiez les valeurs des paramètres pour les caractères non pris en charge : `:``?`,`&`,,`=`, `%` `/` 1. Appliquez un codage URL approprié pour les caractères spéciaux (voir) [MediaTailor référence et limites des paramètres](parameter-comprehensive-reference.md) 1. Évitez les caractères doubles tels que `%%%` ou `==` 1. Envisagez d'autres formats de paramètres si la version complète URLs ne peut pas être utilisée **Example Exemple de codage d'URL** Au lieu d'utiliser : ``` manifest.redirect_url=https://example.com/path?param=value ``` Utilisez un format URL codé : ``` manifest.redirect_url=https%3A%2F%2Fexample.com%2Fpath%3Fparam%3Dvalue ``` ## Erreurs de limitation de longueur Les paramètres qui dépassent les limites de longueur peuvent être tronqués ou provoquer des erreurs. **Limites de longueur** Les limites de longueur suivantes s'appliquent (voir [MediaTailor référence et limites des paramètres](parameter-comprehensive-reference.md) pour plus de détails) : + Paramètres de requête du manifeste (total) : 2 000 caractères + noms des paramètres ADS : 10 000 caractères + Valeurs des paramètres ADS : 25 000 caractères + ADS URLs : 25.000 lettres **Stratégies de résolution** Pour gérer les limites de longueur : 1. Utilisez des noms et des valeurs de paramètres plus courts dans la mesure du possible 1. Divisez les grandes valeurs de paramètres en plusieurs paramètres plus petits 1. Utilisez des alias de configuration pour associer des alias courts à des valeurs plus longues (voir) [MediaTailor vue d'ensemble des alias de configuration](configuration-aliases-overview.md) 1. Envisagez d'utiliser un stockage externe pour les données volumineuses avec des références de paramètres ## Erreurs liées aux alias de configuration Les problèmes d'alias de configuration peuvent entraîner des erreurs HTTP 400 ou des valeurs de paramètres inattendues. **Erreurs d'alias de configuration courantes** Les erreurs suivantes se produisent fréquemment avec les alias de configuration : + Erreur HTTP 400 : valeur d'alias manquante ou non valide + Les variables de domaine ne sont pas résolues correctement + Les paramètres du joueur ne sont pas remplacés par des valeurs d'alias **Liste de contrôle de résolution** Pour résoudre les erreurs liées aux alias de configuration : 1. Vérifiez que toutes les variables de domaine sont définies comme `ConfigurationAliases` 1. Assurez-vous que les variables des paramètres du joueur utilisent un `player_params.` préfixe 1. Vérifiez que la liste des valeurs aliasées est exhaustive pour les variables de domaine dans critical URLs (`VideoContentSourceUrl`,`AdSegmentUrlPrefix`,`ContentSegmentUrlPrefix`) 1. Vérifiez que les demandes d'initialisation de session spécifient des valeurs d'alias valides 1. Valider la structure JSON du ConfigurationAliases paramètre Pour obtenir des conseils de dépannage détaillés, consultez[MediaTailor guide de résolution des problèmes liés aux alias de configuration](configuration-aliases-troubleshooting.md). **Example Validation des alias de configuration** Assurez-vous que votre configuration inclut tous les alias requis : ``` "ConfigurationAliases": { "player_params.origin_domain": { "pdx": "abc.mediapackage.us-west-2.amazonaws.com", "iad": "xyz.mediapackage.us-east-1.amazonaws.com" // Must include all possible values used in session initialization } } ``` ## Problèmes de flux de traitement des paramètres La compréhension du flux de traitement des paramètres permet de résoudre les problèmes liés au transfert et à la transformation des paramètres. **Ordre de traitement des paramètres** MediaTailor traite les paramètres dans l'ordre suivant : 1. Validation des paramètres d'initialisation de session 1. Résolution des alias de configuration (le cas échéant) 1. Filtrage des paramètres (ADS vs origine vs manifeste) 1. Encodage et formatage d'URL 1. Application de paramètres à URLs **Flux de paramètres de débogage** Pour résoudre les problèmes de traitement des paramètres : 1. Vérifiez que les paramètres sont correctement spécifiés lors de l'initialisation de la session 1. Vérifiez que les alias de configuration correspondent aux valeurs attendues 1. Vérifiez que les paramètres apparaissent correctement URLs (manifeste, ADS, origine) 1. Valider que le codage de l'URL est correctement appliqué **Example Exemple de flux de paramètres** Initialisation de la session : ``` POST master.m3u8 { "playerParams": {"origin_domain": "pdx"}, "manifestParams": {"test": "123"} } ``` Après la résolution et le traitement des alias : + Demande d'origine : `https://abc.mediapackage.us-west-2.amazonaws.com/out/v1/abcd` + URL du manifeste : `/v1/master/.../index.m3u8?aws.sessionId=session&test=123` ## Considérations sur la sécurité et bonnes pratiques en la matière MediaTailor met en œuvre des mesures de sécurité pour la gestion des paramètres afin de prévenir les problèmes de sécurité courants. **Mesures de sécurité** MediaTailor met en œuvre les mesures de sécurité suivantes : 1. Limitations de taille d'entrée pour éviter le gonflement de la base de données 1. Encodage et nettoyage appropriés des entrées utilisateur 1. Encodage URL de l'entrée pour empêcher la corruption de la réponse **Bonnes pratiques** Suivez les meilleures pratiques suivantes pour une gestion sécurisée des paramètres : + Valider les valeurs des paramètres côté client avant de les envoyer + Utiliser des alias de configuration pour limiter les valeurs de paramètres possibles + Évitez d'inclure des informations sensibles dans les paramètres + Surveillez l'utilisation des paramètres pour détecter les modèles inhabituels + Maintenir les valeurs des paramètres dans les limites de longueur recommandées # MediaTailor guide de résolution des problèmes liés aux alias de configuration AWS Elemental MediaTailor fournit des conseils de dépannage systématiques pour les problèmes d'alias de configuration courants et les scénarios d'erreur. ## Erreurs de validation des alias de configuration Lorsque les alias de configuration sont manquants ou non valides, MediaTailor renvoie des réponses d'erreur spécifiques pour aider à identifier le problème. **Scénarios d'erreur courants** Le tableau suivant décrit les erreurs d'alias de configuration courantes et leurs étapes de résolution : | Erreur | Cause | Résolution | | --- | --- | --- | | HTTP 400 : alias de paramètre de joueur non valide | La valeur du paramètre du joueur est introuvable dans ConfigurationAliases | Vérifiez que la valeur du paramètre du joueur existe sous forme de clé dans le ConfigurationAliases mappage correspondant | | HTTP 400 : alias de configuration requis manquant | Variable de domaine utilisée sans ConfigurationAliases entrée correspondante | Ajoutez le paramètre de joueur manquant à tous ConfigurationAliases les mappages d'alias requis | | HTTP 400 : échec de la validation de la configuration | ConfigurationAliases la structure est mal formée ou incomplète | Validez la structure JSON et assurez-vous que toutes les variables de domaine ont des alias correspondants | | Remplacement d'une chaîne vide dans URLs | Alias de variable autre que le domaine introuvable | Ajoutez un mappage d'alias manquant ou fournissez une valeur par défaut dans ConfigurationAliases | **Liste de contrôle pour la validation** Utilisez la liste de contrôle suivante pour valider la configuration de vos alias de configuration : 1. **Couverture des variables de domaine :** assurez-vous que toutes les variables utilisées dans les parties du domaine URLs ont des ConfigurationAliases entrées correspondantes 1. **Exhaustivité des alias :** vérifiez que toutes les valeurs possibles des paramètres du joueur sont incluses sous forme de clés dans les mappages d'alias 1. **Structure JSON :** vérifiez que le ConfigurationAliases JSON est correctement formaté et imbriqué 1. **Dénomination des paramètres :** vérifiez que tous les paramètres du joueur utilisent le `player_params.` préfixe 1. **Cohérence des valeurs :** assurez-vous que les valeurs des alias sont valides pour l'usage auquel elles sont destinées (noms de profilURLs, etc.) ## Résolution des alias de configuration de débogage Suivez cette approche systématique pour résoudre les problèmes de résolution des alias de configuration. **Step-by-step méthodologie de débogage** Procédez comme suit pour identifier et résoudre les problèmes liés aux alias de configuration : **Procédure de débogage des alias de configuration** 1. **Vérifiez la structure de configuration :** vérifiez que votre configuration de lecture inclut un formatage correct ConfigurationAliases ``` { "ConfigurationAliases": { "player_params.example_param": { "alias1": "value1", "alias2": "value2" } } } ``` 1. **Vérifiez le format des paramètres du lecteur :** assurez-vous que l'initialisation de la session inclut les paramètres du lecteur correctement formatés ``` { "playerParams": { "example_param": "alias1" } } ``` 1. **Valider le mappage des alias :** vérifiez que la valeur du paramètre du joueur (« alias1 ») existe sous forme de clé dans le mappage ConfigurationAliases 1. **Test avec une configuration simple :** commencez par une configuration minimale pour isoler le problème 1. **Surveiller les réponses aux erreurs :** vérifiez les réponses aux MediaTailor erreurs pour des messages de validation spécifiques 1. **Vérifier la résolution URLs :** confirmez que les résolutions finales URLs sont valides et accessibles ## Meilleures pratiques en matière d'alias de configuration Suivez ces bonnes pratiques pour garantir une implémentation fiable des alias de configuration. **Considérations sur la sécurité** Mettez en œuvre les mesures de sécurité suivantes lorsque vous utilisez des alias de configuration : + **Validation des entrées :** validez toutes les valeurs des paramètres du joueur avant de les utiliser dans la résolution des alias + Nettoyage des **valeurs d'alias :** assurez-vous que les valeurs d'alias contiennent uniquement les caractères et les formats attendus + **Restrictions de domaine :** limitez les alias de domaine aux domaines fiables et contrôlés + **Contrôle d'accès :** limiter les modifications de configuration au personnel autorisé uniquement **Optimisation des performances** Optimisez les performances des alias de configuration à l'aide des recommandations suivantes : + **Minimiser le nombre d'alias :** utilisez uniquement les alias nécessaires pour réduire la charge de traitement + **Nommage efficace :** utilisez des conventions de dénomination claires et cohérentes pour les alias et les paramètres + **Valeurs par défaut :** fournissez des alias par défaut adaptés aux cas d'utilisation courants + **Mise en cache de configuration :** Tirez parti MediaTailor de la mise en cache de configuration pour améliorer les performances **Maintenance et surveillance** Maintenez des opérations d'alias de configuration fiables grâce aux pratiques suivantes : + **Validation régulière :** vérifiez régulièrement que tous les mappages d'alias sont à jour et fonctionnels + **Surveillance des erreurs :** surveillez les erreurs HTTP 400 liées à des alias manquants ou non valides + **Documentation :** Conservez une documentation claire de tous les mappages d'alias et de leurs objectifs + **Procédures de test :** mise en œuvre de tests complets pour toutes les combinaisons d'alias