Requisitos previos Paso 1: recuperar una imagen base de Amazon Elastic Container Registry (Amazon ECR)Paso 2: personalizar una imagen base Paso 3: (opcional, pero recomendado) validar una imagen personalizada Paso 4: publicar una imagen personalizada Paso 5: enviar una carga de trabajo de Spark en Amazon EMR mediante una imagen personalizada Personalice las imágenes de Docker para puntos de conexión interactivos Uso de imágenes multiarquitectura

Cómo personalizar las imágenes de Docker

Siga estos pasos para personalizar las imágenes de Docker de Amazon EMR en EKS.

Requisitos previos
Paso 1: recuperar una imagen base de Amazon Elastic Container Registry (Amazon ECR)
Paso 2: personalizar una imagen base
Paso 3: (opcional, pero recomendado) validar una imagen personalizada
Paso 4: publicar una imagen personalizada
Paso 5: enviar una carga de trabajo de Spark en Amazon EMR mediante una imagen personalizada

Estas son otras opciones que quizás desee tener en cuenta al personalizar las imágenes de Docker:

Personalice las imágenes de Docker para puntos de conexión interactivos
Uso de imágenes multiarquitectura

Requisitos previos

Complete los pasos Configuración de Amazon EMR en EKS de Amazon EMR en EKS.
Instale Docker en su entorno. Para obtener más información, consulte Obtener Docker.

Paso 1: recuperar una imagen base de Amazon Elastic Container Registry (Amazon ECR)

La imagen base contiene el tiempo de ejecución de Amazon EMR y los conectores que se utilizan para acceder a otros servicios de AWS . Para Amazon EMR 6.9.0 y versiones posteriores, puede obtener las imágenes base en Amazon ECR Public Gallery. Navegue por la galería para encontrar el enlace a la imagen y llevarla a su espacio de trabajo local. Por ejemplo, para la versión 7.1.0 de Amazon EMR, el siguiente docker pull comando le proporciona la imagen base estándar más reciente. Puede sustituir emr-7.1.0:latest por emr-7.1.0-spark-rapids:latest para recuperar la imagen que tiene el acelerador de Nvidia RAPIDS. También puede sustituir emr-7.1.0:latest por emr-7.1.0-java11:latest para recuperar la imagen con el tiempo de ejecución de Java 11.


docker pull public.ecr.aws/emr-on-eks/spark/emr-7.1.0:latest

Si desea recuperar la imagen base de Amazon EMR 6.9.0 o versiones anteriores, o si prefiere recuperarla de las cuentas de registro de Amazon ECR de cada región, siga estos pasos:

Elija un URI de imagen base. El URI de imagen sigue este formato, ECR-registry-account.dkr.ecr.Region.amazonaws.com/spark/container-image-tag, tal como se muestra en el siguiente ejemplo.
```
895885662937.dkr.ecr.us-west-2.amazonaws.com/spark/emr-6.6.0:latest
```
Para elegir una imagen base en su región, consulte Cómo seleccionar un URI de imagen base.
Inicie sesión en el repositorio de Amazon ECR donde está almacenada la imagen base. Sustituya 895885662937 y us-west-2 por la cuenta de registro de Amazon ECR y la región que haya seleccionado. AWS
```
aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin 895885662937.dkr.ecr.us-west-2.amazonaws.com
```
Coloque la imagen base en su espacio de trabajo local. Sustituya emr-6.6.0:latest por la etiqueta de imagen de contenedor que haya seleccionado.
```
docker pull 895885662937.dkr.ecr.us-west-2.amazonaws.com/spark/emr-6.6.0:latest
```

Paso 2: personalizar una imagen base

Siga estos pasos para personalizar la imagen base que ha obtenido de Amazon ECR.

Cree un Dockerfile nuevo en su espacio de trabajo local.
Edite el Dockerfile que acaba de crear y agregue el siguiente contenido. Este Dockerfile usa la imagen del contenedor de la que ha extraído de 895885662937.dkr.ecr.us-west-2.amazonaws.com/spark/emr-6.6.0:latest.
```
FROM 895885662937.dkr.ecr.us-west-2.amazonaws.com/spark/emr-6.6.0:latest
USER root
### Add customization commands here ####
USER hadoop:hadoop
```
Agregue comandos en el Dockerfile para personalizar la imagen base. Por ejemplo, agregue un comando para instalar bibliotecas de Python, como se muestra en el siguiente Dockerfile.
```
FROM 895885662937.dkr.ecr.us-west-2.amazonaws.com/spark/emr-6.6.0:latest
USER root
RUN pip3 install --upgrade boto3 pandas numpy // For python 3
USER hadoop:hadoop
```
Desde el mismo directorio en el que Dockerfile se creó, ejecute el siguiente comando para crear la imagen de Docker. Proporcione un nombre para la imagen de Docker, por ejemplo, emr6.6_custom.
```
docker build -t emr6.6_custom .
```

