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.
# Cómo personalizar las imágenes de Docker
Siga estos pasos para personalizar las imágenes de Docker de Amazon EMR en EKS. Los pasos muestran cómo obtener una imagen base, personalizarla y publicarla, y cómo enviar una carga de trabajo mediante la imagen.
+ [Requisitos previos](#docker-custom-images-prereq)
+ [Paso 1: recuperar una imagen base de Amazon Elastic Container Registry (Amazon ECR)](#docker-custom-images-retrieve)
+ [Paso 2: personalizar una imagen base](#docker-custom-images-customize)
+ [Paso 3: (opcional, pero recomendado) validar una imagen personalizada](#docker-custom-images-validate)
+ [Paso 4: publicar una imagen personalizada](#docker-custom-images-publish)
+ [Paso 5: enviar una carga de trabajo de Spark en Amazon EMR mediante una imagen personalizada](#docker-custom-images-submit)
**nota**
Otras opciones que quizás desee tener en cuenta al personalizar las imágenes de Docker son la personalización para puntos de conexión interactivos, lo que se hace para garantizar que cuenta con las dependencias necesarias, o el uso de imágenes de contenedor con varias arquitecturas:
[Personalice las imágenes de Docker para puntos de conexión interactivos](docker-custom-images-managed-endpoint.md)
[Uso de imágenes multiarquitectura](docker-custom-images-multi-architecture.md)
## Requisitos previos
+ Complete los pasos [Configuración de Amazon EMR en EKS](setting-up.md) de Amazon EMR en EKS.
+ Instale Docker en su entorno. Para obtener más información, consulte [Obtener Docker](https://docs.docker.com/get-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.12.0 de Amazon EMR, el siguiente `docker pull` comando le proporciona la imagen base estándar más reciente. Puede sustituir `emr-7.12.0:latest` por `emr-7.12.0-spark-rapids:latest` para recuperar la imagen que tiene el acelerador de Nvidia RAPIDS. También puede sustituir `emr-7.12.0:latest` por `emr-7.12.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.12.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:
1. 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 [Información sobre cómo seleccionar un URI de imagen base](docker-custom-images-tag.md).
1. 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 AWS región que haya seleccionado.
```
aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin 895885662937.dkr.ecr.us-west-2.amazonaws.com
```
1. Coloque la imagen base en su espacio de trabajo local. *emr-6.6.0:latest*Sustitúyala por la etiqueta de imagen del contenedor que hayas 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.
1. Cree un `Dockerfile` nuevo en su espacio de trabajo local.
1. 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
```
1. 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
```
1. 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\$1custom*.
```
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](https://github.com/awslabs/amazon-emr-on-eks-custom-image-cli) 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.
1. 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](https://github.com/awslabs/amazon-emr-on-eks-custom-image-cli/blob/main/installer/assets/INSTALLATION_GUIDE.md).
1. 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
```
1. 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.
1. 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\$1custom\$1repo*. Reemplace la *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](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html#cli-create-repository) en la *Guía del usuario de Amazon ECR*.
1. 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](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html#cli-authenticate-registry) en la *Guía del usuario de Amazon ECR*.
1. 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](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html#cli-push-image) 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, *emr-6.6.0-latest* sustitúyalo por la 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 [Información sobre cómo seleccionar un URI de imagen base](docker-custom-images-tag.md).
**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.