Utilisation des blocs-notes Jupyter auto-hébergés

Vous pouvez héberger et gérer Jupyter ou des JupyterLab blocs-notes sur une EC2 instance Amazon ou sur votre propre EKS cluster Amazon 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

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 EC2 console Amazon ou Amazon EC2 SDK pour 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 EC2 l'utilisateur Amazon. Vous devez créer le groupe de sécurité à l'VPCendroit où vous souhaitez déployer votre serveur portable.

Pour suivre l'exemple de ce guide, utilisez-le VPC comme votre EKS cluster Amazon. Si vous souhaitez héberger votre bloc-notes dans un environnement différent de VPC celui VPC de votre EKS cluster Amazon, vous devrez peut-être créer une connexion d'appairage entre les deuxVPCs. Pour savoir comment créer une connexion d'appairage entre deux personnesVPCs, consultez la section Créer une connexion d'VPCappairage dans le guide de VPC démarrage Amazon.

Vous avez besoin de l'ID du groupe de sécurité pour créer un point de terminaison Amazon EMR on EKS Interactive à l'étape suivante.

Créez un point de terminaison Amazon EMR sur EKS Interactive

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 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é.

Insérez l'identifiant de sécurité à la place de your-notebook-security-group-id dans les 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érez le serveur URL de passerelle de votre point de terminaison interactif

Après avoir créé un point de terminaison interactif, récupérez le serveur de passerelle URL à l'aide de la describe-managed-endpoint commande dans le AWS CLI. Vous en avez besoin URL pour connecter votre bloc-notes au terminal. Le serveur de passerelle URL 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 en avez besoin URL pour connecter votre bloc-notes au terminal lorsque vous déployez votre Jupyter ou votre bloc-notes auto-hébergé. 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 le. 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

Le ARN de votre point de terminaison. Vous pouvez le trouver ARN dans le résultat d'un describe-managed-endpoint appel.

virtualClusterArn

Le ARN du cluster virtuel.

executionRoleArn

Le 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é. 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 EKS cluster Amazon avec votre point de terminaison interactif.

1. Créez un espace de noms pour exécuter le serveur de bloc-notes.

2. 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érez le serveur URL de passerelle de votre point de terminaison interactif .

   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.

   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
             "

3. Déployez les spécifications du pod sur votre EKS cluster Amazon :

   kubectl apply -f notebook.yaml -n namespace

   Cela démarrera un JupyterLab bloc-notes minimal connecté à votre Amazon EMR sur un point de terminaison EKS interactif. 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

4. 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

   2. Ouvrez la EKS console Amazon à l'adresse https://console.aws.amazon.com/eks/home#/clusters.

   3. Accédez à l'onglet Compute de votre EKS cluster Amazon et sélectionnez le nœud identifié par la describe pod commande. Sélectionnez l'identifiant d'instance du nœud.

   4. 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é.

   5. Si vous déployez le module de bloc-notes Jupyter sur AWS Fargate, créez-en un SecurityGroupPolicyà 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

5. 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 :

   

6. À 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()

   

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

2. 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. Initialement, votre point de terminaison sera à l'état TERMINATING. Une fois que toutes les ressources ont été nettoyées, elles passent à l'état TERMINATED.

3. 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é pour d'autres déploiements de blocs-notes Jupyter, vous pouvez le supprimer. Consultez Supprimer un groupe de sécurité dans le guide de EC2 l'utilisateur Amazon pour plus d'informations.