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.
# Commencer à utiliser Amazon EMR Serverless
Ce didacticiel vous aide à démarrer avec EMR Serverless lorsque vous déployez un exemple de charge de travail Spark ou Hive. Vous allez créer, exécuter et déboguer votre propre application. Nous présentons les options par défaut dans la plupart des parties de ce didacticiel.
Avant de lancer une application EMR sans serveur, effectuez les tâches suivantes.
**Topics**
+ [
## Accorder des autorisations pour utiliser EMR Serverless
](#gs-permissions)
+ [
## Préparer le stockage pour EMR Serverless
](#gs-prepare-storage)
+ [
## Création d'un studio EMR pour exécuter des charges de travail interactives
](#gs-interactive)
+ [
## Création d'un rôle d'exécution de tâches
](#gs-runtime-role)
+ [
# Commencer à utiliser EMR Serverless depuis la console
](gs-console.md)
+ [
# Commencer à partir du AWS CLI
](gs-cli.md)
## Accorder des autorisations pour utiliser EMR Serverless
Pour utiliser EMR Serverless, vous avez besoin d'un utilisateur ou d'un rôle IAM associé à une politique qui accorde des autorisations pour EMR Serverless. Pour créer un utilisateur et associer la politique appropriée à cet utilisateur, suivez les instructions figurant dans[Accorder des autorisations](setting-up.md#setting-up-iam).
## Préparer le stockage pour EMR Serverless
Dans ce didacticiel, vous allez utiliser un compartiment S3 pour stocker les fichiers de sortie et les journaux de l'exemple de charge de travail Spark ou Hive que vous exécuterez à l'aide d'une application EMR sans serveur. Pour créer un bucket, suivez les instructions de la section [Création d'un bucket](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/create-bucket.html) dans le *guide de l'utilisateur de la console Amazon Simple Storage Service*. Remplacez toute autre référence `amzn-s3-demo-bucket` à par le nom du compartiment nouvellement créé.
## Création d'un studio EMR pour exécuter des charges de travail interactives
Si vous souhaitez utiliser EMR Serverless pour exécuter des requêtes interactives via des blocs-notes hébergés dans EMR Studio, vous devez spécifier un compartiment S3 et le [rôle de service minimum pour EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-studio-service-role.html#emr-studio-service-role-serverless) Serverless afin de créer un espace de travail. Pour connaître les étapes de configuration, consultez la section [Configurer un studio EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-studio-set-up.html) dans le guide de gestion Amazon *EMR.* Pour plus d'informations sur les charges de travail interactives, consultez[Exécutez des charges de travail interactives avec EMR Serverless via EMR Studio](interactive-workloads.md).
## Création d'un rôle d'exécution de tâches
Les exécutions de tâches dans EMR Serverless utilisent un rôle d'exécution qui fournit des autorisations détaillées à des ressources spécifiques Services AWS lors de l'exécution. Dans ce didacticiel, un compartiment S3 public héberge les données et les scripts. Le bucket `amzn-s3-demo-bucket` stocke la sortie.
Pour configurer un rôle d'exécution de tâche, créez d'abord un rôle d'exécution avec une politique de confiance afin qu'EMR Serverless puisse utiliser le nouveau rôle. Ensuite, associez la politique d'accès S3 requise à ce rôle. Les étapes suivantes vous guident tout au long du processus.
------
#### [ Console ]
1. Accédez à la console IAM à [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) l'adresse.
1. Dans le volet de navigation de gauche, choisissez **Politiques**.
1. Choisissez **Create Policy** (Créer une politique).
1. La page **Créer une politique** s'ouvre dans un nouvel onglet. Sélectionnez l'**éditeur de politique en** tant que Json et collez le JSON de politique ci-dessous.
**Important**
Remplacez `amzn-s3-demo-bucket` dans la politique ci-dessous par le nom réel du bucket créé dans[Préparer le stockage pour EMR Serverless](#gs-prepare-storage). Il s'agit d'une politique de base pour l'accès à S3. Pour d'autres exemples de rôles d'exécution de tâches, consultez[Rôles d'exécution des tâches pour Amazon EMR Serverless](security-iam-runtime-role.md).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ReadAccessForEMRSamples",
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::*.elasticmapreduce",
"arn:aws:s3:::*.elasticmapreduce/*"
]
},
{
"Sid": "FullAccessToOutputBucket",
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetObject",
"s3:ListBucket",
"s3:DeleteObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::amzn-s3-demo-bucket/*"
]
},
{
"Sid": "GlueCreateAndReadDataCatalog",
"Effect": "Allow",
"Action": [
"glue:GetDatabase",
"glue:CreateDatabase",
"glue:GetDataBases",
"glue:CreateTable",
"glue:GetTable",
"glue:UpdateTable",
"glue:DeleteTable",
"glue:GetTables",
"glue:GetPartition",
"glue:GetPartitions",
"glue:CreatePartition",
"glue:BatchCreatePartition",
"glue:GetUserDefinedFunctions"
],
"Resource": [
"*"
]
}
]
}
```
------
1. Choisissez **Suivant** pour saisir le nom de votre politique, tel que `EMRServerlessS3AndGlueAccessPolicy` « **Créer une politique** »
1. Dans le volet de navigation gauche de la console IAM, sélectionnez **Rôles**.
1. Choisissez **Créer un rôle**.
1. Pour le type de rôle, choisissez **Politique de confiance personnalisée** et collez la politique de confiance suivante. Cela permet aux tâches soumises à vos applications Amazon EMR Serverless d'accéder à d'autres applications en votre Services AWS nom.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"sts:AssumeRole"
],
"Resource": "arn:aws:iam::123456789012:role/EMRServerlessExecutionRole",
"Sid": "AllowSTSAssumerole"
}
]
}
```
------
1. Choisissez **Suivant** pour accéder à la page **Ajouter des autorisations**, puis sélectionnez **EMRServerlessS3 AndGlueAccessPolicy**.
1. Dans la page **Nom, révision et création**, pour **Nom du rôle**, entrez le nom de votre rôle, par exemple,`EMRServerlessS3RuntimeRole`. Pour créer ce rôle IAM, choisissez **Create role**.
------
#### [ CLI ]
1. Créez un fichier nommé `emr-serverless-trust-policy.json` contenant la stratégie d'approbation à utiliser pour le rôle IAM. Le fichier doit contenir la politique suivante.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "EMRServerlessTrustPolicy",
"Action": [
"sts:AssumeRole"
],
"Effect": "Allow",
"Resource": "arn:aws:iam::123456789012:role/EMRServerlessExecutionRole"
}
]
}
```
------
1. Créez un rôle IAM nommé `EMRServerlessS3RuntimeRole`. Utilisez la politique de confiance que vous avez créée à l'étape précédente.
```
aws iam create-role \
--role-name EMRServerlessS3RuntimeRole \
--assume-role-policy-document file://emr-serverless-trust-policy.json
```
Notez l'ARN dans la sortie. Vous utilisez l'ARN du nouveau rôle lors de la soumission des tâches, appelé ensuite`job-role-arn`.
1. Créez un fichier nommé `emr-sample-access-policy.json` qui définit la politique IAM pour votre charge de travail. Cela fournit un accès en lecture au script et aux données stockées dans des compartiments S3 publics et un accès en lecture-écriture à. `amzn-s3-demo-bucket`
**Important**
Remplacez `amzn-s3-demo-bucket` dans la politique ci-dessous par le nom réel du bucket créé dans[Préparer le stockage pour EMR Serverless](#gs-prepare-storage).. Il s'agit d'une politique de base pour l'accès à AWS Glue et S3. Pour d'autres exemples de rôles d'exécution de tâches, consultez[Rôles d'exécution des tâches pour Amazon EMR Serverless](security-iam-runtime-role.md).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ReadAccessForEMRSamples",
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::*.elasticmapreduce",
"arn:aws:s3:::*.elasticmapreduce/*"
]
},
{
"Sid": "FullAccessToOutputBucket",
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetObject",
"s3:ListBucket",
"s3:DeleteObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::amzn-s3-demo-bucket/*"
]
},
{
"Sid": "GlueCreateAndReadDataCatalog",
"Effect": "Allow",
"Action": [
"glue:GetDatabase",
"glue:CreateDatabase",
"glue:GetDataBases",
"glue:CreateTable",
"glue:GetTable",
"glue:UpdateTable",
"glue:DeleteTable",
"glue:GetTables",
"glue:GetPartition",
"glue:GetPartitions",
"glue:CreatePartition",
"glue:BatchCreatePartition",
"glue:GetUserDefinedFunctions"
],
"Resource": [
"*"
]
}
]
}
```
------
1. Créez une stratégie IAM nommée `EMRServerlessS3AndGlueAccessPolicy` avec le fichier de stratégie que vous avez créé à l'**étape 3**. Prenez note de l'ARN dans la sortie, car vous utiliserez l'ARN de la nouvelle politique à l'étape suivante.
```
aws iam create-policy \
--policy-name EMRServerlessS3AndGlueAccessPolicy \
--policy-document file://emr-sample-access-policy.json
```
Notez l'ARN de la nouvelle politique dans le résultat. Vous le remplacerez `policy-arn` à l'étape suivante.
1. Associez la politique IAM `EMRServerlessS3AndGlueAccessPolicy` au rôle `EMRServerlessS3RuntimeRole` d'exécution du job.
```
aws iam attach-role-policy \
--role-name EMRServerlessS3RuntimeRole \
--policy-arn policy-arn
```
------
# Commencer à utiliser EMR Serverless depuis la console
Cette section décrit l'utilisation d'EMR Serverless, notamment la création d'un studio EMR. Il décrit également comment soumettre des exécutions de tâches et consulter les journaux.
**Topics**
+ [
## Étape 1 : Création d'une application EMR sans serveur
](#gs-application-console)
+ [
## Étape 2 : Soumettre une exécution de tâche ou une charge de travail interactive
](#gs-job-run-console)
+ [
## Étape 3 : Afficher l'interface utilisateur et les journaux de l'application
](#gs-output-console)
+ [
## Étape 4 : nettoyer
](#gs-cleanup-console)
## Étape 1 : Création d'une application EMR sans serveur
Créez une nouvelle application avec EMR Serverless comme suit.
1. [Connectez-vous à la console Amazon EMR AWS Management Console et ouvrez-la à https://console.aws.amazon.com l'adresse /emr.](https://console.aws.amazon.com/emr)
1. Dans le volet de navigation de gauche, choisissez **EMR Serverless** pour accéder à la page d'accueil EMR Serverless.
1. Pour créer ou gérer des applications EMR Serverless, vous avez besoin de l'interface utilisateur d'EMR Studio.
+ Si vous disposez déjà d'un studio EMR dans Région AWS lequel vous souhaitez créer une application, sélectionnez **Gérer les applications** pour accéder à votre studio EMR ou sélectionnez le studio que vous souhaitez utiliser.
+ Si vous ne disposez pas d'un studio EMR dans l' Région AWS endroit où vous souhaitez créer une application, choisissez **Commencer**, puis Choisissez **Créer et lancez** Studio. EMR Serverless crée pour vous un studio EMR afin que vous puissiez créer et gérer des applications.
1. Dans l'interface utilisateur de **Create studio** qui s'ouvre dans un nouvel onglet, entrez le nom, le type et la version de publication de votre application. Si vous souhaitez uniquement exécuter des tâches par lots, sélectionnez **Utiliser les paramètres par défaut pour les tâches par lots uniquement**. Pour les charges de travail interactives, sélectionnez **Utiliser les paramètres par défaut pour les charges de travail interactives**. Vous pouvez également exécuter des tâches par lots sur des applications interactives grâce à cette option. Si nécessaire, vous pouvez modifier ces paramètres ultérieurement.
Pour plus d'informations, voir [Création d'un studio](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-studio-create-studio.html).
1. Sélectionnez **Créer une application** pour créer votre première application.
Passez à la section suivante [Étape 2 : Soumettre une exécution de tâche ou une charge de travail interactive](#gs-job-run-console) pour soumettre une exécution de tâche ou une charge de travail interactive.
## Étape 2 : Soumettre une exécution de tâche ou une charge de travail interactive
------
#### [ Spark job run ]
Dans ce didacticiel, nous utilisons un PySpark script pour calculer le nombre d'occurrences de mots uniques dans plusieurs fichiers texte. Un compartiment S3 public en lecture seule stocke à la fois le script et le jeu de données.
**Pour exécuter une tâche Spark**
1. Téléchargez l'exemple de script `wordcount.py` dans votre nouveau compartiment à l'aide de la commande suivante.
```
aws s3 cp s3://us-east-1.elasticmapreduce/emr-containers/samples/wordcount/scripts/wordcount.py s3://amzn-s3-demo-bucket/scripts/
```
1. Si vous [Étape 1 : Création d'une application EMR sans serveur](#gs-application-console) le complétez, vous accédez à la page des **détails de l'application** dans EMR Studio. À cet endroit, choisissez l'option **Soumettre le travail**.
1. Sur la page **Soumettre une tâche**, effectuez les opérations suivantes.
+ Dans le champ **Nom**, entrez le nom que vous souhaitez appeler votre tâche exécutée.
+ Dans le champ **Rôle d'exécution**, entrez le nom du rôle que vous avez créé dans[Création d'un rôle d'exécution de tâches](getting-started.md#gs-runtime-role).
+ Dans le champ **Emplacement du script**, entrez `s3://amzn-s3-demo-bucket/scripts/wordcount.py` l'URI S3.
+ Dans le champ **Arguments du script**, entrez`["s3://amzn-s3-demo-bucket/emr-serverless-spark/output"]`.
+ Dans la section **des propriétés de Spark**, choisissez **Modifier sous forme de texte** et entrez les configurations suivantes.
```
--conf spark.executor.cores=1 --conf spark.executor.memory=4g --conf spark.driver.cores=1 --conf spark.driver.memory=4g --conf spark.executor.instances=1
```
1. Pour démarrer l'exécution de la tâche, choisissez **Soumettre la tâche**.
1. Dans l'onglet **Exécutions de tâches**, vous devriez voir votre nouvelle tâche exécutée avec le statut En **cours d'exécution**.
------
#### [ Hive job run ]
Dans cette partie du didacticiel, nous créons une table, insérons quelques enregistrements et exécutons une requête d'agrégation de comptes. Pour exécuter la tâche Hive, créez d'abord un fichier contenant toutes les requêtes Hive à exécuter dans le cadre d'une tâche unique, téléchargez le fichier sur S3 et spécifiez ce chemin S3 au démarrage de la tâche Hive.
**Pour exécuter une tâche Hive**
1. Créez un fichier appelé `hive-query.ql` contenant toutes les requêtes que vous souhaitez exécuter dans votre tâche Hive.
```
create database if not exists emrserverless;
use emrserverless;
create table if not exists test_table(id int);
drop table if exists Values__Tmp__Table__1;
insert into test_table values (1),(2),(2),(3),(3),(3);
select id, count(id) from test_table group by id order by id desc;
```
1. `hive-query.ql`Téléchargez-le dans votre compartiment S3 à l'aide de la commande suivante.
```
aws s3 cp hive-query.ql s3://amzn-s3-demo-bucket/emr-serverless-hive/query/hive-query.ql
```
1. Si vous [Étape 1 : Création d'une application EMR sans serveur](#gs-application-console) le complétez, vous accédez à la page des **détails de l'application** dans EMR Studio. À cet endroit, choisissez l'option **Soumettre le travail**.
1. Sur la page **Soumettre une tâche**, effectuez les opérations suivantes.
+ Dans le champ **Nom**, entrez le nom que vous souhaitez appeler votre tâche exécutée.
+ Dans le champ **Rôle d'exécution**, entrez le nom du rôle que vous avez créé dans[Création d'un rôle d'exécution de tâches](getting-started.md#gs-runtime-role).
+ Dans le champ **Emplacement du script**, entrez `s3://amzn-s3-demo-bucket/emr-serverless-hive/query/hive-query.ql` l'URI S3.
+ Dans la section **Propriétés de la ruche**, choisissez **Modifier sous forme de texte** et entrez les configurations suivantes.
```
--hiveconf hive.log.explain.output=false
```
+ Dans la section **Configuration du Job**, choisissez **Modifier au format JSON**, puis entrez le code JSON suivant.
```
{
"applicationConfiguration":
[{
"classification": "hive-site",
"properties": {
"hive.exec.scratchdir": "s3://amzn-s3-demo-bucket/emr-serverless-hive/hive/scratch",
"hive.metastore.warehouse.dir": "s3://amzn-s3-demo-bucket/emr-serverless-hive/hive/warehouse",
"hive.driver.cores": "2",
"hive.driver.memory": "4g",
"hive.tez.container.size": "4096",
"hive.tez.cpu.vcores": "1"
}
}]
}
```
1. Pour démarrer l'exécution de la tâche, choisissez **Soumettre la tâche**.
1. Dans l'onglet **Exécutions de tâches**, vous devriez voir votre nouvelle tâche exécutée avec le statut En **cours d'exécution**.
------
#### [ Interactive workload ]
Avec Amazon EMR 6.14.0 et versions ultérieures, vous pouvez utiliser des blocs-notes hébergés dans EMR Studio pour exécuter des charges de travail interactives pour Spark dans EMR Serverless. Pour plus d'informations, notamment sur les autorisations et les conditions requises, consultez[Exécutez des charges de travail interactives avec EMR Serverless via EMR Studio](interactive-workloads.md).
Une fois que vous avez créé votre application et configuré les autorisations requises, procédez comme suit pour exécuter un bloc-notes interactif avec EMR Studio :
1. Accédez à l'onglet **Espaces de travail** dans EMR Studio. Si vous devez toujours configurer un emplacement de stockage Amazon S3 et un [rôle de service EMR Studio](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-studio-service-role.html), sélectionnez le bouton **Configurer le studio** dans la bannière en haut de l'écran.
1. Pour accéder à un bloc-notes, sélectionnez un espace de travail ou créez-en un nouveau. Utilisez **le lancement rapide** pour ouvrir votre espace de travail dans un nouvel onglet.
1. Accédez à l'onglet qui vient d'être ouvert. Sélectionnez l'icône **Calculer** dans le menu de navigation de gauche. **Sélectionnez EMR Serverless comme type de calcul.**
1. Sélectionnez l'application interactive que vous avez créée dans la section précédente.
1. Dans le champ **Rôle d'exécution**, entrez le nom du rôle IAM que votre application EMR Serverless peut assumer pour l'exécution de la tâche. Pour en savoir plus sur les rôles d'exécution, consultez la section [Rôles d'exécution Job](https://docs.aws.amazon.com/emr/latest/EMR-Serverless-UserGuide/security-iam-runtime-role.html) dans le guide de l'*utilisateur Amazon EMR Serverless*.
1. Sélectionnez **Joindre**. Cela peut prendre jusqu'à une minute. La page sera actualisée une fois jointe.
1. Choisissez un noyau et lancez un bloc-notes. Vous pouvez également consulter des exemples de blocs-notes sur EMR Serverless et les copier dans votre espace de travail. Pour accéder aux exemples de blocs-notes, accédez au **`{...}`**menu de navigation de gauche et parcourez les blocs-notes dont le nom de fichier est indiqué `serverless` dans le bloc-notes.
1. Dans le bloc-notes, vous pouvez accéder au lien du journal du pilote et à un lien vers l'interface utilisateur d'Apache Spark, une interface en temps réel qui fournit des indicateurs pour surveiller votre travail. Pour plus d'informations, consultez la section [Surveillance des applications et des tâches EMR sans serveur](https://docs.aws.amazon.com/emr/latest/EMR-Serverless-UserGuide/app-job-metrics.html) dans le guide de l'utilisateur Amazon *EMR* Serverless.
Lorsque vous associez une application à un espace de travail Studio, le démarrage de l'application se déclenche automatiquement si elle n'est pas déjà en cours d'exécution. Vous pouvez également prédémarrer l'application et la garder prête avant de l'associer à l'espace de travail.
------
## Étape 3 : Afficher l'interface utilisateur et les journaux de l'application
Pour afficher l'interface utilisateur de l'application, identifiez d'abord le travail exécuté. Une option pour l'**interface utilisateur Spark** ou **Hive Tez** est disponible dans la première ligne d'options pour cette tâche exécutée, en fonction du type de tâche. Sélectionnez l'option appropriée.
Si vous avez choisi l'interface utilisateur Spark, cliquez sur l'onglet **Executors** pour afficher les journaux des pilotes et des exécuteurs. Si vous avez choisi l'interface utilisateur Hive Tez, cliquez sur l'onglet **Toutes les tâches** pour afficher les journaux.
Une fois que le statut d'exécution de la tâche indique **Success**, vous pouvez consulter le résultat de la tâche dans votre compartiment S3.
## Étape 4 : nettoyer
Bien que l'application que vous avez créée doive s'arrêter automatiquement après 15 minutes d'inactivité, nous vous recommandons tout de même de libérer des ressources que vous n'avez pas l'intention de réutiliser.
Pour supprimer l'application, accédez à la page **Répertorier les applications**. Sélectionnez l'application que vous avez créée et choisissez **Actions → Arrêter** pour arrêter l'application. Une fois que l'application est dans `STOPPED` cet état, sélectionnez-la et choisissez **Actions → Supprimer**.
Pour d'autres exemples d'exécution de tâches Spark et Hive, consultez [Utilisation des configurations Spark lorsque vous exécutez des tâches EMR sans serveur](jobs-spark.md) et[Utilisation de configurations Hive lorsque vous exécutez des tâches EMR sans serveur](jobs-hive.md).
# Commencer à partir du AWS CLI
Commencez à utiliser EMR Serverless à l' AWS CLI aide des commandes with pour créer une application, exécuter des tâches, vérifier le résultat de l'exécution des tâches et supprimer vos ressources.
## Étape 1 : Création d'une application EMR sans serveur
Utilisez la [https://docs.aws.amazon.com/emr-serverless/latest/APIReference/API_CreateApplication.html](https://docs.aws.amazon.com/emr-serverless/latest/APIReference/API_CreateApplication.html)commande pour créer votre première application EMR Serverless. Vous devez spécifier le type d'application et l'étiquette de publication Amazon EMR associés à la version de l'application que vous souhaitez utiliser. Le nom de l'application est facultatif.
------
#### [ Spark ]
Pour créer une application Spark, exécutez la commande suivante.
```
aws emr-serverless create-application \
--release-label emr-6.6.0 \
--type "SPARK" \
--name my-application
```
------
#### [ Hive ]
Pour créer une application Hive, exécutez la commande suivante.
```
aws emr-serverless create-application \
--release-label emr-6.6.0 \
--type "HIVE" \
--name my-application
```
------
Notez l'ID de l'application renvoyé dans la sortie. Vous utiliserez cet identifiant pour démarrer la candidature et lors de la soumission des offres d'emploi, appelé ensuite`application-id`.
Avant de passer à[Étape 2 : Soumettre une tâche exécutée à votre application EMR Serverless](#gs-job-run-cli), assurez-vous que votre application a atteint l'`CREATED`état correspondant à l'[https://docs.aws.amazon.com/emr-serverless/latest/APIReference/API_GetApplication.html](https://docs.aws.amazon.com/emr-serverless/latest/APIReference/API_GetApplication.html)API.
```
aws emr-serverless get-application \
--application-id application-id
```
EMR Serverless crée des travailleurs pour répondre aux tâches que vous demandez. Par défaut, ils sont créés à la demande, mais vous pouvez également spécifier une capacité pré-initialisée en définissant le `initialCapacity` paramètre lors de la création de l'application. Vous pouvez également limiter la capacité maximale totale qu'une application peut utiliser avec le `maximumCapacity` paramètre. Pour en savoir plus sur ces options, consultez [Configuration d'une application lorsque vous travaillez avec EMR Serverless](application-capacity.md).
## Étape 2 : Soumettre une tâche exécutée à votre application EMR Serverless
Votre application EMR Serverless est maintenant prête à exécuter des tâches.
------
#### [ Spark ]
Dans cette étape, nous utilisons un PySpark script pour calculer le nombre d'occurrences de mots uniques dans plusieurs fichiers texte. Un compartiment S3 public en lecture seule stocke à la fois le script et le jeu de données. L'application envoie le fichier de sortie et les données du journal depuis le moteur d'exécution Spark vers le compartiment S3 que vous avez créé `/output` et les `/logs` répertoires qu'il contient.
**Pour exécuter une tâche Spark**
1. Utilisez la commande suivante pour copier le script d'exemple que nous allons exécuter dans votre nouveau compartiment.
```
aws s3 cp s3://us-east-1.elasticmapreduce/emr-containers/samples/wordcount/scripts/wordcount.py s3://amzn-s3-demo-bucket/scripts/
```
1. Dans la commande suivante, remplacez-le par `application-id` l'ID de votre application. `job-role-arn`Remplacez-le par l'ARN du rôle d'exécution dans lequel vous l'avez créé[Création d'un rôle d'exécution de tâches](getting-started.md#gs-runtime-role). *`job-run-name`*Remplacez-le par le nom que vous souhaitez appeler votre tâche exécutée. Remplacez toutes les `amzn-s3-demo-bucket` chaînes par le compartiment Amazon S3 que vous avez créé et ajoutez-les `/output` au chemin. Cela crée un nouveau dossier dans votre compartiment dans lequel EMR Serverless peut copier les fichiers de sortie de votre application.
```
aws emr-serverless start-job-run \
--application-id application-id \
--execution-role-arn job-role-arn \
--name job-run-name \
--job-driver '{
"sparkSubmit": {
"entryPoint": "s3://amzn-s3-demo-bucket/scripts/wordcount.py",
"entryPointArguments": ["s3://amzn-s3-demo-bucket/emr-serverless-spark/output"],
"sparkSubmitParameters": "--conf spark.executor.cores=1 --conf spark.executor.memory=4g --conf spark.driver.cores=1 --conf spark.driver.memory=4g --conf spark.executor.instances=1"
}
}'
```
1. Notez l'ID d'exécution de la tâche renvoyé dans la sortie. `job-run-id`Remplacez-le par cet ID dans les étapes suivantes.
------
#### [ Hive ]
Dans ce didacticiel, nous créons une table, insérons quelques enregistrements et exécutons une requête d'agrégation de comptes. Pour exécuter la tâche Hive, créez d'abord un fichier contenant toutes les requêtes Hive à exécuter dans le cadre d'une tâche unique, téléchargez le fichier sur S3 et spécifiez ce chemin S3 lorsque vous démarrez la tâche Hive.
**Pour exécuter une tâche Hive**
1. Créez un fichier appelé `hive-query.ql` contenant toutes les requêtes que vous souhaitez exécuter dans votre tâche Hive.
```
create database if not exists emrserverless;
use emrserverless;
create table if not exists test_table(id int);
drop table if exists Values__Tmp__Table__1;
insert into test_table values (1),(2),(2),(3),(3),(3);
select id, count(id) from test_table group by id order by id desc;
```
1. `hive-query.ql`Téléchargez-le dans votre compartiment S3 à l'aide de la commande suivante.
```
aws s3 cp hive-query.ql s3://amzn-s3-demo-bucket/emr-serverless-hive/query/hive-query.ql
```
1. Dans la commande suivante, remplacez-le `application-id` par votre propre ID d'application. `job-role-arn`Remplacez-le par l'ARN du rôle d'exécution dans lequel vous l'avez créé[Création d'un rôle d'exécution de tâches](getting-started.md#gs-runtime-role). Remplacez toutes les `amzn-s3-demo-bucket` chaînes par le compartiment Amazon S3 que vous avez créé, puis ajoutez `/output` et `/logs` au chemin. Cela crée de nouveaux dossiers dans votre compartiment, dans lesquels EMR Serverless peut copier les fichiers de sortie et les fichiers journaux de votre application.
```
aws emr-serverless start-job-run \
--application-id application-id \
--execution-role-arn job-role-arn \
--job-driver '{
"hive": {
"query": "s3://amzn-s3-demo-bucket/emr-serverless-hive/query/hive-query.ql",
"parameters": "--hiveconf hive.log.explain.output=false"
}
}' \
--configuration-overrides '{
"applicationConfiguration": [{
"classification": "hive-site",
"properties": {
"hive.exec.scratchdir": "s3://amzn-s3-demo-bucket/emr-serverless-hive/hive/scratch",
"hive.metastore.warehouse.dir": "s3://amzn-s3-demo-bucket/emr-serverless-hive/hive/warehouse",
"hive.driver.cores": "2",
"hive.driver.memory": "4g",
"hive.tez.container.size": "4096",
"hive.tez.cpu.vcores": "1"
}
}],
"monitoringConfiguration": {
"s3MonitoringConfiguration": {
"logUri": "s3://amzn-s3-demo-bucket/emr-serverless-hive/logs"
}
}
}'
```
1. Notez l'ID d'exécution de la tâche renvoyé dans la sortie. `job-run-id`Remplacez-le par cet ID dans les étapes suivantes.
------
## Étape 3 : passez en revue le résultat de votre exécution
L'exécution de la tâche doit généralement prendre 3 à 5 minutes.
------
#### [ Spark ]
Vous pouvez vérifier l'état de votre tâche Spark à l'aide de la commande suivante.
```
aws emr-serverless get-job-run \
--application-id application-id \
--job-run-id job-run-id
```
Lorsque la destination de votre journal est définie sur`s3://amzn-s3-demo-bucket/emr-serverless-spark/logs`, vous pouvez trouver les journaux de cette tâche spécifique exécutée sous`s3://amzn-s3-demo-bucket/emr-serverless-spark/logs/applications/application-id/jobs/job-run-id`.
Pour les applications Spark, EMR Serverless envoie les journaux d'événements toutes les 30 secondes vers le `sparklogs` dossier de destination de votre journal S3. Lorsque votre tâche est terminée, les journaux d'exécution de Spark pour le pilote et les exécuteurs sont téléchargés dans des dossiers nommés de manière appropriée par le type de travailleur, tels que `driver` ou`executor`. La sortie de la PySpark tâche est transférée vers. `s3://amzn-s3-demo-bucket/output/`
------
#### [ Hive ]
Vous pouvez vérifier l'état de votre tâche Hive à l'aide de la commande suivante.
```
aws emr-serverless get-job-run \
--application-id application-id \
--job-run-id job-run-id
```
Lorsque la destination de votre journal est définie sur`s3://amzn-s3-demo-bucket/emr-serverless-hive/logs`, vous pouvez trouver les journaux de cette tâche spécifique exécutée sous`s3://amzn-s3-demo-bucket/emr-serverless-hive/logs/applications/application-id/jobs/job-run-id`.
Pour les applications Hive, EMR Serverless télécharge en permanence le pilote Hive dans le dossier et `HIVE_DRIVER` les journaux de tâches Tez dans `TEZ_TASK` le dossier de votre destination de journal S3. Une fois que le job a atteint son `SUCCEEDED` état, le résultat de votre requête Hive est disponible à l'emplacement Amazon S3 que vous avez spécifié dans le `monitoringConfiguration` champ de`configurationOverrides`.
------
## Étape 4 : nettoyer
Lorsque vous aurez terminé de travailler sur ce didacticiel, pensez à supprimer les ressources que vous avez créées. Nous vous recommandons de libérer les ressources que vous n'avez pas l'intention de réutiliser.
### Supprimer votre candidature
Pour supprimer une application, utilisez la commande suivante.
```
aws emr-serverless delete-application \
--application-id application-id
```
### Supprimer votre bucket de log S3
Pour supprimer votre compartiment de journalisation et de sortie S3, utilisez la commande suivante. Remplacez `amzn-s3-demo-bucket` par le nom réel du compartiment S3 créé dans[Préparer le stockage pour EMR Serverless](getting-started.md#gs-prepare-storage)..
```
aws s3 rm s3://amzn-s3-demo-bucket --recursive
aws s3api delete-bucket --bucket amzn-s3-demo-bucket
```
### Supprimer votre rôle d'exécution des tâches
Pour supprimer le rôle d'exécution, détachez la politique du rôle. Vous pouvez ensuite supprimer à la fois le rôle et la politique.
```
aws iam detach-role-policy \
--role-name EMRServerlessS3RuntimeRole \
--policy-arn policy-arn
```
Pour supprimer le rôle, utilisez la commande suivante.
```
aws iam delete-role \
--role-name EMRServerlessS3RuntimeRole
```
Pour supprimer la politique attachée au rôle, utilisez la commande suivante.
```
aws iam delete-policy \
--policy-arn policy-arn
```
Pour d'autres exemples d'exécution de tâches Spark et Hive, consultez [Utilisation des configurations Spark lorsque vous exécutez des tâches EMR sans serveur](jobs-spark.md) et[Utilisation de configurations Hive lorsque vous exécutez des tâches EMR sans serveur](jobs-hive.md).