Monitoreo de trabajos de Spark Plantillas de pods personalizadas Implementación de un pod de JEG en un grupo de nodos Opciones de configuración de JEG Modificación de PySpark los parámetros Imagen de kernel personalizada

Configuración de los ajustes de los puntos de conexión interactivos

Supervisión de trabajos de Spark de

Para poder supervisar y solucionar los errores, configure los puntos de enlace interactivos de modo que los trabajos iniciados con el punto de conexión puedan enviar la información de registro a Amazon S3, Amazon CloudWatch Logs o a ambos. En las siguientes secciones, se describe cómo enviar los registros de las aplicaciones de Spark a Amazon S3 para los trabajos de Spark que lance con Amazon EMR en los puntos de conexión interactivos de EKS.

Configurar la política de IAM para los registros de Amazon S3

Para que los kernels puedan enviar datos de registro a Amazon S3, la política de permisos del rol de ejecución de trabajos debe incluir los siguientes permisos. Sustituya DOC-EXAMPLE-BUCKET-LOGGING por el nombre de su bucket de registro.


{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "s3:PutObject",
                "s3:GetObject",
                "s3:ListBucket"
            ],
            "Resource": [
                "arn:aws:s3:::DOC-EXAMPLE-BUCKET-LOGGING",
                "arn:aws:s3:::DOC-EXAMPLE-BUCKET-LOGGING/*",
            ]
        }
    ]
}

nota

Amazon EMR en EKS también puede crear un bucket de S3. Si no hay ningún bucket de S3 disponible, incluya el permiso s3:CreateBucket en la política de IAM.

Una vez que haya otorgado a su rol de ejecución los permisos necesarios para enviar registros al bucket de S3, los datos de registro se envían a las siguientes ubicaciones de Amazon S3. Esto sucede cuando s3MonitoringConfiguration se pasa a la sección monitoringConfiguration de una solicitud create-managed-endpoint.

Registros del controlador: logUri/virtual-cluster-id/endpoints/endpoint-id/containers/spark-application-id/spark-application-id-driver/(stderr.gz/stdout.gz)
Registros del ejecutor: logUri/virtual-cluster-id/endpoints/endpoint-id/containers/spark-application-id/executor-pod-name-exec-<Number>/(stderr.gz/stdout.gz)

nota

Amazon EMR en EKS no carga los registros de los puntos de conexión a su bucket de S3.

Especificar plantillas de pods personalizadas con puntos de conexión interactivos

Puede crear puntos de conexión interactivos en los que especifique plantillas de pods personalizadas para los controladores y ejecutores. Las plantillas de pods son especificaciones que determinan cómo ejecutar cada pod. Puede usar archivos de plantillas de pods para definir las configuraciones de los pods controladores o ejecutores que las configuraciones de Spark no admiten. Actualmente, las plantillas de pods son compatibles con las versiones 6.3.0 y posteriores de Amazon EMR.

Para obtener más información sobre las plantillas de pods, consulte Uso de plantillas de pods en la Guía de desarrollo de Amazon EMR en EKS.

En el ejemplo siguiente, se muestra cómo crear un punto de conexión interactivo con plantillas 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"
            }
        }]
    }'

Implementación de un pod de JEG en un grupo de nodos

La colocación del pod de JEG (Jupyter Enterprise Gateway) es una característica que permite implementar un punto de conexión interactivo en un grupo de nodos específico. Con esta característica, puede configurar ajustes como instance type para el punto de conexión interactivo.

Asociación de un pod de JEG a un grupo de nodos administrado

La siguiente propiedad de configuración le permite especificar el nombre de un grupo de nodos administrado en el clúster de Amazon EKS en el que se implementará el pod de JEG.


//payload 
--configuration-overrides '{
      "applicationConfiguration": [
            {
                "classification": "endpoint-configuration",
                "properties": {
                    "managed-nodegroup-name": NodeGroupName
                }        
            }
        ] 
    }'

Un grupo de nodos debe tener la etiqueta de Kubernetes for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName adjuntada a todos los nodos que forman parte del grupo de nodos. Para enumerar todos los nodos de un grupo de nodos que tienen esta etiqueta, use el siguiente comando:


kubectl get nodes --show-labels | grep for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName

Si el resultado del comando anterior no devuelve los nodos que forman parte del grupo de nodos administrado, significa que no hay nodos en el grupo de nodos que tengan la etiqueta de Kubernetes for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName adjunta. En este caso, siga los pasos que se indican a continuación para adjuntar esa etiqueta a los nodos del grupo de nodos.

Use el comando siguiente para agregar la etiqueta de Kubernetes for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName a todos los nodos de un grupo de nodos administrado: NodeGroupName
```
kubectl label nodes --selector eks:nodegroup-name=NodeGroupName for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName
```

