

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.

# Qu'est-ce que l'agent de mise à niveau Apache Spark pour Amazon EMR
Agent de mise à niveau Apache Spark

## Introduction


L'agent de mise à niveau Apache Spark pour Amazon EMR est une fonctionnalité d'intelligence artificielle conversationnelle qui accélère les mises à niveau des versions d'Apache Spark pour vos applications EMR. Les mises à niveau traditionnelles de Spark nécessitent des mois d'efforts d'ingénierie pour analyser les modifications des API, résoudre les conflits de dépendance et valider l'exactitude fonctionnelle. L'agent simplifie le processus de mise à niveau grâce à des instructions en langage naturel, à la transformation automatique du code et à la validation de la qualité des données.

Vous pouvez utiliser l'agent pour mettre à niveau PySpark les applications Scala s'exécutant sur Amazon EMR on EC2 et Amazon EMR Serverless. L'agent analyse votre code, identifie les modifications requises et effectue des transformations automatisées tout en gardant le contrôle de l'approbation de toutes les modifications.

**Note**  
L'agent de mise à niveau Apache Spark est disponible sans frais supplémentaires dans le cadre d'Amazon EMR. Vous ne payez que pour les ressources Amazon EMR sous-jacentes utilisées lors de l'exécution des tâches de validation.

## Présentation de l'architecture


