Prérequis Étape 1 : Récupération d'une image de base à partir d'Amazon Elastic Container Registry (Amazon ECR)Étape 2 : Personnaliser une image de base Étape 3 : (facultative, mais recommandée) Valider une image personnalisée Étape 4 : Publier une image personnalisée Étape 5 : Soumettre une charge de travail Spark dans Amazon EMR à l'aide d'une image personnalisée Personnalisation des images Docker pour les points de terminaison interactifs Utilisation d'images multi-architectures

Instructions de personnalisation des images Docker

Suivez les étapes ci-dessous pour personnaliser les images Docker pour Amazon EMR on EKS.

Prérequis
Étape 1 : Récupération d'une image de base à partir d'Amazon Elastic Container Registry (Amazon ECR)
Étape 2 : Personnaliser une image de base
Étape 3 : (facultative, mais recommandée) Valider une image personnalisée
Étape 4 : Publier une image personnalisée
Étape 5 : Soumettre une charge de travail Spark dans Amazon EMR à l'aide d'une image personnalisée

Voici d'autres options que vous pouvez envisager lors de la personnalisation des images Docker :

Personnalisation des images Docker pour les points de terminaison interactifs
Utilisation d'images multi-architectures

Prérequis

Suivez les étapes Configuration d'Amazon EMR on EKS pour Amazon EMR on EKS.
Installez Docker dans votre environnement. Pour plus d'informations, consultez Obtenir Docker.

Étape 1 : Récupération d'une image de base à partir d'Amazon Elastic Container Registry (Amazon ECR)

L'image de base contient le moteur d'exécution Amazon EMR et les connecteurs utilisés pour accéder à d'autres services AWS . Pour Amazon EMR 6.9.0 et les versions ultérieures, vous pouvez obtenir les images de base à partir de la galerie publique d'Amazon ECR. Parcourez la galerie pour trouver le lien de l'image et extrayez l'image dans votre espace de travail local. Par exemple, pour la version 7.1.0 d'Amazon EMR, la docker pull commande suivante permet d'obtenir la dernière image de base standard. Vous pouvez remplacer emr-7.1.0:latest par emr-7.1.0-spark-rapids:latest pour récupérer l'image qui possède l'accélérateur Nvidia RAPIDS. Vous pouvez également remplacer emr-7.1.0:latest par emr-7.1.0-java11:latest pour récupérer l'image avec le moteur d'exécution Java 11.


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

Si vous souhaitez récupérer l'image de base d'Amazon EMR 6.9.0 ou de versions antérieures, ou si vous préférez récupérer l'image à partir des comptes de registre Amazon ECR de chaque région, procédez comme suit :

Choisissez l'URI de l'image de base. Le format de l'URI de l'image est ECR-registry-account.dkr.ecr.Region.amazonaws.com/spark/container-image-tag, comme le montre l'exemple ci-dessous.
```
895885662937.dkr.ecr.us-west-2.amazonaws.com/spark/emr-6.6.0:latest
```
Pour choisir une image de base dans votre région, consultez Instructions de sélection de l'URI d'une image de base.
Connectez-vous au référentiel Amazon ECR dans lequel l'image de base est stockée. Remplacez 895885662937 et us-west-2 par le compte de registre Amazon ECR et la région que vous avez sélectionnée. AWS
```
aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin 895885662937.dkr.ecr.us-west-2.amazonaws.com
```
Extrayez l'image de base dans votre espace de travail local. Remplacez emr-6.6.0:latest par la balise d'image du conteneur que vous avez sélectionnée.
```
docker pull 895885662937.dkr.ecr.us-west-2.amazonaws.com/spark/emr-6.6.0:latest
```

Étape 2 : Personnaliser une image de base

Suivez les étapes ci-dessous pour personnaliser l'image de base que vous avez extraite à partir d'Amazon ECR.

