Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Instructions de personnalisation des images Docker
Suivez ces étapes pour personnaliser les images Docker pour Amazon EMR sur EKS. Les étapes vous indiquent comment obtenir une image de base, la personnaliser et la publier, et soumettre une charge de travail à l'aide de cette image.
+ [Conditions préalables](#docker-custom-images-prereq)
+ [Étape 1 : Récupération d'une image de base à partir d'Amazon Elastic Container Registry (Amazon ECR)](#docker-custom-images-retrieve)
+ [Étape 2 : Personnaliser une image de base](#docker-custom-images-customize)
+ [Étape 3 : (facultative, mais recommandée) Valider une image personnalisée](#docker-custom-images-validate)
+ [Étape 4 : Publier une image personnalisée](#docker-custom-images-publish)
+ [Étape 5 : Soumettre une charge de travail Spark dans Amazon EMR à l'aide d'une image personnalisée](#docker-custom-images-submit)
**Note**
Parmi les autres options que vous pouvez envisager lors de la personnalisation des images Docker, citons la personnalisation pour les points de terminaison interactifs, afin de vous assurer que vous disposez des dépendances requises, ou l'utilisation d'images de conteneurs multi-architecturales :
[Personnalisation des images Docker pour les points de terminaison interactifs](docker-custom-images-managed-endpoint.md)
[Utilisation d'images multi-architectures](docker-custom-images-multi-architecture.md)
## Conditions préalables
+ Suivez les étapes [Configuration d'Amazon EMR on EKS](setting-up.md) pour Amazon EMR on EKS.
+ Installez Docker dans votre environnement. Pour plus d'informations, consultez [Obtenir Docker](https://docs.docker.com/get-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.12.0 d'Amazon EMR, la `docker pull` commande suivante permet d'obtenir la dernière image de base standard. Vous pouvez remplacer `emr-7.12.0:latest` par `emr-7.12.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.12.0:latest` par `emr-7.12.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.12.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 :
1. 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 [Détails relatifs à la sélection d'une URI d'image de base](docker-custom-images-tag.md).
1. 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 AWS région que vous avez sélectionnée.
```
aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin 895885662937.dkr.ecr.us-west-2.amazonaws.com
```
1. Extrayez l'image de base dans votre espace de travail local. *emr-6.6.0:latest*Remplacez-le par le tag d'image du conteneur que vous avez sélectionné.
```
docker pull 895885662937.dkr.ecr.us-west-2.amazonaws.com/spark/emr-6.6.0:latest
```
## Étape 2 : Personnaliser une image de base
Suivez ces étapes pour personnaliser l'image de base que vous avez extraite d'Amazon ECR.
1. Créez un nouveau espace de travail `Dockerfile` sur votre espace de travail local.
1. 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
```
1. 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
```
1. À 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, *emr6.6\$1custom* par exemple.
```
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](https://github.com/awslabs/amazon-emr-on-eks-custom-image-cli) 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.
1. 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](https://github.com/awslabs/amazon-emr-on-eks-custom-image-cli/blob/main/installer/assets/INSTALLATION_GUIDE.md).
1. 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
```
1. 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.
1. Exécutez la commande suivante pour créer un référentiel Amazon ECR pour stocker votre image Docker. Donnez un nom à votre dépôt, par exemple,*emr6.6\$1custom\$1repo*. 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](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html#cli-create-repository) dans le *Guide de l'utilisateur Amazon ECR*.
1. 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](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html#cli-authenticate-registry) dans le *Guide de l'utilisateur Amazon ECR*.
1. 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](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html#cli-push-image) 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-le *emr-6.6.0-latest* par la version de votre version d'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 [Détails relatifs à la sélection d'une URI d'image de base](docker-custom-images-tag.md).
**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.
1. Suivez les [étapes 1 à 4](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/docker-custom-images-steps.html#docker-custom-images-retrieve) 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 [Détails relatifs à la sélection d'une URI d'image de base](docker-custom-images-tag.md).
**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.
1. 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](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-studio-create-eks-cluster.html#emr-studio-create-managed-endpoint).
1. Connectez-vous au point de terminaison interactif via EMR Studio. Pour plus d'informations, consultez la rubrique [Connexion à partir de Studio](https://emr-on-eks.workshop.aws/advanced/emr-studio/connecting-from-studio.html).
# 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](https://aws.amazon.com/blogs/containers/introducing-multi-architecture-container-images-for-amazon-ecr/).
Les images personnalisées Amazon EMR on EKS prennent en charge à la fois les instances EC2 AWS basées sur Graviton et les instances EC2. non-Graviton-based Les images basées sur Graviton sont stockées dans les mêmes référentiels d'images d'Amazon ECR que les images. non-Graviton-based
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 :
1. 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
```
1. Suivez les instructions de la rubrique [Présentation des images de conteneurs multi-architectures pour Amazon ECR](https://aws.amazon.com/blogs/containers/introducing-multi-architecture-container-images-for-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](https://docs.docker.com/desktop/multi-arch/).
1. 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 AWS basées sur Graviton et des instances non-Graviton-based EC2, l'instance détermine l'image d'architecture correcte en fonction de l'architecture d'instance qui extrait l'image.