L'agent de mise à niveau comporte trois composants principaux : tout assistant AI compatible avec MCP présent dans votre environnement de développement pour l'interaction, le [proxy MCP AWS qui gère les](https://github.com/aws/mcp-proxy-for-aws) communications sécurisées entre votre client et le serveur MCP, et le serveur MCP géré par Amazon SageMaker Unified Studio (en version préliminaire) qui fournit des outils de mise à niveau Spark spécialisés pour Amazon EMR. Ce schéma illustre la manière dont vous interagissez avec le serveur MCP géré par Amazon SageMaker Unified Studio via votre assistant AI.

![\[Agent de mise à niveau Apache Spark\]](http://docs.aws.amazon.com/fr_fr/emr/latest/ReleaseGuide/images/SparkUpgradeIntroduction.png)


L'assistant AI orchestrera la mise à niveau à l'aide d'outils spécialisés fournis par le serveur MCP en suivant les étapes suivantes :

1. **Planification** : l'agent analyse la structure de votre projet et génère ou révise un plan de mise à niveau qui guide le processus de mise à niveau de end-to-end Spark.

1. **Compiler et compiler** : l'agent met à jour l'environnement de construction et les dépendances, compile le projet et corrige de manière itérative les échecs de compilation et de test.

1. **Outils d'édition de code Spark** : l'agent applique des mises à jour de code ciblées pour résoudre les incompatibilités entre les versions de Spark, en corrigeant à la fois les erreurs de compilation et d'exécution.

1. **Exécution et validation** : l'agent soumet des tâches de validation à distance à EMR, surveille l'exécution et les journaux, et résout de manière itérative les problèmes d'exécution et de qualité des données.

1. **Observabilité** : l'agent suit la progression de la mise à niveau à l'aide des outils d'observabilité EMR et permet aux utilisateurs de consulter les analyses et le statut des mises à niveau à tout moment.

Référez-vous [Utilisation des outils de mise à niveau Spark](emr-spark-upgrade-agent-tools.md) à la liste des principaux outils pour chaque étape.

**Topics**
+ [

## Introduction
](#emr-spark-upgrade-agent-intro)
+ [

## Présentation de l'architecture
](#emr-spark-upgrade-agent-architecture)
+ [

# Configuration de l'agent de mise à niveau
](emr-spark-upgrade-agent-setup.md)
+ [

# Utilisation de l'agent de mise à niveau
](emr-spark-upgrade-agent-using.md)
+ [

# Caractéristiques et capacités
](emr-spark-upgrade-agent-features.md)
+ [

# Résolution des problèmes et questions et réponses
](emr-spark-upgrade-agent-troubleshooting.md)
+ [

# Détails du flux de travail de l'agent Spark Upgrade
](emr-spark-upgrade-agent-workflow-details.md)
+ [

# Activer la validation de la qualité des données
](emr-spark-upgrade-agent-data-quality-validation.md)
+ [

# Exemples rapides pour l'agent de mise à niveau Spark
](emr-spark-upgrade-agent-prompt-examples.md)
+ [

# Création d'un cluster EMR cible/d'une application EMR-S à partir de clusters EMR existants
](emr-spark-upgrade-agent-target-cluster.md)
+ [

# Configuration du rôle IAM
](emr-spark-upgrade-agent-iam-role.md)
+ [

# Configuration des points de terminaison VPC d'interface pour Amazon Unified Studio MCP SageMaker
](spark-upgrade-agent-vpc-endpoints.md)
+ [

# Utilisation des outils de mise à niveau Spark
](emr-spark-upgrade-agent-tools.md)
+ [

# Traitement interrégional pour l'agent de mise à niveau Apache Spark
](emr-spark-upgrade-agent-cross-region.md)
+ [

# Journalisation des appels MCP Amazon SageMaker Unified Studio à l'aide de AWS CloudTrail
](spark-upgrade-cloudtrail-integration.md)
+ [

# Améliorations des services pour les agents Apache Spark
](emr-spark-agent-service-improvements.md)

# Configuration de l'agent de mise à niveau


**Note**  
L'agent de mise à niveau Apache Spark utilise l'inférence entre régions pour traiter les demandes en langage naturel et générer des réponses. Pour plus de détails, veuillez consulter cette page sur[Traitement interrégional pour l'agent de mise à niveau Apache Spark](emr-spark-upgrade-agent-cross-region.md). Le serveur Amazon SageMaker Unified Studio MCP est en version préliminaire et est sujet à modification. 

## Conditions préalables


Avant de commencer notre processus de configuration pour l'intégration à Kiro CLI, assurez-vous que les éléments suivants sont installés sur votre poste de travail :
+  [Installation de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) 
+  [Installez Python 3.10\$1](https://www.python.org/downloads/release/python-3100/) 
+  [Installez le gestionnaire de `uv` packages](https://docs.astral.sh/uv/getting-started/installation/) pour [MCP Proxy](https://github.com/aws/mcp-proxy-for-aws?tab=readme-ov-file) pour AWS
+  [Installez Kiro CLI](https://kiro.dev/docs/cli/) 
+ AWS informations d'identification locales configurées (via une [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html), des variables d'environnement ou des rôles IAM) : pour les opérations locales telles que le téléchargement d'artefacts de tâche mis à niveau pour l'exécution de tâches de validation EMR.

## Ressources de configuration


Vous pouvez utiliser un CloudFormation modèle pour configurer la ressource pour le serveur MCP. Ces modèles sont des exemples que vous devez modifier pour répondre à vos besoins. Le modèle crée les ressources suivantes pour le processus de mise à niveau :
+ Rôle IAM autorisé à appeler le serveur MCP et aux autorisations requises pour le processus de mise à niveau de la plate-forme EMR sous-jacente.
+ Compartiment intermédiaire Amazon S3 utilisé pour télécharger des artefacts de mise à niveau et une clé KMS facultative pour le chiffrement Amazon S3.

Choisissez l'un des boutons **Launch Stack** (Lancer la pile) du tableau suivant. Cela lance la pile sur la CloudFormation console dans la région correspondante.


| Région | Lancer | 
| --- | --- | 
| USA Est (Virginie du Nord) |  [https://console.aws.amazon.com/cloudformation/home?region=us-east-1#/stacks/new?stackName=spark-upgrade-mcp-setup&templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-us-east-1.s3.us-east-1.amazonaws.com/cloudformation/spark-upgrade-mcp-setup.yaml](https://console.aws.amazon.com/cloudformation/home?region=us-east-1#/stacks/new?stackName=spark-upgrade-mcp-setup&templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-us-east-1.s3.us-east-1.amazonaws.com/cloudformation/spark-upgrade-mcp-setup.yaml)  | 
| USA Est (Ohio) |  [https://console.aws.amazon.com/cloudformation/home?region=us-east-2#/stacks/new?stackName=spark-upgrade-mcp-setup&templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-us-east-2.s3.us-east-2.amazonaws.com/cloudformation/spark-upgrade-mcp-setup.yaml](https://console.aws.amazon.com/cloudformation/home?region=us-east-2#/stacks/new?stackName=spark-upgrade-mcp-setup&templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-us-east-2.s3.us-east-2.amazonaws.com/cloudformation/spark-upgrade-mcp-setup.yaml)  | 
| USA Ouest (Oregon) |  [https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?stackName=spark-upgrade-mcp-setup&templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-us-west-2.s3.us-west-2.amazonaws.com/cloudformation/spark-upgrade-mcp-setup.yaml](https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?stackName=spark-upgrade-mcp-setup&templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-us-west-2.s3.us-west-2.amazonaws.com/cloudformation/spark-upgrade-mcp-setup.yaml)  | 
| Europe (Irlande) |  [https://console.aws.amazon.com/cloudformation/home?region=eu-west-1#/stacks/new?stackName=spark-upgrade-mcp-setup&templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-west-1.s3.eu-west-1.amazonaws.com/cloudformation/spark-upgrade-mcp-setup.yaml](https://console.aws.amazon.com/cloudformation/home?region=eu-west-1#/stacks/new?stackName=spark-upgrade-mcp-setup&templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-west-1.s3.eu-west-1.amazonaws.com/cloudformation/spark-upgrade-mcp-setup.yaml)  | 
| Asie-Pacifique (Tokyo) |  [https://console.aws.amazon.com/cloudformation/home?region=ap-northeast-1#/stacks/new?stackName=spark-upgrade-mcp-setup&templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-northeast-1.s3.ap-northeast-1.amazonaws.com/cloudformation/spark-upgrade-mcp-setup.yaml](https://console.aws.amazon.com/cloudformation/home?region=ap-northeast-1#/stacks/new?stackName=spark-upgrade-mcp-setup&templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-northeast-1.s3.ap-northeast-1.amazonaws.com/cloudformation/spark-upgrade-mcp-setup.yaml)  | 
| Asie-Pacifique (Singapour) |  [https://console.aws.amazon.com/cloudformation/home?region=ap-southeast-1#/stacks/new?stackName=spark-upgrade-mcp-setup&templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-southeast-1.s3.ap-southeast-1.amazonaws.com/cloudformation/spark-upgrade-mcp-setup.yaml](https://console.aws.amazon.com/cloudformation/home?region=ap-southeast-1#/stacks/new?stackName=spark-upgrade-mcp-setup&templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-southeast-1.s3.ap-southeast-1.amazonaws.com/cloudformation/spark-upgrade-mcp-setup.yaml)  | 
| Asie-Pacifique (Sydney) |  [https://console.aws.amazon.com/cloudformation/home?region=ap-southeast-2#/stacks/new?stackName=spark-upgrade-mcp-setup&templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-southeast-2.s3.ap-southeast-2.amazonaws.com/cloudformation/spark-upgrade-mcp-setup.yaml](https://console.aws.amazon.com/cloudformation/home?region=ap-southeast-2#/stacks/new?stackName=spark-upgrade-mcp-setup&templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-southeast-2.s3.ap-southeast-2.amazonaws.com/cloudformation/spark-upgrade-mcp-setup.yaml)  | 
| Canada (Centre) |  [https://console.aws.amazon.com/cloudformation/home?region=ca-central-1#/stacks/new?stackName=spark-upgrade-mcp-setup&templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ca-central-1.s3.ca-central-1.amazonaws.com/cloudformation/spark-upgrade-mcp-setup.yaml](https://console.aws.amazon.com/cloudformation/home?region=ca-central-1#/stacks/new?stackName=spark-upgrade-mcp-setup&templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ca-central-1.s3.ca-central-1.amazonaws.com/cloudformation/spark-upgrade-mcp-setup.yaml)  | 
| Amérique du Sud (São Paulo) |  [https://console.aws.amazon.com/cloudformation/home?region=sa-east-1#/stacks/new?stackName=spark-upgrade-mcp-setup&templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-sa-east-1.s3.sa-east-1.amazonaws.com/cloudformation/spark-upgrade-mcp-setup.yaml](https://console.aws.amazon.com/cloudformation/home?region=sa-east-1#/stacks/new?stackName=spark-upgrade-mcp-setup&templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-sa-east-1.s3.sa-east-1.amazonaws.com/cloudformation/spark-upgrade-mcp-setup.yaml)  | 
| Europe (Francfort) |  [https://console.aws.amazon.com/cloudformation/home?region=eu-central-1#/stacks/new?stackName=spark-upgrade-mcp-setup&templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-central-1.s3.eu-central-1.amazonaws.com/cloudformation/spark-upgrade-mcp-setup.yaml](https://console.aws.amazon.com/cloudformation/home?region=eu-central-1#/stacks/new?stackName=spark-upgrade-mcp-setup&templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-central-1.s3.eu-central-1.amazonaws.com/cloudformation/spark-upgrade-mcp-setup.yaml)  | 
| Europe (Stockholm) |  [https://console.aws.amazon.com/cloudformation/home?region=eu-north-1#/stacks/new?stackName=spark-upgrade-mcp-setup&templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-north-1.s3.eu-north-1.amazonaws.com/cloudformation/spark-upgrade-mcp-setup.yaml](https://console.aws.amazon.com/cloudformation/home?region=eu-north-1#/stacks/new?stackName=spark-upgrade-mcp-setup&templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-north-1.s3.eu-north-1.amazonaws.com/cloudformation/spark-upgrade-mcp-setup.yaml)  | 
| Europe (Londres) |  [https://console.aws.amazon.com/cloudformation/home?region=eu-west-2#/stacks/new?stackName=spark-upgrade-mcp-setup&templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-west-2.s3.eu-west-2.amazonaws.com/cloudformation/spark-upgrade-mcp-setup.yaml](https://console.aws.amazon.com/cloudformation/home?region=eu-west-2#/stacks/new?stackName=spark-upgrade-mcp-setup&templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-west-2.s3.eu-west-2.amazonaws.com/cloudformation/spark-upgrade-mcp-setup.yaml)  | 
| Europe (Paris) |  [https://console.aws.amazon.com/cloudformation/home?region=eu-west-3#/stacks/new?stackName=spark-upgrade-mcp-setup&templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-west-3.s3.eu-west-3.amazonaws.com/cloudformation/spark-upgrade-mcp-setup.yaml](https://console.aws.amazon.com/cloudformation/home?region=eu-west-3#/stacks/new?stackName=spark-upgrade-mcp-setup&templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-west-3.s3.eu-west-3.amazonaws.com/cloudformation/spark-upgrade-mcp-setup.yaml)  | 
| Asie-Pacifique (Séoul) |  [https://console.aws.amazon.com/cloudformation/home?region=ap-northeast-2#/stacks/new?stackName=spark-upgrade-mcp-setup&templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-northeast-2.s3.ap-northeast-2.amazonaws.com/cloudformation/spark-upgrade-mcp-setup.yaml](https://console.aws.amazon.com/cloudformation/home?region=ap-northeast-2#/stacks/new?stackName=spark-upgrade-mcp-setup&templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-northeast-2.s3.ap-northeast-2.amazonaws.com/cloudformation/spark-upgrade-mcp-setup.yaml)  | 
| Asie-Pacifique (Mumbai) |  [https://console.aws.amazon.com/cloudformation/home?region=ap-south-1#/stacks/new?stackName=spark-upgrade-mcp-setup&templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-south-1.s3.ap-south-1.amazonaws.com/cloudformation/spark-upgrade-mcp-setup.yaml](https://console.aws.amazon.com/cloudformation/home?region=ap-south-1#/stacks/new?stackName=spark-upgrade-mcp-setup&templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-south-1.s3.ap-south-1.amazonaws.com/cloudformation/spark-upgrade-mcp-setup.yaml)  | 

Accédez à la page **Spécifier les détails de la pile**, entrez le **nom de la pile**. Saisissez des informations supplémentaires sous **Paramètres**. Fournissez les informations suivantes et procédez à la création de la pile.
+ **SparkUpgradeIAMRoleNom** : nom du rôle IAM à utiliser pour le processus de mise à niveau de Spark
+ **Activer EMREC2 - Activer** les autorisations de EC2 mise à niveau EMR (valeur par défaut : true)
+ **Activer EMRServerless** : active les autorisations de mise à niveau sans serveur EMR (valeur par défaut : true)
+ **StagingBucketPath**- Chemin Amazon S3 pour le stockage des artefacts (par exemple, s3://my - bucket/spark-upgrade or my-bucket/spark -upgrade). Laissez le champ vide pour générer automatiquement un nouveau compartiment
+ **Uses3Encryption** : active le chiffrement KMS pour le compartiment intermédiaire Amazon S3 (par défaut : false, défini sur true pour utiliser le chiffrement KMS au lieu du chiffrement S3 par défaut)
+ **S3 KmsKeyArn** : ARN (facultatif) de la clé KMS existante pour le chiffrement du compartiment Amazon S3. Utilisé uniquement si Uses3Encryption est vrai et que vous avez un bucket existant avec une clé KMS
+ **CloudWatchKmsKeyArn**- (Facultatif) ARN de la clé KMS existante pour le chiffrement CloudWatch des journaux (EMR sans serveur uniquement, laissez le champ vide pour le chiffrement par défaut)
+ **EMRServerlessS3 LogPath** - (Facultatif) Chemin S3 où sont stockés les journaux des applications sans serveur EMR (par exemple, s3://my - bucket/emr-serverless-logs or my-bucket/emr -serverless-logs). Lorsqu'il est fourni, accorde au rôle IAM un accès en lecture à ces journaux à des fins d'analyse. Utilisé uniquement lorsque Enable EMRServerless est vrai
+ **ExecutionRoleToGrantS3Access** - (facultatif) Nom du rôle IAM ou ARN du rôle d'exécution EMR- EC2 /EMR-Serverless existant pour accorder l'accès au bucket intermédiaire Amazon S3. S'applique uniquement lorsqu'un nouveau bucket intermédiaire est créé. Utile pour accorder aux rôles d'exécution de tâches EMR l'accès au bucket intermédiaire. Supporte à la fois des noms de rôle simples et ARNs des chemins.

Vous pouvez également télécharger et consulter [le CloudFormation modèle](https://github.com/aws-samples/aws-emr-utilities/blob/03c20fece616de23ec0ea5389f0113a5bc65fc3a/utilities/apache-spark-agents/spark-upgrade-agent-cloudformation/spark-upgrade-mcp-setup.yaml), spécifier les options ci-dessus et lancer le modèle vous-même à l'aide des commandes de la CloudFormation CLI, voir un exemple ci-dessous :

```
# deploy the stack with CloudFormation CLI commands
aws cloudformation deploy \
  --template-file spark-upgrade-mcp-setup.yaml \
  --stack-name spark-mcp-setup \
  --region <your mcp server launch region> \
  --capabilities CAPABILITY_NAMED_IAM \
  --parameter-overrides \
    ExecutionRoleToGrantS3Access=<your EMR or EMR Serverless job execution role>


# retrieve the 1-line instruction to set the local environment variables, which will be used for the following MCP server configuration
aws cloudformation describe-stacks \
  --stack-name spark-mcp-setup \
  --region <your mcp server launch region> \
  --query "Stacks[0].Outputs[?OutputKey=='ExportCommand'].OutputValue" \
  --output text
```

Ouvrez l'onglet Sorties (ou récupérez-la à partir de la commande de la CLI CloudFormation describe-stacks ci-dessus) et copiez l'`ExportCommand`instruction d'une ligne, puis exécutez-la dans votre environnement local. Exemple d'instruction d'une ligne :

```
export SMUS_MCP_REGION=<your mcp server launch region> && export IAM_ROLE=arn:aws:iam::111122223333:role/spark-upgrade-role-xxxxxx && export STAGING_BUCKET_PATH=<your staging bucket path>
```

Exécutez ensuite la commande suivante localement pour configurer le profil IAM et la configuration du serveur MCP

```
# Step 1: Configure AWS CLI Profile  
aws configure set profile.spark-upgrade-profile.role_arn ${IAM_ROLE}  
aws configure set profile.spark-upgrade-profile.source_profile <AWS CLI Profile to assume the IAM role - ex: default>  
aws configure set profile.spark-upgrade-profile.region ${SMUS_MCP_REGION}  
  
# Step 2: if you are using Kiro CLI, use the following command to add the MCP configuration  
kiro-cli-chat mcp add \  
    --name "spark-upgrade" \  
    --command "uvx" \  
    --args "[\"mcp-proxy-for-aws@latest\",\"https://sagemaker-unified-studio-mcp.${SMUS_MCP_REGION}.api.aws/spark-upgrade/mcp\", \"--service\", \"sagemaker-unified-studio-mcp\", \"--profile\", \"spark-upgrade-profile\", \"--region\", \"${SMUS_MCP_REGION}\", \"--read-timeout\", \"180\"]" \  
    --timeout 180000\  
    --scope global
```

Cela devrait être mis `~/.kiro/settings/mcp.json` à jour pour inclure la configuration du serveur MCP comme indiqué ci-dessous.

```
{  
  "mcpServers": {  
    "spark-upgrade": {  
      "type": "stdio",  
      "command": "uvx",  
      "args": [  
        "mcp-proxy-for-aws@latest",  
        "https://sagemaker-unified-studio-mcp.us-east-1.api.aws/spark-upgrade/mcp",  
        "--service",  
        "sagemaker-unified-studio-mcp",  
        "--profile",  
        "spark-upgrade-profile",  
        "--region",  
        "us-east-1",  
        "--read-timeout",  
        "180"  
      ],  
      "timeout": 180000,  
      "disabled": false  
    }  
  }  
}
```

Consultez [Utilisation de l'agent de mise à niveau](emr-spark-upgrade-agent-using.md) les conseils de configuration pour différents clients MCP tels que Kiro, Cline et. GitHub CoPilot

# Utilisation de l'agent de mise à niveau


## Modes de déploiement pris en charge


L'agent de mise à niveau Apache Spark pour Amazon EMR prend en charge les deux modes de déploiement suivants pour l'expérience de mise à niveau de l'application end-to-end Spark, notamment la mise à niveau du fichier de build, script/dependency le test local et la validation avec le cluster EMR cible ou l'application EMR Serverless, et la validation de la qualité des données.
+ EMR activé EC2
+ EMR sans serveur

Veuillez vous référer [Caractéristiques et capacités](emr-spark-upgrade-agent-features.md) à cette section pour comprendre les caractéristiques détaillées, les capacités et les limites.

## Interfaces prises en charge


### Intégration avec Amazon SageMaker Unified Studio VS Code Editor Spaces


Sur Amazon SageMaker Unified Studio VS Code Editor Spaces, vous pouvez configurer le profil IAM et la configuration MCP comme décrit dans la section Configuration de l'agent de mise à niveau en suivant simplement la capture d'écran ci-dessous :

![\[Agent de mise à niveau Apache Spark\]](http://docs.aws.amazon.com/fr_fr/emr/latest/ReleaseGuide/images/SparkUpgradeVSCodeEditor.png)


Une démonstration de l'expérience EMR lors de la EC2 mise à niveau avec l'éditeur de code SMUS VS. Cela commence par une simple invite à demander à l'agent de démarrer le processus de mise à niveau de Spark.

```
Upgrade my Spark application <local-project-path> from EMR version 6.0.0 to 7.12.0.   
Use EMR-EC2 Cluster <cluster-id> to run the validation and s3 paths   
s3://<please fill in your staging bucket path> to store updated application artifacts.   
Use spark-upgrade-profile for AWS CLI operations.
```

[![AWS Videos](http://img.youtube.com/vi/https://www.youtube.com/embed/Hk4_GPvYeqI/0.jpg)](http://www.youtube.com/watch?v=https://www.youtube.com/embed/Hk4_GPvYeqI)


### Intégration avec Kiro CLI (QCLI)


Démarrez Kiro CLI ou votre assistant AI et vérifiez les outils chargés pour l'agent de mise à niveau.

```
...  
spark-upgrade (MCP):   
- check_and_update_build_environment     * not trusted  
- check_and_update_python_environment    * not trusted  
- check_job_status                       * not trusted  
- compile_and_build_project              * not trusted  
...
```

Une démonstration de l'expérience de mise à niveau EMR sans serveur avec Kiro CLI. Vous pouvez simplement démarrer le processus de mise à niveau en suivant le message suivant :

```
Upgrade my Spark application <local-project-path> from EMR version 6.0.0 to 7.12.0.   
Use EMR-Serverless Applicaion <application-id> and execution role <your EMR Serverless job execution role> to run the validation and s3 paths   
s3://<please fill in your staging bucket path> to store updated application artifacts.
```

[![AWS Videos](http://img.youtube.com/vi/https://www.youtube.com/embed/Kw8E2wWv4uQ/0.jpg)](http://www.youtube.com/watch?v=https://www.youtube.com/embed/Kw8E2wWv4uQ)


### Intégration avec d'autres IDEs


La [configuration](emr-spark-upgrade-agent-setup.md#spark-upgrade-agent-setup-resources) peut également être utilisée dans d'autres applications IDEs pour se connecter au serveur Managed MCP :
+ **Intégration avec Cline** - Pour utiliser le serveur MCP avec Cline, modifiez `cline_mcp_settings.json` et ajoutez la configuration ci-dessus. Consultez [la documentation de Cline](https://docs.cline.bot/mcp/configuring-mcp-servers) pour plus d'informations sur la gestion de la configuration MCP.
+ **Intégration avec Claude Code** Pour utiliser le serveur MCP avec Claude Code, modifiez le fichier de configuration pour inclure la configuration MCP. Le chemin du fichier varie en fonction de votre système d'exploitation. Reportez-vous à [https://code.claude.com/docs/en/mcp](https://code.claude.com/docs/en/mcp) pour une configuration détaillée.
+ **Intégration avec GitHub Copilot** - Pour utiliser le serveur MCP avec GitHub Copilot, suivez les instructions contenues dans [ https://docs.github.com/en/copilot/how-tos/provide-context/use-mcp/extend- copilot-chat-with-mcp](https://docs.github.com/en/copilot/how-tos/provide-context/use-mcp/extend-copilot-chat-with-mcp) pour modifier le fichier de configuration correspondant et suivez les instructions de chaque IDE pour activer l'installation.

## Configuration du cluster EMR ou de l'application EMR sans serveur pour la version cible


Créez le cluster EMR ou l'application EMR Serverless avec la version Spark attendue que vous prévoyez d'utiliser pour l'application mise à niveau. Le cluster EMR ou l'application EMR-S cible seront utilisés pour soumettre les tâches de validation après la mise à niveau des artefacts de l'application Spark afin de vérifier la réussite de la mise à niveau ou de corriger les erreurs supplémentaires rencontrées lors de la validation. Si vous possédez déjà un cluster EMR cible ou une application EMR Serverless, vous pouvez vous référer au cluster EMR existant et ignorer cette étape. Utilisez des comptes de développeur hors production et sélectionnez des exemples de jeux de données fictifs qui représentent vos données de production, mais dont la taille est réduite pour la validation avec Spark Upgrades. Reportez-vous à cette page pour obtenir des conseils sur la création d'un cluster EMR cible ou d'une application EMR Serverless à partir de clusters EMR existants :. [Création d'un cluster EMR cible/d'une application EMR-S à partir de clusters EMR existants](emr-spark-upgrade-agent-target-cluster.md)

# Caractéristiques et capacités


## Technologies prises en charge

+ **Langages** : applications Python et Scala
+ **Systèmes de construction** : Maven et SBT pour les projets Scala ; requirements.txt, Pipfile et Setuptools pour les projets Python
+ **Plateformes cibles** : Amazon EMR et EMR Serverless
+ **Versions prises en charge** : nous prenons en charge les mises à niveau d'Apache Spark de la version 2.4 à la version 3.5. Les mappages de mode de déploiement correspondants sont les suivants :
  + **Pour EMR- EC2**
    + **Version source :** EMR 5.20.0 et versions ultérieures
    + **Version cible :** EMR 7.12.0 et versions antérieures, devraient être plus récentes que EMR 5.20.0
  + **Pour EMR Serverless**
    + **Version source :** EMR Serverless 6.6.0 et versions ultérieures
    + **Version cible :** EMR Serverless 7.12.0 et versions antérieures

## Ce que nous améliorons


L'agent de mise à niveau fournit des mises à niveau complètes des applications Spark :
+ **Configuration de construction** : met automatiquement à jour les fichiers de gestion des dépendances (pom.xml, requirements.txt, etc.)
+ **Code source** : corrige les problèmes de compatibilité des API et l'utilisation de méthodes obsolètes
+ **Code de test** : garantit que les tests unitaires et d'intégration fonctionnent avec la version cible de Spark
+ **Dépendances** : met à niveau les dépendances packagées vers des versions compatibles avec la version EMR cible
+ **Validation** : compile et valide les applications sur les clusters EMR cibles
+ **Analyse de la qualité des données** : détecte les différences de schéma, les dérives statistiques au niveau des valeurs (min/max/mean) et les incohérences entre les nombres de lignes agrégés, avec des rapports d'impact détaillés.

## Régions disponibles


L'agent de mise à niveau Spark est disponible dans les régions suivantes :
+ **Asie-Pacifique** : Tokyo (ap-northeast-1), Séoul (ap-northeast-2), Singapour (ap-southeast-1), Sydney (ap-southeast-2) et Mumbai (ap-southeast-1)
+ **Amérique du** Nord : Canada (ca-central-1)
+ **Europe** : Stockholm (eu-nord-1), Irlande (eu-west-1), Londres (eu-west-2), Paris (eu-west-3) et Francfort (eu-central-1)
+ **Amérique du Sud** : São Paulo (sa-east-1)
+ **États-Unis** : Virginie du Nord (us-east-1), Ohio (us-east-2) et Oregon (us-west-2)

## Étendue des mises à niveau et exigences des utilisateurs

+ **Gestion des clusters** : Spark Upgrade Agent se concentre sur les mises à niveau du code des applications. Les clusters EMR cibles pour les nouvelles versions doivent être créés et gérés par les utilisateurs.
+ **Actions de démarrage :** l'agent de mise à niveau Spark ne met pas à niveau les scripts de démarrage personnalisés en dehors du code de l'application Spark. Ils doivent être mis à jour par l'utilisateur.
+ **Mise à niveau pour la compilation et les tests** : l'agent de mise à niveau effectuera la compilation et exécutera vos tests unitaires et d'intégration sur votre environnement de développement localement pour valider que les applications se compilent correctement avec la version cible de Spark. Si vous avez des restrictions (politiques de sécurité, limites de ressources, restrictions réseau ou directives d'entreprise) concernant le code d'application Spark pour une exécution locale, pensez à utiliser [Amazon SageMaker Unified Studio VSCode IDE Spaces](https://docs.aws.amazon.com/sagemaker-unified-studio/latest/userguide/create-space.html) ou EC2 à exécuter l'agent de mise à niveau. L'agent de mise à niveau utilise votre EC2 cluster EMR cible ou vos applications EMR-S pour valider et mettre à niveau. end-to-end
+ **Approche axée sur les erreurs** : l'agent de mise à niveau utilise une méthodologie basée sur les erreurs, apportant un correctif à la fois en fonction d'erreurs de compilation ou d'exécution plutôt que de plusieurs correctifs à la fois. Cette approche itérative garantit que chaque problème est correctement traité avant de passer au suivant.
+ **Dépendances privées** : les dépendances installées à partir de référentiels d'artefacts privés ne peuvent pas être mises à niveau automatiquement dans le cadre de ce processus. Ils doivent être mis à jour par l'utilisateur.
+ **Ressources régionales** : l'agent de mise à niveau Spark est régional et utilise les ressources EMR sous-jacentes de cette région pour le processus de mise à niveau. Les mises à niveau entre régions ne sont pas prises en charge.

# Résolution des problèmes et questions et réponses


## Résolution des problèmes


Le message d'erreur du processus de mise à niveau est disponible de différentes manières pour les différents clients MCP. Dans cette page, nous listons quelques conseils généraux concernant les problèmes courants que vous pouvez rencontrer lors de l'utilisation de l'agent de mise à niveau Apache Spark pour Amazon EMR.

**Topics**
+ [

### Erreur : le serveur MCP géré par SMUS n'a pas pu être chargé
](#spark-upgrade-agent-mcp-server-failed)
+ [

### Observation : chargement lent des outils
](#spark-upgrade-agent-slow-tool-loading)
+ [

### Erreur : échec de l'invocation de l'outil en raison d'une erreur de régulation
](#spark-upgrade-agent-throttling-error)
+ [

### Erreur : l'outil répond avec une erreur utilisateur
](#spark-upgrade-agent-user-error)
+ [

### Erreur : l'outil répond avec une erreur interne
](#spark-upgrade-agent-internal-error)

### Erreur : le serveur MCP géré par SMUS n'a pas pu être chargé

+  Vérifiez que votre configuration MCP est correctement configurée. 
+ **Validez la syntaxe JSON** :
  + Assurez-vous que votre JSON est valide et qu'il n'y a aucune erreur de syntaxe
  + Vérifiez s'il manque des virgules, des guillemets ou des crochets
+ Vérifiez vos AWS informations d'identification locales et vérifiez que la politique du rôle MCP IAM est correctement configurée.
+ Exécutez /mcp pour vérifier la disponibilité du serveur MCP pour le cas `Kiro-CLI`

### Observation : chargement lent des outils

+ Le chargement des outils peut prendre quelques secondes lors de la première tentative de lancement du serveur.
+ Si aucun outil ne s'affiche, essayez de redémarrer le chat,
+ Exécutez `/tools` la commande pour vérifier la disponibilité de l'outil.
+ Exécuter `/mcp` si le serveur est lancé sans erreur.

### Erreur : échec de l'invocation de l'outil en raison d'une erreur de régulation


Si vous atteignez votre limite de service, attendez quelques secondes pour lancer un appel d'outil si vous voyez une exception de limitation.

### Erreur : l'outil répond avec une erreur utilisateur

+ AccessDeniedException - vérifiez le message d'erreur et corrigez le problème d'autorisation.
+ InvalidInputException - vérifiez le message d'erreur et corrigez les paramètres d'entrée de l'outil.
+ ResourceNotFoundException - vérifiez le message d'erreur et corrigez le paramètre d'entrée pour la référence aux ressources.

### Erreur : l'outil répond avec une erreur interne

+ Si cela s'affiche, `The service is handling high-volume requests` veuillez réessayer d'invoquer l'outil dans quelques secondes.
+ Si vous voyez, `INTERNAL SERVICE EXCEPTION` veuillez documenter l'identifiant d'analyse, le nom de l'outil, tout message d'erreur disponible dans le journal MCP ou la réponse de l'outil, ainsi que l'historique des conversations désinfecté en option, puis contactez le AWS support.

## QUESTIONS-RÉPONSES


### 1. Dois-je activer le paramètre « confiance » pour les outils par défaut ?


N'activez pas le paramètre « trust » par défaut pour tous les appels d'outils au départ et opérez sur un environnement de construction versionné par git. Passez en revue l'exécution de chaque outil pour comprendre les modifications apportées, par exemple, passez en revue le plan de mise à niveau avant de donner votre consentement. Ne vous fiez jamais au Kiro ou à l'`fs_write`outil de votre agent : cet outil modifie les fichiers de votre projet et vous devez toujours revoir les modifications avant qu'elles ne soient enregistrées/validées. En général, examinez toutes les modifications proposées aux fichiers avant de les autoriser à être écrites. Utilisez git pour modifier les versions et créer des points de contrôle tout au long du processus de mise à niveau. Renforcez progressivement la confiance : si vous utilisez le système à plusieurs reprises pour plusieurs mises à niveau et que vous avez acquis confiance dans les outils, vous pouvez faire confiance à certains outils de manière sélective.

### 2. Quels sont les exemples d'instructions courants pour tirer parti des outils de mise à niveau ?


Reportez-vous à [Exemples rapides pour l'agent de mise à niveau Spark](emr-spark-upgrade-agent-prompt-examples.md) des exemples rapides sur l'utilisation des outils de mise à niveau.

# Détails du flux de travail de l'agent Spark Upgrade


Pour lancer le processus de mise à niveau, vous aurez besoin du code de l'application Spark cloné dans votre environnement de développement (localement EC2 ou [Amazon SageMaker Unified Studio IDE Spaces](https://docs.aws.amazon.com/sagemaker-unified-studio/latest/userguide/create-space.html)), de préférence avec le contrôle de version Git initialisé. En outre, un cluster EMR exécutant la version cible de Spark doit être provisionné et accessible. Enfin, un chemin de compartiment Amazon S3 désigné doit être configuré pour stocker les artefacts de déploiement et le résumé de la mise à niveau tout au long du processus de mise à niveau.

Une fois ces exigences établies, vous pouvez envoyer une invite comme celle-ci pour lancer le flux de travail de mise à niveau :

```
Upgrade my Spark application <local-project-path> from EMR version 6.0.0 to 7.12.0.   
Use EMR-EC2 Cluster <cluster-id> to run the validation and s3 paths   
s3://<please fill in your staging bucket path> to store updated application artifacts.
```

À ce stade, l'agent va orchestrer la mise à niveau à l'aide d'outils spécialisés (pour plus de [détails](emr-spark-upgrade-agent-tools.md)). Le flux de travail suit les étapes suivantes :

1. **Générer un plan** : l'agent analysera la structure de votre projet et générera un plan de mise à niveau. Passez en revue le plan et donnez votre consentement pour continuer.

1. **Révision et personnalisation du plan** : Lorsque vous êtes invité à revoir le plan, plusieurs options s'offrent à vous :

   1. **Procéder tel quel** : accepter le plan et poursuivre l'exécution

   1. **Faites part de vos commentaires** : personnalisez le plan en :

      1. Supprimer les étapes inutiles - Exemple : supprimez toute exécution de test d'intégration. Uniquement compile/build localement, puis passez à la validation EMR.

      1. Ajout d'étapes supplémentaires - Exemple : ajoutez une étape pour exécuter le fichier de test `tests/test_jobs/test_etl_job_x.py` avant la validation EMR.

      1. Modification de l'approche de mise à niveau - Exemple : appliquez Python 3.10 et Java 17 pendant les étapes de compilation et de validation.

1. L'agent régénérera le plan en fonction de vos commentaires et vous demandera à nouveau votre consentement. Ce processus se poursuit jusqu'à ce que vous approuviez le plan final

1. **Compiler et compiler** : l'agent apportera des modifications itératives pour corriger les erreurs de compilation jusqu'à ce que l'application soit compilée et compilée avec succès.

1. **Exécuter des tests unitaires et d'intégration** : si le projet comporte des tests, l'agent exécutera les tests après une compilation réussie. Si l'un des tests échoue, l'agent modifiera le code source de manière itérative jusqu'à ce que les tests soient réussis avant de procéder à la validation EMR.

1. **Correctifs d'exécution et validation : l'agent validera l'application sur le cluster EMR cible et corrigera** de manière itérative les erreurs d'exécution jusqu'à ce que la validation soit réussie. Une fois terminé, vous verrez un résumé de toutes les modifications apportées pour des raisons de compatibilité.

1. **Résumé de la mise à niveau** : une fois la mise à niveau terminée, l'agent vous fournira un résumé de toutes les modifications de code et de configuration, des mises à jour des versions de dépendance et de toute anomalie de qualité des données détectée pour votre examen.

# Activer la validation de la qualité des données


Vous pouvez activer les contrôles de qualité des données en indiquant à la fois le cluster source et le cluster cible IDs dans votre invite. Le système exécute votre application existante sur le cluster source afin de collecter des métadonnées de base à des fins de comparaison.

**Remarque : seules les opérations d'écriture de Spark peuvent être suivies en termes de qualité des données.**

```
Upgrade my pyspark application <local-path>/pyspark-example-24/ from EMR version 6.0.0 to 7.12.0. Use EMR-EC2 Cluster <source-cluster-id> for source version run  
and <target-cluster-id> for target version run. Use s3 path s3://<please fill in your staging bucket path> to store updated application artifacts  
and s3://<please fill in your staging bucket path>/metadata for storing metadata. Enable data quality checks.
```

## Différences entre les flux de travail liés à


Le flux de travail suit les mêmes étapes que le processus de mise à niveau standard, avec ces étapes supplémentaires dans l'ordre ci-dessus :
+ **[Après l'étape 3 : révision et personnalisation du plan]**
  + **Construire avec la configuration actuelle** : créez l'application avec la configuration actuelle pour la soumission du cluster source.
  + **Valider sur le cluster EMR source** : exécutez l'application d'origine sur la version source de Spark et collectez les métadonnées de sortie pour une comparaison de référence.
+ **[Après l'étape 7 : Résumé de la mise à niveau] Résumé de la qualité des données** : rapport de comparaison de la qualité des données entre les versions et les analyses.

### La fonctionnalité d'inadéquation de la qualité des données inclut actuellement :

+ **Vérifications du schéma** : détecte les modifications de la structure des colonnes : colonnes manquantes ou récemment ajoutées, différences de type de données et modifications de nullabilité.
+ **Vérifications des valeurs** *(colonnes numériques et chaînes uniquement*)
  + Compare les valeurs minimale, maximale et moyenne (moyenne uniquement pour les colonnes numériques).
  + Pour les chaînes, min et max sont basés sur l'ordre lexicographique.
+ **Contrôles statistiques agrégés** : compare le nombre total de lignes entre les sorties source et cible.

## Validation de la qualité des données : portée et limites


La validation de la qualité des données prend en charge l'EC2 étape EMR à l'aide de la commande spark-submit avec la version Spark >= 3.0 et le cluster EMR ne peut pas avoir > 1. StepConcurrencyLevel La validation de la qualité des données évalue les statistiques au niveau des nœuds récepteurs de données du plan de requête Spark (les métadonnées de la source de données/des transformations ne sont pas capturées) et couvre les opérations d'écriture courantes de Spark, notamment les écritures de fichiers, les insertions de base de données, la création de tables et les différentes sorties de sources de données.

# Exemples rapides pour l'agent de mise à niveau Spark


Nous listons quelques exemples de commandes qui peuvent être utilisés dans le processus de mise à niveau.

## 1. Fournir des informations sur l'étape EMR existante à l'agent pour la mise à niveau d'une application Spark


```
Upgrade my Spark application <local-project-path> from EMR version 6.0.0 to 7.12.0.   
Use EMR-EC2 Cluster <cluster-id> to run the validation and s3 paths   
s3://<please fill in your staging bucket path> to store updated application artifacts. The Spark   
application is already executed in the source EMR-EC2 Cluster <cluster-id> with   
step id <step-id>.
```

## 2. Analyse de la liste (utilisée pour les mises à niveau) et vérification de l'état d'une analyse spécifique


```
Can you list all the spark upgrade analysis.
```

```
Describe the analysis with analysis id <analysis id>.
```

## 3. Modifier un plan de mise à niveau après sa génération


```
Help me to update the generated upgrade plan to skip the local test step.
```

## 4. Remplacer la configuration par défaut pour l'exécution d'une tâche de validation de mise à niveau


```
For submitting my EMR Severless validaiton job. I would like to use S3 logging instead  
of CW logging, and use this S3 path <S3 path prefix>.
```

# Création d'un cluster EMR cible/d'une application EMR-S à partir de clusters EMR existants


Si vous possédez déjà un EC2 cluster EMR exécutant la version source de Spark, vous pouvez le cloner pour créer un nouveau cluster avec la même configuration mais une version EMR mise à jour pour exécuter les étapes de validation pendant le processus de mise à niveau.

## Étapes :


1. Connectez-vous à la console Amazon EMR AWS Management Console et ouvrez-la.

1. Dans le volet de navigation de gauche, choisissez Clusters sous EMR activé. EC2

1. Dans la liste des clusters :
   + Utilisez la recherche ou des filtres si nécessaire pour trouver votre cluster.
   + Cochez la case à côté du cluster que vous souhaitez cloner.
   + L'option Cloner apparaîtra en haut de la liste. Choisissez Clone (Cloner).
   + Si le cluster possède des étapes configurées, choisissez Inclure les étapes, puis Continuer pour cloner les étapes ainsi que les autres paramètres du cluster.

1. Vérifiez les paramètres du nouveau cluster qui ont été copiés à partir du cluster d'origine.

1. Mettez à jour la version d'Amazon EMR vers la version cible.

1. Pour des raisons de rentabilité, pensez à activer l'autoscaling lors de la configuration du cluster afin d'ajuster automatiquement la capacité en fonction des demandes de charge de travail.

1. Lorsque vous êtes satisfait de la configuration, sélectionnez Créer un cluster pour lancer le nouveau cluster.

1. Attendez que le cluster atteigne le statut En cours d'exécution et notez l'ID du cluster. Fournissez cet ID à l'agent lorsqu'il est invité à valider l'application mise à jour.

1. [Si vous préférez créer un nouveau cluster à partir de zéro, consultez la documentation EMR : https://docs.aws.amazon.com/emr/ latest/ManagementGuide/emr -gs.html.](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-gs.html)

## Clonage d'une application EMR sans serveur vers la version cible


Il n'existe aucun moyen direct de cloner une application EMR Serverless vers une nouvelle application avec une version EMR différente. Vous pouvez plutôt utiliser l'EMR Serverless SDK/CLI ou la console pour créer une nouvelle application et réutiliser la configuration d'une application existante.

Voici quelques commandes d'assistance de la CLI pour démarrer :

```
aws emr-serverless get-application --application-id XXX > old-config.json  
cat old-config.json | jq '{  
  name: (.application.name + "<suffix to differentiate name from old application>"),  
  releaseLabel: "<target EMR release version>",  
  type: .application.type,  
  initialCapacity: .application.initialCapacity,  
  maximumCapacity: .application.maximumCapacity,  
  autoStartConfiguration: .application.autoStartConfiguration,  
  autoStopConfiguration: .application.autoStopConfiguration,  
  tags: .application.tags,  
  architecture: .application.architecture,  
  runtimeConfiguration: .application.runtimeConfiguration,  
  monitoringConfiguration: .application.monitoringConfiguration  
}' > new-config.json  
aws emr-serverless create-application --cli-input-json file://new-config.json
```

**Remarque :** Assurez-vous que le rôle d'exécution de la tâche pour la nouvelle application autorise EMR Serverless à assumer ce rôle. Examinez la stratégie d'approbation du rôle. Si vous réutilisez le même rôle d'exécution de tâches que celui de l'ancienne application, mettez à jour la politique de confiance pour inclure la nouvelle application, comme indiqué ci-dessous :

```
#Replace the old application id and new application id in the policy  
{  
    "Version": "2012-10-17",		 	 	  
    "Statement": [  
        {  
            "Sid": "ServerlessTrustPolicy",  
            "Effect": "Allow",  
            "Principal": {  
                "Service": "emr-serverless.amazonaws.com"  
            },  
            "Action": "sts:AssumeRole",  
            "Condition": {  
                "StringLike": {  
                    "aws:SourceArn": [  
                        "arn:aws:emr-serverless:us-east-1:<account>:/applications/<old application id>",  
                        "arn:aws:emr-serverless:us-east-1:<account>:/applications/<new application id>"  
                    ]  
                }  
            }  
        }  
    ]  
}
```

# Configuration du rôle IAM


La CloudFormation pile des instructions de configuration automatise la configuration du rôle IAM pour vous. Si vous souhaitez l'exécuter manuellement, veuillez suivre les instructions ci-dessous :

## Configuration du rôle IAM pour le serveur MCP


Pour accéder au serveur MCP géré par SMUS, un rôle IAM est requis avec la politique en ligne suivante :

```
{  
    "Version": "2012-10-17",		 	 	 
    "Statement": [  
        {  
            "Sid": "AllowUseSagemakerUnifiedStudioMcpServer",  
            "Effect": "Allow",  
            "Action": [  
                "sagemaker-unified-studio-mcp:InvokeMcp",  
                "sagemaker-unified-studio-mcp:CallReadOnlyTool",  
                "sagemaker-unified-studio-mcp:CallPrivilegedTool"  
            ],  
            "Resource": [  
                "*"  
            ]  
        }  
    ]  
}
```

Au cours des prochaines étapes, nous allons créer un profil pour ce rôle. Le compte qui assume ce rôle pour obtenir les informations d'identification doit être ajouté à la politique d'attribution du rôle.

```
{  
  "Version": "2012-10-17",		 	 	 
  "Statement": [  
    {  
      "Sid": "AllowAccountToAssumeRole",  
      "Effect": "Allow",  
      "Principal": { "AWS": "arn:aws:iam::<accountId>:root" },  
      "Action": "sts:AssumeRole"  
    }  
  ]  
}
```

## Autorisations supplémentaires par mode de déploiement (EMR- /EMR-S) EC2


### Demandes d'EMR EC2


Remplacez le compartiment intermédiaire Amazon S3 dans la politique par le compartiment Amazon S3 dans lequel vous souhaitez que les artefacts mis à niveau soient stockés

```
{  
  "Version": "2012-10-17",		 	 	 
  "Statement": [  
    {  
      "Effect": "Allow",  
      "Action": [  
        "elasticmapreduce:DescribeCluster",  
        "elasticmapreduce:DescribeStep",  
        "elasticmapreduce:ListSteps",  
        "elasticmapreduce:ListClusters",  
        "elasticmapreduce:DescribeJobFlows",  
        "elasticmapreduce:AddJobFlowSteps",  
        "elasticmapreduce:CreatePersistentAppUI",  
        "elasticmapreduce:DescribePersistentAppUI",  
        "elasticmapreduce:GetPersistentAppUIPresignedURL"  
      ],  
      "Resource": "*"  
    },  
    {  
      "Effect": "Allow",  
      "Action": [  
        "s3:GetBucket*",  
        "s3:GetObject*",  
        "s3:List*",  
        "s3:Put*"  
      ],  
      "Resource": [  
        "arn:aws:s3:::<s3-staging-bucket>",  
        "arn:aws:s3:::<s3-staging-bucket>/*"  
      ]  
    }  
  ]  
}
```

#### Autorisations KMS - Staging Bucket


Si le bucket intermédiaire est chiffré à l'aide d'une clé CMK, ajoutez la politique suivante. Le service utilisera automatiquement la clé CMK configurée sur le compartiment lors du téléchargement des données.

```
{  
  "Effect": "Allow",  
  "Action": [  
    "kms:GenerateDataKey",  
    "kms:Encrypt"  
  ],  
  "Resource": "arn:aws:kms:<region>:<account-id>:key/<cmk-key-id>"  
}
```

### Applications EMR sans serveur


Remplacez le compartiment intermédiaire Amazon S3 dans la politique par le compartiment Amazon S3 dans lequel vous souhaitez que les artefacts mis à niveau soient stockés

```
{  
  "Version": "2012-10-17",		 	 	 
  "Statement": [  
    {  
      "Effect": "Allow",  
      "Action": [  
        "emr-serverless:StartJobRun",  
        "emr-serverless:GetJobRun",  
        "emr-serverless:GetApplication",  
        "emr-serverless:ListApplications",  
        "emr-serverless:GetDashboardForJobRun"  
      ],  
      "Resource": "*"  
    },  
    {  
      "Effect": "Allow",  
      "Action": "iam:PassRole",  
      "Resource": "*",  
      "Condition": {  
        "StringLike": {  
          "iam:PassedToService": "emr-serverless.amazonaws.com"  
        }  
      }  
    },  
    {  
      "Effect": "Allow",  
      "Action": [  
        "logs:GetLogEvents",  
        "logs:DescribeLogStreams"  
      ],  
      "Resource": "arn:aws:logs:*:*:log-group:*"  
    },  
    {  
      "Effect": "Allow",  
      "Action": [  
        "s3:GetBucket*",  
        "s3:GetObject*",  
        "s3:List*",  
        "s3:Put*"  
      ],  
      "Resource": [  
        "arn:aws:s3:::<s3-staging-bucket>",  
        "arn:aws:s3:::<s3-staging-bucket>/*"  
      ]  
    }  
  ]  
}
```

#### Autorisations KMS - Staging Bucket


Si le bucket intermédiaire est chiffré à l'aide d'une clé CMK, ajoutez la politique suivante. Le service utilisera automatiquement la clé CMK configurée sur le compartiment lors du téléchargement des données

```
{  
  "Effect": "Allow",  
  "Action": [  
    "kms:GenerateDataKey",  
    "kms:Encrypt"  
  ],  
  "Resource": "arn:aws:kms:<region>:<account-id>:key/<cmk-key-id>"  
}
```

#### Autorisations KMS - CloudWatch Journaux


Si les CloudWatch journaux sont chiffrés à l'aide d'une clé CMK, ajoutez la politique suivante afin que le service puisse lire les journaux des applications sans serveur EMR.

```
{  
"Effect": "Allow",  
"Action": [  
    "kms:Decrypt",  
    "kms:DescribeKey"  
],  
"Resource": "arn:aws:kms:<region>:<account-id>:key/<cw-logs-cmk-id>"  
}
```

# Configuration des points de terminaison VPC d'interface pour Amazon Unified Studio MCP SageMaker
Configuration des points de terminaison VPC

Vous pouvez établir une connexion privée entre votre VPC et le service Amazon SageMaker Unified Studio MCP en créant un point de terminaison *VPC* d'interface. Les points de terminaison de l'interface sont alimentés par [Amazon VPC](https://aws.amazon.com/vpc/), qui vous permet d'accéder en privé au serveur MCP de votre VPC sans passerelle Internet, appareil NAT, connexion VPN ou connexion. Les instances de votre VPC n'ont pas besoin d'adresses IP publiques pour communiquer avec le service MCP et le trafic entre votre VPC et le service MCP ne quitte pas le réseau Amazon.

Chaque point de terminaison d'interface est représenté par une ou plusieurs [interfaces réseau élastiques](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html) dans vos sous-réseaux VPC. Pour plus d'informations, consultez la section [Points de terminaison VPC d'interface dans le guide](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html) de l'utilisateur Amazon *VPC.*

## Étape 1 : Création d'un point de terminaison VPC d'interface pour Amazon SageMaker Unified Studio MCP


Vous pouvez créer un point de terminaison VPC pour le service Amazon SageMaker Unified Studio MCP à l'aide de la console Amazon VPC ou du. AWS CLI Pour plus d’informations, consultez [Création d’un point de terminaison d’interface](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html#create-interface-endpoint) dans le *Guide de l’utilisateur Amazon VPC*.

Créez un point de terminaison VPC pour Amazon SageMaker Unified Studio MCP en utilisant le nom de service suivant :
+ com.amazonaws. *<aws-region>*. sagemaker-unified-studio-mcp

Si vous activez le DNS privé pour le point de terminaison, vous pouvez envoyer des demandes d'API à Amazon SageMaker Unified Studio MCP en utilisant son nom DNS par défaut pour la région, par exemple, `sagemaker-unified-studio-mcp.us-east-1.api.aws`

Pour plus d’informations, consultez [Accès à un service via un point de terminaison d’interface](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html#access-service-though-endpoint) dans le *Guide de l’utilisateur Amazon VPC*.

## Étape 2 : Création d'une politique de point de terminaison VPC pour Amazon SageMaker Unified Studio MCP


Vous pouvez associer une politique de point de terminaison à votre point de terminaison VPC qui contrôle l'accès à Amazon SageMaker Unified Studio MCP. La politique spécifie les informations suivantes :
+ Le principal qui peut exécuter des actions.
+ Les actions qui peuvent être effectuées.
+ Les ressources sur lesquelles les actions peuvent être exécutées.

Pour plus d’informations, consultez [Contrôle de l’accès aux services avec points de terminaison d’un VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints-access.html) dans le *Guide de l’utilisateur Amazon VPC*.

### Exemple : politique de point de terminaison VPC permettant à MCP d'accéder à un rôle IAM spécifique


Voici un exemple de politique de point de terminaison pour l'accès à Amazon SageMaker Unified Studio MCP. Lorsqu'elle est attachée à un point de terminaison, cette politique accorde l'accès aux actions Amazon SageMaker Unified Studio MCP répertoriées pour un principal de rôle IAM spécifique sur toutes les ressources.

```
{
  "Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "AWS": "arn:aws:iam::ACCOUNT-ID:role/YourRoleName"
      },
      "Action": [
        "sagemaker-unified-studio-mcp:InvokeMcp",
        "sagemaker-unified-studio-mcp:CallReadOnlyTool",
        "sagemaker-unified-studio-mcp:CallPrivilegedTool"
      ],
      "Resource": "*"
    }
  ]
}
```

## Étape 3 : test de votre VPC


La `curl` commande valide la connectivité end-to-end réseau entre votre réseau VPC EC2 () et le point de terminaison VPC en effectuant une demande. HTTP/HTTPS Une réponse curl recevant un message du serveur MCP confirme que le chemin réseau complet est fonctionnel.

### Méthode 1 : avec le DNS privé activé (recommandé)


```
curl https://sagemaker-unified-studio-mcp.us-east-1.api.aws/spark-upgrade/mcp
```

### Méthode 2 : sans activation du DNS privé


```
curl -k https://vpce-0069xxxx-ejwh6xxx.sagemaker-unified-studio-mcp.us-east-1.vpce.amazonaws.com/spark-upgrade/mcp
```

**Note**  
L'`-k`indicateur contourne la vérification du certificat SSL en raison d'une incompatibilité du nom d'hôte entre le nom DNS du point de terminaison du VPC et le nom commun (CN) du certificat.

Dans les deux cas, la commande curl renvoie une réponse :`{"Message":"...."}`. Le retour avec un message vérifie que le chemin réseau est correctement connecté au point de terminaison VPC du service MCP.

## Étape 4 : Commencez à utiliser le point de terminaison VPC MCP


Une fois que vous avez vérifié la connexion, vous pouvez suivre les étapes pour configurer le MCP dans[Configuration de l'agent de mise à niveau](emr-spark-upgrade-agent-setup.md). Utilisez simplement le point de terminaison VPC privé dans votre configuration MCP.

# Utilisation des outils de mise à niveau Spark


## Outils de mise à niveau disponibles


Le service MCP fournit plusieurs outils pour faciliter les mises à niveau de Spark. Les principaux outils sont les suivants :


|  | Nom de l'outil | Catégorie d'outil | Description | 
| --- | --- | --- | --- | 
| 1 | generate\$1spark\$1upgrade\$1plan | Planificateur | Génération d'un plan de mise à niveau EMR- EC2 /EMR-S | 
| 2 | réutiliser\$1existing\$1spark\$1upgrade\$1plan | Planificateur | Réutiliser le plan de mise à niveau local existant | 
| 3 | mettre à jour la configuration | Génération | Mettre à niveau les fichiers de configuration de build | 
| 4 | check\$1and\$1update\$1build\$1environment | Génération | Vérifier/mettre à jour l'environnement Java pour la mise à niveau de Spark | 
| 5 | compile\$1et\$1build\$1project | Génération | Fournir des conseils pour le compiling/building projet | 
| 6 | exécuter\$1validation\$1job | test | Soumettre l'application Spark à EMR- /EMR-S EC2 | 
| 7 | check\$1job\$1status | test | Vérifier l'état de l'exécution de l'EC2 étape EMR ou de la tâche EMR-S | 
| 8 | check\$1and\$1update\$1python\$1environment | Modification du code Spark | Vérifier/mettre à jour l'environnement Python pour la mise à niveau de Spark | 
| 9 | réparer un échec de mise à niveau | Modification du code Spark | Analyser une panne et proposer des solutions | 
| 10 | get\$1data\$1quality\$1summary | Observabilité | Récupérez le résumé de la qualité des données après la mise à niveau de l'application | 
| 11 | describe\$1upgrade\$1analysis | Observabilité | décrire l'analyse donnée | 
| 12 | liste\$1upgrade\$1analyses | Observabilité | liste toutes les analyses créées par le compte courant | 

Pour une liste complète de tous les outils de mise à niveau fournis par le serveur SMUS Managed MCP, vous pouvez répertorier tous les outils du serveur.

# Traitement interrégional pour l'agent de mise à niveau Apache Spark


L'agent de mise à niveau Apache Spark utilise l'inférence entre régions pour traiter les demandes en langage naturel et générer des réponses. Avec l'inférence entre régions, l'agent achemine automatiquement votre demande d'inférence afin d'optimiser les performances, de maximiser les ressources informatiques disponibles et la disponibilité des modèles, et de fournir la meilleure expérience client possible. Le type d'inférence entre régions utilisé dépend de la région dans laquelle vous exécutez l'agent de mise à niveau Apache Spark. Dans la plupart des régions, l'agent sélectionnera la région optimale au sein de votre zone géographique pour traiter vos demandes d'inférence. Toutefois, dans certaines régions, une demande d'inférence faite par l'agent sera acheminée de manière sécurisée vers toutes les ressources informatiques disponibles dans toutes les régions commerciales AWS du monde.

## Inférence interrégionale


L'agent Apache Spark Upgrade est alimenté par et utilise l'inférence entre régions pour répartir le trafic entre les différentes AWS régions afin d'améliorer les performances et la fiabilité de l'inférence des grands modèles de langage (LLM).

Bien que l'inférence entre régions ne change pas l'endroit où votre application Spark ou votre expérience de mise à niveau sont hébergées ou où vos données sont stockées, vos invites de saisie et les résultats de sortie peuvent être transmis à différentes régions pour le traitement des inférences. Toutes les données seront transmises chiffrées sur le réseau sécurisé d’Amazon.

L'utilisation de l'inférence interrégionale n'entraîne aucun coût supplémentaire.

## Régions prises en charge pour l’inférence entre régions


### Régions utilisant l'inférence géographique entre régions


Pour la plupart des régions, les demandes d'inférence entre régions sont conservées dans les AWS régions qui font partie de la même zone géographique que celle où vous exécutez l'agent de mise à niveau Apache Spark. Par exemple, une demande émanant de l'agent de la région de l'Est des États-Unis (Virginie du Nord) est acheminée uniquement vers AWS les régions situées dans la zone géographique des États-Unis d'Amérique. Le tableau suivant décrit les régions vers lesquelles vos demandes peuvent être acheminées en fonction de la zone géographique d'origine de la demande :


|  | Zone géographique prise en charge | Régions d’inférence | 
| --- | --- | --- | 
| 1 | États-Unis | USA Est (Virginie du Nord) (us-east-1), USA Ouest (Oregon) (us-west-2), USA Est (Ohio) (us-east-2), USA Ouest (Californie du Nord) (us-west-2) | 
| 2 | Europe | Europe (Francfort) (eu-central-1), Europe (Irlande) (eu-ouest-1), Europe (Paris) (eu-ouest-3), Europe (Stockholm) (eu-nord-1), Europe (Londres) (eu-ouest-2) | 
| 3 | Asie-Pacifique | Asie-Pacifique (Tokyo) (ap-northeast-1), Asie-Pacifique (Séoul) (ap-northeast-2), Asie-Pacifique (Mumbai) (ap-south-1) | 

### Régions utilisant l'inférence interrégionale globale


**Important**  
Les AWS régions suivantes utilisent l'inférence interrégionale globale. Lorsque vous utilisez l'agent de mise à niveau Apache Spark dans ces régions, vos demandes peuvent être transmises dans le monde entier à d'autres AWS régions pour le traitement des inférences afin d'optimiser les performances et la disponibilité :
+ Amérique du Sud (São Paulo) (sa-east-1)
+ Asie-Pacifique (Singapour) (ap-southeast-1)
+ Asie-Pacifique (Sydney) (ap-southeast-2)
+ Canada (Centre) (ca-central-1)

# Journalisation des appels MCP Amazon SageMaker Unified Studio à l'aide de AWS CloudTrail
CloudTrail Journalisation

Le serveur Amazon SageMaker Unified Studio MCP est intégré à AWS CloudTrail un service qui fournit un enregistrement des actions effectuées par un utilisateur, un rôle ou un AWS service dans le serveur Amazon SageMaker Unified Studio MCP. CloudTrail capture tous les appels d'API pour le serveur Amazon SageMaker Unified Studio MCP sous forme d'événements. Les appels capturés incluent des appels vers le serveur MCP Amazon SageMaker Unified Studio et des appels de code vers d'autres AWS opérations lors de l'exécution de l'outil depuis le serveur SageMaker Unified Studio MCP. Si vous créez un suivi, vous pouvez activer la diffusion continue d' CloudTrail événements vers un compartiment Amazon S3, y compris des événements pour le serveur MCP Amazon SageMaker Unified Studio. Si vous ne configurez pas de suivi, vous pouvez toujours consulter les événements les plus récents dans la CloudTrail console dans **Historique des événements**. À l'aide des informations collectées par CloudTrail, vous pouvez déterminer la demande envoyée au serveur Amazon SageMaker Unified Studio MCP, l'adresse IP à partir de laquelle la demande a été faite, l'auteur de la demande, la date à laquelle elle a été faite, ainsi que des informations supplémentaires.

Pour en savoir plus CloudTrail, consultez le [guide de AWS CloudTrail l'utilisateur](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/).

## Informations sur le serveur MCP Amazon SageMaker Unified Studio dans CloudTrail


CloudTrail est activé sur votre AWS compte lorsque vous le créez. Lorsqu'une activité se produit sur le serveur Amazon SageMaker Unified Studio MCP, cette activité est enregistrée dans un CloudTrail événement avec d'autres événements de AWS service dans **l'historique** des événements. Vous pouvez consulter, rechercher et télécharger les événements récents dans votre AWS compte. Pour plus d'informations, consultez la section [Affichage des événements à l'aide de l'historique des CloudTrail événements](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/view-cloudtrail-events.html).

Pour un enregistrement continu des événements de votre AWS compte, y compris des événements relatifs au serveur SageMaker Unified Studio MCP, créez une trace. Un suivi permet CloudTrail de fournir des fichiers journaux à un compartiment Amazon S3. Par défaut, lorsque vous créez un parcours dans la console, celui-ci s'applique à toutes les AWS régions. Le journal enregistre les événements de toutes les régions de la AWS partition et transmet les fichiers journaux au compartiment Amazon S3 que vous spécifiez. En outre, vous pouvez configurer d'autres AWS services pour analyser plus en détail les données d'événements collectées dans les CloudTrail journaux et agir en conséquence. Pour plus d’informations, consultez les ressources suivantes :
+ [Présentation de la création d’un journal de suivi](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail.html)
+ [CloudTrail services et intégrations pris en charge](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-aws-service-specific-topics.html)
+ [Configuration des notifications Amazon SNS pour CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/configure-sns-notifications-for-cloudtrail.html)
+ [Réception de fichiers CloudTrail journaux de plusieurs régions](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/receive-cloudtrail-log-files-from-multiple-regions.html) et [réception de fichiers CloudTrail journaux de plusieurs comptes](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-receive-logs-from-multiple-accounts.html)

Tous les appels d'outils du serveur SageMaker Unified Studio MCP et les appels d'API aux AWS services pendant les exécutions de l'outil sont enregistrés par. CloudTrail Par exemple, les appels aux différents outils et les appels de AWS service effectués à partir des outils génèrent des entrées dans les fichiers CloudTrail journaux.

Chaque événement ou entrée de journal contient des informations sur la personne ayant initié la demande. Les informations relatives à l’identité permettent de déterminer les éléments suivants :
+ Si la demande a été effectuée avec des informations d’identification d’utilisateur root ou IAM.
+ Si la demande a été effectuée avec des informations d’identification de sécurité temporaires pour un rôle ou un utilisateur fédéré.
+ Si la demande a été faite par un autre AWS service.

Pour de plus amples informations, veuillez consulter l'[élément userIdentity CloudTrail ](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-user-identity.html).

## Comprendre les entrées du fichier journal du serveur Amazon SageMaker Unified Studio MCP


Un suivi est une configuration qui permet de transmettre des événements sous forme de fichiers journaux à un compartiment Amazon S3 que vous spécifiez. CloudTrail les fichiers journaux contiennent une ou plusieurs entrées de journal. Un événement représente une demande unique provenant de n'importe quelle source et inclut des informations sur l'action demandée, la date et l'heure de l'action, les paramètres de la demande, etc. CloudTrail les fichiers journaux ne constituent pas une trace ordonnée des appels d'API publics, ils n'apparaissent donc pas dans un ordre spécifique.

L'exemple suivant montre une entrée de CloudTrail journal illustrant l'`CallTool`action.

```
{
    "eventVersion": "1.09",
    "userIdentity": {
        ...
    },
    "eventTime": "...",
    "eventSource": "sagemaker-unified-studio-mcp.amazonaws.com",
    "eventName": "CallPrivilegedTool",
    "awsRegion": "us-east-1",
    "sourceIPAddress": "...",
    "userAgent": "...",
    "requestParameters": {
        "id": 1,
        "method": "tools/call",
        "params": {
            "name": "generate_spark_upgrade_plan",
            "arguments": "***",
            "_meta": {
                "progressToken": 1
            }
        },
        "jsonrpc": "2.0"
    },
    "responseElements": {
        "result": {
            "content": "***",
            "structuredContent": "***",
            "isError": false
        },
        "id": 1,
        "jsonrpc": "2.0"
    },
    "requestID": "12345678-1234-1234-1234-123456789012",
    "eventID": "87654321-4321-4321-4321-210987654321",
    "readOnly": false,
    "eventType": "AwsMcpEvent",
    "managementEvent": true,
    "recipientAccountId": "123456789012",
    "eventCategory": "Management"
}
```

L'exemple suivant montre une entrée de CloudTrail journal qui illustre l'`AddJobFlowSteps`action d'Amazon SageMaker Unified Studio MCP lors de l'appel d'un outil de mise à niveau.

```
{
    "eventVersion": "1.11",
    "userIdentity": {
        "type": "AssumedRole",
        "principalId": "...",
        "arn": "...",
        "accountId": "123456789012",
        "accessKeyId": "...",
        "sessionContext": {
            ...
        },
        "invokedBy": "sagemaker-unified-studio-mcp.amazonaws.com"
    },
    "eventTime": "...",
    "eventSource": "elasticmapreduce.amazonaws.com",
    "eventName": "AddJobFlowSteps",
    "awsRegion": "us-east-1",
    "sourceIPAddress": "sagemaker-unified-studio-mcp.amazonaws.com",
    "userAgent": "sagemaker-unified-studio-mcp.amazonaws.com",
    "requestParameters": {
        "jobFlowId": "j-2PY4KXXXXXX63",
        "steps": [
            ...
        ]
    },
    "responseElements": {
        "stepIds": [
            ...
        ]
    },
    "requestID": "12345678-1234-1234-1234-123456789013",
    "eventID": "87654321-4321-4321-4321-210987654322",
    "readOnly": false,
    "eventType": "AwsApiCall",
    "managementEvent": true,
    "recipientAccountId": "123456789012",
    "sharedEventID": "12345678-1234-1234-1234-123456789012",
    "vpcEndpointId": "sagemaker-unified-studio-mcp.amazonaws.com",
    "vpcEndpointAccountId": "sagemaker-unified-studio-mcp.amazonaws.com",
    "eventCategory": "Management"
}
```

# Améliorations des services pour les agents Apache Spark
Améliorations du service

L'agent Apache Spark pour Amazon EMR peut utiliser du contenu, par exemple, pour aider l'agent à fournir de meilleures réponses aux questions courantes, à résoudre des problèmes opérationnels ou à des fins de débogage.

## Contenu susceptible d' AWS être utilisé pour améliorer le service

+ Vos demandes en langage naturel et vos réponses générées par les agents Apache Spark pour Amazon EMR et Amazon Notebooks SageMaker 

## Contenu qui AWS n'est pas utilisé pour améliorer le service

+ Code que vous écrivez vous-même pour les applications Spark
+ SageMaker Contexte et métadonnées du bloc-notes
+ Données issues de votre catalogue de données ou d'autres sources de données

Seuls les employés d’Amazon auront accès à ces données. Votre confiance, votre confidentialité et la sécurité du contenu de vos clients sont nos priorités absolues et garantissent que notre utilisation est conforme à nos engagements envers vous. Pour plus d’informations, consultez FAQ sur la confidentialité des données.

## Comment se désinscrire


Pour refuser la collecte de données pour les agents Apache Spark, configurez une politique de désactivation des services d'intelligence artificielle dans le service MCP d'Amazon SageMaker Unified Studio. Pour plus d'informations, consultez les [politiques de désinscription des services d'intelligence artificielle](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_ai-opt-out.html) dans le *Guide de l'utilisateur AWS des Organizations*.

Lorsque vous configurez une politique de désinscription des services d'intelligence artificielle, cela a les effets suivants :
+ AWS supprimera les données collectées et stockées pour améliorer le service avant votre désinscription (le cas échéant).
+ Après votre désinscription, AWS nous ne collecterons ni ne stockerons plus ces données.
+ AWS n'utilisera plus votre contenu pour améliorer le service.