Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Uso de cuadernos Jupyter autoalojados
<a name="managed-endpoints-self-hosted"></a>

*Puede alojar y gestionar Jupyter o JupyterLab notebooks en una instancia de Amazon EC2 o en su propio clúster de Amazon EKS como un bloc de notas Jupyter autohospedado.* A continuación, puede ejecutar cargas de trabajo interactivas con sus cuadernos de Jupyter autoalojados. En las siguientes secciones se explica el proceso de configuración e implementación de un cuaderno de Jupyter autoalojado en un clúster de Amazon EKS.



**Topics**
+ [Creación de un grupo de seguridad](#managed-endpoints-self-hosted-security)
+ [Crear un punto de conexión interactivo de Amazon EMR en EKS](#managed-endpoints-self-hosted-create-me)
+ [Recuperar la URL del servidor de puerta de enlace de su punto de conexión interactivo](#managed-endpoints-self-hosted-gateway)
+ [Recuperar un token de autenticación para conectarse al punto de conexión interactivo](#managed-endpoints-self-hosted-auth)
+ [Ejemplo: implementar un portátil JupyterLab](#managed-endpoints-self-hosted-example)
+ [Eliminar un cuaderno de Jupyter autoalojado](#managed-endpoints-self-hosted-cleanup)

## Creación de un grupo de seguridad
<a name="managed-endpoints-self-hosted-security"></a>

Antes de poder crear un punto de conexión interactivo y ejecutar un Jupyter o un JupyterLab bloc de notas autohospedado, debe crear un grupo de seguridad para controlar el tráfico entre el portátil y el punto de conexión interactivo. Para usar la consola de Amazon EC2 o el SDK de Amazon EC2 para crear el grupo de seguridad, consulte los pasos en [Crear un grupo de seguridad](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/working-with-security-groups.html#creating-security-group) en la *Guía del usuario de Amazon EC2*. Debe crear el grupo de seguridad en la VPC en la que desee implementar el servidor de su cuaderno.

Para seguir el ejemplo de esta guía, utilice la misma VPC que su clúster de Amazon EKS. Si desea alojar su portátil en una VPC diferente de la VPC de su clúster de Amazon EKS, es posible que necesite crear una conexión de emparejamiento entre ambas. VPCs Para ver los pasos para crear una conexión de emparejamiento entre dos VPCs, consulte [Crear una conexión de emparejamiento de VPC en la Guía](https://docs.aws.amazon.com/vpc/latest/peering/create-vpc-peering-connection.html) de introducción de Amazon VPC.

En el siguiente paso, necesitará el ID del grupo de seguridad para [crear un punto de conexión interactivo de Amazon EMR en EKS](https://docs.aws.amazon.com/).

## Crear un punto de conexión interactivo de Amazon EMR en EKS
<a name="managed-endpoints-self-hosted-create-me"></a>

Después de crear el grupo de seguridad de su cuaderno, siga los pasos que se indican en [Creación de un punto de conexión interactivo para su clúster virtual](create-managed-endpoint.md) para crear un punto de conexión interactivo. Debe proporcionar el ID del grupo de seguridad que creó para su cuaderno en [Creación de un grupo de seguridad](#managed-endpoints-self-hosted-security). 

Inserte el ID de seguridad en lugar de los siguientes ajustes de *your-notebook-security-group-id* anulación de la configuración:

```
--configuration-overrides '{
    "applicationConfiguration": [
        {
            "classification": "endpoint-configuration",
            "properties": {
                "notebook-security-group-id": "your-notebook-security-group-id"
            }
        }
    ],
    "monitoringConfiguration": {
    ...'
```

## Recuperar la URL del servidor de puerta de enlace de su punto de conexión interactivo
<a name="managed-endpoints-self-hosted-gateway"></a>

Tras crear un punto de conexión interactivo, recupere la URL del servidor de puerta de enlace con el comando `describe-managed-endpoint` incluido en la AWS CLI. Necesita esta URL para conectar su cuaderno al punto de conexión. La URL del servidor de puerta de enlace es un punto de conexión privado.

```
aws emr-containers describe-managed-endpoint \
--region region \
--virtual-cluster-id virtualClusterId \
--id endpointId
```

Al principio, el estado del punto de conexión es **CREATING**. Pasados unos minutos, pasa al estado **ACTIVE**. Cuando el estado del punto de conexión sea **ACTIVE**, estará listo para usarse.

Tome nota del atributo `serverUrl` que el comando `aws emr-containers describe-managed-endpoint` devuelve desde el punto de conexión activo. Necesitará esta URL para conectar su portátil al punto final al [implementar su Jupyter o portátil autohospedado](https://docs.aws.amazon.com/). JupyterLab 

## Recuperar un token de autenticación para conectarse al punto de conexión interactivo
<a name="managed-endpoints-self-hosted-auth"></a>

Para conectarte a un punto final interactivo desde un Jupyter o un JupyterLab bloc de notas, debes generar un token de sesión con la API. `GetManagedEndpointSessionCredentials` El token actúa como prueba de autenticación para conectarse al servidor del punto de conexión interactivo. 

El siguiente comando se explica con más detalle con un ejemplo de resultado.

```
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`**  
El ARN de su punto de conexión. Puede encontrar el ARN en el resultado de una llamada `describe-managed-endpoint`.

**`virtualClusterArn`**  
El ARN del clúster virtual.

**`executionRoleArn`**  
El ARN del rol de ejecución.

**`durationInSeconds`**  
La duración en segundos durante la cual el token es válido. La duración predeterminada es de 15 minutos (`900`) y la máxima, de 12 horas (`43200`).

**`region` **  
La misma región que el punto de conexión.

El resultado debería parecerse al siguiente ejemplo. Toma nota del `session-token` valor que utilizarás al [implementar tu Jupyter o portátil autohospedado](https://docs.aws.amazon.com/). JupyterLab 

```
{
    "id": "credentialsId",
    "credentials": {
        "token": "session-token"
    },
    "expiresAt": "2022-07-05T17:49:38Z"
}
```

## Ejemplo: implementar un portátil JupyterLab
<a name="managed-endpoints-self-hosted-example"></a>

Una vez que haya completado los pasos anteriores, puede probar este procedimiento de ejemplo para implementar un JupyterLab bloc de notas en el clúster de Amazon EKS con su punto de enlace interactivo.

1. Cree un espacio de nombres para ejecutar el servidor de cuadernos.

1. Cree un archivo localmente denominado `notebook.yaml` y con el siguiente contenido. El contenido del archivo se describe a continuación.

   ```
   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 va a implementar el cuaderno de Jupyter en un clúster exclusivo de Fargate, etiquete el pod de Jupyter con una etiqueta de `role`, tal como se muestra en el siguiente ejemplo:

   ```
   ...
   metadata:
     name: jupyter-notebook
     namespace: default
     labels:
       role: example-role-name-label
   spec:
               ...
   ```  
**`namespace`**  
El espacio de nombres de Kubernetes en el que se implementa el cuaderno.  
**`serverUrl`**  
El atributo `serverUrl` que el comando `describe-managed-endpoint` devolvió en [Recuperar la URL del servidor de puerta de enlace de su punto de conexión interactivo](#managed-endpoints-self-hosted-gateway).  
**`session-token`**  
El atributo `session-token` que el comando `get-managed-endpoint-session-credentials` devolvió en [Recuperar un token de autenticación para conectarse al punto de conexión interactivo](#managed-endpoints-self-hosted-auth).  
**`KERNEL_LAUNCH_TIMEOUT`**  
La cantidad de tiempo en segundos que el punto de conexión interactivo espera a que el kernel entre en estado **RUNNING**. Asegúrese de que haya tiempo suficiente para que se complete el inicio del kernel configurando el tiempo de espera de inicio del kernel en un valor adecuado (máximo 400 segundos).  
**`KERNEL_EXTRA_SPARK_OPTS`**  
Si lo desea, puede transferir configuraciones de Spark adicionales a los kernels de Spark. Establezca esta variable de entorno con los valores como propiedad de configuración de Spark, tal como se muestra en el siguiente ejemplo:  

   ```
   - 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. Implemente la especificación del pod en su clúster de Amazon EKS:

   ```
   kubectl apply -f notebook.yaml -n namespace
   ```

   Esto pondrá en marcha un JupyterLab portátil mínimo conectado a su terminal interactivo Amazon EMR en EKS. Espere a que el estado del pod sea **RUNNING**. Puede comprobarlo con el siguiente comando:

   ```
   kubectl get pod jupyter-notebook -n namespace
   ```

   Cuando el pod esté listo, el comando `get pod` devuelve un resultado similar al siguiente:

   ```
   NAME              READY  STATUS   RESTARTS  AGE
   jupyter-notebook  1/1    Running  0         46s
   ```

1. Adjunte el grupo de seguridad del cuaderno al nodo en el que está programado el cuaderno.

   1. En primer lugar, identifique el nodo en el que está programado el pod de `jupyter-notebook` con el comando `describe pod`.

      ```
      kubectl describe pod jupyter-notebook -n namespace
      ```

   1. Abra la consola Amazon EKS en [https://console.aws.amazon.com/eks/home\$1/clusters](https://console.aws.amazon.com/eks/home#/clusters).

   1. Vaya a la pestaña **Computación** de su clúster de Amazon EKS y seleccione el nodo identificado por el comando `describe pod`. Seleccione el ID de la instancia para el nodo.

   1. En el menú **Acciones**, seleccione **Seguridad** > **Cambiar grupos de seguridad** para adjuntar el grupo de seguridad que creó en [Creación de un grupo de seguridad](#managed-endpoints-self-hosted-security).

   1. Si va a implementar el módulo de Jupyter Notebook AWS Fargate, cree un módulo []()para aplicarlo al módulo de Jupyter Notebook con la siguiente etiqueta de rol:

      ```
      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. Ahora, redireccione el puerto para que pueda acceder localmente a la interfaz: JupyterLab 

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

   Una vez que se esté ejecutando, navegue hasta su navegador local y visite `localhost:8888` para ver la JupyterLab interfaz:  
![\[Captura de pantalla de la pantalla de JupyterLab inicio.\]](http://docs.aws.amazon.com/es_es/emr/latest/EMR-on-EKS-DevelopmentGuide/images/emr-on-eks-Jupyter-notebook-start.png)

1. Desde JupyterLab, crea un nuevo cuaderno de Scala. Aquí tiene un ejemplo de fragmento de código que puede ejecutar para aproximar el valor 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()
   ```  
![\[Captura de pantalla de un ejemplo del código de un cuaderno Scala. JupyterLab\]](http://docs.aws.amazon.com/es_es/emr/latest/EMR-on-EKS-DevelopmentGuide/images/emr-on-eks-Jupyter-notebook-scala-program.png)

## Eliminar un cuaderno de Jupyter autoalojado
<a name="managed-endpoints-self-hosted-cleanup"></a>

Cuando lo tenga todo listo para eliminar su cuaderno autoalojado, también puede eliminar el punto de conexión interactivo y el grupo de seguridad. Lleve a cabo las acciones en el siguiente orden:

1. Utilice el siguiente comando para eliminar el pod de `jupyter-notebook`:

   ```
   kubectl delete pod jupyter-notebook -n namespace
   ```

1. A continuación, elimine el punto de conexión interactivo con el comando `delete-managed-endpoint`. Para ver los pasos para eliminar un punto de conexión interactivo, consulte [Eliminar un punto de conexión interactivo](delete-managed-endpoint.md). Inicialmente, el estado del punto de conexión será **TERMINATING**. Una vez que se hayan depurado todos los recursos, pasará al estado **TERMINATED**.

1. Si no piensa utilizar el grupo de seguridad de cuadernos que creó en [Creación de un grupo de seguridad](#managed-endpoints-self-hosted-security) para otras implementaciones de cuaderno de Jupyter, puede eliminarlo. Para obtener más información, consulte [Eliminar un grupo de seguridad](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/working-with-security-groups.html#deleting-security-group) en la Guía del usuario de Amazon EC2.