As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Como personalizar imagens do Docker
Siga as etapas a seguir para personalizar as imagens do Docker para o Amazon EMR no EKS. As etapas mostram como obter uma imagem base, personalizá-la e publicá-la e enviar uma workload usando a imagem.
+ [Pré-requisitos](#docker-custom-images-prereq)
+ [Etapa 1: recuperar uma imagem base do Amazon Elastic Container Registry (Amazon ECR)](#docker-custom-images-retrieve)
+ [Etapa 2: personalizar uma imagem base](#docker-custom-images-customize)
+ [Etapa 3: (opcional, mas recomendada) validar uma imagem personalizada](#docker-custom-images-validate)
+ [Etapa 4: publicar uma imagem personalizada](#docker-custom-images-publish)
+ [Etapa 5: enviar uma workload do Spark no Amazon EMR usando uma imagem personalizada](#docker-custom-images-submit)
**nota**
Outras opções que você pode considerar ao personalizar imagens do Docker são a personalização para endpoints interativos, feita para garantir que tenha as dependências necessárias, ou o uso de imagens de contêiner com várias arquiteturas:
[Personalização de imagens do Docker para endpoints interativos](docker-custom-images-managed-endpoint.md)
[Trabalho com imagens de múltiplas arquiteturas](docker-custom-images-multi-architecture.md)
## Pré-requisitos
+ Conclua as etapas em [Configuração do Amazon EMR no EKS](setting-up.md) para o Amazon EMR no EKS.
+ Instale o Docker em seu ambiente. Para obter mais informações, consulte [Get Docker](https://docs.docker.com/get-docker/).
## Etapa 1: recuperar uma imagem base do Amazon Elastic Container Registry (Amazon ECR)
A imagem base contém o runtime do Amazon EMR e os conectores usados para acessar outros serviços da AWS . Para a versão 6.9.0 e posteriores do Amazon EMR, você pode obter as imagens base na galeria pública do Amazon ECR. Navegue pela galeria para encontrar o link da imagem e extraia-a para seu Workspace local. Por exemplo, para a versão 7.12.0 do Amazon EMR, o `docker pull` comando a seguir fornece a última imagem base padrão. Você pode substituir `emr-7.12.0:latest` por `emr-7.12.0-spark-rapids:latest` para recuperar a imagem que tem o acelerador RAPIDS da Nvidia. Você também pode substituir `emr-7.12.0:latest` por `emr-7.12.0-java11:latest` para recuperar a imagem com o runtime do Java 11.
```
docker pull public.ecr.aws/emr-on-eks/spark/emr-7.12.0:latest
```
Se você desejar recuperar a imagem base para uma versão 6.9.0 ou para versões anteriores do Amazon EMR, ou se preferir recuperá-la de contas de registro do Amazon ECR em cada região, use as seguintes etapas:
1. Escolha um URI de imagem base. O URI de imagem segue este formato, `ECR-registry-account.dkr.ecr.Region.amazonaws.com/spark/container-image-tag`, como demonstra o exemplo a seguir.
```
895885662937.dkr.ecr.us-west-2.amazonaws.com/spark/emr-6.6.0:latest
```
Para escolher uma imagem base em sua região, consulte [Detalhes sobre como selecionar um URI de imagem base](docker-custom-images-tag.md).
1. Faça login no repositório do Amazon ECR no qual a imagem base está armazenada. Substitua *895885662937* e *us-west-2* pela conta de registro do Amazon ECR e pela AWS região que você selecionou.
```
aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin 895885662937.dkr.ecr.us-west-2.amazonaws.com
```
1. Extraia a imagem base para seu Workspace local. *emr-6.6.0:latest*Substitua pela tag de imagem do contêiner que você selecionou.
```
docker pull 895885662937.dkr.ecr.us-west-2.amazonaws.com/spark/emr-6.6.0:latest
```
## Etapa 2: personalizar uma imagem base
Siga as etapas a seguir para personalizar a imagem base extraída do Amazon ECR.
1. Crie um novo `Dockerfile` em seu Workspace local.
1. Edite o `Dockerfile` que você acabou de criar e adicione o conteúdo a seguir. Este `Dockerfile` usa a imagem de contêiner que você extraiu 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. Adicione comandos no `Dockerfile` para personalizar a imagem base. Por exemplo, adicione um comando para instalar bibliotecas Python, como demonstra o `Dockerfile` a seguir.
```
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. No mesmo diretório em que o `Dockerfile` foi criado, execute o comando apresentado a seguir para criar a imagem do Docker. Forneça um nome para a imagem do Docker, por exemplo,*emr6.6\$1custom*.
```
docker build -t emr6.6_custom .
```
## Etapa 3: (opcional, mas recomendada) validar uma imagem personalizada
Recomendamos testar a compatibilidade da sua imagem personalizada antes de publicá-la. Você pode usar a [CLI de imagem personalizada do Amazon EMR no EKS](https://github.com/awslabs/amazon-emr-on-eks-custom-image-cli) para verificar se sua imagem tem as estruturas de arquivos necessárias e as configurações corretas para a execução no Amazon EMR no EKS.
**nota**
A CLI de imagem personalizada do Amazon EMR no EKS não pode confirmar se sua imagem está isenta de erros. Tenha cuidado ao remover dependências das imagens base.
Siga as etapas apresentadas a seguir para validar a imagem personalizada.
1. Faça download e instale a CLI de imagem personalizada do Amazon EMR no EKS. Para obter mais informações, consulte [Amazon EMR on EKS custom image CLI Installation Guide](https://github.com/awslabs/amazon-emr-on-eks-custom-image-cli/blob/main/installer/assets/INSTALLATION_GUIDE.md).
1. Execute o comando apresentado a seguir para testar a instalação.
```
emr-on-eks-custom-image --version
```
Confira a seguir um exemplo da saída.
```
Amazon EMR on EKS Custom Image CLI
Version: x.xx
```
1. Execute o comando apresentado a seguir para validar a imagem personalizada.
```
emr-on-eks-custom-image validate-image -i image_name -r release_version [-t image_type]
```
+ `-i` especifica o URI da imagem local que precisa ser validado. Pode ser o URI da imagem, qualquer nome ou etiqueta que você definiu para a imagem.
+ `-r` especifica a versão de liberação exata para a imagem base, por exemplo, `emr-6.6.0-latest`.
+ `-t` especifica o tipo de imagem. Se for uma imagem do Spark, insira `spark`. O valor padrão é `spark`. A versão atual da CLI de imagem personalizada do Amazon EMR no EKS oferece suporte somente para imagens de runtime do Spark.
Se você executar o comando com êxito e a imagem personalizada atender a todas as configurações e estruturas de arquivos necessárias, a saída retornada exibirá os resultados de todos os testes, como demonstra o exemplo a seguir.
```
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.
-----------------------------------------------------------------
```
Se a imagem personalizada não atender às configurações ou estruturas de arquivos necessárias, você obterá mensagens de erro. A saída retornada fornece informações sobre configurações ou estruturas de arquivos incorretas.
## Etapa 4: publicar uma imagem personalizada
Publique a nova imagem do Docker no registro do Amazon ECR.
1. Execute o comando apresentado a seguir para criar um repositório do Amazon ECR para o armazenamento da imagem do Docker. Forneça um nome para seu repositório, por exemplo,*emr6.6\$1custom\$1repo*. Substitua *us-west-2* pela sua região.
```
aws ecr create-repository \
--repository-name emr6.6_custom_repo \
--image-scanning-configuration scanOnPush=true \
--region us-west-2
```
Para obter mais informações, consulte [Criar um repositório](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html#cli-create-repository) no *Guia do usuário do Amazon ECR*.
1. Execute o comando apresentado a seguir para realizar a autenticação em seu registro padrão.
```
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 obter mais informações, consulte [Autenticar-se no registro padrão](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html#cli-authenticate-registry) no *Guia do usuário do Amazon ECR*.
1. Faça a marcação e publique uma imagem no repositório do Amazon ECR que você criou.
Marque a imagem.
```
docker tag emr6.6_custom aws_account_id.dkr.ecr.us-west-2.amazonaws.com/emr6.6_custom_repo
```
Envie a imagem.
```
docker push aws_account_id.dkr.ecr.us-west-2.amazonaws.com/emr6.6_custom_repo
```
Para obter mais informações, consulte [Enviar uma imagem ao Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html#cli-push-image) no *Guia do usuário do Amazon ECR*.
## Etapa 5: enviar uma workload do Spark no Amazon EMR usando uma imagem personalizada
Depois que uma imagem personalizada for criada e publicada, será possível enviar um trabalho do Amazon EMR no EKS usando uma imagem personalizada.
Primeiro, crie um start-job-run-request arquivo.json e especifique o `spark.kubernetes.container.image` parâmetro para referenciar a imagem personalizada, como demonstra o exemplo de arquivo JSON a seguir.
**nota**
Você pode usar o esquema `local://` para se referir aos arquivos disponíveis na imagem personalizada, conforme mostrado com o argumento `entryPoint` no trecho de código JSON abaixo. Você também pode usar o esquema `local://` para se referir às dependências da aplicação. Todos os arquivos e as dependências referenciados usando o esquema `local://` já devem estar presentes no caminho especificado na imagem 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"
}
}
}
```
Você também pode fazer referência à imagem personalizada com propriedades `applicationConfiguration`, como demonstra o exemplo a seguir.
```
{
"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"
}
}
]
}
}
```
Em seguida, execute o comando `start-job-run` para enviar o trabalho.
```
aws emr-containers start-job-run --cli-input-json file://./start-job-run-request.json
```
Nos exemplos de JSON acima, *emr-6.6.0-latest* substitua pela sua versão de lançamento do Amazon EMR. Recomendamos fortemente usar a versão de liberação `-latest` para garantir que a versão selecionada contenha as atualizações de segurança mais recentes. Para obter mais informações sobre as versões de liberação do Amazon EMR e suas etiquetas de imagem, consulte [Detalhes sobre como selecionar um URI de imagem base](docker-custom-images-tag.md).
**nota**
É possível usar `spark.kubernetes.driver.container.image` e `spark.kubernetes.executor.container.image` para especificar uma imagem diferente para pods de drivers e de executores.
# Personalização de imagens do Docker para endpoints interativos
Você também pode personalizar as imagens do Docker para endpoints interativos com a finalidade de executar imagens base de kernel personalizadas. Isso ajuda a garantir que você tenha as dependências necessárias ao executar workloads interativas do EMR Studio.
1. Siga as [etapas 1 a 4](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/docker-custom-images-steps.html#docker-custom-images-retrieve) descritas acima para personalizar uma imagem do Docker. Para versões 6.9.0 e posteriores do Amazon EMR, é possível obter o URI da imagem base na galeria pública do Amazon ECR. Para versões anteriores ao Amazon EMR 6.9.0, você pode obter a imagem nas contas de registro do Amazon ECR em cada Região da AWS, e a única diferença é o URI da imagem base em seu Dockerfile. O URI da imagem base segue o formato:
```
ECR-registry-account.dkr.ecr.Region.amazonaws.com/notebook-spark/container-image-tag
```
Você precisa usar `notebook-spark` no URI da imagem base, em vez de `spark`. A imagem base contém o runtime do Spark e os kernels do caderno que são executados com ele. Para obter mais informações sobre como selecionar as regiões e as etiquetas de imagem de contêiner, consulte [Detalhes sobre como selecionar um URI de imagem base](docker-custom-images-tag.md).
**nota**
Atualmente, somente substituições de imagens básicas são suportadas e a introdução de kernels completamente novos de outros tipos além dos fornecidos pelas imagens AWS básicas não é suportada.
1. Crie um endpoint interativo que possa ser usado com a imagem personalizada.
Primeiro, crie um arquivo JSON chamado `custom-image-managed-endpoint.json` com o conteúdo apresentado a seguir.
```
{
"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"
}
}
]
}
]
}
}
```
Em seguida, crie um endpoint interativo usando as configurações especificadas no arquivo JSON, como demonstra o exemplo a seguir.
```
aws emr-containers create-managed-endpoint --cli-input-json custom-image-managed-endpoint.json
```
Para obter mais informações, consulte [Criação de um endpoint interativo para o cluster virtual](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-studio-create-eks-cluster.html#emr-studio-create-managed-endpoint).
1. Conecte-se ao endpoint interativo usando o EMR Studio. Para obter mais informações, consulte [Connecting from Studio](https://emr-on-eks.workshop.aws/advanced/emr-studio/connecting-from-studio.html).
# Trabalho com imagens de múltiplas arquiteturas
O Amazon EMR no EKS oferece suporte a imagens de contêiner de múltiplas arquiteturas para o Amazon Elastic Container Registry (Amazon ECR). Para obter mais informações, consulte [Introducing multi-architecture container images for Amazon ECR](https://aws.amazon.com/blogs/containers/introducing-multi-architecture-container-images-for-amazon-ecr/).
As imagens personalizadas do Amazon EMR no EKS oferecem suporte tanto para instâncias EC2 AWS baseadas em Graviton quanto para instâncias EC2. non-Graviton-based As imagens baseadas em Graviton são armazenadas nos mesmos repositórios de imagens no Amazon ECR que as imagens. non-Graviton-based
Por exemplo, para inspecionar a lista de manifestos do Docker para imagens 6.6.0, execute o comando a seguir.
```
docker manifest inspect 895885662937.dkr.ecr.us-west-2.amazonaws.com/spark/emr-6.6.0:latest
```
Confira a saída a seguir. A arquitetura `arm64` é para instâncias baseadas no Graviton. A arquitetura `amd64` é para instâncias não baseadas no 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"
}
}
]
}
```
Execute as seguintes etapas para criar imagens de múltiplas arquiteturas:
1. Crie um `Dockerfile` com o conteúdo apresentado a seguir para que você possa extrair a imagem `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. Siga as instruções em [Introducing multi-architecture container images for Amazon ECR](https://aws.amazon.com/blogs/containers/introducing-multi-architecture-container-images-for-amazon-ecr/) para desenvolver uma imagem com múltiplas arquiteturas.
**nota**
Você deve criar imagens `arm64` em instâncias `arm64`. De forma semelhante, você deve criar imagens `amd64` em instâncias `amd64`.
Também é possível desenvolver imagens com múltiplas arquiteturas sem a necessidade de criar cada tipo de instância específico com o comando `buildx` do Docker. Para obter mais informações, consulte [Leverage multi-CPU architecture support](https://docs.docker.com/desktop/multi-arch/).
1. Após criar uma imagem com múltiplas arquiteturas, você poderá enviar um trabalho com o mesmo parâmetro `spark.kubernetes.container.image` e direcioná-lo para a imagem. Em um cluster heterogêneo com instâncias AWS baseadas em Graviton e non-Graviton-based EC2, a instância determina a imagem correta da arquitetura com base na arquitetura da instância que extrai a imagem.