Pré-requisitos Etapa 1: recuperar uma imagem base do Amazon Elastic Container Registry (Amazon ECR)Etapa 2: personalizar uma imagem base Etapa 3: (opcional, mas recomendada) validar uma imagem personalizada Etapa 4: publicar uma imagem personalizada Etapa 5: enviar uma workload do Spark no Amazon EMR usando uma imagem personalizada Personalização de imagens do Docker para endpoints interativos Trabalho com imagens de múltiplas arquiteturas

Como personalizar imagens do Docker

Siga as etapas a seguir para personalizar as imagens do Docker para o Amazon EMR no EKS.

Pré-requisitos
Etapa 1: recuperar uma imagem base do Amazon Elastic Container Registry (Amazon ECR)
Etapa 2: personalizar uma imagem base
Etapa 3: (opcional, mas recomendada) validar uma imagem personalizada
Etapa 4: publicar uma imagem personalizada
Etapa 5: enviar uma workload do Spark no Amazon EMR usando uma imagem personalizada

Confira outras opções que você pode considerar ao personalizar as imagens do Docker:

Personalização de imagens do Docker para endpoints interativos
Trabalho com imagens de múltiplas arquiteturas

Pré-requisitos

Conclua as etapas em Configuração do Amazon EMR no EKS para o Amazon EMR no EKS.
Instale o Docker em seu ambiente. Para obter mais informações, consulte 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.1.0 do Amazon EMR, o docker pull comando a seguir fornece a última imagem base padrão. Você pode substituir emr-7.1.0:latest por emr-7.1.0-spark-rapids:latest para recuperar a imagem que tem o acelerador RAPIDS da Nvidia. Você também pode substituir emr-7.1.0:latest por emr-7.1.0-java11:latest para recuperar a imagem com o runtime do Java 11.


docker pull public.ecr.aws/emr-on-eks/spark/emr-7.1.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:

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 Como selecionar um URI de imagem base.
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 região que você selecionou. AWS
```
aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin 895885662937.dkr.ecr.us-west-2.amazonaws.com
```
Extraia a imagem base para seu Workspace local. Substitua emr-6.6.0:latest pela etiqueta 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 apresentadas a seguir para personalizar a imagem base extraída do Amazon ECR.

Crie um novo Dockerfile em seu Workspace local.
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
```
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
```
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_custom.
```
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 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.

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.
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
```

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.

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 o repositório, por exemplo, emr6.6_custom_repo. 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 no Guia do usuário do Amazon ECR.
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 no Guia do usuário do Amazon ECR.
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 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 JSON acima, substitua emr-6.6.0-latest pela versão de liberação 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 Como selecionar um URI de imagem base.

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.

Siga as etapas 1 a 4 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 Como selecionar um URI de imagem base.

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.

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.

Conecte-se ao endpoint interativo usando o EMR Studio. Para obter mais informações, consulte Connecting from Studio.

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.

As imagens personalizadas do Amazon EMR no EKS oferecem suporte a instâncias EC2 baseadas em AWS Graviton e instâncias EC2 não baseadas em Graviton. As imagens baseadas no Graviton são armazenadas nos mesmos repositórios de imagens no Amazon ECR que as imagens não baseadas no Graviton.

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:

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

Siga as instruções em 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.
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 EC2 baseadas em AWS Graviton e não baseadas em Graviton, a instância determina a imagem de arquitetura correta com base na arquitetura de instância que extrai a imagem.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Personalização de imagens do Docker

Como selecionar um URI de imagem base