Créez un nouveau espace de travail Dockerfile sur votre espace de travail local.
Modifiez le Dockerfile que vous venez de créer et ajoutez le contenu qui suit. Ce Dockerfile utilise l'image du conteneur que vous avez extrait à partir 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
```
Ajoutez des commandes dans le Dockerfile pour personnaliser l'image de base. Par exemple, ajoutez une commande pour installer les bibliothèques Python, comme le montre le fichier Dockerfile ci-dessous.
```
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
```
À partir du répertoire où le Dockerfile est créé, exécutez la commande suivante pour créer l'image Docker. Donnez un nom à l'image Docker, par exemple emr6.6_custom.
```
docker build -t emr6.6_custom .
```

Étape 3 : (facultative, mais recommandée) Valider une image personnalisée

Nous vous recommandons de tester la compatibilité de votre image personnalisée avant de la publier. Vous pouvez utiliser l'interface CLI pour les images personnalisées d'Amazon EMR on EKS pour vérifier si votre image possède les structures de fichiers requises et les configurations correctes pour être exécutée sur Amazon EMR on EKS.

Note

L'interface CLI pour les images personnalisées d'Amazon EMR on EKS ne peut pas confirmer que votre image est exempte d'erreur. Faites attention lorsque vous supprimez des dépendances des images de base.

Suivez les étapes ci-dessous pour valider votre image personnalisée.

Téléchargez et installez l'interface CLI pour les images personnalisées d'Amazon EMR on EKS. Pour plus d'informations, consultez le Guide d'installation de l'interface CLI pour les images personnalisées d'Amazon EMR on EKS.
Exécutez la commande suivante pour tester l'installation.
```
emr-on-eks-custom-image --version
```
Voici un exemple de résultat.
```
Amazon EMR on EKS Custom Image CLI
Version: x.xx
```

Exécutez la commande suivante pour valider votre image personnalisée.


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

-i indique l'URI de l'image locale qui doit être validée. Il peut s'agir de l'URI de l'image, d'un nom ou d'une balise que vous avez défini pour votre image.
-r indique la version exacte de l'image de base, par exemple, emr-6.6.0-latest.
-t indique le type d'image. S'il s'agit d'une image Spark, saisissez spark. La valeur par défaut est spark. La version actuelle de l'interface CLI pour les images personnalisées d'Amazon EMR on EKS ne prend en charge que les images d'exécution Spark.

Si vous exécutez la commande avec succès et que l'image personnalisée respecte toutes les configurations et structures de fichiers requises, le résultat renvoyé affiche les résultats de tous les tests, comme le montre l'exemple ci-dessous.


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 l'image personnalisée ne répond pas aux configurations ou aux structures de fichiers requises, des messages d'erreur apparaissent. Le résultat renvoyé fournit des informations sur les configurations ou les structures de fichiers incorrectes.

Étape 4 : Publier une image personnalisée

Publiez la nouvelle image Docker dans votre registre Amazon ECR.

Exécutez la commande suivante pour créer un référentiel Amazon ECR pour stocker votre image Docker. Donnez un nom à votre référentiel, par exemple emr6.6_custom_repo. Remplacez us-west-2 par votre région.
```
aws ecr create-repository \
    --repository-name emr6.6_custom_repo \
    --image-scanning-configuration scanOnPush=true \
    --region us-west-2