Paso 3: (opcional, pero recomendado) validar una imagen personalizada

Le recomendamos que pruebe la compatibilidad de la imagen personalizada antes de publicarla. Puede utilizar la CLI de imágenes personalizadas de Amazon EMR en EKS para comprobar si la imagen tiene las estructuras de archivos requeridas y las configuraciones correctas para ejecutarse en Amazon EMR en EKS.

nota

La CLI de imagen personalizada de Amazon EMR en EKS no puede confirmar que la imagen no contenga errores. Tenga cuidado al eliminar las dependencias de las imágenes base.

Siga estos pasos para validar la imagen personalizada.

Descargue e instale Amazon EMR en EKS en la CLI de imágenes personalizadas. Para obtener más información, consulte la Guía de instalación de la CLI de imagen personalizada de Amazon EMR en EKS.
Ejecute el siguiente comando para evaluar la instalación.
```
emr-on-eks-custom-image --version
```
A continuación se muestra un ejemplo de este resultado.
```
Amazon EMR on EKS Custom Image CLI
Version: x.xx
```

Ejecute el siguiente comando para validar la imagen personalizada.


emr-on-eks-custom-image validate-image -i image_name -r release_version [-t image_type]

-i especifica el URI de imagen local que debe validarse. Puede ser el URI de imagen o cualquier nombre o etiqueta que haya definido para la imagen.
-r especifica la versión de lanzamiento exacta de la imagen base, por ejemplo, emr-6.6.0-latest.
-t especifica el tipo de imagen. Si se trata de una imagen de Spark, ingrese spark. El valor predeterminado es spark. La versión actual de la CLI de imágenes personalizadas de Amazon EMR en EKS solo admite imágenes en tiempo de ejecución de Spark.

Si ejecuta el comando correctamente y la imagen personalizada cumple con todas las configuraciones y estructuras de archivos requeridas, el resultado devuelto muestra los resultados de todas las pruebas, tal y como se muestra en el siguiente ejemplo.


Amazon EMR on EKS Custom Image Test
Version: x.xx
... Checking if docker cli is installed
... Checking Image Manifest
[INFO] Image ID: xxx
[INFO] Created On: 2021-05-17T20:50:07.986662904Z
[INFO] Default User Set to hadoop:hadoop : PASS
[INFO] Working Directory Set to /home/hadoop : PASS
[INFO] Entrypoint Set to /usr/bin/entrypoint.sh : PASS
[INFO] SPARK_HOME is set with value: /usr/lib/spark : PASS
[INFO] JAVA_HOME is set with value: /etc/alternatives/jre : PASS
[INFO] File Structure Test for spark-jars in /usr/lib/spark/jars: PASS
[INFO] File Structure Test for hadoop-files in /usr/lib/hadoop: PASS
[INFO] File Structure Test for hadoop-jars in /usr/lib/hadoop/lib: PASS
[INFO] File Structure Test for bin-files in /usr/bin: PASS
... Start Running Sample Spark Job
[INFO] Sample Spark Job Test with local:///usr/lib/spark/examples/jars/spark-examples.jar : PASS
-----------------------------------------------------------------
Overall Custom Image Validation Succeeded.
-----------------------------------------------------------------

Si la imagen personalizada no cumple con las configuraciones o estructuras de archivos requeridas, aparecen mensajes de error. El resultado devuelto proporciona información sobre las configuraciones o estructuras de archivos incorrectas.

Paso 4: publicar una imagen personalizada

Publique la nueva imagen de Docker en su registro de Amazon ECR.

Ejecute el siguiente comando para crear un repositorio de Amazon ECR para almacenar la imagen de Docker. Proporcione un nombre para su repositorio, por ejemplo, emr6.6_custom_repo. Sustituya us-west-2 por su región.
```
aws ecr create-repository \
    --repository-name emr6.6_custom_repo \
    --image-scanning-configuration scanOnPush=true \
    --region us-west-2
```
Para obtener más información, consulte Crear un repositorio en la Guía del usuario de Amazon ECR.
Ejecute el siguiente comando para autenticarse en el registro predeterminado.
```
aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin aws_account_id.dkr.ecr.us-west-2.amazonaws.com
```
Para obtener más información, consulte Autenticar en su registro predeterminado en la Guía del usuario de Amazon ECR.
Etiquete y publique una imagen en el repositorio de Amazon ECR que ha creado.

