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.
# Exécution de charges de travail interactives sur Amazon EMR on EKS
Le *point de terminaison interactif* est une passerelle qui relie Amazon EMR Studio à Amazon EMR on EKS afin que vous puissiez exécuter des charges de travail interactives. [Vous pouvez utiliser des points de terminaison interactifs avec EMR Studio pour exécuter des analyses interactives avec des jeux de données dans des magasins de données tels qu'[Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/) et Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/gettingstartedguide/).
**Cas d’utilisation**
+ Créez un script ETL avec l'expérience de l'IDE EMR Studio. L'IDE ingère des données sur site et les stocke dans Amazon S3 après les avoir transformées en vue d'une analyse ultérieure.
+ Utilisez des blocs-notes pour explorer des jeux de données et entraînez un modèle de machine learning pour détecter des anomalies dans les jeux de données.
+ Créez des scripts qui génèrent des rapports quotidiens pour les applications analytiques telles que les tableaux de bord commerciaux.
**Topics**
+ [Vue d'ensemble des points de terminaison interactifs](how-it-works.md)
+ [Conditions préalables à la création d'un point de terminaison interactif sur Amazon EMR on EKS](prereqs-for-studio.md)
+ [Création d'un point de terminaison interactif pour votre cluster virtuel](create-managed-endpoint.md)
+ [Configuration des paramètres pour les points de terminaison interactifs](managed-endpoint-parameters.md)
+ [Surveillance des points de terminaison interactifs](managed-endpoints-customer-metrics.md)
+ [Utilisation des blocs-notes Jupyter auto-hébergés](managed-endpoints-self-hosted.md)
+ [Obtenir des informations sur les points de terminaison interactifs à l'aide des commandes CLI](other-operations.md)
# Vue d'ensemble des points de terminaison interactifs
Le *point de terminaison interactif* permet à des clients interactifs tels qu'Amazon EMR Studio de se connecter à Amazon EMR sur des clusters EKS pour exécuter des charges de travail interactives. Le point de terminaison interactif est soutenu par une passerelle Jupyter Enterprise Gateway qui fournit la capacité de gestion à distance du cycle de vie du noyau dont les clients interactifs ont besoin. Les *noyaux* sont des processus spécifiques au langage qui interagissent avec le client Amazon EMR Studio basé sur Jupyter pour exécuter des charges de travail interactives.
Les points de terminaison interactifs prennent en charge les noyaux suivants :
+ Python 3
+ PySpark sur Kubernetes
+ Apache Spark avec Scala
**Note**
La tarification d'Amazon EMR on EKS s'applique aux points de terminaison et aux noyaux interactifs. Pour plus d'informations, consultez la [page de tarification d'Amazon EMR on EKS](https://aws.amazon.com/emr/pricing/#Amazon_EMR_on_Amazon_EKS).
Les entités suivantes sont nécessaires pour qu'EMR Studio se connecte à Amazon EMR on EKS.
+ **Cluster virtuel Amazon EMR on EKS** : le *cluster virtuel* est un espace de noms Kubernetes que vous enregistrez sur Amazon EMR. Amazon EMR utilise des clusters virtuels pour exécuter des tâches et héberger des points de terminaison. Vous pouvez sauvegarder plusieurs clusters virtuels avec le même cluster physique. Toutefois, chaque cluster virtuel correspond à un espace de noms sur un cluster Amazon EKS. Les clusters virtuels ne créent aucune ressource active qui contribue à votre facture ou qui nécessite une gestion du cycle de vie en dehors du service.
+ **Point de terminaison interactif Amazon EMR on EKS** : le *point de terminaison interactif* est un point de terminaison HTTPS auquel les utilisateurs d'EMR Studio peuvent connecter un espace de travail. Vous ne pouvez accéder aux points de terminaison HTTPS que depuis votre EMR Studio, et vous les créez dans un sous-réseau privé d'Amazon Virtual Private Cloud (Amazon VPC) pour votre cluster Amazon EKS.
Les noyaux Python et Spark Scala utilisent les autorisations définies dans votre rôle d'exécution de tâches Amazon EMR on EKS pour en invoquer d'autres. PySpark Services AWS Tous les noyaux et utilisateurs qui se connectent au point de terminaison interactif utilisent le rôle que vous avez spécifié lors de la création du point de terminaison. Nous vous recommandons de créer des points de terminaison distincts pour les différents utilisateurs, et de veiller à ce que les utilisateurs aient des rôles Gestion des identités et des accès AWS (IAM) différents.
+ AWS Contrôleur **Application Load Balancer : le contrôleur AWS ** *Application Load Balancer gère Elastic Load Balancing* pour un cluster Amazon EKS Kubernetes. Le contrôleur provisionne un équilibreur de charge Application Load Balancer (ALB) lorsque vous créez une ressource Kubernetes Ingress. L'équilibreur de charge ALB expose un service Kubernetes, tel qu'un point de terminaison interactif, en dehors du cluster Amazon EKS, mais au sein du même Amazon VPC. Lorsque vous créez un point de terminaison interactif, une ressource Ingress est également déployée pour exposer le point de terminaison interactif au moyen de l'équilibreur de charge ALB afin que les clients interactifs puissent s'y connecter. Il vous suffit d'installer un contrôleur AWS Application Load Balancer pour chaque cluster Amazon EKS.
Le diagramme suivant décrit l'architecture des points de terminaison interactifs dans Amazon EMR on EKS. Le cluster Amazon EKS comprend le *calcul* nécessaire pour exécuter les charges de travail analytiques et le *point de terminaison interactif*. Le contrôleur d'équilibreur de charge Application Load Balancer s'exécute dans l'espace de noms `kube-system` ; les charges de travail et les points de terminaison interactifs s'exécutent dans l'espace de noms que vous indiquez lors de la création du cluster virtuel. Lorsque vous créez un point de terminaison interactif, le plan de contrôle Amazon EMR on EKS crée le déploiement du point de terminaison interactif dans le cluster Amazon EKS. En outre, une instance de l'entrée de l'équilibreur de charge de l'application est créée par le contrôleur de l'équilibreur de AWS charge. L'équilibreur de charge Application Load Balancer fournit une interface externe permettant aux clients comme EMR Studio de se connecter au cluster Amazon EMR et exécuter des charges de travail interactives.
![\[Diagramme d'architecture des points de terminaison interactifs\]](http://docs.aws.amazon.com/fr_fr/emr/latest/EMR-on-EKS-DevelopmentGuide/images/emr-on-eks-managed-endpoints-architecture.png)
# Conditions préalables à la création d'un point de terminaison interactif sur Amazon EMR on EKS
Cette section décrit les conditions préalables à la configuration d'un point de terminaison interactif qu'EMR Studio peut utiliser pour se connecter à un cluster Amazon EMR on EKS et exécuter des charges de travail interactives.
## AWS CLI
Suivez les étapes décrites dans [Installer ou mettre à jour vers la dernière version du AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) pour installer la dernière version du AWS Command Line Interface (AWS CLI).
## Installation d'eksctl
Suivez les étapes décrites dans [Installer kubectl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html) pour installer la dernière version d'eksctl. Si vous utilisez Kubernetes en version 1.22 ou ultérieure pour votre cluster Amazon EKS, utilisez une version eksctl supérieure à 0.117.0.
## Cluster Amazon EKS
Créez un cluster Amazon EKS. Enregistrez le cluster en tant que cluster virtuel dans Amazon EMR on EKS. Les exigences et considérations pour ce cluster sont les suivantes :
+ Le cluster doit se trouver dans le même cloud privé virtuel (VPC) Amazon que votre EMR Studio.
+ Le cluster doit disposer d'au moins un sous-réseau privé pour activer les points de terminaison interactifs, pour lier les référentiels Git et pour lancer l'équilibreur de charge Application Load Balancer en mode privé.
+ Il doit y avoir au moins un sous-réseau privé en commun entre votre EMR Studio et le cluster Amazon EKS que vous utilisez pour enregistrer votre cluster virtuel. Ainsi, votre point de terminaison interactif apparaît comme une option dans vos espaces de travail Studio et active la connectivité de Studio à l'équilibreur de charge Application Load Balancer.
Vous pouvez choisir entre deux méthodes pour connecter votre Studio et votre cluster Amazon EKS :
+ Créez un cluster Amazon EKS et associez-le aux sous-réseaux appartenant à votre EMR Studio.
+ Vous pouvez également créer un EMR Studio et spécifier les sous-réseaux privés de votre cluster Amazon EKS.
+ ARM optimisé pour Amazon EKS Amazon Linux AMIs n'est pas pris en charge pour Amazon EMR sur les points de terminaison interactifs EKS.
+ Seuls les [groupes de nœuds gérés par Amazon EKS et les](https://docs.aws.amazon.com/eks/latest/userguide/managed-node-groups.html) nœuds provisionnés par Karpenter sont pris en charge.
## Autorisation d'Amazon EMR on EKS à accéder aux clusters
Suivez les étapes décrites dans la rubrique [Autorisation de l'accès aux clusters pour Amazon EMR on EKS](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/setting-up-cluster-access.html) pour accorder à Amazon EMR on EKS l'accès à un espace de noms spécifique de votre cluster.
## Activation d'IRSA sur le cluster Amazon EKS
Pour activer les rôles IAM pour les comptes de service (IRSA) sur le cluster Amazon EKS, suivez les étapes décrites dans la rubrique [Activation des rôles IAM pour les comptes de service (IRSA)](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/setting-up-enable-IAM.html).
## Création d'un rôle d'exécution des tâches IAM
Vous devez créer un rôle IAM pour exécuter des charges de travail sur Amazon EMR sur des points de terminaison interactifs EKS. Dans cette documentation, nous appelons ce rôle IAM le *rôle d'exécution des tâches*. Ce rôle IAM est attribué à la fois au conteneur de point de terminaison interactif et aux conteneurs d'exécution réels créés lorsque vous soumettez des tâches avec EMR Studio. Vous aurez besoin du nom Amazon Resource Name (ARN) associé à votre rôle d'exécution des tâches pour Amazon EMR on EKS. Deux étapes sont nécessaires pour cela :
+ [Créer un rôle IAM pour l'exécution des tâches.](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/creating-job-execution-role.html)
+ [Mettre à jour la politique d'approbation du rôle d'exécution des tâches.](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/setting-up-trust-policy.html)
## Autorisation des utilisateurs à accéder à Amazon EMR on EKS
L'entité IAM (utilisateur ou rôle) qui effectue la demande de création d'un point de terminaison interactif doit également disposer des autorisations Amazon EC2 et `emr-containers` suivantes. Suivez les étapes décrites dans [Autorisation des utilisateurs à accéder à Amazon EMR on EKS](setting-up-iam.md) pour accorder ces autorisations qui permettent à Amazon EMR on EKS de créer, de gérer et de supprimer les groupes de sécurité qui limitent le trafic entrant à l'équilibreur de charge de votre point de terminaison interactif.
Les autorisations `emr-containers` suivantes permettent à l'utilisateur d'effectuer des opérations de base sur le point de terminaison interactif :
```
"ec2:CreateSecurityGroup",
"ec2:DeleteSecurityGroup",
"ec2:AuthorizeSecurityGroupEgress",
"ec2:AuthorizeSecurityGroupIngress",
"ec2:RevokeSecurityGroupEgress",
"ec2:RevokeSecurityGroupIngress"
"emr-containers:CreateManagedEndpoint",
"emr-containers:ListManagedEndpoints",
"emr-containers:DescribeManagedEndpoint",
"emr-containers:DeleteManagedEndpoint"
```
## Enregistrement du cluster Amazon EKS dans Amazon EMR
Configurez un cluster virtuel et mappez-le à l'espace de noms du cluster Amazon EKS dans lequel vous souhaitez exécuter vos tâches. Pour les AWS Fargate clusters réservés uniquement, utilisez le même espace de noms pour le cluster virtuel Amazon EMR on EKS et pour le profil Fargate.
Pour plus d'informations sur la configuration d'un cluster virtuel Amazon EMR on EKS, consultez [Enregistrement du cluster Amazon EKS dans Amazon EMR](setting-up-registration.md).
## Déployer le AWS Load Balancer Controller sur le cluster Amazon EKS
Un AWS Application Load Balancer est requis pour votre cluster Amazon EKS. Il vous suffit de configurer un contrôleur d'équilibreur de charge Application Load Balancer pour chaque cluster Amazon EKS. Pour plus d'informations sur la configuration du contrôleur AWS Application Load Balancer, consultez la section [Installation du module complémentaire AWS Load Balancer Controller](https://docs.aws.amazon.com/eks/latest/userguide/aws-load-balancer-controller.html) dans le guide de l'utilisateur *Amazon EKS*.
# Création d'un point de terminaison interactif pour votre cluster virtuel
Cette rubrique décrit deux manières de créer un point de terminaison interactif à l'aide de l'interface de ligne de AWS commande (AWS CLI) et inclut des détails sur les paramètres de configuration disponibles.
## Création d'un point de terminaison interactif à l'aide de la commande `create-managed-endpoint`
Indiquez les paramètres de la commande `create-managed-endpoint` comme suit. Amazon EMR on EKS prend en charge la création de points de terminaison interactifs avec les versions 6.7.0 et supérieures d'Amazon EMR.
```
aws emr-containers create-managed-endpoint \
‐‐type JUPYTER_ENTERPRISE_GATEWAY \
‐‐virtual‐cluster‐id 1234567890abcdef0xxxxxxxx \
‐‐name example-endpoint-name \
‐‐execution-role-arn arn:aws:iam::444455556666:role/JobExecutionRole \
‐‐release-label emr-6.9.0-latest \
‐‐configuration-overrides '{
"applicationConfiguration": [{
"classification": "spark-defaults",
"properties": {
"spark.driver.memory": "2G"
}
}],
"monitoringConfiguration": {
"cloudWatchMonitoringConfiguration": {
"logGroupName": "log_group_name",
"logStreamNamePrefix": "log_stream_prefix"
},
"persistentAppUI": "ENABLED",
"s3MonitoringConfiguration": {
"logUri": "s3://my_s3_log_location"
}
}
}'
```
Pour de plus amples informations, veuillez consulter [Paramètres de création d'un point de terminaison interactif](#parameters-for-creating).
## Création d'un point de terminaison interactif avec les paramètres spécifiés dans un fichier JSON
1. Créez un fichier `create-managed-endpoint-request.json` et indiquez les paramètres requis pour votre point de terminaison, comme indiqué dans le fichier JSON suivant :
```
{
"name": "MY_TEST_ENDPOINT",
"virtualClusterId": "MY_CLUSTER_ID",
"type": "JUPYTER_ENTERPRISE_GATEWAY",
"releaseLabel": "emr-6.9.0-latest",
"executionRoleArn": "arn:aws:iam::444455556666:role/JobExecutionRole",
"configurationOverrides":
{
"applicationConfiguration":
[
{
"classification": "spark-defaults",
"properties":
{
"spark.driver.memory": "8G"
}
}
],
"monitoringConfiguration":
{
"persistentAppUI": "ENABLED",
"cloudWatchMonitoringConfiguration":
{
"logGroupName": "my_log_group",
"logStreamNamePrefix": "log_stream_prefix"
},
"s3MonitoringConfiguration":
{
"logUri": "s3://my_s3_log_location"
}
}
}
}
```
1. Utilisez la commande `create-managed-endpoint` avec un chemin d'accès au fichier `create-managed-endpoint-request.json` stocké localement ou dans Amazon S3.
```
aws emr-containers create-managed-endpoint \
‐‐cli-input-json file://./create-managed-endpoint-request.json ‐‐region AWS-Region
```
## Résultat de la création d'un point de terminaison interactif
Vous devriez voir le résultat suivant dans le terminal. Le résultat comprend le nom et l'identifiant de votre nouveau point de terminaison interactif :
```
{
"id": "1234567890abcdef0",
"name": "example-endpoint-name",
"arn": "arn:aws:emr-containers:us-west-2:111122223333:/virtualclusters/444455556666/endpoints/444455556666",
"virtualClusterId": "111122223333xxxxxxxx"
}
```
L'exécution de `aws emr-containers create-managed-endpoint` crée un certificat auto-signé qui permet la communication HTTPS entre EMR Studio et le serveur de point de terminaison interactif.
Si vous exécutez `create-managed-endpoint` et que vous n'avez pas rempli les conditions préalables, Amazon EMR renvoie un message d'erreur indiquant les actions à entreprendre pour continuer.
## Paramètres de création d'un point de terminaison interactif
**Topics**
+ [Paramètres requis pour les points de terminaison interactifs](#parameters-for-creating-required)
+ [Paramètres facultatifs pour les points de terminaison interactifs](#parameters-for-creating-optional)
### Paramètres requis pour les points de terminaison interactifs
Vous devez spécifier les paramètres suivants lorsque vous créez un point de terminaison interactif :
**`‐‐type`**
Utilisez `JUPYTER_ENTERPRISE_GATEWAY`. C'est le seul type pris en charge.
**`‐‐virtual-cluster-id`**
L'identifiant du cluster virtuel que vous avez enregistré dans Amazon EMR on EKS.
**`‐‐name`**
Nom descriptif du point de terminaison interactif qui permet aux utilisateurs d'EMR Studio de le sélectionner dans la liste déroulante.
**`‐‐execution-role-arn`**
L'Amazon Resource Name (ARN) de votre rôle d'exécution de tâches IAM pour Amazon EMR on EKS qui a été créé dans le cadre des conditions préalables.
**`‐‐release-label`**
L'étiquette de la version d'Amazon EMR à utiliser pour le point de terminaison. Par exemple, `emr-6.9.0-latest`. Amazon EMR on EKS prend en charge les points de terminaison interactifs avec les versions 6.7.0 et supérieures d'Amazon EMR.
### Paramètres facultatifs pour les points de terminaison interactifs
En option, vous pouvez également spécifier les paramètres suivants lorsque vous créez un point de terminaison interactif :
**`‐‐configuration-overrides`**
Pour remplacer les configurations par défaut des applications, il faut fournir un objet de configuration. Vous pouvez utiliser une syntaxe abrégée pour fournir la configuration, ou vous pouvez faire référence à l'objet de configuration dans un fichier JSON.
Les objets de configuration sont composés d'une classification, de propriétés et de configurations imbriquées en option. Les propriétés sont les paramètres que vous souhaitez remplacer dans ce fichier. Vous pouvez spécifier plusieurs classifications pour plusieurs applications d'un seul objet JSON. Les classifications de configuration disponibles varient selon la version d'Amazon EMR on EKS. Pour la liste des classifications de configuration disponibles pour chaque version d'Amazon EMR on EKS, consultez [Versions Amazon EMR on EKS](emr-eks-releases.md). Outre les classifications de configuration répertoriées pour chaque version, les points de terminaison interactifs apportent la classification supplémentaire `jeg-config`. Pour de plus amples informations, veuillez consulter [Options de configuration de Jupyter Enterprise Gateway (JEG)](jeg-config-options.md).
# Configuration des paramètres pour les points de terminaison interactifs
Cette section contient une série de rubriques qui couvrent les différentes configurations des points de terminaison interactifs et des paramètres des pods. Ils vous permettent de surveiller et de résoudre les défaillances, d'envoyer des informations de journal à Amazon S3 ou à Amazon S3 Amazon CloudWatch Logs, ou de créer des points de terminaison interactifs dans lesquels vous spécifiez des modèles de pods personnalisés.
**Topics**
+ [Surveillance des tâches Spark](monitoring-spark-jobs.md)
+ [Spécification de modèles de pods personnalisés avec des points de terminaison interactifs](custom-pod-templates.md)
+ [Déploiement d'un pod JEG sur un groupe de nœuds](managed-endpoint-nodegroups-setup.md)
+ [Options de configuration de Jupyter Enterprise Gateway (JEG)](jeg-config-options.md)
+ [Modification des paramètres PySpark de session](modify-pyspark-parameters.md)
+ [Image de noyau personnalisée avec point de terminaison interactif](custom-kernel.md)
# Surveillance des tâches Spark
Afin de pouvoir surveiller et résoudre les défaillances, configurez vos points de terminaison interactifs afin que les tâches initiées avec le point de terminaison puissent envoyer des informations de journal à Amazon S3, Amazon CloudWatch Logs ou aux deux. Les sections suivantes décrivent comment envoyer les journaux d'application Spark à Amazon S3 pour les tâches Spark que vous lancez avec Amazon EMR sur des points de terminaison interactifs EKS.
**Configuration de la politique IAM pour les journaux Amazon S3**
Avant que vos noyaux puissent envoyer des données de journal à Amazon S3, la politique d'autorisations pour le rôle d'exécution des tâches doit inclure les autorisations suivantes. *amzn-s3-demo-destination-bucket*Remplacez-le par le nom de votre bucket de journalisation.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetObject",
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::amzn-s3-demo-bucket/*"
],
"Sid": "AllowS3Putobject"
}
]
}
```
------
**Note**
Amazon EMR on EKS peut également créer un compartiment S3. Si aucun compartiment S3 n'est disponible, incluez l'autorisation `s3:CreateBucket` dans la politique IAM.
Une fois que vous avez accordé à votre rôle d'exécution les autorisations nécessaires pour envoyer des journaux au compartiment S3, vos données de journal sont envoyées aux emplacements Amazon S3 suivants. Cela se produit lorsque `s3MonitoringConfiguration` est transmise dans la section `monitoringConfiguration` d'une demande `create-managed-endpoint`.
+ **Journaux de pilote** – `logUri/virtual-cluster-id/endpoints/endpoint-id/containers/spark-application-id/spark-application-id-driver/(stderr.gz/stdout.gz)`
+ **Journaux d'exécuteur** – `logUri/virtual-cluster-id/endpoints/endpoint-id/containers/spark-application-id/executor-pod-name-exec-/(stderr.gz/stdout.gz)`
**Note**
Amazon EMR on EKS ne charge pas les journaux des points de terminaison dans votre compartiment S3.
# Spécification de modèles de pods personnalisés avec des points de terminaison interactifs
Vous pouvez créer des points de terminaison interactifs dans lesquels vous indiquez des modèles de pods personnalisés pour les pilotes et les exécuteurs. Les *modèles de pods* sont des spécifications qui déterminent comment exécuter chaque pod. Vous pouvez utiliser des fichiers de modèles de pods pour définir les configurations de pods de pilotes ou d'exécuteurs que les configurations Spark ne prennent pas en charge. Les modèles de pods sont actuellement pris en charge dans les versions 6.3.0 et supérieures d'Amazon EMR.
Pour plus d'informations sur les modèles de pods, consultez la rubrique [Utilisation des modèles de pods](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/pod-templates.html) dans le *Guide de développement d'Amazon EMR on EKS*.
L'exemple suivant montre comment créer un point de terminaison interactif à l'aide de modèles de pods :
```
aws emr-containers create-managed-endpoint \
--type JUPYTER_ENTERPRISE_GATEWAY \
--virtual-cluster-id virtual-cluster-id \
--name example-endpoint-name \
--execution-role-arn arn:aws:iam::aws-account-id:role/EKSClusterRole \
--release-label emr-6.9.0-latest \
--configuration-overrides '{
"applicationConfiguration": [
{
"classification": "spark-defaults",
"properties": {
"spark.kubernetes.driver.podTemplateFile": "path/to/driver/template.yaml",
"spark.kubernetes.executor.podTemplateFile": "path/to/executor/template.yaml"
}
}]
}'
```
# Déploiement d'un pod JEG sur un groupe de nœuds
Le placement du pod JEG (Jupyter Enterprise Gateway) est une fonctionnalité qui vous permet de déployer un point de terminaison interactif sur un groupe de nœuds spécifique. Grâce à cette fonctionnalité, vous pouvez configurer des paramètres tels que `instance type` pour le point de terminaison interactif.
## Association d'un pod JEG à un groupe de nœuds géré
La propriété de configuration suivante vous permet de spécifier le nom d'un groupe de nœuds géré sur votre cluster Amazon EKS où le pod JEG sera déployé.
```
//payload
--configuration-overrides '{
"applicationConfiguration": [
{
"classification": "endpoint-configuration",
"properties": {
"managed-nodegroup-name": NodeGroupName
}
}
]
}'
```
Le groupe de nœuds doit avoir l'étiquette Kubernetes `for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName` attachée à tous les nœuds qui font partie du groupe de nœuds. Pour répertorier tous les nœuds d'un groupe de nœuds dotés de cette balise, utilisez la commande suivante :
```
kubectl get nodes --show-labels | grep for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName
```
Si le résultat de la commande ci-dessus ne renvoie pas de nœuds faisant partie de votre groupe de nœuds géré, cela signifie qu'aucun nœud du groupe de nœuds n'a l'étiquette Kubernetes `for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName` attachée. Dans ce cas, suivez les étapes ci-dessous pour attacher cette étiquette aux nœuds de votre groupe de nœuds.
1. Utilisez la commande suivante pour ajouter l'étiquette Kubernetes `for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName` à tous les nœuds d'un groupe de nœuds géré `NodeGroupName` :
```
kubectl label nodes --selector eks:nodegroup-name=NodeGroupName for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName
```
1. Vérifiez que les nœuds ont été correctement étiquetés à l'aide de la commande suivante :
```
kubectl get nodes --show-labels | grep for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName
```
Le groupe de nœuds géré doit être associé au groupe de sécurité d'un cluster Amazon EKS, ce qui est généralement le cas si vous avez créé votre cluster et votre groupe de nœuds gérés à l'aide de l'outil `eksctl`. Vous pouvez le vérifier dans la AWS console en procédant comme suit.
1. Accédez à votre cluster dans la console Amazon EKS.
1. Allez dans l'onglet de mise en réseau de votre cluster et notez le groupe de sécurité du cluster.
1. Accédez à l'onglet de calcul de votre cluster et cliquez sur le nom du groupe de nœuds géré.
1. Dans l'onglet **Détails** du groupe de nœuds géré, vérifiez que le groupe de sécurité du cluster que vous avez noté précédemment est répertorié sous **Groupes de sécurité**.
Si le groupe de nœuds géré n'est pas attaché au groupe de sécurité du cluster Amazon EKS, vous devez attacher la balise `for-use-with-emr-containers-managed-endpoint-sg=ClusterName/NodeGroupName` au groupe de sécurité du groupe de nœuds. Suivez les étapes ci-dessous pour attacher cette étiquette.
1. Accédez à la console Amazon EC2 et cliquez sur les groupes de sécurité dans le volet de navigation de gauche.
1. Sélectionnez le groupe de sécurité de votre groupe de nœuds géré en cochant la case.
1. Sous l'onglet **Balises**, ajoutez la balise `for-use-with-emr-containers-managed-endpoint-sg=ClusterName/NodeGroupName` à l'aide du bouton **Gérer les balises**.
## Association d'un pod JEG à un groupe de nœuds autogéré
La propriété de configuration suivante vous permet de spécifier le nom d'un groupe de nœuds autogéré ou non géré sur le cluster Amazon EKS où le pod JEG sera déployé.
```
//payload
--configuration-overrides '{
"applicationConfiguration": [
{
"classification": "endpoint-configuration",
"properties": {
"self-managed-nodegroup-name": NodeGroupName
}
}
]
}'
```
Le groupe de nœuds doit avoir l'étiquette Kubernetes `for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName` attachée à tous les nœuds qui font partie du groupe de nœuds. Pour répertorier tous les nœuds d'un groupe de nœuds dotés de cette balise, utilisez la commande suivante :
```
kubectl get nodes --show-labels | grep for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName
```
Si le résultat de la commande ci-dessus ne renvoie pas de nœuds faisant partie de votre groupe de nœuds autogéré, cela signifie qu'aucun nœud du groupe de nœuds n'a l'étiquette Kubernetes `for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName` attachée. Dans ce cas, suivez les étapes ci-dessous pour attacher cette étiquette aux nœuds de votre groupe de nœuds.
1. Si vous avez créé le groupe de nœuds autogéré à l'aide de l'outil `eksctl`, utilisez la commande suivante pour ajouter l'étiquette Kubernetes `for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName` à tous les nœuds du groupe de nœuds autogéré `NodeGroupName` en une seule fois.
```
kubectl label nodes --selector alpha.eksctl.io/nodegroup-name=NodeGroupName for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName
```
Si vous n'avez pas utilisé `eksctl` pour créer le groupe de nœuds autogéré, vous devrez remplacer le sélecteur dans la commande ci-dessus par une étiquette Kubernetes différente qui est attachée à tous les nœuds du groupe de nœuds.
1. Utilisez la commande suivante pour vérifier que les nœuds ont été étiquetés correctement :
```
kubectl get nodes --show-labels | grep for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName
```
Le groupe de sécurité du groupe de nœuds autogérés doit avoir la balise `for-use-with-emr-containers-managed-endpoint-sg=ClusterName/NodeGroupName` attachée. Procédez comme suit pour attacher la balise au groupe de sécurité à partir de la AWS Management Console.
1. Accédez à la console Amazon EC2. Dans le volet de navigation de gauche, sélectionnez **Groupes de sécurité**.
1. Cochez la case à côté du groupe de sécurité pour votre groupe de nœuds autogéré.
1. Sous l'onglet **Balises**, utilisez le bouton **Gérer les balises** pour ajouter la balise `for-use-with-emr-containers-managed-endpoint-sg=ClusterName/NodeGroupName`. Remplacez `ClusterName` et `NodeGroupName` par les valeurs appropriées.
## Association d'un pod JEG à un groupe de nœuds géré à l'aide d'instances à la demande
Vous pouvez également définir des étiquettes supplémentaires, appelées *sélecteurs d'étiquettes Kubernetes*, afin de spécifier des contraintes ou des restrictions supplémentaires pour exécuter un point de terminaison interactif sur un nœud ou un groupe de nœuds donné. L'exemple suivant montre comment utiliser des instances Amazon EC2 à la demande pour un pod JEG.
```
--configuration-overrides '{
"applicationConfiguration": [
{
"classification": "endpoint-configuration",
"properties": {
"managed-nodegroup-name": NodeGroupName,
"node-labels": "eks.amazonaws.com/capacityType:ON_DEMAND"
}
}
]
}'
```
**Note**
Vous ne pouvez utiliser la propriété `node-labels` qu'avec une propriété `managed-nodegroup-name` ou `self-managed-nodegroup-name`.
# Options de configuration de Jupyter Enterprise Gateway (JEG)
Amazon EMR on EKS utilise Jupyter Enterprise Gateway (JEG) pour activer les points de terminaison interactifs. Vous pouvez définir les valeurs suivantes pour les configurations JEG répertoriées comme autorisées lorsque vous créez le point de terminaison.
+ **`RemoteMappingKernelManager.cull_idle_timeout`** : délai d'expiration en secondes (entier), après quoi un noyau est considéré comme inactif et prêt à être éliminé. Les valeurs de `0` ou moins désactivent l'élimination. Des délais d'expiration trop courts risquent d'entraîner l'élimination des noyaux pour les utilisateurs disposant de connexions réseau médiocres.
+ **`RemoteMappingKernelManager.cull_interval`** : intervalle en secondes (entier) pendant lequel il faut vérifier si les noyaux inactifs dépassent la valeur du délai d'élimination.
# Modification des paramètres PySpark de session
À partir d'Amazon EMR on EKS version 6.9.0, dans Amazon EMR Studio, vous pouvez ajuster la configuration Spark associée à une PySpark session en exécutant la `%%configure` commande magique dans la cellule du bloc-notes EMR.
L'exemple suivant montre un exemple de charge utile que vous pouvez utiliser pour modifier la mémoire, les cœurs et d'autres propriétés du pilote et de l'exécuteur Spark. Pour les paramètres `conf`, vous pouvez configurer n'importe quelle configuration Spark mentionnée dans la [documentation de configuration d'Apache Spark](https://spark.apache.org/docs/latest/configuration.html).
```
%%configure -f
{
"driverMemory": "16G",
"driverCores": 4,
"executorMemory" : "32G",
"executorCores": 2,
"conf": {
"spark.dynamicAllocation.maxExecutors" : 10,
"spark.dynamicAllocation.minExecutors": 1
}
}
```
L'exemple suivant montre un exemple de charge utile que vous pouvez utiliser pour ajouter des fichiers, des pyFiles et des dépendances JAR à un moteur d'exécution Spark.
```
%%configure -f
{
"files": "s3://amzn-s3-demo-bucket-emr-eks/sample_file.txt",
"pyFiles": : "path-to-python-files",
"jars" : "path-to-jars
}
```
# Image de noyau personnalisée avec point de terminaison interactif
Pour garantir que vous disposez des dépendances appropriées pour votre application lorsque vous exécutez des charges de travail interactives à partir d'Amazon EMR Studio, vous pouvez personnaliser les images Docker pour les points de terminaison interactifs et exécuter des images de noyau de base personnalisées. Pour créer un point de terminaison interactif et le connecter à une image Docker personnalisée, suivez les étapes ci-dessous.
**Note**
Vous ne pouvez remplacer que les images de base. Vous ne pouvez pas ajouter de nouveaux types d'images de noyau.
1. **Créez et publiez une image Docker personnalisée.** L'image de base contient le moteur d'exécution Spark et les noyaux de bloc-notes qui s'exécutent avec celui-ci. Pour créer l'image, vous pouvez suivre les étapes 1 à 4 dans [Instructions de personnalisation des images Docker](docker-custom-images-steps.md). À l'étape 1, l'URI de l'image de base de votre fichier Docker doit utiliser `notebook-spark` à la place de `spark`.
```
ECR-registry-account.dkr.ecr.Region.amazonaws.com/notebook-spark/container-image-tag
```
Pour plus d'informations sur la manière de sélectionner Régions AWS et de mettre en conteneur des balises d'image, consultez[Détails relatifs à la sélection d'une URI d'image de base](docker-custom-images-tag.md).
1. **Créez un point de terminaison interactif qui peut être utilisé avec l'image personnalisée.**
1. Créez un fichier JSON `custom-image-managed-endpoint.json` avec le contenu suivant. Cet exemple utilise la version 6.9.0 d'Amazon EMR.
**Example**
```
{
"name": "endpoint-name",
"virtualClusterId": "virtual-cluster-id",
"type": "JUPYTER_ENTERPRISE_GATEWAY",
"releaseLabel": "emr-6.9.0-latest",
"executionRoleArn": "execution-role-arn",
"configurationOverrides": {
"applicationConfiguration": [
{
"classification": "jupyter-kernel-overrides",
"configurations": [
{
"classification": "python3",
"properties": {
"container-image": "123456789012.dkr.ecr.us-west-2.amazonaws.com/custom-notebook-python:latest"
}
},
{
"classification": "spark-python-kubernetes",
"properties": {
"container-image": "123456789012.dkr.ecr.us-west-2.amazonaws.com/custom-notebook-spark:latest"
}
}
]
}
]
}
}
```
1. Créez un point de terminaison interactif avec les configurations spécifiées dans le fichier JSON, comme indiqué dans l'exemple ci-dessous. Pour de plus amples informations, veuillez consulter [Création d'un point de terminaison interactif à l'aide de la commande `create-managed-endpoint`](create-managed-endpoint.md#create-using-json-file).
```
aws emr-containers create-managed-endpoint --cli-input-json custom-image-managed-endpoint.json
```
1. **Connectez-vous au point de terminaison interactif via EMR Studio.** Pour plus d'informations et pour connaître les étapes à suivre, consultez la section [Connexion depuis Studio](https://emr-on-eks.workshop.aws/advanced/emr-studio/connecting-from-studio.html) dans la section Amazon EMR on EKS de la documentation de AWS Workshop Studio.
# Surveillance des points de terminaison interactifs
Avec Amazon EMR on EKS version 6.10 et versions ultérieures, les points de terminaison interactifs émettent des métriques CloudWatch Amazon pour surveiller et résoudre les problèmes liés aux opérations du cycle de vie du noyau. Les métriques sont déclenchées par des clients interactifs, tels qu'EMR Studio ou des blocs-notes Jupyter auto-hébergés. Chacune des opérations prises en charge par les points de terminaison interactifs est associée à des métriques. Les opérations sont modélisées sous forme de dimensions pour chaque métrique, comme indiqué dans le tableau ci-dessous. Les métriques émises par les points de terminaison interactifs sont visibles sous un espace de noms personnalisé EMRContainers, dans votre compte.
| Métrique | Description | Unit |
| --- | --- | --- |
| RequestCount | Nombre cumulé de demandes d'une opération traitées par le point de terminaison interactif. | Nombre |
| RequestLatency | Temps écoulé entre l'arrivée d'une demande au point de terminaison interactif et l'envoi d'une réponse par le point de terminaison interactif. | Milliseconde |
| 4 XXError | Émis lorsqu'une demande d'opération aboutit à une erreur 4xx lors du traitement. | Nombre |
| 5 XXError | Émis lorsqu'une demande d'opération aboutit à une erreur 5Xxx du côté du serveur. | Nombre |
| KernelLaunchSuccess | Applicable uniquement pour l' CreateKernel opération. Cela indique le nombre cumulé de lancements de noyaux qui ont réussi jusqu'à et incluant cette demande. | Nombre |
| KernelLaunchFailure | Applicable uniquement pour l' CreateKernel opération. Cela indique le nombre cumulé d'échecs de lancement de noyaux jusqu'à et incluant cette demande. | Nombre |
Les dimensions suivantes sont associées à chaque métrique interactive du point de terminaison :
+ **`ManagedEndpointId`** : identifiant du point de terminaison interactif
+ **`OperationName`** : l'opération déclenchée par le client interactif
Les valeurs possibles de la dimension **`OperationName`** sont indiquées dans le tableau suivant :
| `operationName` | Description de l'opération |
| --- | --- |
| `CreateKernel` | Demandez au point de terminaison interactif de démarrer un noyau. |
| `ListKernels` | Demandez que le point de terminaison interactif répertorie les noyaux qui ont été précédemment démarrés à l'aide du même jeton de session. |
| `GetKernel` | Demandez au point de terminaison interactif d'obtenir des informations sur un noyau spécifique qui a déjà été démarré. |
| `ConnectKernel` | Demandez au point de terminaison interactif d'établir une connectivité entre le client du bloc-notes et le noyau. |
| `ConfigureKernel` | Publiez `%%configure magic request` sur un noyau PySpark. |
| `ListKernelSpecs` | Demande au point de terminaison interactif de répertorier les spécifications disponibles du noyau. |
| `GetKernelSpec` | Demande au point de terminaison interactif d'obtenir les spécifications d'un noyau qui a été lancé précédemment. |
| `GetKernelSpecResource` | Demande au point de terminaison interactif d'obtenir des ressources spécifiques associées aux spécifications du noyau précédemment lancé. |
## Exemples
### Pour accéder au nombre total de noyaux lancés pour un point de terminaison interactif un jour donné :
1. Sélectionnez l'espace de noms personnalisé : `EMRContainers`
1. Sélectionnez votre `ManagedEndpointId`, `OperationName – CreateKernel`
1. La métrique `RequestCount` avec les statistiques `SUM` et la période `1 day` fournira toutes les demandes de lancement de noyau effectuées au cours des dernières 24 heures.
1. KernelLaunchSuccess Une métrique avec statistiques `SUM` et période `1 day` fournira toutes les demandes de lancement de noyau réussies effectuées au cours des dernières 24 heures.
### Pour accéder au nombre d'échecs du noyau pour un point de terminaison interactif un jour donné :
1. Sélectionnez l'espace de noms personnalisé : EMRContainers
1. Sélectionnez votre `ManagedEndpointId`, `OperationName – CreateKernel`
1. La métrique `KernelLaunchFailure` avec les statistiques `SUM` et la période `1 day` fournira toutes les demandes de lancement de noyau échouées au cours des dernières 24 heures. Vous pouvez également sélectionner la métrique `4XXError` et `5XXError` pour savoir quel type d'échec de lancement de noyau s'est produit.
# Utilisation des blocs-notes Jupyter auto-hébergés
*Vous pouvez héberger et gérer Jupyter ou des JupyterLab blocs-notes sur une instance Amazon EC2 ou sur votre propre cluster Amazon EKS en tant que bloc-notes Jupyter auto-hébergé.* Vous pouvez ensuite exécuter des charges de travail interactives avec vos blocs-notes Jupyter auto-hébergés. Les sections suivantes décrivent le processus de configuration et de déploiement d'un bloc-notes Jupyter auto-hébergé sur un cluster Amazon EKS.
**Topics**
+ [Création d’un groupe de sécurité](#managed-endpoints-self-hosted-security)
+ [Création d'un point de terminaison interactif Amazon EMR on EKS](#managed-endpoints-self-hosted-create-me)
+ [Récupération de l'URL du serveur de passerelle de votre point de terminaison interactif](#managed-endpoints-self-hosted-gateway)
+ [Récupération d'un jeton d'authentification pour la connexion au point de terminaison interactif](#managed-endpoints-self-hosted-auth)
+ [Exemple : déploiement d'un JupyterLab bloc-notes](#managed-endpoints-self-hosted-example)
+ [Suppression d'un bloc-notes Jupyter auto-hébergé](#managed-endpoints-self-hosted-cleanup)
## Création d’un groupe de sécurité
Avant de créer un point de terminaison interactif et d'exécuter un Jupyter ou un JupyterLab bloc-notes auto-hébergé, vous devez créer un groupe de sécurité pour contrôler le trafic entre votre bloc-notes et le point de terminaison interactif. Pour utiliser la console Amazon EC2 ou le SDK Amazon EC2 afin de créer le groupe de sécurité, reportez-vous aux étapes décrites dans la section [Créer un groupe de sécurité dans le guide de l'utilisateur](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/working-with-security-groups.html#creating-security-group) Amazon *EC2*. Vous devez créer le groupe de sécurité dans le VPC où vous souhaitez déployer votre serveur de bloc-notes.
Pour suivre l'exemple de ce guide, utilisez le même VPC que votre cluster Amazon EKS. Si vous souhaitez héberger votre bloc-notes dans un VPC différent de celui de votre cluster Amazon EKS, vous devrez peut-être créer une connexion d'appairage entre les deux. VPCs Pour savoir comment créer une connexion d'appairage entre deux personnes VPCs, consultez la section [Créer une connexion d'appairage VPC dans le](https://docs.aws.amazon.com/vpc/latest/peering/create-vpc-peering-connection.html) guide de démarrage Amazon VPC.
Vous avez besoin de l'identifiant du groupe de sécurité pour [créer un point de terminaison interactif Amazon EMR on EKS](https://docs.aws.amazon.com/) à l'étape suivante.
## Création d'un point de terminaison interactif Amazon EMR on EKS
Après avoir créé un groupe de sécurité pour votre bloc-notes, suivez les étapes décrites dans [Création d'un point de terminaison interactif pour votre cluster virtuel](create-managed-endpoint.md) pour créer un point de terminaison interactif. Vous devez fournir l'identifiant du groupe de sécurité que vous avez créé pour votre bloc-notes dans [Création d’un groupe de sécurité](#managed-endpoints-self-hosted-security).
Insérez l'ID de sécurité *your-notebook-security-group-id* à la place des paramètres de remplacement de configuration suivants :
```
--configuration-overrides '{
"applicationConfiguration": [
{
"classification": "endpoint-configuration",
"properties": {
"notebook-security-group-id": "your-notebook-security-group-id"
}
}
],
"monitoringConfiguration": {
...'
```
## Récupération de l'URL du serveur de passerelle de votre point de terminaison interactif
Après avoir créé un point de terminaison interactif, récupérez l'URL du serveur de passerelle à l'aide de la commande `describe-managed-endpoint` de la AWS CLI. Vous avez besoin de cette URL pour connecter votre bloc-notes au point de terminaison. L'URL du serveur de passerelle est un point de terminaison privé.
```
aws emr-containers describe-managed-endpoint \
--region region \
--virtual-cluster-id virtualClusterId \
--id endpointId
```
Initialement, votre point de terminaison est à l'état **CREATING**. Après quelques minutes, il passe à l'état **ACTIVE**. Lorsque le point de terminaison est à l'état **ACTIVE**, il est prêt à être utilisé.
Prenez note de l'attribut `serverUrl` renvoyé par la commande `aws emr-containers describe-managed-endpoint` à partir du point de terminaison actif. Vous avez besoin de cette URL pour connecter votre bloc-notes au point de terminaison lorsque vous [déployez votre Jupyter ou votre bloc-notes auto-hébergé](https://docs.aws.amazon.com/). JupyterLab
## Récupération d'un jeton d'authentification pour la connexion au point de terminaison interactif
Pour vous connecter à un point de terminaison interactif depuis un Jupyter ou un JupyterLab bloc-notes, vous devez générer un jeton de session avec l'`GetManagedEndpointSessionCredentials`API. Le jeton sert de preuve d'authentification pour la connexion au serveur de point de terminaison interactif.
La commande suivante est expliquée plus en détail avec un exemple de résultat ci-dessous.
```
aws emr-containers get-managed-endpoint-session-credentials \
--endpoint-identifier endpointArn \
--virtual-cluster-identifier virtualClusterArn \
--execution-role-arn executionRoleArn \
--credential-type "TOKEN" \
--duration-in-seconds durationInSeconds \
--region region
```
**`endpointArn`**
L'ARN de votre point de terminaison. Vous pouvez trouver l'ARN dans le résultat d'un appel `describe-managed-endpoint`.
**`virtualClusterArn`**
L'ARN du cluster virtuel.
**`executionRoleArn`**
L'ARN du rôle d'exécution.
**`durationInSeconds`**
La durée en secondes pendant laquelle le jeton est valide. La durée par défaut est de 15 minutes (`900`) et la durée maximale est de 12 heures (`43200`).
**`region` **
La même région que votre point de terminaison.
Votre résultat devrait ressembler à l'exemple suivant. Prenez note de la `session-token` valeur que vous utiliserez lorsque vous [déploierez votre Jupyter ou votre bloc-notes auto-hébergé](https://docs.aws.amazon.com/). JupyterLab
```
{
"id": "credentialsId",
"credentials": {
"token": "session-token"
},
"expiresAt": "2022-07-05T17:49:38Z"
}
```
## Exemple : déploiement d'un JupyterLab bloc-notes
Une fois les étapes ci-dessus terminées, vous pouvez essayer cet exemple de procédure pour déployer un JupyterLab bloc-notes dans le cluster Amazon EKS avec votre point de terminaison interactif.
1. Créez un espace de noms pour exécuter le serveur de bloc-notes.
1. Créez un fichier local, `notebook.yaml`, avec le contenu suivant. Le contenu du fichier est décrit ci-dessous.
```
apiVersion: v1
kind: Pod
metadata:
name: jupyter-notebook
namespace: namespace
spec:
containers:
- name: minimal-notebook
image: jupyter/all-spark-notebook:lab-3.1.4 # open source image
ports:
- containerPort: 8888
command: ["start-notebook.sh"]
args: ["--LabApp.token=''"]
env:
- name: JUPYTER_ENABLE_LAB
value: "yes"
- name: KERNEL_LAUNCH_TIMEOUT
value: "400"
- name: JUPYTER_GATEWAY_URL
value: "serverUrl"
- name: JUPYTER_GATEWAY_VALIDATE_CERT
value: "false"
- name: JUPYTER_GATEWAY_AUTH_TOKEN
value: "session-token"
```
Si vous déployez le bloc-notes Jupyter sur un cluster Fargate, étiquetez le pod Jupyter avec une étiquette `role`, comme indiqué dans l'exemple ci-dessous :
```
...
metadata:
name: jupyter-notebook
namespace: default
labels:
role: example-role-name-label
spec:
...
```
**`namespace`**
L'espace de noms Kubernetes dans lequel le bloc-notes est déployé.
**`serverUrl`**
Attribut `serverUrl` renvoyé par la commande `describe-managed-endpoint` dans [Récupération de l'URL du serveur de passerelle de votre point de terminaison interactif](#managed-endpoints-self-hosted-gateway).
**`session-token`**
Attribut `session-token` renvoyé par la commande `get-managed-endpoint-session-credentials` dans [Récupération d'un jeton d'authentification pour la connexion au point de terminaison interactif](#managed-endpoints-self-hosted-auth).
**`KERNEL_LAUNCH_TIMEOUT`**
Durée en secondes pendant laquelle le point de terminaison interactif attend que le noyau passe à l'état **RUNNING**. Veillez à ce que le lancement du noyau ait suffisamment de temps pour se terminer en définissant le délai de lancement du noyau sur une valeur appropriée (400 secondes au maximum).
**`KERNEL_EXTRA_SPARK_OPTS`**
Vous pouvez éventuellement transmettre des configurations Spark supplémentaires pour les noyaux Spark. Définissez cette variable d'environnement avec les valeurs de la propriété de configuration Spark, comme indiqué dans l'exemple ci-dessous :
```
- name: KERNEL_EXTRA_SPARK_OPTS
value: "--conf spark.driver.cores=2
--conf spark.driver.memory=2G
--conf spark.executor.instances=2
--conf spark.executor.cores=2
--conf spark.executor.memory=2G
--conf spark.dynamicAllocation.enabled=true
--conf spark.dynamicAllocation.shuffleTracking.enabled=true
--conf spark.dynamicAllocation.minExecutors=1
--conf spark.dynamicAllocation.maxExecutors=5
--conf spark.dynamicAllocation.initialExecutors=1
"
```
1. Déployez la spécification de pod sur votre cluster Amazon EKS :
```
kubectl apply -f notebook.yaml -n namespace
```
Cela démarrera un JupyterLab bloc-notes minimal connecté à votre point de terminaison interactif Amazon EMR on EKS. Attendez que le pod passe à l'état **RUNNING**. Vous pouvez vérifier son état à l'aide de la commande suivante :
```
kubectl get pod jupyter-notebook -n namespace
```
Lorsque le pod est prêt, la commande `get pod` renvoie un résultat similaire à celui-ci :
```
NAME READY STATUS RESTARTS AGE
jupyter-notebook 1/1 Running 0 46s
```
1. Associez le groupe de sécurité du bloc-notes au nœud sur lequel le bloc-notes est programmé.
1. Identifiez d'abord le nœud sur lequel le pod `jupyter-notebook` est programmé à l'aide de la commande `describe pod`.
```
kubectl describe pod jupyter-notebook -n namespace
```
1. Ouvrez la console Amazon EKS à l'adresse [https://console.aws.amazon.com/eks/home\$1/clusters](https://console.aws.amazon.com/eks/home#/clusters).
1. Accédez à l'onglet **Calcul** de votre cluster Amazon EKS et sélectionnez le nœud identifié par la commande `describe pod`. Sélectionnez l'identifiant d'instance du nœud.
1. Dans le menu **Actions**, sélectionnez **Sécurité** > **Modifier les groupes de sécurité** pour associer le groupe de sécurité que vous avez créé dans [Création d’un groupe de sécurité](#managed-endpoints-self-hosted-security).
1. Si vous déployez le module de bloc-notes Jupyter sur AWS Fargate, créez-en un []()à appliquer au module de bloc-notes Jupyter avec le libellé du rôle :
```
cat >my-security-group-policy.yaml <
val x = random * 2 - 1
val y = random * 2 - 1
if (x*x + y*y <= 1) 1 else 0
}.reduce(_ + _)
println(s"Pi is roughly ${4.0 * count / (n - 1)}")
session.stop()
```
![\[Capture d'écran d'un exemple de code de bloc-notes Scala dans. JupyterLab\]](http://docs.aws.amazon.com/fr_fr/emr/latest/EMR-on-EKS-DevelopmentGuide/images/emr-on-eks-Jupyter-notebook-scala-program.png)
## Suppression d'un bloc-notes Jupyter auto-hébergé
Lorsque vous êtes prêt à supprimer votre bloc-notes auto-hébergé, vous pouvez également supprimer le point de terminaison interactif et le groupe de sécurité. Effectuez les actions dans l'ordre suivant :
1. Utilisez la commande suivante pour supprimer le pod `jupyter-notebook` :
```
kubectl delete pod jupyter-notebook -n namespace
```
1. Supprimez ensuite votre point de terminaison interactif à l'aide de la commande `delete-managed-endpoint`. Pour savoir comment supprimer un point de terminaison interactif, consultez [Suppression d'un point de terminaison interactif](delete-managed-endpoint.md). Initialement, votre point de terminaison sera à l'état **TERMINATING**. Une fois que toutes les ressources ont été nettoyées, elles passent à l'état **TERMINATED**.
1. Si vous ne prévoyez pas d'utiliser le groupe de sécurité des blocs-notes que vous avez créé dans [Création d’un groupe de sécurité](#managed-endpoints-self-hosted-security) pour d'autres déploiements de blocs-notes Jupyter, vous pouvez le supprimer. Pour de plus amples informations, consultez la rubrique [Suppression d'un groupe de sécurité](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/working-with-security-groups.html#deleting-security-group) dans le Guide de l'utilisateur Amazon EC2.
# Obtenir des informations sur les points de terminaison interactifs à l'aide des commandes CLI
Cette rubrique couvre les opérations prises en charge sur un point de terminaison interactif autre que [`create-managed-endpoint`](create-managed-endpoint.md).
## Récupération des détails du point de terminaison interactif
Après avoir créé un point de terminaison interactif, vous pouvez récupérer ses détails à l'aide de la `describe-managed-endpoint` AWS CLI commande. Insérez vos propres valeurs pour *managed-endpoint-id**virtual-cluster-id*, et *region* :
```
aws emr-containers describe-managed-endpoint ‐‐id managed-endpoint-id \
‐‐virtual-cluster-id virtual-cluster-id ‐‐region region
```
Le résultat ressemble à ce qui suit, avec le point de terminaison spécifié, tel que l'ARN, l'identifiant et le nom.
```
{
"id": "as3ys2xxxxxxx",
"name": "endpoint-name",
"arn": "arn:aws:emr-containers:us-east-1:1828xxxxxxxx:/virtualclusters/lbhl6kwwyoxxxxxxxxxxxxxxx/endpoints/as3ysxxxxxxxx",
"virtualClusterId": "lbhl6kwwyoxxxxxxxxxxxxxxx",
"type": "JUPYTER_ENTERPRISE_GATEWAY",
"state": "ACTIVE",
"releaseLabel": "emr-6.9.0-latest",
"executionRoleArn": "arn:aws:iam::1828xxxxxxxx:role/RoleName",
"certificateAuthority": {
"certificateArn": "arn:aws:acm:us-east-1:1828xxxxxxxx:certificate/zzzzzzzz-e59b-4ed0-aaaa-bbbbbbbbbbbb",
"certificateData": "certificate-data"
},
"configurationOverrides": {
"applicationConfiguration": [
{
"classification": "spark-defaults",
"properties": {
"spark.driver.memory": "8G"
}
}
],
"monitoringConfiguration": {
"persistentAppUI": "ENABLED",
"cloudWatchMonitoringConfiguration": {
"logGroupName": "log-group-name",
"logStreamNamePrefix": "log-stream-name-prefix"
},
"s3MonitoringConfiguration": {
"logUri": "s3-bucket-name"
}
}
},
"serverUrl": "https://internal-k8s-namespace-ingressa-aaaaaaaaaa-zzzzzzzzzz.us-east-1.elb.amazonaws.com:18888 (https://internal-k8s-nspluto-ingressa-51e860abbd-1620715833.us-east-1.elb.amazonaws.com:18888/)",
"createdAt": "2022-09-19T12:37:49+00:00",
"securityGroup": "sg-aaaaaaaaaaaaaa",
"subnetIds": [
"subnet-11111111111",
"subnet-22222222222",
"subnet-33333333333"
],
"stateDetails": "Endpoint created successfully. It took 3 Minutes 15 Seconds",
"tags": {}
}
```
## Liste de tous les points de terminaison interactifs associés à un cluster virtuel
Utilisez la `list-managed-endpoints` AWS CLI commande pour récupérer la liste de tous les points de terminaison interactifs associés à un cluster virtuel spécifié. Remplacez `virtual-cluster-id` par l'identifiant de votre cluster virtuel.
```
aws emr-containers list-managed-endpoints ‐‐virtual-cluster-id virtual-cluster-id
```
Le résultat de la commande `list-managed-endpoint` est illustré ci-dessous :
```
{
"endpoints": [{
"id": "as3ys2xxxxxxx",
"name": "endpoint-name",
"arn": "arn:aws:emr-containers:us-east-1:1828xxxxxxxx:/virtualclusters/lbhl6kwwyoxxxxxxxxxxxxxxx/endpoints/as3ysxxxxxxxx",
"virtualClusterId": "lbhl6kwwyoxxxxxxxxxxxxxxx",
"type": "JUPYTER_ENTERPRISE_GATEWAY",
"state": "ACTIVE",
"releaseLabel": "emr-6.9.0-latest",
"executionRoleArn": "arn:aws:iam::1828xxxxxxxx:role/RoleName",
"certificateAuthority": {
"certificateArn": "arn:aws:acm:us-east-1:1828xxxxxxxx:certificate/zzzzzzzz-e59b-4ed0-aaaa-bbbbbbbbbbbb",
"certificateData": "certificate-data"
},
"configurationOverrides": {
"applicationConfiguration": [{
"classification": "spark-defaults",
"properties": {
"spark.driver.memory": "8G"
}
}],
"monitoringConfiguration": {
"persistentAppUI": "ENABLED",
"cloudWatchMonitoringConfiguration": {
"logGroupName": "log-group-name",
"logStreamNamePrefix": "log-stream-name-prefix"
},
"s3MonitoringConfiguration": {
"logUri": "s3-bucket-name"
}
}
},
"serverUrl": "https://internal-k8s-namespace-ingressa-aaaaaaaaaa-zzzzzzzzzz.us-east-1.elb.amazonaws.com:18888 (https://internal-k8s-nspluto-ingressa-51e860abbd-1620715833.us-east-1.elb.amazonaws.com:18888/)",
"createdAt": "2022-09-19T12:37:49+00:00",
"securityGroup": "sg-aaaaaaaaaaaaaa",
"subnetIds": [
"subnet-11111111111",
"subnet-22222222222",
"subnet-33333333333"
],
"stateDetails": "Endpoint created successfully. It took 3 Minutes 15 Seconds",
"tags": {}
}]
}
```
# Suppression d'un point de terminaison interactif
Pour supprimer un point de terminaison interactif associé à un cluster virtuel Amazon EMR on EKS, utilisez la `delete-managed-endpoint` AWS CLI commande. Lorsque vous supprimez un point de terminaison interactif, Amazon EMR on EKS supprime les groupes de sécurité par défaut créés pour ce point de terminaison.
Utilisez les valeurs des paramètres suivants de la commande :
+ **‐‐id** : identifiant du point de terminaison interactif que vous souhaitez supprimer.
+ **‐‐ virtual-cluster-id** — L'identifiant du cluster virtuel associé au point de terminaison interactif que vous souhaitez supprimer. Il s'agit du même identifiant de cluster virtuel que celui spécifié lors de la création du point de terminaison interactif.
```
aws emr-containers delete-managed-endpoint ‐‐id managed-endpoint-id ‐‐virtual-cluster-id virtual-cluster-id
```
La commande renvoie un résultat similaire au suivant pour confirmer que vous avez supprimé le point de terminaison interactif :
```
{
"id":"8gai4l4exxxxx",
"virtualClusterId":"0b0qvauoy3ch1nqodxxxxxxxx"
}
```