Création d'un segment similaire

Pour créer un segment similaire dans AWS Clean Rooms

1. Connectez-vous au Console de gestion AWS et ouvrez la AWS Clean Rooms console avec votre Compte AWS (si ce n'est pas encore fait).

2. Dans le volet de navigation de gauche, choisissez Collaborations.

3. Dans l'onglet Avec un abonnement actif, choisissez une collaboration.

4. Dans l'onglet ML Models, choisissez Créer un segment similaire.

5. Sur la page Créer un segment similaire, pour Modèle similaire configuré associé, choisissez le modèle similaire configuré associé à utiliser pour ce segment similaire.

6. Pour les détails du segment Lookalike, entrez un nom et une description facultative.

7. Pour les profils Seed, choisissez votre méthode Seed en sélectionnant une option, puis en effectuant l'action recommandée.

   Option	Action recommandée
   Parcours Amazon S3	Sélectionnez un emplacement Amazon S3. (Facultatif) Choisissez Inclure les profils de départ dans la sortie.
   Requête SQL	Écrivez une requête SQL et utilisez ses résultats comme données de départ.
   Modèle d'analyse	Choisissez un modèle d'analyse dans la liste déroulante et utilisez les résultats créés par un modèle d'analyse.

8. Choisissez le type de travailleur à utiliser lors de la création de cette source de données. Le type de travailleur par défaut est CR.1X. Spécifiez le nombre de travailleurs à utiliser. La valeur par défaut est le travailleur numéro 16. Pour spécifier les propriétés de Spark  :

   1. Développez les propriétés Spark.

   2. Choisissez Ajouter des propriétés Spark.

   3. Dans la boîte de dialogue des propriétés de Spark, choisissez un nom de propriété dans la liste déroulante et entrez une valeur.

   Les tableaux suivants fournissent une définition pour chaque propriété.

   Pour plus d'informations sur les propriétés de Spark, consultez la section Propriétés de Spark dans la documentation d'Apache Spark.

   Note

   Vous pouvez configurer un maximum de 50 propriétés Spark. Chaque valeur de propriété peut comporter jusqu'à 500 caractères.

   Nom de propriété	Description	Valeur par défaut
   Échecs de Spark.Task.Max	Contrôle le nombre de fois consécutives qu'une tâche peut échouer avant que la tâche échoue. Nécessite une valeur supérieure ou égale à 1. Le nombre de nouvelles tentatives autorisées est égal à cette valeur moins 1. Le nombre d'échecs est réinitialisé en cas de réussite d'une tentative. Les échecs liés à différentes tâches ne s'accumulent pas au-delà de cette limite.	4
   spark.sql.files.max PartitionBytes	Définit le nombre maximum d'octets à regrouper dans une seule partition lors de la lecture à partir de sources basées sur des fichiers telles que Parquet, JSON et ORC.	128 MO
   spark.Hadoop.FS.S3.max réessaie	Définit le nombre maximum de nouvelles tentatives pour les opérations sur les fichiers Amazon S3.	(aucun)
   spark.network.timeout	Définit le délai d'expiration par défaut pour toutes les interactions réseau. Remplace les paramètres de délai d'expiration suivants s'ils ne sont pas configurés : spark.storage.block ManagerHeartbeatTimeoutMs Spark.Shuffle.io.Délai de connexion Spark.RPC.AskTimeout Délai de recherche de Spark.RPC	Années 120
   spark.rdd.compress	Spécifie s'il faut compresser les partitions RDD sérialisées à l'aide de spark.io.compression.codec. S'applique à StorageLevel.MEMORY _ONLY_SER en Java et Scala, ou StorageLevel.MEMORY à _ONLY en Python. Réduit l'espace de stockage mais nécessite un temps de traitement CPU supplémentaire.	false
   spark.shuffle.spill.compress	Spécifie s'il faut compresser les données de déversement aléatoire à l'aide de spark.io.compression.codec.	true
   spark.shuffle.compress	Spécifie s'il faut compresser les fichiers de sortie cartographiques. La compression utilise spark.io.compression.codec.	true
   spark.shuffle.service.index.cache.size	Définit la limite de taille du cache, en octets, sauf indication contraire.	100 m
   spark.shuffle.io.max réessaie	Définit le nombre maximum de nouvelles tentatives pour les récupérations qui échouent en raison d' IO-related exceptions.	3
   spark.shuffle.io. Réessayez d'attendre	Définit le temps d'attente entre les nouvelles tentatives de récupération. Le délai maximum causé par une nouvelle tentative est de 15 secondes par défaut, calculé comme MaxRetries * RetryWait.	5s
   Spark.Shuffle.io.Délai de connexion	Définit le délai pendant lequel les connexions établies entre les serveurs shuffle et les clients doivent être marquées comme inactives et fermées s'il y a toujours des demandes de récupération en attente mais aucun trafic sur le canal.	(valeur de spark.network.timeout)
   spark.driver.max ResultSize	Définit la limite de taille totale des résultats sérialisés de toutes les partitions pour chaque action Spark, en octets. Doit être d'au moins 1 m, ou 0 pour un nombre illimité.	1 g
   étincelle, mémoire, fraction	Définit la fraction de (espace de tas - 300 Mo) utilisée pour l'exécution et le stockage. Plus cette valeur est faible, plus les fuites et l'expulsion des données mises en cache sont fréquentes. Il est recommandé de laisser cette valeur à la valeur par défaut.	0.6
   spark.scheduler.mode	Définit le mode de planification entre les tâches qui lui sont soumises SparkContext. Peut être réglé sur FAIR pour utiliser le partage équitable au lieu de mettre les tâches en file d'attente les unes après les autres. Valeurs prises en charge : FAIR, FIFO.	FIFO
   spark.sql.adaptive.advisory PartitionSizeInBytes	Définit la taille cible en octets pour les partitions aléatoires lors de l'optimisation adaptative lorsque spark.sql.adaptive.enabled est true. Contrôle la taille des partitions lors de la fusion de petites partitions ou de la division de partitions asymétriques.	(valeur de PostShuffleInputSize spark.sql.adaptive.shuffle.target)
   spark.sql.adaptive.auto BroadcastJoinThreshold	Définit la taille maximale de la table en octets pour la diffusion vers les nœuds de travail lors des jointures. S'applique uniquement dans le cadre adaptatif. Utilise la même valeur par défaut que BroadcastJoinThreshold spark.sql.auto. Réglez sur -1 pour désactiver la diffusion.	(aucun)
   spark.sql.adaptive.coalesce Partitions.enabled	Spécifie s'il faut fusionner des partitions shuffle contiguës en fonction de spark.sql.adaptive.advisory pour optimiser la taille des tâches. PartitionSizeInBytes Nécessite que spark.sql.adaptive.enabled soit true.	true
   spark.sql.adaptive.coalesce Partitions.initialPartitionNum	Définit le nombre initial de partitions mélangées avant la fusion. Nécessite que spark.sql.adaptive.enabled et spark.sql.adaptive.coalesce soient vrais. Partitions.enabled La valeur par défaut est spark.sql.shuffle.partitions.	(aucun)
   spark.sql.adaptive.coalesce Partitions.minPartitionSize	Définit la taille minimale pour les partitions shuffle fusionnées afin d'éviter que les partitions ne deviennent trop petites lors de l'optimisation adaptative.	1 Mo
   spark.sql.adaptive.coalesce Partitions.parallelismFirst	Spécifie s'il faut calculer la taille des partitions en fonction du parallélisme des clusters au lieu de PartitionSizeInBytes spark.sql.adaptive.advisory lors de la fusion des partitions. Génère des tailles de partition inférieures à la taille cible configurée afin de maximiser le parallélisme. Nous vous recommandons de définir cette valeur sur false sur les clusters occupés afin d'améliorer l'utilisation des ressources en évitant les petites tâches excessives.	true
   spark.sql.adaptive.enabled	Spécifie s'il faut activer l'exécution adaptative des requêtes afin de réoptimiser les plans de requêtes pendant l'exécution des requêtes, sur la base de statistiques d'exécution précises.	true
   spark.sql.adaptive.force OptimizeSkewedJoin	Spécifie s'il faut forcer l'activation OptimizeSkewedJoin même si cela introduit un shuffle supplémentaire.	false
   spark.sql.adaptive.local ShuffleReader.enabled	Spécifie s'il faut utiliser des lecteurs aléatoires locaux lorsque le partitionnement aléatoire n'est pas requis, par exemple après la conversion des jointures sort-merge en jointures broadcast-hash. Nécessite que spark.sql.adaptive.enabled soit true.	true
   spark.sql.adaptive.max ShuffledHashJoinLocalMapThreshold	Définit la taille de partition maximale en octets pour la création de cartes de hachage locales. Donne la priorité aux jointures par hachage mélangées par rapport aux jointures par triage et fusion lorsque : Cette valeur est égale ou supérieure à spark.sql.adaptive.advisory PartitionSizeInBytes Toutes les tailles de partition se situent dans cette limite Remplace le paramètre SortMergeJoin spark.sql.join.prefer.	0 octets
   spark.sql.adaptive.optimize SkewsInRebalancePartitions.enabled	Spécifie s'il faut optimiser les partitions biaisées en les divisant en partitions plus petites en fonction de spark.sql.adaptive.advisory. PartitionSizeInBytes Nécessite que spark.sql.adaptive.enabled soit true.	true
   spark.sql.adaptive.rebalance PartitionsSmallPartitionFactor	Définit le seuil de taille pour la fusion de partitions lors du fractionnement. Les partitions inférieures à ce facteur multiplié par PartitionSizeInBytes spark.sql.adaptive.advisory sont fusionnées.	0.2
   spark.sql.adaptive.skew Join.enabled	Spécifie s'il faut gérer l'asymétrie des données dans les jointures mélangées en divisant et, éventuellement, en répliquant les partitions asymétriques. S'applique à la fusion par tri et aux jointures par hachage mélangées. Nécessite que spark.sql.adaptive.enabled soit true.	true
   spark.sql.adaptive.skew Join.skewedPartitionFactor	Détermine le facteur de taille qui détermine l'inclinaison de la partition. Une partition est asymétrique lorsque sa taille dépasse à la fois : Ce facteur multiplié par la taille de partition médiane La valeur de spark.sql.adaptive.skew Join.skewedPartitionThresholdInBytes	5
   spark.sql.adaptive.skew Join.skewedPartitionThresholdInBytes	Définit le seuil de taille en octets pour identifier les partitions asymétriques. Une partition est asymétrique lorsque sa taille dépasse à la fois : Ce seuil Taille de partition médiane multipliée par spark.sql.adaptive.skew Join.skewedPartitionFactor Nous vous recommandons de définir une valeur supérieure à PartitionSizeInBytes spark.sql.adaptive.advisory.	256 MO
   Délai de diffusion de spark.sql.	Contrôle le délai d'attente en secondes pour les opérations de diffusion lors des jointures de diffusion.	300 secondes
   spark.sql.cbo.enabled	Spécifie s'il faut activer l'optimisation basée sur les coûts (CBO) pour l'estimation des statistiques du plan.	false
   spark.sql.cbo.join Reorder.dp.star.filter	Spécifie s'il faut appliquer l'heuristique du filtre de jointure en étoile lors de l'énumération des jointures basée sur les coûts.	false
   spark.sql.cbo.join Reorder.dp.threshold	Définit le nombre maximum de nœuds joints autorisés dans l'algorithme de programmation dynamique.	12
   spark.sql.cbo.join Reorder.enabled	Spécifie s'il faut activer la réorganisation des jointures dans l'optimisation basée sur les coûts (CBO).	false
   spark.sql.cbo.plan Stats.enabled	Spécifie s'il faut extraire le nombre de lignes et les statistiques de colonnes du catalogue lors de la génération du plan logique.	false
   spark.sql.cbo.star SchemaDetection	Spécifie s'il faut activer la réorganisation des jointures en fonction de la détection du schéma en étoile.	false
   spark.sql.files.max PartitionNum	Définit le nombre maximum cible de partitions de fichiers fractionnées pour les sources basées sur des fichiers (Parquet, JSON et ORC). Redimensionne les partitions lorsque le nombre initial dépasse cette valeur. Il s'agit d'un objectif suggéré et non d'une limite garantie.	(aucun)
   spark.sql.files.max RecordsPerFile	Définit le nombre maximum d'enregistrements à écrire dans un seul fichier. Aucune limite ne s'applique lorsqu'elle est définie sur zéro ou sur une valeur négative.	0
   spark.sql.files.min PartitionNum	Définit le nombre minimal cible de partitions de fichiers fractionnées pour les sources basées sur des fichiers (Parquet, JSON et ORC). La valeur par défaut est spark.sql.leafNodeDefaultParallelism. Il s'agit d'un objectif suggéré et non d'une limite garantie.	(aucun)
   spark.sql.in MemoryColumnarStorage.batchSize	Contrôle la taille du lot pour la mise en cache en colonnes. L'augmentation de la taille améliore l'utilisation de la mémoire et la compression, mais augmente le risque d'erreurs de mémoire insuffisante.	10 000
   spark.sql.in MemoryColumnarStorage.compressed	Spécifie s'il faut sélectionner automatiquement les codecs de compression pour les colonnes en fonction des statistiques des données.	true
   spark.sql.in MemoryColumnarStorage.enableVectorizedReader	Spécifie s'il faut activer la lecture vectorisée pour la mise en cache en colonnes.	true
   spark.sql.legacy.allow HashOnMapType	Spécifie s'il faut autoriser les opérations de hachage sur les structures de données de type carte. Cet ancien paramètre maintient la compatibilité avec la gestion des types de carte des anciennes versions de Spark.	(aucun)
   spark.sql.legacy.allow NegativeScaleOfDecimal	Spécifie si les valeurs d'échelle négatives doivent être autorisées dans les définitions de type décimal. Cet ancien paramètre maintient la compatibilité avec les anciennes versions de Spark qui prenaient en charge les échelles décimales négatives.	(aucun)
   spark.sql.legacy.cast ComplexTypesToString.enabled	Spécifie s'il faut activer le comportement traditionnel pour convertir des types complexes en chaînes. Maintient la compatibilité avec les règles de conversion de type des anciennes versions de Spark.	(aucun)
   spark.sql.legacy.char VarcharAsString	Spécifie s'il faut traiter les types CHAR et VARCHAR comme des types STRING. Ce paramètre hérité assure la compatibilité avec la gestion des types de chaînes des anciennes versions de Spark.	(aucun)
   spark.sql.legacy.create EmptyCollectionUsingStringType	Spécifie s'il faut créer des collections vides à l'aide d'éléments de type chaîne. Ce paramètre hérité maintient la compatibilité avec le comportement d'initialisation des collections des anciennes versions de Spark.	(aucun)
   spark.sql.legacy.exponent LiteralAsDecimal.enabled	Spécifie s'il faut interpréter les littéraux exponentiels comme des types décimaux. Cet ancien paramètre maintient la compatibilité avec la gestion littérale numérique des anciennes versions de Spark.	(aucun)
   spark.sql.legacy.json.allow EmptyString.enabled	Spécifie s'il faut autoriser les chaînes vides dans le traitement JSON. Cet ancien paramètre maintient la compatibilité avec le comportement d'analyse JSON des anciennes versions de Spark.	(aucun)
   spark.sql.legacy.parquet.int96 RebaseModeInRead	Spécifie s'il faut utiliser le mode de rebase d'horodatage INT96 existant lors de la lecture de fichiers Parquet. Ce paramètre hérité maintient la compatibilité avec la gestion de l'horodatage des anciennes versions de Spark.	(aucun)
   spark.sql.legacy.time ParserPolicy	Contrôle le comportement d'analyse temporelle à des fins de rétrocompatibilité. Ce paramètre hérité détermine la manière dont les horodatages et les dates sont analysés à partir des chaînes.	(aucun)
   spark.sql.legacy.type Coercion.datetimeToString.enabled	Spécifie s'il faut activer le comportement de coercition des types hérités lors de la conversion de valeurs date/heure en chaînes. Maintient la compatibilité avec les règles de conversion date/heure des anciennes versions de Spark.	(aucun)
   spark.sql.max SinglePartitionBytes	Définit la taille de partition maximale en octets. Le planificateur introduit des opérations de shuffle pour les partitions plus grandes afin d'améliorer le parallélisme.	128 m
   Spark.sql.MetadataCachettlSecondes	Contrôle la durée de vie (TTL) des caches de métadonnées. S'applique aux métadonnées des fichiers de partition et aux caches du catalogue de sessions. Nécessite : Une valeur positive supérieure à zéro spark.sql.CatalogImplementation défini sur hive PartitionFileCacheSize spark.sql.hive.filesource supérieur à zéro FilesourcePartitions spark.sql.hive.manage défini sur true	-1 000 ms
   spark.sql.optimizer.collapse ProjectAlwaysInline	Spécifie s'il faut réduire les projections adjacentes et les expressions en ligne, même si cela entraîne une duplication.	false
   spark.sql.optimizer.dynamic PartitionPruning.enabled	Spécifie s'il faut générer des prédicats pour les colonnes de partition utilisées comme clés de jointure.	true
   spark.sql.optimizer.enable CsvExpressionOptimization	Spécifie s'il faut optimiser les expressions CSV dans l'optimiseur SQL en supprimant les colonnes inutiles des opérations from_csv.	true
   spark.sql.optimizer.enable JsonExpressionOptimization	Spécifie s'il faut optimiser les expressions JSON dans l'optimiseur SQL en : Élagage des colonnes inutiles à partir des opérations from_json Simplifier les combinaisons from_json et to_json Optimisation des opérations named_struct	true
   Règles exclues de spark.sql.Optimizer.	Définit les règles de l'optimiseur à désactiver, identifiées par des noms de règles séparés par des virgules. Certaines règles ne peuvent pas être désactivées car elles sont nécessaires pour être correctes. L'optimiseur enregistre les règles qui ont été désactivées avec succès.	(aucun)
   spark.sql.optimizer.runtime.bloom Filter.applicationSideScanSizeThreshold	Définit la taille de scan agrégée minimale en octets requise pour injecter un filtre Bloom côté application.	10 GO
   spark.sql.optimizer.runtime.bloom Filter.creationSideThreshold	Définit le seuil de taille maximum pour injecter un filtre Bloom côté création.	10 MO
   spark.sql.optimizer.runtime.bloom Filter.enabled	Spécifie s'il faut insérer un filtre Bloom pour réduire les données de mélange lorsqu'un côté d'une jointure aléatoire possède un prédicat sélectif.	true
   spark.sql.optimizer.runtime.bloom Filter.expectedNumItems	Définit le nombre par défaut d'éléments attendus dans le filtre Bloom d'exécution.	1000000
   spark.sql.optimizer.runtime.bloom Filter.maxNumBits	Définit le nombre maximum de bits autorisés dans le filtre Bloom d'exécution.	67108864
   spark.sql.optimizer.runtime.bloom Filter.maxNumItems	Définit le nombre maximum d'éléments attendus autorisés dans le filtre Bloom d'exécution.	4000000
   spark.sql.optimizer.runtime.bloom Filter.numBits	Définit le nombre de bits par défaut utilisés dans le filtre Bloom d'exécution.	8388608
   spark.sql.optimizer.runtime.row LevelOperationGroupFilter.enabled	Spécifie s'il faut activer le filtrage des groupes d'exécution pour les opérations au niveau des lignes. Permet aux sources de données de : Élaguez des groupes entiers de données (tels que des fichiers ou des partitions) à l'aide de filtres de source de données Exécuter des requêtes d'exécution pour identifier les enregistrements correspondants Supprimez les groupes inutiles pour éviter des réécritures coûteuses Limites: Toutes les expressions ne peuvent pas être converties en filtres de source de données Certaines expressions nécessitent une évaluation Spark (comme les sous-requêtes)	true
   spark.sql.optimizer.runtime Filter.number.threshold	Définit le nombre total de filtres d'exécution injectés (non DPP). Cela permet d'éviter les OOM des pilotes contenant trop de filtres Bloom.	10
   spark.sql.optimizer.runtime Filter.semiJoinReduction.enabled	Spécifie s'il faut insérer une semi-jointure pour réduire les données de mélange lorsqu'un côté d'une jointure aléatoire possède un prédicat sélectif.	false
   Spark.sql.Parquet.AggregatePushdown	Spécifie s'il faut envoyer les agrégats vers Parquet à des fins d'optimisation. Supports : MIN et MAX pour les types booléen, entier, flottant et date COUNT pour tous les types de données Lance une exception si des statistiques sont manquantes dans le pied de page d'un fichier Parquet.	false
   spark.sql.parquet.columnar ReaderBatchSize	Contrôle le nombre de lignes dans chaque lot de lecteurs vectorisés Parquet. Choisissez une valeur qui équilibre les coûts liés aux performances et à l'utilisation de la mémoire afin d'éviter les erreurs liées à l'épuisement de la mémoire.	4096
   spark.sql.parquet.enable VectorizedReader	Spécifie s'il faut activer le décodage Parquet vectorisé.	true
   spark.sql.shuffle.partitions	Définit le nombre de partitions par défaut pour le brassage des données lors des jointures ou des agrégations. Ne peut pas être modifié entre les redémarrages de requêtes de streaming structurées à partir du même point de contrôle.	200
   spark.sql.shuffled HashJoinFactor	Définit le facteur de multiplication utilisé pour déterminer l'éligibilité des jointures par hachage aléatoire. Une jointure par hachage aléatoire est sélectionnée lorsque la taille des données du petit côté multipliée par ce facteur est inférieure à la taille des données du côté supérieur.	3
   spark.sql.sources.parallel PartitionDiscovery.threshold	Définit le nombre maximum de chemins pour la liste des fichiers côté pilote avec des sources basées sur des fichiers (Parquet, JSON et ORC). En cas de dépassement lors de la découverte d'une partition, les fichiers sont répertoriés à l'aide d'une tâche distribuée Spark distincte.	32
   spark.sql.statistics.histogram.enabled	Spécifie s'il faut générer des histogrammes à hauteur égale lors du calcul des statistiques des colonnes afin d'améliorer la précision de l'estimation. Nécessite une analyse de table supplémentaire en plus de celle requise pour les statistiques de base des colonnes.	false
   spark.dynamic Allocation.executorIdleTimeout	Définit la durée pendant laquelle un exécuteur doit être inactif avant d'être supprimé lorsque l'allocation dynamique est activée.	Années 60
   spark.dynamic Allocation.schedulerBacklogTimeout	Définit la durée pendant laquelle les tâches en attente doivent être enregistrées avant que de nouveaux exécuteurs ne soient demandés lorsque l'allocation dynamique est activée.	1s
   spark.dynamic Allocation.sustainedSchedulerBacklogTimeout	Identique à spark.dynamicAllocation.schedulerBacklogTimeout, mais utilisé uniquement pour les requêtes ultérieures de l'exécuteur.	(valeur de spark.dynamicAllocation.schedulerBacklogTimeout)
   spark.scheduler.min RegisteredResourcesRatio	Définit le ratio minimum de ressources enregistrées (ressources enregistrées/ressources totales attendues) à attendre avant de commencer la planification. Spécifié comme un double compris entre 0,0 et 1,0. Que le ratio minimum de ressources soit atteint ou non, la durée maximale d'attente avant le début de la planification est contrôlée par RegisteredResourcesWaitingTime spark.scheduler.max.	0.8
   spark.scheduler.max RegisteredResourcesWaitingTime	Définit la durée maximale d'attente de l'enregistrement des ressources avant le début de la planification.	années 30
   spark.sql.hive.metastore PartitionPruningFallbackOnException	Spécifie s'il faut revenir à l'extraction de toutes les partitions depuis le métastore Hive et effectuer un élagage des partitions côté client Spark lors de la rencontre MetaException depuis le métastore.	false
   spark.sql.cross Join.enabled	Spécifie s'il faut autoriser les requêtes contenant un produit cartésien sans syntaxe CROSS JOIN explicite.	true
   Itérations Spark.SQL.Analyzer.Max	Définit le nombre maximum d'itérations que l'analyseur de requêtes exécute avant d'abandonner. Des valeurs plus élevées permettent à l'analyseur de traiter des requêtes très volumineuses ou profondément imbriquées.	100
   spark.sql.dataprefetch.filescan.max ParallelismPerTask	Définit le nombre maximum de divisions de fichiers à préextraire simultanément pour chaque tâche lors de l'analyse de fichiers.	4
   spark.sql.iceberg.data-prefetch.enabled	Spécifie s'il faut activer l'optimisation de la pré-extraction des données lors de la lecture Iceberg de tableaux.	true
   spark.sql.legacy.null ValueWrittenAsQuotedEmptyStringCsv	Spécifie s'il faut restaurer le comportement traditionnel consistant à écrire des valeurs nulles sous forme de chaînes vides entre guillemets dans la sortie CSV. Lorsque la valeur est fausse, Spark écrit des valeurs nulles sous forme de chaînes vides sans guillemets.	false
   spark.max RemoteBlockSizeFetchToMem	Définit le seuil de taille au-dessus duquel Spark extrait les blocs distants sur le disque plutôt que dans la mémoire. Cela permet d'éviter qu'une seule demande importante ne consomme trop de mémoire.	200 m
   spark.emr-serverless.allocation.batch.size	Définit le nombre d'exécuteurs à demander en une seule fois à chaque cycle d'attribution des exécuteurs.	20

   Nom de propriété	Description	Valeur par défaut
   spark.sql.auto BroadcastJoinThreshold	Définit la taille maximale de la table en octets pour la diffusion vers les nœuds de travail lors des jointures. Réglez sur -1 pour désactiver la diffusion.	10 Mo (-1 pour CR.4X 32 travailleurs)
   spark.dynamic Allocation.enabled	Spécifie s'il faut utiliser l'allocation dynamique des ressources, qui augmente ou diminue le nombre d'exécuteurs enregistrés auprès de cette application en fonction de la charge de travail.	true
   spark.files.fetch Failure.unRegisterOutputOnHost	Spécifie s'il faut annuler l'enregistrement de toutes les sorties cartographiques sur un hôte en cas d'échec d'extraction. Lorsque la valeur est fausse, Spark annule uniquement les sorties de l'exécuteur spécifique qui a échoué, ce qui réduit les recalculs d'étape inutiles.	false
   codec spark.io.compression.codec	Définit le codec utilisé pour compresser les données internes telles que les partitions RDD, le journal des événements, les variables de diffusion et les sorties de lecture aléatoire. Valeurs prises en charge : lz4, snappy, zstd, gzip.	snappy
   spark.sql.session.zone horaire	Définit le fuseau horaire de session pour la gestion des horodatages dans les chaînes littérales et la conversion d'objets Java. Accepte : Region-based Identifiants au area/city format (tels que America/Los _Angeles) Décalages de zone au HH:mm:ss format (+/-) HH, (+/-) HH:mm ou (+/-) (par exemple -08 ou + 01:00) UTC ou Z comme alias pour + 00:00	UTC

9. Pour Accès au service, choisissez le nom du rôle de service existant qui sera utilisé pour accéder à ce tableau.

10. Si vous souhaitez activer les balises pour le jeu de données d'entraînement, choisissez Ajouter une nouvelle étiquette, puis entrez la paire clé/valeur.

11. Choisissez Créer un segment similaire.