Etiquete la imagen.
```
docker tag emr6.6_custom aws_account_id.dkr.ecr.us-west-2.amazonaws.com/emr6.6_custom_repo
```
Inserte la imagen.
```
docker push aws_account_id.dkr.ecr.us-west-2.amazonaws.com/emr6.6_custom_repo
```
Para obtener más información, consulte Insertar una imagen en Amazon ECR en la Guía del usuario de Amazon ECR.

Paso 5: enviar una carga de trabajo de Spark en Amazon EMR mediante una imagen personalizada

Una vez creada y publicada una imagen personalizada, puede enviar un trabajo de Amazon EMR en EKS mediante una imagen personalizada.

En primer lugar, cree un start-job-run-request archivo.json y especifique el spark.kubernetes.container.image parámetro para hacer referencia a la imagen personalizada, como se muestra en el siguiente archivo JSON de ejemplo.

nota

Puede usar el esquema local:// para hacer referencia a los archivos disponibles en la imagen personalizada, tal como se muestra con el argumento entryPoint en el siguiente fragmento de código JSON. También puede usar el esquema local:// para hacer referencia a las dependencias de las aplicaciones. Todos los archivos y dependencias a los que se hace referencia mediante el esquema local:// ya deben estar presentes en la ruta especificada en la imagen personalizada.



{
    "name": "spark-custom-image", 
    "virtualClusterId": "virtual-cluster-id", 
    "executionRoleArn": "execution-role-arn", 
    "releaseLabel": "emr-6.6.0-latest", 
    "jobDriver": {
      "sparkSubmitJobDriver": {
        "entryPoint": "local:///usr/lib/spark/examples/jars/spark-examples.jar", 
        "entryPointArguments": [
                  "10"
              ],
         "sparkSubmitParameters": "--class org.apache.spark.examples.SparkPi --conf spark.kubernetes.container.image=123456789012.dkr.ecr.us-west-2.amazonaws.com/emr6.6_custom_repo"
       }
    }
}

También puede hacer referencia a la imagen personalizada con las propiedades applicationConfiguration, tal como se muestra en el siguiente ejemplo.



{
    "name": "spark-custom-image", 
    "virtualClusterId": "virtual-cluster-id", 
    "executionRoleArn": "execution-role-arn", 
    "releaseLabel": "emr-6.6.0-latest", 
    "jobDriver": {
      "sparkSubmitJobDriver": {
        "entryPoint": "local:///usr/lib/spark/examples/jars/spark-examples.jar", 
        "entryPointArguments": [
                  "10"
              ],
         "sparkSubmitParameters": "--class org.apache.spark.examples.SparkPi"
       }
    },
    "configurationOverrides": {
        "applicationConfiguration": [
            {
                "classification": "spark-defaults",
                "properties": {
                    "spark.kubernetes.container.image": "123456789012.dkr.ecr.us-west-2.amazonaws.com/emr6.6_custom_repo"
                }
            }
        ]
    }
}

A continuación, ejecute el comando start-job-run para enviar el trabajo.



aws emr-containers start-job-run --cli-input-json file://./start-job-run-request.json

En los ejemplos de JSON anteriores, sustituya emr-6.6.0-latest por su versión de lanzamiento de Amazon EMR. Le recomendamos que utilice la versión de lanzamiento -latest para asegurarse de que la versión seleccionada contenga las actualizaciones de seguridad más recientes. Para obtener más información sobre las versiones de lanzamiento de Amazon EMR y sus etiquetas de imagen, consulte Cómo seleccionar un URI de imagen base.

nota

Puede usar spark.kubernetes.driver.container.image y spark.kubernetes.executor.container.image para especificar una imagen diferente para los pods controladores y ejecutores.

Personalice las imágenes de Docker para puntos de conexión interactivos

También puede personalizar las imágenes de Docker de puntos de conexión interactivos, de modo que pueda ejecutar imágenes base del kernel personalizadas. Esto le ayuda a garantizar que disponga de las dependencias que necesita al ejecutar cargas de trabajo interactivas desde EMR Studio.

Siga los pasos 1-4 descritos anteriormente para personalizar una imagen de Docker. Para las versiones 6.9.0 y posteriores de Amazon EMR, puede obtener el URI de imagen base en Amazon ECR Public Gallery. Para las versiones anteriores a Amazon EMR 6.9.0, puede obtener la imagen en las cuentas de Amazon ECR Registry de cada Región de AWS, y la única diferencia es el URI de la imagen base de su archivo de Docker. El URI de imagen base sigue el siguiente formato:
```
ECR-registry-account.dkr.ecr.Region.amazonaws.com/notebook-spark/container-image-tag
```
Debe usar notebook-spark en el URI de imagen base en lugar de spark. La imagen base contiene el tiempo de ejecución de Spark y los kernels del cuaderno que se ejecutan con él. Para obtener más información sobre cómo seleccionar las regiones y las etiquetas de imagen de contenedores, consulte Cómo seleccionar un URI de imagen base.