Compruebe que los nodos estén etiquetados correctamente con el siguiente comando:


kubectl get nodes --show-labels | grep for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName

Un grupo de nodos administrado debe estar asociado al grupo de seguridad de un clúster de Amazon EKS, lo que suele ocurrir si ha creado el clúster y el grupo de nodos administrado mediante eksctl. Puede verificarlo en la AWS consola mediante los siguientes pasos.

Vaya a su clúster en la consola de Amazon EKS.
Vaya a la pestaña de redes del clúster y anote su grupo de seguridad.
Vaya a la pestaña de procesamiento del clúster y haga clic en el nombre del grupo de nodos administrado.
En la pestaña Detalles del grupo de nodos administrado, compruebe que el grupo de seguridad del clúster que indicó anteriormente aparezca en Grupos de seguridad.

Si el grupo de nodos administrado no está asociado al grupo de seguridad del clúster de Amazon EKS, debe adjuntar la etiqueta for-use-with-emr-containers-managed-endpoint-sg=ClusterName/NodeGroupName al grupo de seguridad del grupo de nodos. Siga estos pasos para adjuntar la etiqueta.

Vaya a la consola de Amazon EC2 y haga clic en los grupos de seguridad del panel de navegación izquierdo.
Para seleccionar el grupo de seguridad del grupo de nodos administrado, haga clic en la casilla de verificación.
En la pestaña Etiquetas, agregue la etiqueta for-use-with-emr-containers-managed-endpoint-sg=ClusterName/NodeGroupName con el botón Administrar etiquetas.

Asociación de un pod de JEG a un grupo de nodos autoadministrado

La siguiente propiedad de configuración le permite especificar el nombre de un grupo de nodos autoadministrado o no administrado en el clúster de Amazon EKS en el que se implementará el pod de JEG.


//payload 
--configuration-overrides '{
      "applicationConfiguration": [
            {
                "classification": "endpoint-configuration",
                "properties": {
                    "self-managed-nodegroup-name": NodeGroupName
                }        
            }
        ] 
    }'

El grupo de nodos debe tener la etiqueta de Kubernetes for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName adjunta a todos los nodos que forman parte del grupo de nodos. Para enumerar todos los nodos de un grupo de nodos que tienen esta etiqueta, use el comando siguiente:


kubectl get nodes --show-labels | grep for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName

Si el resultado del comando anterior no devuelve los nodos que forman parte del grupo de nodos autoadministrado, significa que no hay nodos en el grupo de nodos que tengan la etiqueta de Kubernetes for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName adjunta. En este caso, siga los pasos que se indican a continuación para adjuntar esa etiqueta a los nodos del grupo de nodos.

Si ha creado el grupo de nodos autoadministrado con eksctl, utilice el siguiente comando para agregar la etiqueta de Kubernetes for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName a todos los nodos del grupo de nodos autoadministrado NodeGroupName a la vez.
```
kubectl label nodes --selector alpha.eksctl.io/nodegroup-name=NodeGroupName for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName
```
Si no utilizó eksctl para crear el grupo de nodos autoadministrado, tendrá que sustituir el selector del comando anterior por una etiqueta de Kubernetes diferente que esté adjunta a todos los nodos del grupo de nodos.

Utilice el siguiente comando para verificar que los nodos estén etiquetados correctamente:


kubectl get nodes --show-labels | grep for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName

El grupo de seguridad del grupo de nodos autoadministrado debe tener la etiqueta for-use-with-emr-containers-managed-endpoint-sg=ClusterName/NodeGroupName adjunta. Siga estos pasos para adjuntar la etiqueta al grupo de seguridad desde la AWS Management Console.

Vaya a la consola de Amazon EC2. En el panel de navegación izquierdo, elija Grupos de seguridad.
Seleccione la casilla de verificación junto al grupo de seguridad de su grupo de nodos autoadministrado.
En la pestaña Etiquetas, use el botón Administrar etiquetas para agregar la etiqueta for-use-with-emr-containers-managed-endpoint-sg=ClusterName/NodeGroupName. Sustituya ClusterName y NodeGroupName por los valores adecuados.

Asociación de un pod de JEG a un grupo de nodos administrado con instancias bajo demanda

También puede definir etiquetas adicionales, conocidas como selectores de etiquetas de Kubernetes, para especificar restricciones o restricciones adicionales para ejecutar un punto de conexión interactivo en un nodo o grupo de nodos determinado. En el ejemplo siguiente, se muestra cómo utilizar instancias de Amazon EC2 para un pod de JEG.


