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.

# Utilisation des blocs-notes Jupyter auto-hébergés
<a name="managed-endpoints-self-hosted"></a>

*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é
<a name="managed-endpoints-self-hosted-security"></a>

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
<a name="managed-endpoints-self-hosted-create-me"></a>

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
<a name="managed-endpoints-self-hosted-gateway"></a>

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
<a name="managed-endpoints-self-hosted-auth"></a>

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
<a name="managed-endpoints-self-hosted-example"></a>

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 <<EOF
      apiVersion: vpcresources.k8s.aws/v1beta1
      kind: SecurityGroupPolicy
      metadata:
        name: example-security-group-policy-name
        namespace: default
      spec:
        podSelector:
          matchLabels:
            role: example-role-name-label
        securityGroups:
          groupIds:
            - your-notebook-security-group-id
      EOF
      ```

1. Maintenant, redirigez le port afin que vous puissiez accéder localement à l' JupyterLab interface :

   ```
   kubectl port-forward jupyter-notebook 8888:8888 -n namespace
   ```

   Une fois que cela est lancé, accédez à votre navigateur local et rendez-vous `localhost:8888` pour voir l' JupyterLab interface :  
![\[Capture d'écran de l'écran de JupyterLab démarrage.\]](http://docs.aws.amazon.com/fr_fr/emr/latest/EMR-on-EKS-DevelopmentGuide/images/emr-on-eks-Jupyter-notebook-start.png)

1. À partir de JupyterLab, créez un nouveau bloc-notes Scala. Voici un exemple d'extrait de code que vous pouvez exécuter pour calculer approximativement la valeur de Pi :

   ```
   import scala.math.random
   import org.apache.spark.sql.SparkSession
   
   /** Computes an approximation to pi */
   val session = SparkSession
     .builder
     .appName("Spark Pi")
     .getOrCreate()
   
   val slices = 2
   // avoid overflow
   val n = math.min(100000L * slices, Int.MaxValue).toInt 
    
   val count = session.sparkContext
   .parallelize(1 until n, slices)
   .map { i =>
     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é
<a name="managed-endpoints-self-hosted-cleanup"></a>

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.