```
Pour plus d'informations, consultez la rubrique Création d'un référentiel dans le Guide de l'utilisateur Amazon ECR.
Exécutez la commande suivante pour vous authentifier dans votre registre par défaut.
```
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
```
Pour plus d'informations, consultez la rubrique Authentification dans votre registre par défaut dans le Guide de l'utilisateur Amazon ECR.
Marquez et publiez une image dans le référentiel Amazon ECR que vous avez créé.

Balisez l'image.
```
docker tag emr6.6_custom aws_account_id.dkr.ecr.us-west-2.amazonaws.com/emr6.6_custom_repo
```
Transmettez l'image.
```
docker push aws_account_id.dkr.ecr.us-west-2.amazonaws.com/emr6.6_custom_repo
```
Pour plus d'informations, consultez la rubrique Transmission d'une image à Amazon ECR dans le Guide de l'utilisateur Amazon ECR.

Étape 5 : Soumettre une charge de travail Spark dans Amazon EMR à l'aide d'une image personnalisée

Une fois qu'une image personnalisée a été créée et publiée, vous pouvez soumettre une tâche Amazon EMR on EKS à l'aide d'une image personnalisée.

Créez d'abord un fichier start-job-run-request .json et spécifiez le spark.kubernetes.container.image paramètre pour référencer l'image personnalisée, comme le montre l'exemple de fichier JSON suivant.

Note

Vous pouvez utiliser le schéma local:// pour faire référence aux fichiers disponibles dans l'image personnalisée, comme le montre l'argument entryPoint dans l'extrait JSON ci-dessous. Vous pouvez également utiliser le schéma local:// pour faire référence aux dépendances des applications. Tous les fichiers et dépendances auxquels il est fait référence à l'aide du schéma local:// doivent déjà être présents au chemin spécifié dans l'image personnalisée.



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

Vous pouvez également référencer l'image personnalisée à l'aide des propriétés applicationConfiguration, comme le montre l'exemple ci-dessous.



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

Exécutez ensuite la commande start-job-run pour soumettre la tâche.



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

Dans les exemples JSON ci-dessus, remplacez emr-6.6.0-latest par votre version Amazon EMR. Nous vous recommandons vivement d'utiliser la version -latest pour vous assurer que la version sélectionnée contient les dernières mises à jour de sécurité. Pour plus d'informations sur les versions Amazon EMR et leurs balises d'image, consultez Instructions de sélection de l'URI d'une image de base.

Note

Vous pouvez utiliser spark.kubernetes.driver.container.image et spark.kubernetes.executor.container.image indiquer une image différente pour les pods de pilote et d'exécuteur.

Personnalisation des images Docker pour les points de terminaison interactifs

Vous pouvez également personnaliser les images Docker pour les points de terminaison interactifs afin de pouvoir exécuter des images de noyau de base personnalisées. Cela vous permet de vous assurer que vous disposez des dépendances dont vous avez besoin lorsque vous exécutez des charges de travail interactives à partir d'EMR Studio.

Suivez les étapes 1 à 4 décrites ci-dessus pour personnaliser une image Docker. Pour les versions 6.9.0 et ultérieures d'Amazon EMR, vous pouvez obtenir l'URI de l'image de base à partir de la galerie publique d'Amazon ECR. Pour les versions antérieures à Amazon EMR 6.9.0, vous pouvez obtenir l'image dans les comptes du registre Amazon ECR de chaque Région AWS. La seule différence réside dans l'URI de l'image de base de votre Dockerfile. L'URI de l'image de base respecte le format ci-dessous :
```
ECR-registry-account.dkr.ecr.Region.amazonaws.com/notebook-spark/container-image-tag
```
Vous devez utiliser notebook-spark dans l'URI de l'image de base, au lieu de spark. L'image de base contient le moteur d'exécution Spark et les noyaux de bloc-notes qui s'exécutent avec celui-ci. Pour plus d'informations sur la sélection des balises de régions et d'images de conteneurs, consultez Instructions de sélection de l'URI d'une image de base.

Note
Actuellement, seuls les remplacements d'images de base sont pris en charge et l'introduction de nouveaux noyaux d'autres types que ceux AWS fournis par les images de base n'est pas prise en charge.

Créez un point de terminaison interactif qui peut être utilisé avec l'image personnalisée.

Tout d'abord, créez un fichier JSON appelé custom-image-managed-endpoint.json avec le contenu suivant.


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

Ensuite, créez un point de terminaison interactif en utilisant les configurations spécifiées dans le fichier JSON, comme le montre l'exemple ci-dessous.


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

Pour plus d'informations, consultez la rubrique Création d'un point de terminaison interactif pour votre cluster virtuel.

Connectez-vous au point de terminaison interactif via EMR Studio. Pour plus d'informations, consultez la rubrique Connexion à partir de Studio.

Utilisation d'images multi-architectures

Amazon EMR on EKS prend en charge les images de conteneurs multi-architectures pour Amazon Elastic Container Registry (Amazon ECR). Pour plus d'informations, consultez la rubrique Présentation des images de conteneurs multi-architectures pour Amazon ECR.

Les images personnalisées Amazon EMR on EKS prennent en charge à la fois les instances EC2 basées sur AWS Graviton et les instances EC2 non basées sur Graviton. Les images basées sur Graviton sont stockées dans les mêmes référentiels d'images dans Amazon ECR que les images non basées sur Graviton.

Par exemple, pour inspecter la liste des manifestes Docker pour les images 6.6.0, exécutez la commande ci-dessous.


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

Voici la sortie. L'architecture arm64 est destinée aux instances Graviton. L'architecture amd64 est destinée aux instances non-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"
         }
      }
   ]
}

Pour créer des images multi-architectures, procédez comme suit :

Créez un Dockerfile avec le contenu suivant afin de pouvoir extraire l'image 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

Suivez les instructions de la rubrique Présentation des images de conteneurs multi-architectures pour Amazon ECR pour créer une image multi-architectures.

Note
Vous devez créer des images arm64 sur les instances arm64. De même, vous devez créer des images amd64 sur des instances amd64.

Grâce à la commande Docker buildx, nous pouvez également créer des images multi-architectures sans utiliser chaque type d'instance spécifique. Pour plus d'informations, consultez la rubrique Exploitation de la prise en charge de l'architecture multi-CPU.
Après avoir créé l'image multi-architectures, vous pouvez soumettre une tâche avec le même paramètre spark.kubernetes.container.image et la pointer vers l'image. Dans un cluster hétérogène comprenant à la fois des instances EC2 AWS basées sur Graviton et non basées sur Graviton, l'instance détermine l'image d'architecture correcte en fonction de l'architecture d'instance qui extrait l'image.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Personnalisation des images Docker

Instructions de sélection de l'URI d'une image de base