nota
Actualmente, solo se admiten las modificaciones de las imágenes base y no se admite la introducción de núcleos completamente nuevos de tipos distintos de los que AWS proporcionan las imágenes base.

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

Primero, cree un archivo JSON denominado custom-image-managed-endpoint.json con el siguiente contenido.


{
    "name": "endpoint-name",
    "virtualClusterId": "virtual-cluster-id",
    "type": "JUPYTER_ENTERPRISE_GATEWAY",
    "releaseLabel": "emr-6.6.0-latest",
    "executionRoleArn": "execution-role-arn",
    "certificateArn": "certificate-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"
                        }
                    }
                ] 
            }
        ]
    }
}

A continuación, cree un punto de conexión interactivo con las configuraciones especificadas en el archivo JSON, tal como se muestra en el siguiente ejemplo.


aws emr-containers create-managed-endpoint --cli-input-json custom-image-managed-endpoint.json

Para obtener más información, consulte Crear un punto de conexión interactivo para su clúster virtual.

Conéctese al punto de conexión interactivo a través de EMR Studio. Para obtener más información, consulte Conexión desde Studio.

Uso de imágenes multiarquitectura

Amazon EMR en EKS es compatible con imágenes de contenedor multiarquitectura de Amazon Elastic Container Registry (Amazon ECR). Para obtener más información, consulte Introducción a las imágenes de contenedores de varias arquitecturas de Amazon ECR.

Las imágenes personalizadas de Amazon EMR en EKS admiten tanto instancias EC2 basadas en AWS Graviton como instancias EC2 no basadas en Graviton. Las imágenes basadas en Graviton se almacenan en los mismos repositorios de imágenes de Amazon ECR que las imágenes no basadas en Graviton.

Por ejemplo, para inspeccionar la lista de manifiesto de Docker en busca de imágenes de 6.6.0, ejecute el siguiente comando.


docker manifest inspect 895885662937.dkr.ecr.us-west-2.amazonaws.com/spark/emr-6.6.0:latest

Esta es la salida. La arquitectura arm64 es para la instancia de Graviton. amd64 es para una instancia que no es de Graviton.


{
   "schemaVersion": 2,
   "mediaType": "application/vnd.docker.distribution.manifest.list.v2+json",
   "manifests": [
      {
         "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
         "size": 1805,
         "digest": "xxx123:6b971cb47d11011ab3d45fff925e9442914b4977ae0f9fbcdcf5cfa99a7593f0",
         "platform": {
            "architecture": "arm64",
            "os": "linux"
         }
      },
      {
         "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
         "size": 1805,
         "digest": "xxx123:6f2375582c9c57fa9838c1d3a626f1b4fc281e287d2963a72dfe0bd81117e52f",
         "platform": {
            "architecture": "amd64",
            "os": "linux"
         }
      }
   ]
}

Siga estos pasos para crear imágenes multiarquitectura:

Cree un Dockerfile con el siguiente contenido para poder extraer la imagen arm64.


FROM --platform=arm64 895885662937.dkr.ecr.us-west-2.amazonaws.com/spark/emr-6.6.0:latest
USER root
 
RUN pip3 install boto3 // install customizations here
USER hadoop:hadoop

Para crear una imagen multiarquitectura en Amazon ECR, siga las instrucciones de Introducción a las imágenes de contenedores de varias arquitecturas de Amazon ECR.

nota
Debe crear imágenes arm64 en las instancias arm64. Del mismo modo, debe crear imágenes amd64 en las instancias amd64.

También puede crear imágenes de varias arquitecturas sin tener que basarse en cada tipo de instancia específico con el comando buildx de Docker. Para obtener más información, consulte Aprovechar la compatibilidad con arquitectura de múltiples CPU.
Tras crear la imagen multiarquitectura, puede enviar un trabajo con el mismo parámetro spark.kubernetes.container.image y dirigirlo a la imagen. En un clúster heterogéneo con instancias EC2 basadas en Graviton y no AWS basadas en Graviton, la instancia determina la imagen de arquitectura correcta en función de la arquitectura de la instancia que extrae la imagen.

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

Personalización de las imágenes de Docker

Cómo seleccionar un URI de imagen base