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.
# Points de terminaison de développement
**Note**
**L'expérience de la console pour les points de terminaison de développement a été supprimée à compter du 31 mars 2023.** La création, la mise à jour et la surveillance des points de terminaison de développement sont toujours disponibles via [API de points de terminaison de développement](aws-glue-api-dev-endpoint.md) et [ AWS Glue CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glue/index.html#cli-aws-glue).
Nous vous recommandons vivement de migrer des points de terminaison de développement vers des séances interactives pour les raisons énumérées ci-dessous. Pour connaître les actions requises en matière de migration des points de terminaison de développement vers des séances interactives, veuillez consulter la rubrique [Migration des points de terminaison de développement vers des séances interactives](https://docs.aws.amazon.com/glue/latest/dg/development-migration-checklist.html).
| Description | Points d'extrémité du développeur | Sessions interactives |
| --- | --- | --- |
| Prise en charge de la version Glue | Prend en charge les versions de AWS Glue 0.9 et 1.0 | Prend en charge AWS Glue version 2.0 et ultérieures. |
| Les points de terminaison de développement ne sont désormais pas disponibles dans les régions Asie-Pacifique (Jakarta) (ap-southeast-3), Moyen-Orient (EAU) (me-central-1) Europe (Espagne) (eu-south-2), Europe (Zurich) (eu-central-2) ou dans les autres nouvelles régions. | Les séances interactives ne sont actuellement pas disponibles dans la région Moyen-Orient (EAU) (me-central-1), mais le seront peut-être ultérieurement. |
| Méthode d'accès au cluster Spark | Supporte SSH, le shell REPL, le bloc-notes Jupyter, l'IDE (par exemple) PyCharm | prend en charge le AWS Glue Studio bloc-notes, le bloc-notes Jupyter, divers IDEs (par exemple, Visual Studio Code PyCharm) et SageMaker le bloc-notes AI |
| Délai jusqu'à la première requête | La configuration d'un cluster Spark prend 10 à 15 minutes | La configuration d'un cluster Spark éphémère peut prendre jusqu'à 1 minute |
| Modèle de tarification | AWS frais pour les points de terminaison de développement en fonction de l'heure à laquelle le point de terminaison est provisionné et du nombre de. DPUs Les points de terminaison du développement n'arrivent pas à expiration. Un temps de facturation minimal de 10 minutes est calculé pour chaque point de terminaison de développement mis en service. En outre, les AWS frais pour le bloc-notes Jupyter sur les EC2 instances Amazon et les blocs-notes SageMaker AI lorsque vous les configurez avec des points de terminaison de développement. | AWS frais pour les sessions interactives en fonction de la durée pendant laquelle la session est active et du nombre de DPUs. Les sessions interactives ont des délais d'inactivité configurables. AWS Glue Studioles ordinateurs portables fournissent une interface intégrée pour les sessions interactives et sont proposés sans frais supplémentaires. Un temps de facturation minimal d'une minute est calculé pour chaque session interactive. Les blocs-notes AWS Glue Studio disposent d'une interface intégrée pour les sessions interactives et sont proposés sans frais supplémentaires |
| Expérience de la console | Disponible uniquement via l'interface de ligne de commande et l'API | Disponible via la AWS Glue console, la CLI et APIs |
# Migration des points de terminaison de développement vers des séances interactives
Utilisez la liste de contrôle suivante pour déterminer la méthode appropriée permettant de migrer des points de terminaison de développement vers des séances interactives.
**Votre script dépend-il de fonctionnalités spécifiques à AWS Glue version 0.9 ou 1.0 (par exemple, HDFS, YARN, etc.) ? **
Si la réponse est oui, consultez [Migrating AWS Glue jobs to AWS Glue version 3.0](https://docs.aws.amazon.com/glue/latest/dg/migrating-version-30.html) pour savoir comment migrer de Glue 0.9 ou 1.0 vers Glue 3.0 et versions ultérieures.
**Quelle méthode vous permet d'accéder à votre point de terminaison de développement ?**
| Si vous utilisez cette méthode, | Procédez comme suit |
| --- | --- |
| SageMaker Carnet AI, bloc-notes Jupyter ou JupyterLab | Migrez vers le [bloc-notes AWS Glue Studio](https://docs.aws.amazon.com/glue/latest/dg/interactive-sessions-gs-notebook.html) en téléchargeant les fichiers .ipynb sur Jupyter et créez une nouvelle tâche de bloc-notes AWS Glue Studio en téléchargeant le fichier .ipynb. Vous pouvez également utiliser [ SageMaker AI Studio](https://aws.amazon.com/blogs/machine-learning/prepare-data-at-scale-in-amazon-sagemaker-studio-using-serverless-aws-glue-interactive-sessions/) et sélectionner le AWS Glue noyau. |
| Zeppelin notebook | Convertissez manuellement le bloc-notes en bloc-notes Jupyter en copiant et collant du code ou automatiquement à l'aide d'un convertisseur tiers tel que ze2nb. Utilisez ensuite le bloc-notes dans AWS Glue Studio Notebook ou SageMaker AI Studio. |
| IDE | Voir [AWS GlueTâches d'auteur PyCharm utilisant des sessions AWS Glue interactives](https://aws.amazon.com/blogs/big-data/author-aws-glue-jobs-with-pycharm-using-aws-glue-interactive-sessions/) ou [Utilisation de sessions interactives avec Microsoft Visual Studio Code](https://docs.aws.amazon.com/glue/latest/dg/interactive-sessions-vscode.html). |
| REPL | Installez le [https://docs.aws.amazon.com/glue/latest/dg/interactive-sessions.html](https://docs.aws.amazon.com/glue/latest/dg/interactive-sessions.html) en local, puis exécutez la commande suivante : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/development-migration-checklist.html) |
| SSH | Il n'existe pas d'option correspondante sur les séances interactives. Vous pouvez également utiliser une image Docker. Pour en savoir plus, veuillez consulter la rubrique [Développement à l'aide d'une image Docker](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-libraries.html#develop-local-docker-image). |
Les sections suivantes renseignent sur l'utilisation des points de terminaison du développeur pour développer des tâches dans AWS Glue (version 1.0).
**Topics**
+ [Migration des points de terminaison de développement vers des séances interactives](development-migration-checklist.md)
+ [Développement de scripts à l'aide de points de terminaison de développement](dev-endpoint.md)
+ [Gestion des blocs-notes](notebooks-with-glue.md)
# Développement de scripts à l'aide de points de terminaison de développement
**Note**
Les points de terminaison de développement ne sont pris en charge que pour les versions AWS Glue antérieures à 2.0. Pour un environnement interactif dans lequel vous pouvez créer et tester des scripts ETL, utilisez [Notebooks on AWS Glue Studio](https://docs.aws.amazon.com/glue/latest/ug/notebooks-chapter.html).
AWS Glue peut créer un environnement (appelé *point de terminaison de développement*) que vous pouvez utiliser pour développer et tester de façon itérative vos scripts d'extraction, transformation et chargement (ETL). Vous pouvez créer, modifier et supprimer des points de terminaison de développement à l'aide de l'API ou de la console AWS Glue.
## Gestion de votre environnement de développement
Lorsque vous créez un point de terminaison de développement, vous fournissez des valeurs de configuration pour mettre en service l'environnement de développement. Ces valeurs indiquent à AWS Glue comment configurer le réseau afin que vous puissiez accéder en toute sécurité au point de terminaison et que ce dernier puisse accéder à vos magasins de données.
Vous pouvez alors créer un bloc-notes qui se connecte au point de terminaison et utiliser votre bloc-notes pour créer et tester votre script ETL. Lorsque vous êtes satisfait des résultats de votre processus de développement, vous pouvez créer une tâche ETL qui exécute votre script. Grâce à ce processus, vous pouvez ajouter des fonctions et déboguer vos scripts de manière interactive.
Suivez les didacticiels de cette section pour apprendre à utiliser votre point de terminaison de développement avec des blocs-notes.
**Topics**
+ [Gestion de votre environnement de développement](#dev-endpoint-managing-dev-environment)
+ [Flux de travail de point de terminaison de développement](dev-endpoint-workflow.md)
+ [Comment les terminaux AWS Glue de développement fonctionnent avec les ordinateurs portables SageMaker](dev-endpoint-how-it-works.md)
+ [Ajout d'un point de terminaison de développement](add-dev-endpoint.md)
+ [Accès à votre point de terminaison de développement](dev-endpoint-elastic-ip.md)
+ [Tutoriel : Configuration d'un bloc-notes Jupyter JupyterLab pour tester et déboguer des scripts ETL](dev-endpoint-tutorial-local-jupyter.md)
+ [Tutoriel : Utiliser un bloc-notes SageMaker AI avec votre terminal de développement](dev-endpoint-tutorial-sage.md)
+ [Didacticiel : Utilisation d'un shell REPL avec votre point de terminaison de développement](dev-endpoint-tutorial-repl.md)
+ [Tutoriel : Configuration d'un PyCharm environnement professionnel avec un terminal de développement](dev-endpoint-tutorial-pycharm.md)
+ [Configuration avancée : partage de points de terminaison de développement entre plusieurs utilisateurs](dev-endpoint-sharing.md)
# Flux de travail de point de terminaison de développement
Pour utiliser un point de terminaison de développement AWS Glue, vous pouvez suivre ce flux de travail :
1. Créez un point de terminaison de développement à l'aide de l'API. Ce point de terminaison est lancé dans un Virtual Private Cloud (VPC) avec vos groupes de sécurité définis.
1. L'API interroge le point de terminaison de développement jusqu'à ce qu'il soit alloué et prêt pour le travail. Lorsqu'il est prêt, connectez-vous au point de terminaison de développement à l'aide d'une des méthodes suivantes pour créer et tester les scripts AWS Glue.
+ Créez un bloc-notes basé sur l' SageMaker IA dans votre compte. Pour plus d'informations sur la création d'un bloc-notes, consultez [Créer du code avec des blocs-notes AWS Glue Studio](notebooks-chapter.md).
+ Ouvrez une fenêtre de terminal pour vous connecter directement à un point de terminaison de développement.
+ Si vous disposez de l'édition professionnelle de l'[IDE JetBrains PyCharm Python](https://www.jetbrains.com/pycharm/), connectez-la à un point de développement et utilisez-la pour développer de manière interactive. Si vous insérez `pydevd` des instructions dans votre script, il PyCharm peut prendre en charge les points d'arrêt distants.
1. Une fois que vous avez terminé le débogage et les tests sur votre point de terminaison de développement, vous pouvez le supprimer.
# Comment les terminaux AWS Glue de développement fonctionnent avec les ordinateurs portables SageMaker
L'un des moyens les plus courants d'accéder à vos terminaux de développement consiste à utiliser [Jupyter](https://jupyter.org/) sur des ordinateurs portables. SageMaker Le bloc-notes Jupyter est une application web open source largement utilisée pour la visualisation, l'analytique, le machine learning, etc. Un AWS Glue SageMaker bloc-notes vous offre une expérience de bloc-notes Jupyter avec des terminaux de AWS Glue développement. Dans le AWS Glue SageMaker bloc-notes, l'environnement du bloc-notes Jupyter est préconfiguré avec [SparkMagic](https://github.com/jupyter-incubator/sparkmagic)un plugin Jupyter open source permettant de soumettre des tâches Spark à un cluster Spark distant. [Apache Livy](https://livy.apache.org) est un service qui permet l'interaction avec un cluster Spark distant via une API REST. Dans le AWS Glue SageMaker bloc-notes, SparkMagic est configuré pour appeler l'API REST sur un serveur Livy exécuté sur un point de AWS Glue développement.
Le flux de texte suivant explique le fonctionnement de chaque composant :
*AWS Glue SageMaker bloc-notes : (Jupyter → SparkMagic) → (réseau) → point de terminaison de AWS Glue développement : (Apache Livy → Apache Spark)*
Une fois que vous avez exécuté votre script Spark écrit dans chaque paragraphe d'un bloc-notes Jupyter, le code Spark est soumis au serveur Livy via SparkMagic, puis une tâche Spark nommée « Livy-session-n » s'exécute sur le cluster Spark. Cette tâche s'appelle une séance Livy. La tâche Spark sera exécutée pendant que la séance du bloc-notes sera active. La tâche Spark sera terminée lorsque vous arrêterez le noyau Jupyter à partir du bloc-notes ou lorsque la séance aura expiré. Une tâche Spark est lancée par fichier (.ipynb) de bloc-notes.
Vous pouvez utiliser un seul point de AWS Glue développement avec plusieurs instances de SageMaker bloc-notes. Vous pouvez créer plusieurs fichiers de bloc-notes dans chaque instance de SageMaker bloc-notes. Lorsque vous ouvrez un fichier de bloc-notes et que vous exécutez les paragraphes, une session Livy est lancée par fichier de bloc-notes sur le cluster Spark via SparkMagic. Chaque séance Livy correspond à une seule tâche Spark.
## Comportement par défaut pour les terminaux AWS Glue de développement et les blocs-notes SageMaker
Les tâches Spark s'exécutent en fonction de la [configuration Spark](https://spark.apache.org/docs/2.4.3/configuration.html). Il existe plusieurs manières de définir la configuration de Spark (par exemple, la configuration du cluster Spark, SparkMagic la configuration de Spark, etc.).
Par défaut, Spark alloue des ressources de cluster à une séance Livy en fonction de la configuration du cluster Spark. Dans les points de terminaison de développement AWS Glue, la configuration du cluster dépend du type de processus. Voici un tableau qui explique les configurations les plus courantes par type de tâche.
****
| | Standard | G.1X | G.2X |
| --- | --- | --- | --- |
| spark.driver.memory | 5G | 10G | 20G |
| spark.executor.memory | 5G | 10G | 20G |
| spark.executor.cores | 4 | 8 | 16 |
| spark.dynamicAllocation.enabled | TRUE | TRUE | TRUE |
Le nombre maximum de programmes d’exécution Spark est calculé automatiquement par combinaison de DPU (ou `NumberOfWorkers`) et de type de processus.
****
| | Standard | G.1X | G.2X |
| --- | --- | --- | --- |
| Nombre maximal de programmes d’exécution Spark | (DPU - 1) \$1 2 - 1 | (NumberOfWorkers - 1) | (NumberOfWorkers - 1) |
Par exemple, si votre point de terminaison de développement a 10 processus et que le type de processus est ` G.1X`, alors vous aurez 9 programmes d’exécution Spark et l'ensemble du cluster aura 90 Go de mémoire d'exécuteur puisque chaque exécuteur aura 10 Go de mémoire.
Quel que soit le type de nœud de processus spécifié, l'allocation dynamique des ressources Spark sera activée. Si un jeu de données est suffisamment volumineux, Spark peut allouer tous les programmes d'exécution à une seule séance Livy, car `spark.dynamicAllocation.maxExecutors` n'est pas défini par défaut. Cela signifie que d'autres séances Livy sur le même point de terminaison de développement attendront le lancement de nouveaux programmes d'exécution. Si le jeu de données est peu volumineux, Spark pourra allouer des programmes d'exécution à plusieurs séances Livy en même temps.
**Note**
Pour plus d'informations sur la façon dont les ressources sont allouées dans différents cas d'utilisation et sur la façon dont vous définissez une configuration pour modifier le comportement, consultez [Configuration avancée : partage de points de terminaison de développement entre plusieurs utilisateurs](dev-endpoint-sharing.md).
# Ajout d'un point de terminaison de développement
Utilisez les points de terminaison de développement pour développer et tester de façon itérative vos scripts ETL (extraction, transformation et chargement) dans AWS Glue. L'utilisation des points de terminaison de développement n'est disponible que via l' AWS Command Line Interface.
1. Dans une fenêtre de ligne de commande, entrez une commande similaire à ce qui suit.
```
aws glue create-dev-endpoint --endpoint-name "endpoint1" --role-arn "arn:aws:iam::account-id:role/role-name" --number-of-nodes "3" --glue-version "1.0" --arguments '{"GLUE_PYTHON_VERSION": "3"}' --region "region-name"
```
Cette commande spécifie AWS Glue version 1.0. Comme cette version prend en charge Python 2 et Python 3, vous pouvez utiliser le paramètre `arguments` pour indiquer la version Python souhaitée. Si le paramètre `glue-version` est omis, AWS Glue version 0.9 est utilisé. Pour de plus amples informations sur les versions d'AWS Glue, veuillez consulter [Glue version job property](add-job.md#glue-version-table).
Pour plus d'informations sur les paramètres de ligne de commande supplémentaires, reportez-vous [create-dev-endpoint](https://docs.aws.amazon.com/cli/latest/reference/glue/create-dev-endpoint.html)à la *référence des AWS CLI commandes*.
1. (Facultatif) Entrez la commande suivante pour vérifier le statut du point de terminaison de développement. Lorsque le statut passe à `READY`, le point de terminaison de développement est prêt à être utilisé.
```
aws glue get-dev-endpoint --endpoint-name "endpoint1"
```
# Accès à votre point de terminaison de développement
Lorsque vous créez un point de terminaison de développement dans un Virtual Private Cloud (VPC), AWS Glue renvoie uniquement une adresse IP privée. Le champ de l'adresse IP publique n'est pas renseigné. Lorsque vous créez un point de terminaison de développement non VPC, AWS Glue renvoie uniquement une adresse IP publique.
Si votre point de terminaison de développement possède une **adresse publique**, vérifiez qu'elle est accessible avec la clé privée SSH pour le point de terminaison de développement, comme dans l'exemple suivant.
```
ssh -i dev-endpoint-private-key.pem glue@public-address
```
Supposons que votre point de terminaison de développement possède une **adresse privée**, que votre sous-réseau VPC soit routable à partir de l'Internet public et que ses groupes de sécurité autorisent l'accès entrant depuis votre client. Dans ce cas, suivez les étapes ci-dessous pour attacher une *adresse IP Elastic* à un point de terminaison de développement afin d'autoriser l'accès depuis Internet.
**Note**
Pour utiliser des adresses IP Elastic, le sous-réseau utilisé nécessite une passerelle Internet associée via la table de routage.
**Pour accéder à un point de terminaison de développement en attachant une adresse IP Elastic**
1. Ouvrez la AWS Glue console à l'adresse [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Dans le panneau de navigation, sélectionnez **Dev endpoints** (Points de terminaison de dév.) et accédez à la page des détails des points de terminaison de développement. Enregistrez l'**adresse privée** pour l'utiliser à l'étape suivante.
1. Ouvrez la EC2 console Amazon à l'adresse [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Dans le panneau de navigation, sous **Network & Security (Réseau et sécurité)**, choisissez **Network Interfaces (Interfaces réseau)**.
1. Recherchez le **DNS privé (IPv4)** correspondant à l'**adresse privée** sur la page de détails du point de terminaison de développement de la AWS Glue console.
Vous devrez peut-être modifier les colonnes affichées sur votre EC2 console Amazon. Notez l'**ID d'interface réseau** (ENI) de cette adresse (par exemple, `eni-12345678`).
1. Sur la EC2 console Amazon, sous **Réseau et sécurité**, sélectionnez **Elastic IPs**.
1. Choisissez **Allocate new address** (Allouer une nouvelle adresse), puis **Allocate** (Allouer) pour allouer une nouvelle adresse IP Elastic.
1. Sur la IPs page **Elastic**, choisissez la nouvelle **adresse IP Elastic** allouée. Puis, choisissez **Actions**, **Associate Address** (Associer l'adresse).
1. Dans la page **Associer l'adresse**, procédez comme suit :
+ Pour **Resource type** (Type de ressource), choisissez **Network interface (Interface réseau)**.
+ Dans la zone **Interface réseau**, entrez l'**ID d'interface réseau** (ENI) de l'adresse privée.
+ Choisissez **Associer**.
1. Vérifiez que l'adresse IP Elastic nouvellement associée est accessible avec la clé privée SSH associée au point de terminaison de développement, comme dans l'exemple suivant.
```
ssh -i dev-endpoint-private-key.pem glue@elastic-ip
```
Pour plus d'informations sur l'utilisation d'un hôte bastion pour obtenir un accès SSH à l'adresse privée du point de terminaison de développement, consultez le billet de blog sur la AWS sécurité [Connectez-vous en toute sécurité aux instances Linux exécutées dans un Amazon VPC](https://aws.amazon.com/blogs/security/securely-connect-to-linux-instances-running-in-a-private-amazon-vpc/) privé.
# Tutoriel : Configuration d'un bloc-notes Jupyter JupyterLab pour tester et déboguer des scripts ETL
Dans ce didacticiel, vous allez connecter un bloc-notes Jupyter en JupyterLab cours d'exécution sur votre machine locale à un point de terminaison de développement. Vous procédez ainsi pour pouvoir exécuter, déboguer et tester de manière interactive les scripts Extract-transform-load (ETL) AWS Glue avant de les déployer. Ce didacticiel utilise le réacheminement de port Secure Shell (SSH) pour connecter votre ordinateur local à un point de terminaison de développement AWS Glue. Pour plus d'informations, consultez la page Wikipedia [Redirection de port](https://en.wikipedia.org/wiki/Port_forwarding).
## Étape 1 : Installation JupyterLab et Sparkmagic
Vous pouvez effectuer l'installation JupyterLab en utilisant `conda` ou`pip`. `conda`est un système de gestion de paquets open source et un système de gestion d'environnement qui fonctionne sous Windows, macOS et Linux. `pip`est le programme d'installation du package pour Python.
Si vous effectuez l'installation sur macOS, vous devez avoir installé Xcode avant de pouvoir installer Sparkmagic.
1. Install JupyterLab, Sparkmagic et les extensions associées.
```
$ conda install -c conda-forge jupyterlab
$ pip install sparkmagic
$ jupyter nbextension enable --py --sys-prefix widgetsnbextension
$ jupyter labextension install @jupyter-widgets/jupyterlab-manager
```
1. Vérifiez le répertoire `sparkmagic` depuis `Location`.
```
$ pip show sparkmagic | grep Location
Location: /Users/username/.pyenv/versions/anaconda3-5.3.1/lib/python3.7/site-packages
```
1. Remplacez votre répertoire par celui renvoyé pour`Location`, et installez les noyaux pour Scala et. PySpark
```
$ cd /Users/username/.pyenv/versions/anaconda3-5.3.1/lib/python3.7/site-packages
$ jupyter-kernelspec install sparkmagic/kernels/sparkkernel
$ jupyter-kernelspec install sparkmagic/kernels/pysparkkernel
```
1. Télécharger un exemple de fichier `config`
```
$ curl -o ~/.sparkmagic/config.json https://raw.githubusercontent.com/jupyter-incubator/sparkmagic/master/sparkmagic/example_config.json
```
Dans ce fichier de configuration, vous pouvez configurer les paramètres liés à Spark tels que `driverMemory` et `executorCores`.
## Étape 2 : Démarrer JupyterLab
Lorsque vous démarrez JupyterLab, votre navigateur Web par défaut s'ouvre automatiquement et l'URL `http://localhost:8888/lab/workspaces/{workspace_name}` s'affiche.
```
$ jupyter lab
```
## Étape 3 : lancer le transfert de port SSH pour vous connecter à votre point de terminaison de développement
Ensuite, utilisez la redirection de port local SSH pour transférer un port local (ici, `8998`) vers la destination distante définie par AWS Glue (`169.254.76.1:8998`).
1. Ouvrez une fenêtre de terminal séparée qui vous donne accès à SSH. Dans Microsoft Windows, vous pouvez utiliser le shell BASH fourni par [Git pour Windows](https://git-scm.com/downloads) ou installer [Cygwin](https://www.cygwin.com/).
1. Exécutez la commande SSH suivante, modifiée comme suit :
+ Remplacez `private-key-file-path` par un chemin vers le fichier `.pem` qui contient la clé privée correspondant à la clé publique que vous avez utilisée pour créer le point de terminaison de développement.
+ Si vous réacheminez un autre port que `8998`, remplacez `8998` par le numéro de port que vous utilisez localement. L'adresse, `169.254.76.1:8998`, est le port distant et vous ne la modifiez pas.
+ Remplacez `dev-endpoint-public-dns` par l'adresse DNS publique du point de terminaison de développement. Pour trouver cette adresse, accédez à votre point de terminaison dans la console AWS Glue, choisissez le nom et copiez la **Public address** (Adresse publique) qui apparaît dans la page **Endpoint details** (Détails de point de terminaison).
```
ssh -i private-key-file-path -NTL 8998:169.254.76.1:8998 glue@dev-endpoint-public-dns
```
Vous verrez probablement un message d'avertissement, tel que le suivant :
```
The authenticity of host 'ec2-xx-xxx-xxx-xx.us-west-2.compute.amazonaws.com (xx.xxx.xxx.xx)'
can't be established. ECDSA key fingerprint is SHA256:4e97875Brt+1wKzRko+JflSnp21X7aTP3BcFnHYLEts.
Are you sure you want to continue connecting (yes/no)?
```
Entrez **yes** et laissez la fenêtre du terminal ouverte pendant que vous l'utilisez JupyterLab.
1. Vérifiez que le réacheminement du port SSH fonctionne correctement avec le point de terminaison de développement.
```
$ curl localhost:8998/sessions
{"from":0,"total":0,"sessions":[]}
```
## Étape 4 : exécuter un fragment de script simple dans un paragraphe de bloc-notes
Votre bloc-notes JupyterLab devrait désormais fonctionner avec votre terminal de développement. Saisissez le fragment de script ci-après dans votre bloc-notes et exécutez-le.
1. Vérifiez que Spark fonctionne correctement. La commande suivante demande à Spark de calculer `1`, puis d'imprimer la valeur.
```
spark.sql("select 1").show()
```
1. Vérifiez si AWS Glue Data Catalog l'intégration fonctionne. La commande suivante répertorie les tables de Data Catalog.
```
spark.sql("show tables").show()
```
1. Vérifiez qu'un simple fragment de script qui utilise des bibliothèques AWS Glue fonctionne.
Le script suivant utilise les métadonnées de la table `persons_json` dans AWS Glue Data Catalog pour créer un `DynamicFrame` à partir de vos exemples de données. Il affiche ensuite le nombre d'éléments et le schéma des données.
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
# Create a Glue context
glueContext = GlueContext(SparkContext.getOrCreate())
# Create a DynamicFrame using the 'persons_json' table
persons_DyF = glueContext.create_dynamic_frame.from_catalog(database="legislators", table_name="persons_json")
# Print out information about *this* data
print("Count: ", persons_DyF.count())
persons_DyF.printSchema()
```
La sortie du script est la suivante.
```
Count: 1961
root
|-- family_name: string
|-- name: string
|-- links: array
| |-- element: struct
| | |-- note: string
| | |-- url: string
|-- gender: string
|-- image: string
|-- identifiers: array
| |-- element: struct
| | |-- scheme: string
| | |-- identifier: string
|-- other_names: array
| |-- element: struct
| | |-- note: string
| | |-- name: string
| | |-- lang: string
|-- sort_name: string
|-- images: array
| |-- element: struct
| | |-- url: string
|-- given_name: string
|-- birth_date: string
|-- id: string
|-- contact_details: array
| |-- element: struct
| | |-- type: string
| | |-- value: string
|-- death_date: string
```
## Résolution des problèmes
+ Au cours de l'installation de JupyterLab, si votre ordinateur se trouve derrière un proxy ou un pare-feu d'entreprise, vous risquez de rencontrer des erreurs HTTP et SSL en raison de profils de sécurité personnalisés gérés par les services informatiques de l'entreprise.
Voici un exemple d'erreur typique qui se produit lorsque `conda` ne peut pas se connecter à ses propres référentiels :
```
CondaHTTPError: HTTP 000 CONNECTION FAILED for url
```
Cela peut se produire parce que votre entreprise peut bloquer les connexions aux référentiels les plus utilisés en Python et dans JavaScript les communautés. Pour plus d'informations, consultez la section [Problèmes d'installation](https://jupyterlab.readthedocs.io/en/stable/getting_started/installation.html#installation-problems) sur le JupyterLab site Web.
+ Si vous obtenez un message d’erreur *connection refused* (connexion refusée) lorsque vous essayez de vous connecter à votre point de terminaison de développement, vous utilisez peut-être un point de terminaison de développement obsolète. Essayez de créer un nouveau point de terminaison de développement et de vous reconnecter.
# Tutoriel : Utiliser un bloc-notes SageMaker AI avec votre terminal de développement
DansAWS Glue, vous pouvez créer un point de terminaison de développement, puis créer un bloc-notes d' SageMaker IA pour vous aider à développer vos scripts ETL et d'apprentissage automatique. Un bloc-notes SageMaker AI est une instance de calcul d'apprentissage automatique entièrement gérée qui exécute l'application Jupyter Notebook.
1. Dans la console AWS Glue, choisissez **Dev endpoints** (Points de terminaisons de dév.) pour accéder à la liste des points de terminaison de développement.
1. Cochez la case à côté du nom du point de terminaison de développement que vous souhaitez utiliser, puis dans le menu **Action**, choisissez **Créer un SageMaker bloc-notes**.
1. Complétez la page **Create and configure a notebook (Créer et configurer un bloc-notes)** comme suit :
1. Entrez un nom de bloc-notes.
1. Sous **Attach to development endpoint (Attacher au point de terminaison de développement)**, vérifiez le point de terminaison de développement.
1. Créez ou choisissez un rôle Gestion des identités et des accès AWS (IAM).
La création d'un rôle est recommandée. Si vous utilisez un rôle existant, assurez-vous qu'il dispose des autorisations requises. Pour plus d'informations, consultez [Étape 6 : créer une politique IAM pour les ordinateurs portables dotés d' SageMaker intelligence artificielle](create-sagemaker-notebook-policy.md).
1. (Facultatif) Choisissez un VPC, un sous-réseau et un ou plusieurs groupes de sécurité.
1. (Facultatif) Choisissez une clé AWS Key Management Service de chiffrement.
1. (Facultatif) Ajoutez des balises pour l'instance de bloc-notes.
1. Choisissez **Create Notebook (Créer un bloc-notes)**. Sur la page **Notebooks (Bloc-notes)**, choisissez l'icône d’actualisation en haut à droite, puis continuez jusqu'à ce que l'**état** `Ready` s'affiche.
1. Sélectionnez la case à cocher en regard du nom du nouveau bloc-notes, puis choisissez **Open notebook (Ouvrir le bloc-notes)**.
1. Créez un nouveau bloc-notes : sur la page **Jupyter**, choisissez **Nouveau**, puis **Sparkmagic** (). PySpark
Votre écran doit maintenant avoir l'aspect suivant :
![\[La page jupyter comporte une barre de menus, une barre d'outils et un grand champ de texte dans lequel vous pouvez entrer des instructions.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/sagemaker-notebook.png)
1. (Facultatif) En haut de la page, choisissez **Untitled (Sans titre)**, et donnez un nom au bloc-notes.
1. Pour démarrer une application Spark, entrez la commande suivante dans le bloc-notes, puis dans la barre d'outils, choisissez **Run (Exécuter)**.
```
spark
```
Après un court délai, vous devriez voir la réponse suivante :
![\[La réponse du système indique l'état de l'application Spark et affiche le message suivant : SparkSession disponible sous la forme « Spark ».\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/spark-command-response.png)
1. Créez un cadre dynamique et exécutez une requête sur celui-ci : copiez, collez et exécutez le code suivant, qui génère le nombre et le schéma de la table `persons_json`.
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.transforms import *
glueContext = GlueContext(SparkContext.getOrCreate())
persons_DyF = glueContext.create_dynamic_frame.from_catalog(database="legislators", table_name="persons_json")
print ("Count: ", persons_DyF.count())
persons_DyF.printSchema()
```
# Didacticiel : Utilisation d'un shell REPL avec votre point de terminaison de développement
DansAWS Glue, vous pouvez créer un point de terminaison de développement, puis invoquer un shell REPL (Read—Evaluate—Print Loop) pour exécuter le PySpark code de manière incrémentielle afin de pouvoir déboguer de manière interactive vos scripts ETL avant de les déployer.
Pour utiliser un REPL sur un point de terminaison de développement, vous devez être autorisé à accéder au point de terminaison par SSH.
1. Sur votre ordinateur local, ouvrez une fenêtre de terminal pouvant exécuter des commandes SSH, et collez-y la commande SSH modifiée. Exécutez la commande .
En supposant que vous avez accepté la version 1.0 de AWS Glue avec Python 3 pour le point de terminaison de développement, la sortie se présente comme suit :
```
Python 3.6.8 (default, Aug 2 2019, 17:42:44)
[GCC 4.8.5 20150623 (Red Hat 4.8.5-28)] on linux
Type "help", "copyright", "credits" or "license" for more information.
SLF4J: Class path contains multiple SLF4J bindings.
SLF4J: Found binding in [jar:file:/usr/share/aws/glue/etl/jars/glue-assembly.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: Found binding in [jar:file:/usr/lib/spark/jars/slf4j-log4j12-1.7.16.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: See http://www.slf4j.org/codes.html#multiple_bindings for an explanation.
SLF4J: Actual binding is of type [org.slf4j.impl.Log4jLoggerFactory]
Setting default log level to "WARN".
To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).
2019-09-23 22:12:23,071 WARN [Thread-5] yarn.Client (Logging.scala:logWarning(66)) - Neither spark.yarn.jars nor spark.yarn.archive is set, falling back to uploading libraries under SPARK_HOME.
2019-09-23 22:12:26,562 WARN [Thread-5] yarn.Client (Logging.scala:logWarning(66)) - Same name resource file:/usr/lib/spark/python/lib/pyspark.zip added multiple times to distributed cache
2019-09-23 22:12:26,580 WARN [Thread-5] yarn.Client (Logging.scala:logWarning(66)) - Same path resource file:///usr/share/aws/glue/etl/python/PyGlue.zip added multiple times to distributed cache.
2019-09-23 22:12:26,581 WARN [Thread-5] yarn.Client (Logging.scala:logWarning(66)) - Same path resource file:///usr/lib/spark/python/lib/py4j-src.zip added multiple times to distributed cache.
2019-09-23 22:12:26,581 WARN [Thread-5] yarn.Client (Logging.scala:logWarning(66)) - Same path resource file:///usr/share/aws/glue/libs/pyspark.zip added multiple times to distributed cache.
Welcome to
____ __
/ __/__ ___ _____/ /__
_\ \/ _ \/ _ `/ __/ '_/
/__ / .__/\_,_/_/ /_/\_\ version 2.4.3
/_/
Using Python version 3.6.8 (default, Aug 2 2019 17:42:44)
SparkSession available as 'spark'.
>>>
```
1. Vérifiez que le shell de la boucle REPL fonctionne correctement en tapant la déclaration, `print(spark.version)`. Si la version Spark s'affiche, votre REPL est prêt à être utilisé.
1. Vous pouvez maintenant essayer d'exécuter le script simple suivant, ligne par ligne, dans le shell :
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.transforms import *
glueContext = GlueContext(SparkContext.getOrCreate())
persons_DyF = glueContext.create_dynamic_frame.from_catalog(database="legislators", table_name="persons_json")
print ("Count: ", persons_DyF.count())
persons_DyF.printSchema()
```
# Tutoriel : Configuration d'un PyCharm environnement professionnel avec un terminal de développement
Ce didacticiel explique comment connecter l'IDE Python [PyCharm professionnel](https://www.jetbrains.com/pycharm/) exécuté sur votre machine locale à un point de terminaison de développement afin de pouvoir exécuter, déboguer et tester des scripts AWS Glue ETL (extraction, transfert et chargement) de manière interactive avant de les déployer. Les instructions et les captures d'écran du didacticiel sont basées sur la version PyCharm professionnelle 2019.3.
Pour vous connecter à un point de développement de manière interactive, PyCharm Professional doit être installé sur votre ordinateur. Vous ne pouvez pas le faire avec la version gratuite.
**Note**
Le didacticiel utilise Amazon S3 comme source de données. Si vous souhaitez utiliser une source de données JDBC à la place, vous devez exécuter votre point de terminaison de développement dans un cloud privé virtuel (VPC). Pour vous connecter avec SSH à un point de terminaison de développement dans un VPC, vous devez créer un tunnel SSH. Ce didacticiel ne contient pas d'instructions pour la création d'un tunnel SSH. Pour plus d'informations sur l'utilisation de SSH pour se connecter à un point de terminaison de développement dans un VPC, consultez la [section Connexion sécurisée aux instances Linux exécutées dans un Amazon VPC privé](https://aws.amazon.com/blogs/security/securely-connect-to-linux-instances-running-in-a-private-amazon-vpc/) sur le blog de sécurité. AWS
**Topics**
+ [Connecter un PyCharm professionnel à un terminal de développement](#dev-endpoint-tutorial-pycharm-connect)
+ [Déploiement du script sur votre point de terminaison de développement](#dev-endpoint-tutorial-pycharm-deploy)
+ [Configuration d'un interpréteur distant](#dev-endpoint-tutorial-pycharm-interpreter)
+ [Exécution de votre script sur le point de terminaison de développement](#dev-endpoint-tutorial-pycharm-debug-run)
## Connecter un PyCharm professionnel à un terminal de développement
1. Créez un nouveau projet en Python pur dans named. PyCharm `legislators`
1. Créez un fichier nommé `get_person_schema.py` dans le projet avec le contenu suivant :
```
from pyspark.context import SparkContext
from awsglue.context import GlueContext
def main():
# Create a Glue context
glueContext = GlueContext(SparkContext.getOrCreate())
# Create a DynamicFrame using the 'persons_json' table
persons_DyF = glueContext.create_dynamic_frame.from_catalog(database="legislators", table_name="persons_json")
# Print out information about this data
print("Count: ", persons_DyF.count())
persons_DyF.printSchema()
if __name__ == "__main__":
main()
```
1. Effectuez l’une des actions suivantes :
+ Pour la version 0.9 de AWS Glue, téléchargez le fichier de bibliothèque Python AWS Glue, `PyGlue.zip` à l'adresse `https://s3.amazonaws.com/aws-glue-jes-prod-us-east-1-assets/etl/python/PyGlue.zip`, vers un emplacement approprié sur votre ordinateur local.
+ Pour les versions 1.0 et ultérieures de AWS Glue, téléchargez le fichier de bibliothèque Python AWS Glue, `PyGlue.zip` à l'adresse `https://s3.amazonaws.com/aws-glue-jes-prod-us-east-1-assets/etl-1.0/python/PyGlue.zip`, vers un emplacement approprié sur votre ordinateur local.
1. Ajoutez `PyGlue.zip` en tant que racine de contenu pour votre projet dans PyCharm :
+ Dans PyCharm, choisissez **Fichier**, **Paramètres** pour ouvrir la boîte de dialogue **Paramètres**. (Vous pouvez également appuyer sur `Ctrl+Alt+S`.)
+ Développez le projet `legislators` et choisissez **Project Structure** (Structure du projet). Ensuite, dans le panneau droit, sélectionnez **\$1 Add Content Root** (\$1 Ajouter le contenu racine).
+ Accédez à l'emplacement où vous avez enregistré `PyGlue.zip`, sélectionnez-le, puis choisissez **Apply** (Appliquer).
L'écran **Settings** (Paramètres) doit ressembler à ceci :
![\[L'écran des PyCharm paramètres avec PyGlue .zip ajouté en tant que racine de contenu.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/PyCharm_AddContentRoot.png)
Laissez la boîte de dialogue **Settings** (Paramètres) ouverte après avoir choisi **Apply** (Appliquer).
1. Configurez les options de déploiement pour télécharger le script local sur votre terminal de développement à l'aide du protocole SFTP (cette fonctionnalité n'est disponible que dans PyCharm Professional) :
+ Dans la boîte de dialogue **Settings** (Paramètres), développez la section **Build, Execution, Deployment** (Création, exécution, déploiement). Choisissez la sous-section **Deployment** (Déploiement).
+ Sélectionnez l'icône **\$1** en haut du panneau central pour ajouter un nouveau serveur. Définissez **Type** sur `SFTP` et donnez-lui un nom.
+ Définissez **SFTP host (Hôte SFTP)** sur l'**adresse publique** de votre point de terminaison de développement, comme indiqué sur sa page de détails. (Choisissez le nom de votre point de terminaison de développement dans la console AWS Glue pour afficher la page de détails). Pour un point de terminaison de développement s'exécutant dans un VPC, définissez **SFTP host (Hôte SFTP)** sur l'adresse hôte et le port local de votre tunnel SSH sur le point de terminaison de développement.
+ Définissez le champ **User name** (Nom d'utilisateur) sur `glue`.
+ Définissez le champ **Auth type** (Type d'autorisation) sur **Key pair (OpenSSH or Putty)** (Paire de clés (OpenSSH ou Putty)). Définissez le champ **Private key file** (Fichier de clé privée) en accédant à l'emplacement du fichier de clé privée de votre point de terminaison de développement. Notez que PyCharm seuls les types de clés DSA, RSA et ECDSA OpenSSH sont pris en charge et que les clés au format privé de Putty ne sont pas acceptées. Vous pouvez utiliser une up-to-date version de `ssh-keygen` pour générer un type de paire de clés qui PyCharm accepte, en utilisant une syntaxe similaire à la suivante :
```
ssh-keygen -t rsa -f -C ""
```
+ Choisissez **Test connection (Tester la connexion)** et autorisez le test de la connexion. Si la connexion est établie, choisissez **Apply** (Appliquer).
L'écran **Settings** (Paramètres) doit désormais ressembler à ceci :
![\[L'écran des PyCharm paramètres avec un serveur SFTP défini.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/PyCharm_SFTP.png)
Laissez à nouveau la boîte de dialogue **Settings** (Paramètres) ouverte après avoir choisi **Apply** (Appliquer).
1. Mappez le répertoire local à un répertoire distant pour le déploiement :
+ Dans le panneau de droite de la page **Deployment** (Déploiement), sélectionnez l'onglet central en haut, intitulé **Mappings** (Mappages).
+ Dans la colonne **Deployment Path** (Chemin d'accès du déploiement), saisissez un chemin sous `/home/glue/scripts/` pour le déploiement du chemin de votre projet. Par exemple : `/home/glue/scripts/legislators`.
+ Cliquez sur **Appliquer**.
L'écran **Settings** (Paramètres) doit désormais ressembler à ceci :
![\[L'écran PyCharm des paramètres après un mappage de déploiement.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/PyCharm_Mapping.png)
Choisissez **OK** pour fermer la boîte de dialogue ** Settings (Paramètres)**.
## Déploiement du script sur votre point de terminaison de développement
1. Choisissez **Tools (Outils)**, **Deployment (Déploiement)**, puis choisissez le nom sous lequel vous configurez votre point de terminaison de développement, comme illustré dans l'image suivante :
![\[Élément de menu pour le déploiement de votre script.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/PyCharm_Deploy.png)
Une fois que votre script a été déployé, le bas de l'écran doit ressembler à ce qui suit :
![\[En bas de l' PyCharm écran après un déploiement réussi.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/PyCharm_Deployed.png)
1. Dans la barre de menus, choisissez **Tools (Outils)**, **Deployment (Déploiement)**, **Automatic Upload (always) [Téléchargement automatique (toujours)]**. Assurez-vous qu'une coche s'affiche en regard de **Automatic Upload (always) [Téléchargement automatique (toujours)]**.
Lorsque cette option est activée, les fichiers modifiés PyCharm sont automatiquement téléchargés sur le terminal de développement.
## Configuration d'un interpréteur distant
Configurez PyCharm pour utiliser l'interpréteur Python sur le point de terminaison de développement.
1. Dans le menu **File (Fichier)**, choisissez **Settings (Paramètres)**.
1. Développez les **législateurs** du projet et choisissez **Project Interpreter (Interpréteur de projet)**.
1. Choisissez l'icône représentant un engrenage en regard de la liste **Project Interpreter (Interpréteur de projet)**, puis choisissez **Add (Ajouter)**.
1. Dans la boîte de dialogue **Add Python Interpreter (Ajouter un interpréteur Python)** dans le panneau gauche, sélectionnez **SSH Interpreter (Interpréteur SSH)**.
1. Choisissez **Existing server configuration (Configuration du serveur existant)**, et, dans la liste **Deployment configuration (Configuration du déploiement)**, choisissez votre configuration.
Votre écran doit ressembler à l’image suivante.
![\[Dans le panneau gauche, l'interpréteur SSH est sélectionné et, dans le panneau droit, la case d’option Existing server configuration (Configuration du serveur existant) est sélectionnée. Le champ Deployment configuration (Configuration du déploiement) contient le nom de la configuration et le message « Remote SDK is saved in IDE settings, so it needs the deployment server to be saved there too. Which do you prefer? » À la suite de ce message, les choix suivants sont disponsibles : « Create copy of this deployment server in IDE settings » (Créer une copie de ce serveur de déploiement dans les paramètres IDE) et « Move this server to IDE settings. » (Déplacer ce serveur dans les paramètres IDE)\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/PyCharm_Interpreter1.png)
1. Choisissez **Move this server to IDE settings (Déplacer ce serveur dans les paramètres IDE**, puis choisissez **Next (Suivant)**.
1. Dans le champ **Interpreter (Interpréteur)** modifiez le chemin d'accès en ` /usr/bin/gluepython` si vous utilisez Python 2, ou en `/usr/bin/gluepython3` si vous utilisez Python 3. Choisissez ensuite **Finish (Terminer)**.
## Exécution de votre script sur le point de terminaison de développement
Pour exécuter le script :
+ Dans le volet de gauche, cliquez avec le bouton droit sur le nom du fichier et choisissez **Exécuter ** « »**.
Après une série de messages, la sortie finale doit afficher le nombre et le schéma.
```
Count: 1961
root
|-- family_name: string
|-- name: string
|-- links: array
| |-- element: struct
| | |-- note: string
| | |-- url: string
|-- gender: string
|-- image: string
|-- identifiers: array
| |-- element: struct
| | |-- scheme: string
| | |-- identifier: string
|-- other_names: array
| |-- element: struct
| | |-- lang: string
| | |-- note: string
| | |-- name: string
|-- sort_name: string
|-- images: array
| |-- element: struct
| | |-- url: string
|-- given_name: string
|-- birth_date: string
|-- id: string
|-- contact_details: array
| |-- element: struct
| | |-- type: string
| | |-- value: string
|-- death_date: string
Process finished with exit code 0
```
Vous êtes maintenant en mesure de déboguer votre script à distance sur votre point de terminaison de développement.
# Configuration avancée : partage de points de terminaison de développement entre plusieurs utilisateurs
Cette section explique comment vous pouvez tirer parti des terminaux de développement à l'aide de SageMaker blocs-notes dans des cas d'utilisation typiques pour partager des points de développement entre plusieurs utilisateurs.
## Configuration à location unique
Dans les cas d'utilisation à locataire unique, pour simplifier l'expérience du développeur et éviter les conflits de ressources, il est recommandé que chaque développeur utilise son propre point de terminaison de développement dimensionné pour le projet sur lequel il travaille. Cela simplifie également les décisions liées au type de travailleur et au nombre de DPU, les laissant à la discrétion du développeur et du projet sur lequel ils travaillent.
Vous n'aurez pas besoin de vous occuper de l'allocation des ressources, sauf si vous exécutez plusieurs fichiers de bloc-notes simultanément. Si vous exécutez du code dans plusieurs fichiers de bloc-notes simultanément, plusieurs séances Livy seront lancées simultanément. Pour séparer les configurations de cluster Spark afin d'exécuter plusieurs séances Livy simultanément, vous pouvez suivre les étapes qui sont introduites dans les cas d'utilisation multi-locataire.
Par exemple, si votre point de terminaison de développement a 10 processus et que le type de processus est ` G.1X`, alors vous aurez 9 programmes d’exécution Spark et l'ensemble du cluster aura 90 Go de mémoire d'exécuteur puisque chaque exécuteur aura 10 Go de mémoire.
Quel que soit le type de nœud de processus spécifié, l'allocation dynamique des ressources Spark sera activée. Si un jeu de données est suffisamment volumineux, Spark peut allouer tous les programmes d'exécution à une seule séance Livy, car `spark.dynamicAllocation.maxExecutors` n'est pas défini par défaut. Cela signifie que d'autres séances Livy sur le même point de terminaison de développement attendront le lancement de nouveaux programmes d'exécution. Si le jeu de données est peu volumineux, Spark pourra allouer des programmes d'exécution à plusieurs séances Livy en même temps.
**Note**
Pour plus d'informations sur la façon dont les ressources sont allouées dans différents cas d'utilisation et sur la façon dont vous définissez une configuration pour modifier le comportement, consultez [Configuration avancée : partage de points de terminaison de développement entre plusieurs utilisateurs](#dev-endpoint-sharing).
### Configuration multilocataire
**Note**
Veuillez noter que les points de terminaison de développement sont destinés à émuler l'environnement ETL AWS Glue en tant qu'environnement à utilisateur unique. Bien que l'utilisation multi-locataire soit possible, il s'agit d'un cas d'utilisation avancé et il est recommandé à la plupart des utilisateurs de maintenir un modèle de locataire unique pour chaque point de terminaison de développement.
Dans les cas d'utilisation multilocataires, vous devrez peut-être vous occuper de l'allocation des ressources. Le facteur clé est le nombre d'utilisateurs qui utilisent un bloc-notes Jupyter simultanément. Si votre équipe travaille dans un flux de travail follow-the-sun « » et qu'il n'y a qu'un seul utilisateur Jupyter par fuseau horaire, le nombre d'utilisateurs simultanés est d'un seul. Vous n'aurez donc pas à vous soucier de l'allocation des ressources. Cependant, si votre bloc-notes est partagé entre plusieurs utilisateurs et que chaque utilisateur soumet du code de manière ad hoc, vous devrez alors prendre en compte les points ci-dessous.
Pour partitionner les ressources du cluster Spark entre plusieurs utilisateurs, vous pouvez utiliser SparkMagic des configurations. Il existe deux manières différentes de configurer SparkMagic.
#### (A) Utiliser la directive %%configure -f
Si vous souhaitez modifier la configuration par séance Livy à partir du bloc-notes, vous pouvez exécuter la directive `%%configure -f` sur le paragraphe du bloc-notes.
Par exemple, si vous souhaitez exécuter l'application Spark sur 5 programmes d’exécution, vous pouvez exécuter la commande suivante sur le paragraphe du bloc-notes.
```
%%configure -f
{"numExecutors":5}
```
Ensuite, vous ne verrez que 5 programmes d’exécution en cours d'exécution pour le travail sur l'interface utilisateur Spark.
Nous vous recommandons de limiter le nombre maximum d'exécuteurs pour l'allocation dynamique des ressources.
```
%%configure -f
{"conf":{"spark.dynamicAllocation.maxExecutors":"5"}}
```
#### (B) Modifier le fichier de SparkMagic configuration
SparkMagic fonctionne sur la base de l'[API Livy.](https://livy.incubator.apache.org/docs/latest/rest-api.html) SparkMagic crée des sessions Livy avec des configurations telles que`driverMemory`,` driverCores`,`executorMemory`,`executorCores`,,` numExecutors`,`conf`, etc. Ce sont les facteurs clés qui déterminent la quantité de ressources consommées par l'ensemble du cluster Spark. SparkMagic vous permet de fournir un fichier de configuration pour spécifier les paramètres qui sont envoyés à Livy. Pour voir un exemple de fichier de configuration, consultez ce [référentiel Github](https://github.com/jupyter-incubator/sparkmagic/blob/master/sparkmagic/example_config.json).
Si vous souhaitez modifier la configuration de toutes les séances Livy à partir d'un bloc-notes, vous pouvez modifier `/home/ec2-user/.sparkmagic/config.json` pour ajouter `session_config`.
Pour modifier le fichier de configuration sur une instance de SageMaker bloc-notes, vous pouvez suivre ces étapes.
1. Ouvrez un SageMaker bloc-notes.
1. Ouvrez le noyau Terminal.
1. Exécutez les commandes suivantes :
```
sh-4.2$ cd .sparkmagic
sh-4.2$ ls
config.json logs
sh-4.2$ sudo vim config.json
```
Par exemple, vous pouvez ajouter ces lignes à ` /home/ec2-user/.sparkmagic/config.json` et redémarrer le noyau Jupyter à partir du bloc-notes.
```
"session_configs": {
"conf": {
"spark.dynamicAllocation.maxExecutors":"5"
}
},
```
### Consignes et bonnes pratiques
Pour éviter ce type de conflit de ressources, vous pouvez utiliser des approches de base telles que :
+ Accroître la taille d’un cluster Spark en augmentant `NumberOfWorkers` (mise à l'échelle horizontale) et en mettant à niveau `workerType` (mise à l'échelle verticale)
+ Allouer moins de ressources par utilisateur (moins de ressources par séance Livy)
Votre approche dépendra de votre cas d'utilisation. Si vous avez un point de terminaison de développement plus important et qu'il n'y a pas une énorme quantité de données, la possibilité d'un conflit de ressources diminuera considérablement, car Spark peut allouer des ressources en fonction d'une stratégie d'allocation dynamique.
Comme décrit ci-dessus, le nombre de programmes d’exécution Spark peut être calculé automatiquement en fonction d'une combinaison de DPU (ou `NumberOfWorkers`) et de type de processus. Chaque application Spark lance un pilote et plusieurs programmes d’exécution. Pour effectuer un calcul, ` NumberOfWorkers` devra être égal à `NumberOfExecutors + 1`. La matrice ci-dessous explique la capacité dont vous avez besoin dans votre point de terminaison de développement en fonction du nombre d'utilisateurs simultanés.
****
| Nombre d'utilisateurs simultanés de blocs-notes | Nombre d'exécuteurs Spark que vous souhaitez allouer par utilisateur | Total NumberOfWorkers pour votre point de terminaison de développement |
| --- | --- | --- |
| 3 | 5 | 18 |
| 10 | 5 | 60 |
| 50 | 5 | 300 |
Si vous souhaitez allouer moins de ressources par utilisateur, ` spark.dynamicAllocation.maxExecutors` (ou `numExecutors`) serait le paramètre le plus simple à configurer en tant que paramètre de séance Livy. Si vous définissez la configuration ci-dessous`/home/ec2-user/.sparkmagic/config.json`, vous SparkMagic attribuerez un maximum de 5 exécuteurs par session Livy. Cela aidera à répartir les ressources par séance Livy.
```
"session_configs": {
"conf": {
"spark.dynamicAllocation.maxExecutors":"5"
}
},
```
Supposons qu'il y ait un point de terminaison de développement avec 18 processus (G.1X) et qu'il y ait 3 utilisateurs de blocs-notes simultanément. Si votre configuration de séance dispose de ` spark.dynamicAllocation.maxExecutors=5`, chaque utilisateur peut utiliser 1 pilote et 5 programmes d'exécution. Il n'y aura pas de conflits de ressources même si vous exécutez plusieurs paragraphes de bloc-notes en même temps.
#### Compromis
Avec cette configuration de séance `"spark.dynamicAllocation.maxExecutors":"5"`, vous pourrez éviter les erreurs de conflit de ressources et vous n'aurez pas besoin d'attendre l'allocation des ressources lorsqu'il y a des accès utilisateurs simultanés. Cependant, même lorsqu'il existe de nombreuses ressources gratuites (par exemple, il n'y a pas d'autres utilisateurs simultanés), Spark ne peut pas affecter plus de 5 programmes d'exécution pour votre séance Livy.
#### Autres remarques
Il est recommandé d'arrêter le noyau Jupyter lorsque vous arrêtez d'utiliser un bloc-notes. Cela libérera des ressources et les autres utilisateurs de blocs-notes pourront utiliser ces ressources immédiatement sans attendre l'expiration du noyau (arrêt automatique).
### Problèmes courants
Même en suivant les directives, vous pouvez rencontrer certains problèmes.
#### Séance introuvable
Lorsque vous essayez d'exécuter un paragraphe de bloc-notes même si votre séance Livy est déjà résiliée, vous verrez le message ci-dessous. Pour activer la séance Livy, vous devez redémarrer le noyau Jupyter en sélectionnant **Kernel** (Noyau) > **Restart** (Redémarrer) dans le menu Jupyter, puis exécuter à nouveau le paragraphe du bloc-notes.
```
An error was encountered:
Invalid status code '404' from http://localhost:8998/sessions/13 with error payload: "Session '13' not found."
```
#### Nombre de ressources YARN insuffisant
Lorsque vous essayez d'exécuter un paragraphe de bloc-notes même si votre cluster Spark ne dispose pas de suffisamment de ressources pour démarrer une nouvelle séance Livy, le message ci-dessous s'affiche. Vous pouvez souvent éviter ce problème en suivant les instructions. Cependant, il est possible que vous soyez confronté à ce problème. Pour contourner le problème, vous pouvez vérifier s'il existe des séances Livy actives inutiles. S'il existe des séances Livy inutiles, vous devrez les résilier pour libérer les ressources du cluster. Pour en savoir plus, consultez la section suivante.
```
Warning: The Spark session does not have enough YARN resources to start.
The code failed because of a fatal error:
Session 16 did not start up in 60 seconds..
Some things to try:
a) Make sure Spark has enough available resources for Jupyter to create a Spark context.
b) Contact your Jupyter administrator to make sure the Spark magics library is configured correctly.
c) Restart the kernel.
```
### Surveillance et débogage
Cette section décrit les techniques de surveillance des ressources et des séances.
#### Surveillance et débogage de l'allocation des ressources du cluster
Vous pouvez consulter l'interface utilisateur de Spark pour contrôler le nombre de ressources allouées par séance Livy et quelles sont les configurations Spark efficaces sur la tâche. Pour activer l'interface utilisateur de Spark, consultez [Activation de l'interface utilisateur web Apache Spark pour les points de terminaison de développement](https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-dev-endpoints.html).
(Facultatif) Si vous avez besoin d'une vue en temps réel de l'interface utilisateur Spark, vous pouvez configurer un tunnel SSH sur le serveur d'historique Spark exécuté sur le cluster Spark.
```
ssh -i -N -L 8157::18080 glue@
```
Vous pouvez alors ouvrir la page http://localhost:8157 dans votre navigateur pour afficher localement l'interface utilisateur Spark.
#### Séances Livy gratuites inutiles
Passez en revue ces procédures pour arrêter toutes les séances Livy inutiles à partir d'un bloc-notes ou d'un cluster Spark.
**(a). Résilier les séances Livy à partir d'un bloc-notes**
Vous pouvez arrêter le noyau sur un bloc-notes Jupyter pour résilier aux séances Livy inutiles.
**(b). Résilier les séances Livy à partir d'un cluster Spark**
Si des séances Livy inutiles sont toujours en cours d'exécution, vous pouvez les arrêter sur le cluster Spark.
Avant d'effectuer cette procédure, vous devez configurer votre clé publique SSH pour votre point de terminaison de développement.
Pour vous connecter au cluster Spark, vous pouvez exécuter la commande suivante :
```
$ ssh -i glue@
```
Vous pouvez exécuter la commande suivante pour voir les séances Livy actives :
```
$ yarn application -list
20/09/25 06:22:21 INFO client.RMProxy: Connecting to ResourceManager at ip-255-1-106-206.ec2.internal/172.38.106.206:8032
Total number of applications (application-types: [] and states: [SUBMITTED, ACCEPTED, RUNNING]):2
Application-Id Application-Name Application-Type User Queue State Final-State Progress Tracking-URL
application_1601003432160_0005 livy-session-4 SPARK livy default RUNNING UNDEFINED 10% http://ip-255-1-4-130.ec2.internal:41867
application_1601003432160_0004 livy-session-3 SPARK livy default RUNNING UNDEFINED 10% http://ip-255-1-179-185.ec2.internal:33727
```
Vous pouvez ensuite fermer la séance Livy avec la commande suivante :
```
$ yarn application -kill application_1601003432160_0005
20/09/25 06:23:38 INFO client.RMProxy: Connecting to ResourceManager at ip-255-1-106-206.ec2.internal/255.1.106.206:8032
Killing application application_1601003432160_0005
20/09/25 06:23:39 INFO impl.YarnClientImpl: Killed application application_1601003432160_0005
```
# Gestion des blocs-notes
**Note**
Les points de terminaison de développement ne sont pris en charge que pour les versions AWS Glue antérieures à 2.0. Pour un environnement interactif dans lequel vous pouvez créer et tester des scripts ETL, utilisez [Notebooks on AWS Glue Studio](https://docs.aws.amazon.com/glue/latest/ug/notebooks-chapter.html).
Un bloc-notes permet de développer et de tester de manière interactive vos scripts ETL (extraction, transformation et chargement) sur un terminal de développement. AWS Gluefournit une interface pour les ordinateurs SageMaker portables AI Jupyter. AvecAWS Glue, vous créez et gérez des blocs-notes SageMaker dotés d'intelligence artificielle. Vous pouvez également ouvrir des blocs-notes SageMaker AI depuis la AWS Glue console.
En outre, vous pouvez utiliser Apache Spark avec l' SageMaker IA sur les terminaux de AWS Glue développement qui prennent en charge l' SageMaker IA (mais pas les tâches AWS Glue ETL). SageMaker Spark est une bibliothèque Apache Spark open source pour l' SageMaker IA. Pour plus d'informations, consultez la section [Utilisation d'Apache Spark avec Amazon SageMaker](https://docs.aws.amazon.com/sagemaker/latest/dg/apache-spark.html).
| Région | Code |
| --- | --- |
| La gestion des blocs-notes SageMaker IA dotés de points de terminaison de AWS Glue développement est disponible dans les régions suivantes : AWS [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/notebooks-with-glue.html) |
| USA Est (Ohio) | `us-east-2` |
| USA Est (Virginie du Nord) | `us-east-1` |
| USA Ouest (Californie du Nord) | `us-west-1` |
| USA Ouest (Oregon) | `us-west-2` |
| Asie Pacifique (Tokyo) | `ap-northeast-1` |
| Asie-Pacifique (Séoul) | `ap-northeast-2` |
| Asie-Pacifique (Mumbai) | `ap-south-1` |
| Asie-Pacifique (Singapour) | `ap-southeast-1` |
| Asie-Pacifique (Sydney) | `ap-southeast-2` |
| Canada (Centre) | `ca-central-1` |
| Europe (Francfort) | `eu-central-1` |
| Europe (Irlande) | `eu-west-1` |
| Europe (Londres) | `eu-west-2` |
**Topics**