--configuration-overrides '{
      "applicationConfiguration": [
            {
                "classification": "endpoint-configuration",
                "properties": {
                    "managed-nodegroup-name": NodeGroupName,
                    "node-labels": "eks.amazonaws.com/capacityType:ON_DEMAND"
                }        
            }
        ] 
    }'

nota

Solo puede usar la propiedad node-labels con una propiedad managed-nodegroup-name o self-managed-nodegroup-name.

Opciones de configuración de Jupyter Enterprise Gateway (JEG)

Amazon EMR en EKS utiliza Jupyter Enterprise Gateway (JEG) para activar los puntos de conexión interactivos. Puede establecer los siguientes valores para las configuraciones de JEG permitidas cuando crea el punto de conexión.

RemoteMappingKernelManager.cull_idle_timeout: tiempo de espera en segundos (número entero), tras el cual el kernel se considera inactivo y listo para eliminarse. Los valores iguales a 0 o inferiores desactivan la eliminación selectiva. Los tiempos de espera cortos pueden provocar que se eliminen los kernels de los usuarios con conexiones de red deficientes.
RemoteMappingKernelManager.cull_interval: el intervalo en segundos (número entero) para comprobar si hay kernels inactivos que superen el valor de tiempo de espera de eliminación.

Modificar los parámetros PySpark de la sesión

A partir de Amazon EMR en la versión 6.9.0 de EKS, en Amazon EMR Studio puede ajustar la configuración de Spark asociada a una PySpark sesión ejecutando el %%configure comando mágico en la celda del portátil EMR.

En el siguiente ejemplo, se muestra una carga útil de muestra que puede usar para modificar la memoria, los núcleos y otras propiedades del controlador y ejecutor de Spark. En cuanto a los ajustes de conf, puede configurar cualquier configuración de Spark que se mencione en la documentación de configuración de Apache Spark.


%%configure -f
{
  "driverMemory": "16G",
  "driverCores" 4,
  "executorMemory" : "32G"
  "executorCores": 2,
  "conf": {
     "spark.dynamicAllocation.maxExecutors" : 10,
     "spark.dynamicAllocation.minExecutors": 1
  }
}

En el siguiente ejemplo, se muestra una carga útil de muestra que puede usar para agregar archivos, pyFiles y dependencias jar a un tiempo de ejecución de Spark.


%%configure -f
{
  "files": "s3://test-bucket-emr-eks/sample_file.txt",
  "pyFiles": : "path-to-python-files",
  "jars" : "path-to-jars
}

Imagen de kernel personalizada con punto de conexión interactivo

Para asegurarse de que disponga de las dependencias correctas para su aplicación cuando ejecute cargas de trabajo interactivas desde Amazon EMR Studio, puede personalizar las imágenes de Docker para los puntos de conexión interactivos y ejecutar imágenes de kernel base personalizadas. Para crear un punto de conexión interactivo y conectarlo a una imagen de Docker personalizada, siga estos pasos.

nota

Solo puede anular las imágenes base. No puede agregar nuevos tipos de imágenes de kernel.

Cree y publique una imagen de Docker personalizada. La imagen base contiene el tiempo de ejecución de Spark y los kernels del cuaderno que se ejecutan con él. Para crear la imagen, puede seguir los pasos del 1 al 4 de Cómo personalizar las imágenes de Docker. En el paso 1, notebook-spark debe usar el URI de imagen base del archivo de Docker en lugar de spark.
```
ECR-registry-account.dkr.ecr.Region.amazonaws.com/notebook-spark/container-image-tag
```
Para obtener más información sobre cómo seleccionar Regiones de AWS y almacenar etiquetas de imagen, consulte. Cómo seleccionar un URI de imagen base

Cree un punto de conexión interactivo que se pueda utilizar con la imagen personalizada.

Cree un archivo JSON denominado custom-image-managed-endpoint.json con el siguiente contenido. En este ejemplo, se utiliza la versión 6.9.0 de Amazon EMR.


{
    "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"
                        }
                    }
                ] 
            }
        ]
    }
}

Cree un punto de conexión interactivo con las configuraciones especificadas en el archivo JSON, tal como se muestra en el ejemplo siguiente. Para obtener más información, consulte Crear un punto de conexión interactivo con el comando create-managed-endpoint.
```
aws emr-containers create-managed-endpoint --cli-input-json custom-image-managed-endpoint.json
```

Conéctese al punto de conexión interactivo a través de EMR Studio. Para obtener más información y los pasos a seguir, consulte Conexión desde Studio en la sección Amazon EMR en EKS de los documentos de AWS Workshop Studio.

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Creación de un punto de conexión interactivo

Supervisión de puntos de conexión interactivos