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á.
# Apache Spark
O [Apache Spark](https://aws.amazon.com/emr/features/spark/) é um modelo de framework de processamento e de programação distribuído que ajuda você a executar machine learning, processamento de streams ou analytics de gráficos com clusters do Amazon EMR. Semelhante ao Apache Hadoop, o Spark é um sistema de processamento distribuído de código-fonte aberto comumente utilizado para workloads de big data. No entanto, o Spark tem várias diferenças notáveis em relação ao MapReduce Hadoop. O Spark possui um mecanismo de execução otimizado para gráficos acíclicos dirigidos (DAG) e faz ativamente o cache dos dados na memória, o que pode aumentar o desempenho, especialmente para determinados algoritmos e consultas interativas.
O Spark oferece suporte nativo a aplicativos escritos em Scala, Python e Java. [Ele também inclui várias bibliotecas totalmente integradas para SQL ([Spark](https://spark.apache.org/sql/)), aprendizado de máquina ([MLlib](https://spark.apache.org/mllib/)), processamento de fluxo ([streaming Spark](https://spark.apache.org/streaming/)) e processamento gráfico (GraphX).](https://spark.apache.org/graphx/) Essas ferramentas facilitam o aproveitamento da estrutura do Spark para uma grande variedade de casos de uso.
Você pode instalar o Spark em um cluster do Amazon EMR com outras aplicações do Hadoop e ele também pode aproveitar o sistema de arquivos do Amazon EMR (EMRFS) para acessar dados diretamente no Amazon S3. O Hive também é integrado ao Spark para que você possa usar um HiveContext objeto para executar scripts do Hive usando o Spark. Um contexto do Hive está incluído no spark-shell como `sqlContext`.
Para ver um exemplo de tutorial sobre como configurar um cluster do EMR com o Spark e analisar um conjunto de dados de amostra, consulte [Tutorial: Getting started with Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-gs.html) no blog de notícias. AWS
Você pode usar o Apache Spark Troubleshooting Agent para solucionar problemas de seus aplicativos Apache Spark no EMR no EC2 e no EMR Serverless. Para saber mais, consulte[O que é o agente de solução de problemas do Apache Spark para o Amazon EMR](spark-troubleshoot.md).
**Importante**
[[A versão 2.3.1 do Apache Spark, disponível desde a versão 5.16.0 do Amazon EMR, aborda CVE-2018-8024](https://nvd.nist.gov/vuln/detail/CVE-2018-1334) e CVE-2018-1334](https://nvd.nist.gov/vuln/detail/CVE-2018-8024). Recomendamos que você migre as versões anteriores do Spark para a versão 2.3.1 ou posteriores.
A tabela a seguir lista a versão do Spark incluída na versão mais recente da série 7.x do Amazon EMR, além dos componentes que o Amazon EMR instala com o Spark.
Para a versão dos componentes instalados com o Spark nesta versão, consulte Versões de componentes da [versão 7.12.0](emr-7120-release.md).
**Informações sobre a versão do Spark para o emr-7.12.0**
| Rótulo de versão do Amazon EMR | Versão do Spark | Componentes instalados com o Spark |
| --- | --- | --- |
| emr-7.12.0 | Spark 3.5.6-amzn-1 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-hdfs-zkfc, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
A tabela a seguir lista a versão do Spark incluída na versão mais recente da série 6.x do Amazon EMR, além dos componentes que o Amazon EMR instala com o Spark.
Para obter a versão dos componentes instalados com o Spark nessa versão, consulte [Release 6.15.0 Component Versions](emr-6150-release.md).
**Informações de versão do Spark para o emr-6.15.0**
| Rótulo de versão do Amazon EMR | Versão do Spark | Componentes instalados com o Spark |
| --- | --- | --- |
| emr-6.15.0 | Spark 3.4.1-amzn-2 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
**nota**
A versão 6.8.0 do Amazon EMR vem com a versão 3.3.0 do Apache Spark. Esta versão do Spark usa o Apache Log4j 2 e o arquivo `log4j2.properties` para configurar o Log4j nos processos do Spark. Se você usar o Spark no cluster ou criar clusters do EMR com parâmetros de configuração personalizados e quiser atualizar para a versão 6.8.0 do Amazon EMR, deverá migrar para a nova classificação de configuração `spark-log4j2` e para o formato de chave do Apache Log4j 2. Para obter mais informações, consulte [Migrar do Apache Log4j 1.x para Log4j 2.x](emr-spark-configure.md#spark-migrate-logj42).
A tabela a seguir lista a versão do Spark incluída na versão mais recente da série 5.x do Amazon EMR, além dos componentes que o Amazon EMR instala com o Spark.
Para obter a versão dos componentes instalados com o Spark nesse lançamento, consulte [Release 5.36.2 Component Versions](emr-5362-release.md).
**Informações de versão do Spark para o emr-5.36.2**
| Rótulo de versão do Amazon EMR | Versão do Spark | Componentes instalados com o Spark |
| --- | --- | --- |
| emr-5.36.2 | Spark 2.4.8-amzn-2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
**Topics**
+ [
# Criação de um cluster com o Apache Spark
](emr-spark-launch.md)
+ [
# Execução de aplicações do Spark com o Docker no Amazon EMR 6.x
](emr-spark-docker.md)
+ [
# Use o catálogo do AWS Glue Data Catalog com o Spark no Amazon EMR
](emr-spark-glue.md)
+ [
# Trabalhando com uma hierarquia de vários catálogos no AWS Glue Data Catalog com o Spark no Amazon EMR
](emr-multi-catalog.md)
+ [
# Configurar o Spark
](emr-spark-configure.md)
+ [
# O que é o agente de solução de problemas do Apache Spark para o Amazon EMR
](spark-troubleshoot.md)
+ [
# Otimizar a performance do Spark
](emr-spark-performance.md)
+ [
# Armazenamento em Cache de Fragmentos Resultantes do Spark
](emr-spark-fragment-result-caching.md)
+ [
# Uso do RAPIDS Accelerator do NVIDIA para Apache Spark
](emr-spark-rapids.md)
+ [
# Acessar o shell do Spark
](emr-spark-shell.md)
+ [
# Use o Amazon SageMaker Spark para aprendizado de máquina
](emr-spark-sagemaker.md)
+ [
# Escrever uma aplicação do Spark
](emr-spark-application.md)
+ [
# Melhorar a performance do Spark com Amazon S3
](emr-spark-s3-performance.md)
+ [
# Adicionar uma etapa do Spark
](emr-spark-submit-step.md)
+ [
# Visualizar o histórico de aplicações do Spark
](emr-spark-application-history.md)
+ [
# Acesse a web do Spark UIs
](emr-spark-webui.md)
+ [
# Uso do conector do Amazon Kinesis Data Streams para streaming estruturado do Spark
](emr-spark-structured-streaming-kinesis.md)
+ [
# Usar a integração do Amazon Redshift para Apache Spark com o Amazon EMR
](emr-spark-redshift.md)
+ [
# Histórico de versões do Spark
](Spark-release-history.md)
+ [
# Usando visualizações materializadas com o Amazon EMR
](emr-spark-materialized-views.md)
# Criação de um cluster com o Apache Spark
O procedimento a seguir cria um cluster com o [Spark](https://aws.amazon.com/big-data/what-is-spark/) instalado usando **Opções rápidas** no console do Amazon EMR.
Como alternativa, use as **Opções avançadas** para personalizar ainda mais sua configuração de cluster ou para enviar etapas para instalar aplicações de forma programática e depois executar aplicações personalizadas. Com qualquer uma das opções de criação de cluster, você pode optar por usar o AWS Glue como seu metastore do Spark SQL. Consulte [Use o catálogo do AWS Glue Data Catalog com o Spark no Amazon EMR](emr-spark-glue.md) para obter mais informações.
**Para iniciar um cluster com o Spark instalado**
1. [Abra o console do Amazon EMR em https://console.aws.amazon.com /emr.](https://console.aws.amazon.com/emr/)
1. Escolha **Criar cluster** para usar **Opções rápidas**.
1. Insira um **Nome de cluster**. O nome do cluster não pode conter os caracteres <, >, \$1, \$1 ou ` (crase).
1. Em **Configuração de software**, escolha uma opção de **Versão**.
1. Em **Aplicações**, escolha o pacote de aplicações do **Spark**.
1. Selecione outras opções conforme necessário e escolha **Create cluster (Criar cluster)**.
**nota**
Para configurar o Spark quando estiver criando o cluster, consulte [Configurar o Spark](emr-spark-configure.md).
**Para iniciar um cluster com o Spark instalado usando o AWS CLI**
+ Crie o cluster usando o comando a seguir.
```
aws emr create-cluster --name "Spark cluster" --release-label emr-7.12.0 --applications Name=Spark \
--ec2-attributes KeyName=myKey --instance-type m5.xlarge --instance-count 3 --use-default-roles
```
**nota**
Os caracteres de continuação de linha do Linux (\$1) são incluídos para facilitar a leitura. Eles podem ser removidos ou usados em comandos do Linux. No Windows, remova-os ou substitua-os por um sinal de interpolação (^).
**Iniciar um cluster com o Spark instalado usando o SDK para Java**
Especifique o Spark como um aplicativo com `SupportedProductConfig` usado em `RunJobFlowRequest`.
+ O seguinte exemplo mostra como criar um cluster com o Spark usando Java.
```
import com.amazonaws.AmazonClientException;
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.AWSStaticCredentialsProvider;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.elasticmapreduce.AmazonElasticMapReduce;
import com.amazonaws.services.elasticmapreduce.AmazonElasticMapReduceClientBuilder;
import com.amazonaws.services.elasticmapreduce.model.*;
import com.amazonaws.services.elasticmapreduce.util.StepFactory;
public class Main {
public static void main(String[] args) {
AWSCredentials credentials_profile = null;
try {
credentials_profile = new ProfileCredentialsProvider("default").getCredentials();
} catch (Exception e) {
throw new AmazonClientException(
"Cannot load credentials from .aws/credentials file. " +
"Make sure that the credentials file exists and the profile name is specified within it.",
e);
}
AmazonElasticMapReduce emr = AmazonElasticMapReduceClientBuilder.standard()
.withCredentials(new AWSStaticCredentialsProvider(credentials_profile))
.withRegion(Regions.US_WEST_1)
.build();
// create a step to enable debugging in the AWS Management Console
StepFactory stepFactory = new StepFactory();
StepConfig enabledebugging = new StepConfig()
.withName("Enable debugging")
.withActionOnFailure("TERMINATE_JOB_FLOW")
.withHadoopJarStep(stepFactory.newEnableDebuggingStep());
Application spark = new Application().withName("Spark");
RunJobFlowRequest request = new RunJobFlowRequest()
.withName("Spark Cluster")
.withReleaseLabel("emr-5.20.0")
.withSteps(enabledebugging)
.withApplications(spark)
.withLogUri("s3://path/to/my/logs/")
.withServiceRole("EMR_DefaultRole")
.withJobFlowRole("EMR_EC2_DefaultRole")
.withInstances(new JobFlowInstancesConfig()
.withEc2SubnetId("subnet-12ab3c45")
.withEc2KeyName("myEc2Key")
.withInstanceCount(3)
.withKeepJobFlowAliveWhenNoSteps(true)
.withMasterInstanceType("m4.large")
.withSlaveInstanceType("m4.large"));
RunJobFlowResult result = emr.runJobFlow(request);
System.out.println("The cluster ID is " + result.toString());
}
}
```
# Execução de aplicações do Spark com o Docker no Amazon EMR 6.x
**nota**
O procedimento descrito funciona somente com o Amazon EMR versão 6.x.
Com o Amazon EMR 6.0.0, as aplicações do Spark podem usar contêineres do Docker para definir suas dependências de biblioteca, em vez de instalar dependências nas instâncias individuais do Amazon EC2 no cluster. Para executar o Spark com o Docker, primeiro é necessário configurar o registro do Docker e definir parâmetros adicionais ao enviar um aplicativo do Spark. Para obter mais informações, consulte [Configurar a integração do Docker](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-docker.html).
Quando o aplicativo é enviado, o YARN invoca o Docker para extrair a imagem especificada do Docker e executar o aplicativo Spark dentro de um contêiner do Docker. Isso permite definir e isolar dependências facilmente. Isso reduz o tempo de bootstrapping ou de preparação de instâncias no cluster do Amazon EMR com as bibliotecas necessárias para a execução do trabalho.
## Considerações ao executar o Spark com o Docker
Ao executar o Spark com o Docker, verifique se os seguintes pré-requisitos são atendidos:
+ O pacote `docker` e a CLI são instalados somente nos nós core e de tarefa.
+ Nas versões 6.1.0 r posteriores do Amazon EMR, você pode, como alternativa, instalar o Docker em um nó primário usando os comandos a seguir.
+
```
sudo yum install -y docker
sudo systemctl start docker
```
+ O comando `spark-submit` sempre deve ser executado em uma instância primária no cluster do Amazon EMR.
+ Os registros do Docker usados para resolver imagens do Docker devem ser definidos usando a API de classificação com a chave de classificação `container-executor` para definir parâmetros adicionais ao executar o cluster:
+ `docker.trusted.registries`
+ `docker.privileged-containers.registries`
+ Para executar um aplicativo do Spark em um contêiner do Docker, as seguintes opções de configuração são necessárias:
+ `YARN_CONTAINER_RUNTIME_TYPE=docker`
+ `YARN_CONTAINER_RUNTIME_DOCKER_IMAGE={DOCKER_IMAGE_NAME}`
+ Ao usar o Amazon ECR para recuperar imagens do Docker, é necessário configurar o cluster para ele se autenticar. Para fazer isso, é necessário usar a seguinte opção de configuração:
+ YARN\$1CONTAINER\$1RUNTIME\$1DOCKER\$1CLIENT\$1CONFIG=\$1DOCKER\$1CLIENT\$1CONFIG\$1PATH\$1ON\$1HDFS\$1
+ Nas versões 6.1.0 e posteriores do Amazon EMR, você não precisa usar o comando listado `YARN_CONTAINER_RUNTIME_DOCKER_CLIENT_CONFIG={DOCKER_CLIENT_CONFIG_PATH_ON_HDFS}` quando o recurso de autenticação automático do ECR está habilitado.
+ Qualquer imagem do Docker usada com o Spark deve ter o Java instalado na imagem do Docker.
Para obter mais informações sobre os pré-requisitos, consulte [Configurar a integração do Docker](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-docker.html).
## Criar uma imagem do Docker
As imagens do Docker são criadas usando um arquivo do Docker, que define os pacotes e a configuração a serem incluídos na imagem. Os dois exemplos a seguir são usados por Dockerfiles e PySpark SparkR.
**PySpark Dockerfile**
As imagens do Docker criadas a partir desse Dockerfile incluem o Python 3 e o pacote Python. NumPy Esse arquivo do Docker usa o Amazon Linux 2 e o Amazon Corretto JDK 8.
```
FROM amazoncorretto:8
RUN yum -y update
RUN yum -y install yum-utils
RUN yum -y groupinstall development
RUN yum list python3*
RUN yum -y install python3 python3-dev python3-pip python3-virtualenv
RUN python -V
RUN python3 -V
ENV PYSPARK_DRIVER_PYTHON python3
ENV PYSPARK_PYTHON python3
RUN pip3 install --upgrade pip
RUN pip3 install numpy pandas
RUN python3 -c "import numpy as np"
```
**Arquivo do Docker do SparkR**
As imagens do Docker criadas com esse arquivo do Docker incluem R e o pacote randomForest CRAN. Esse arquivo do Docker inclui o Amazon Linux 2 e o Amazon Corretto JDK 8.
```
FROM amazoncorretto:8
RUN java -version
RUN yum -y update
RUN amazon-linux-extras install R4
RUN yum -y install curl hostname
#setup R configs
RUN echo "r <- getOption('repos'); r['CRAN'] <- 'http://cran.us.r-project.org'; options(repos = r);" > ~/.Rprofile
RUN Rscript -e "install.packages('randomForest')"
```
Para obter mais informações sobre a sintaxe do arquivo do Docker, consulte a [documentação de referência do arquivo do Docker](https://docs.docker.com/engine/reference/builder/).
## Usar imagens do Docker do Amazon ECR
O Amazon Elastic Container Registry (Amazon ECR) é um registro de contêiner do Docker totalmente gerenciado que facilita o armazenamento, o gerenciamento e a implantação de imagens de contêiner do Docker. Ao ser usado o Amazon ECR, o cluster deve ser configurado para confiar na instância do ECR e você deve configurar a autenticação para que o cluster use imagens do Docker do Amazon ECR. Para obter mais informações, consulte [Configurar o YARN para acessar o Amazon ECR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-docker.html#emr-docker-ECR).
Para garantir que os hosts do Amazon EMR possam acessar as imagens armazenadas no Amazon ECR, o cluster deve ter as permissões da política `AmazonEC2ContainerRegistryReadOnly` associada ao perfil de instância. Para obter mais informações, consulte [Política `AmazonEC2ContainerRegistryReadOnly`](https://docs.aws.amazon.com/AmazonECR/latest/userguide/ecr_managed_policies.html#AmazonEC2ContainerRegistryReadOnly).
Nesse exemplo, o cluster deve ser criado com a configuração adicional a seguir para garantir que o registro do Amazon ECR seja confiável. Substitua o *123456789123.dkr.ecr.us-east-1.amazonaws.com* endpoint pelo seu endpoint Amazon ECR.
```
[
{
"Classification": "container-executor",
"Configurations": [
{
"Classification": "docker",
"Properties": {
"docker.privileged-containers.registries": "local,centos,123456789123.dkr.ecr.us-east-1.amazonaws.com",
"docker.trusted.registries": "local,centos,123456789123.dkr.ecr.us-east-1.amazonaws.com"
}
}
],
"Properties": {}
}
]
```
**Usando PySpark com o Amazon ECR**
O exemplo a seguir usa o PySpark Dockerfile, que será marcado e carregado no Amazon ECR. Depois de fazer o upload do Dockerfile, você pode executar o PySpark trabalho e consultar a imagem do Docker do Amazon ECR.
Depois de iniciar o cluster, use o SSH para se conectar a um nó principal e execute os comandos a seguir para criar a imagem local do Docker a partir do exemplo do PySpark Dockerfile.
Primeiro, crie um diretório e um arquivo do Docker.
```
mkdir pyspark
vi pyspark/Dockerfile
```
Cole o conteúdo do PySpark Dockerfile e execute os comandos a seguir para criar uma imagem do Docker.
```
sudo docker build -t local/pyspark-example pyspark/
```
Crie o repositório `emr-docker-examples` do ECR para os exemplos.
```
aws ecr create-repository --repository-name emr-docker-examples
```
Marque e carregue a imagem criada localmente no ECR, substituindo-a por seu *123456789123.dkr.ecr.us-east-1.amazonaws.com* endpoint de ECR.
```
sudo docker tag local/pyspark-example 123456789123.dkr.ecr.us-east-1.amazonaws.com/emr-docker-examples:pyspark-example
sudo docker push 123456789123.dkr.ecr.us-east-1.amazonaws.com/emr-docker-examples:pyspark-example
```
Use SSH para se conectar ao nó primário e prepare um script do Python com o nome de arquivo `main.py`. Cole o conteúdo a seguir no arquivo `main.py` e salve-o.
```
from pyspark.sql import SparkSession
spark = SparkSession.builder.appName("docker-numpy").getOrCreate()
sc = spark.sparkContext
import numpy as np
a = np.arange(15).reshape(3, 5)
print(a)
```
No Amazon EMR 6.0.0, para enviar o trabalho, consulte o nome da imagem do Docker. Defina os parâmetros de configuração adicionais para garantir que a execução do trabalho use o Docker como o runtime. Ao ser usado o Amazon ECR, o `YARN_CONTAINER_RUNTIME_DOCKER_CLIENT_CONFIG` deve fazer referência ao arquivo `config.json` contendo as credenciais usadas para fazer a autenticação no Amazon ECR.
```
DOCKER_IMAGE_NAME=123456789123.dkr.ecr.us-east-1.amazonaws.com/emr-docker-examples:pyspark-example
DOCKER_CLIENT_CONFIG=hdfs:///user/hadoop/config.json
spark-submit --master yarn \
--deploy-mode cluster \
--conf spark.executorEnv.YARN_CONTAINER_RUNTIME_TYPE=docker \
--conf spark.executorEnv.YARN_CONTAINER_RUNTIME_DOCKER_IMAGE=$DOCKER_IMAGE_NAME \
--conf spark.executorEnv.YARN_CONTAINER_RUNTIME_DOCKER_CLIENT_CONFIG=$DOCKER_CLIENT_CONFIG \
--conf spark.yarn.appMasterEnv.YARN_CONTAINER_RUNTIME_TYPE=docker \
--conf spark.yarn.appMasterEnv.YARN_CONTAINER_RUNTIME_DOCKER_IMAGE=$DOCKER_IMAGE_NAME \
--conf spark.yarn.appMasterEnv.YARN_CONTAINER_RUNTIME_DOCKER_CLIENT_CONFIG=$DOCKER_CLIENT_CONFIG \
--num-executors 2 \
main.py -v
```
Nas versões 6.1.0 e superiores do Amazon EMR, para enviar o trabalho, consulte o nome da imagem do Docker. Quando a autenticação automática do ECR estiver habilitada, execute o comando a seguir.
```
DOCKER_IMAGE_NAME=123456789123.dkr.ecr.us-east-1.amazonaws.com/emr-docker-examples:pyspark-example
spark-submit --master yarn \
--deploy-mode cluster \
--conf spark.executorEnv.YARN_CONTAINER_RUNTIME_TYPE=docker \
--conf spark.executorEnv.YARN_CONTAINER_RUNTIME_DOCKER_IMAGE=$DOCKER_IMAGE_NAME \
--conf spark.yarn.appMasterEnv.YARN_CONTAINER_RUNTIME_TYPE=docker \
--conf spark.yarn.appMasterEnv.YARN_CONTAINER_RUNTIME_DOCKER_IMAGE=$DOCKER_IMAGE_NAME \
--num-executors 2 \
main.py -v
```
Quando o trabalho for concluído, anote o ID do aplicativo YARN e use o comando a seguir para obter a saída do PySpark trabalho.
```
yarn logs --applicationId application_id | grep -C2 '\[\['
LogLength:55
LogContents:
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]]
```
**Usar o SparkR com o Amazon ECR**
O exemplo a seguir usa o arquivo do Docker do SparkR, que será marcado e carregado no ECR. Depois de carregar o Dockerfile, você pode executar o trabalho do SparkR e consultar a imagem do Docker no Amazon ECR.
Após executar o cluster, use o SSH para se conectar a um nó core e execute os comandos a seguir a fim de criar a imagem local do Docker com base no exemplo de arquivo do Docker do SparkR.
Primeiro, crie um diretório e o arquivo do Docker.
```
mkdir sparkr
vi sparkr/Dockerfile
```
Cole os conteúdos do arquivo do Docker do SparkR e execute os comandos a seguir para criar uma imagem do Docker.
```
sudo docker build -t local/sparkr-example sparkr/
```
Marque e faça o upload da imagem criada localmente para o Amazon ECR, *123456789123.dkr.ecr.us-east-1.amazonaws.com* substituindo-a por seu endpoint Amazon ECR.
```
sudo docker tag local/sparkr-example 123456789123.dkr.ecr.us-east-1.amazonaws.com/emr-docker-examples:sparkr-example
sudo docker push 123456789123.dkr.ecr.us-east-1.amazonaws.com/emr-docker-examples:sparkr-example
```
Use SSH para se conectar ao nó primário e prepare um script R com o nome `sparkR.R`. Cole o conteúdo a seguir no arquivo `sparkR.R`.
```
library(SparkR)
sparkR.session(appName = "R with Spark example", sparkConfig = list(spark.some.config.option = "some-value"))
sqlContext <- sparkRSQL.init(spark.sparkContext)
library(randomForest)
# check release notes of randomForest
rfNews()
sparkR.session.stop()
```
No Amazon EMR 6.0.0, para enviar o trabalho, consulte o nome da imagem do Docker. Defina os parâmetros de configuração adicionais para garantir que a execução do trabalho use o Docker como o runtime. Ao ser usado o Amazon ECR, o `YARN_CONTAINER_RUNTIME_DOCKER_CLIENT_CONFIG` deve fazer referência ao arquivo `config.json` contendo as credenciais usadas para fazer a autenticação no ECR.
```
DOCKER_IMAGE_NAME=123456789123.dkr.ecr.us-east-1.amazonaws.com/emr-docker-examples:sparkr-example
DOCKER_CLIENT_CONFIG=hdfs:///user/hadoop/config.json
spark-submit --master yarn \
--deploy-mode cluster \
--conf spark.executorEnv.YARN_CONTAINER_RUNTIME_TYPE=docker \
--conf spark.executorEnv.YARN_CONTAINER_RUNTIME_DOCKER_IMAGE=$DOCKER_IMAGE_NAME \
--conf spark.executorEnv.YARN_CONTAINER_RUNTIME_DOCKER_CLIENT_CONFIG=$DOCKER_CLIENT_CONFIG \
--conf spark.yarn.appMasterEnv.YARN_CONTAINER_RUNTIME_TYPE=docker \
--conf spark.yarn.appMasterEnv.YARN_CONTAINER_RUNTIME_DOCKER_IMAGE=$DOCKER_IMAGE_NAME \
--conf spark.yarn.appMasterEnv.YARN_CONTAINER_RUNTIME_DOCKER_CLIENT_CONFIG=$DOCKER_CLIENT_CONFIG \
sparkR.R
```
Nas versões 6.1.0 e superiores do Amazon EMR, para enviar o trabalho, consulte o nome da imagem do Docker. Quando a autenticação automática do ECR estiver habilitada, execute o comando a seguir.
```
DOCKER_IMAGE_NAME=123456789123.dkr.ecr.us-east-1.amazonaws.com/emr-docker-examples:sparkr-example
spark-submit --master yarn \
--deploy-mode cluster \
--conf spark.executorEnv.YARN_CONTAINER_RUNTIME_TYPE=docker \
--conf spark.executorEnv.YARN_CONTAINER_RUNTIME_DOCKER_IMAGE=$DOCKER_IMAGE_NAME \
--conf spark.yarn.appMasterEnv.YARN_CONTAINER_RUNTIME_TYPE=docker \
--conf spark.yarn.appMasterEnv.YARN_CONTAINER_RUNTIME_DOCKER_IMAGE=$DOCKER_IMAGE_NAME \
sparkR.R
```
Quando o trabalho for concluído, anote o ID do aplicativo YARN e use o comando a seguir para obter a saída do trabalho do SparkR. Esse exemplo inclui testes para garantir que a biblioteca randomForest, a versão instalada e as notas de release estejam disponíveis.
```
yarn logs --applicationId application_id | grep -B4 -A10 "Type rfNews"
randomForest 4.6-14
Type rfNews() to see new features/changes/bug fixes.
Wishlist (formerly TODO):
* Implement the new scheme of handling classwt in classification.
* Use more compact storage of proximity matrix.
* Allow case weights by using the weights in sampling?
========================================================================
Changes in 4.6-14:
```
# Use o catálogo do AWS Glue Data Catalog com o Spark no Amazon EMR
Usando o Amazon EMR versão 5.8.0 ou posterior, você pode configurar o Spark para usar o AWS Glue Data Catalog como seu metastore Apache Hive. Recomendamos essa configuração quando você precisa de um metastore persistente do Hive ou de um metastore do Hive compartilhado por diferentes clusters, serviços, aplicativos ou contas. AWS
Usando o Amazon EMR versão 6.5.0 ou posterior, você pode configurar o Spark para usar o AWS Glue Data Catalog com o Apache Iceberg.
Usando o Amazon EMR versão 7.5.0 ou posterior, você pode configurar o Spark para usar o AWS Glue Data Catalog como seu catálogo Iceberg REST.
AWS O Glue é um serviço de extração, transformação e carregamento (ETL) totalmente gerenciado que torna simples e econômico categorizar seus dados, limpá-los, enriquecê-los e movê-los de forma confiável entre vários armazenamentos de dados. O AWS Glue Data Catalog fornece um repositório unificado de metadados em uma variedade de fontes e formatos de dados, integrando-se ao Amazon EMR, bem como ao Amazon RDS, Amazon Redshift, Redshift Spectrum, Athena e qualquer aplicativo compatível com o metastore Apache Hive. AWS Os rastreadores do Glue podem inferir automaticamente o esquema dos dados de origem no Amazon S3 e armazenar os metadados associados no catálogo de dados. Para obter mais informações sobre o Catálogo de Dados, consulte [Preenchendo o Catálogo de Dados do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/populate-data-catalog.html) no *Guia do Desenvolvedor do AWS Glue*.
Taxas separadas se aplicam ao AWS Glue. Há uma taxa mensal para armazenar e acessar os metadados no Catálogo de Dados, uma taxa horária cobrada por minuto pelas tarefas do AWS Glue ETL e pelo tempo de execução do rastreador, e uma taxa horária cobrada por minuto para cada endpoint de desenvolvimento provisionado. O Catálogo de Dados permite o armazenamento de até um milhão de objetos gratuitamente. Se você armazenar mais de um milhão de objetos, será cobrado uma taxa de USD\$11 por cada 100.000 objetos em mais de um milhão. Um objeto no Catálogo de Dados é uma tabela, uma partição ou um banco de dados. Para obter mais informações, consulte [Definição de preço do Glue](https://aws.amazon.com/glue/pricing).
**Importante**
Se você criou tabelas usando o Amazon Athena ou o Amazon Redshift Spectrum antes de 14 de agosto de 2017, bancos de dados e tabelas são armazenados em um catálogo gerenciado pelo Athena, que é separado do Glue Data Catalog. AWS Para integrar o Amazon EMR a essas tabelas, você deve fazer o upgrade para o AWS Glue Data Catalog. Para obter mais informações, consulte [Atualização para o catálogo de dados AWS Glue no Guia](https://docs.aws.amazon.com/athena/latest/ug/glue-upgrade.html) do usuário do *Amazon Athena*.
## Especificando o AWS Glue Data Catalog como metastore do Apache Hive
Você pode especificar o AWS Glue Data Catalog como metastore usando a API Console de gerenciamento da AWS AWS CLI, ou Amazon EMR. Ao usar a CLI ou a API, você usa a classificação de configuração do Spark para especificar o Catálogo de Dados. Além disso, com o Amazon EMR 5.16.0 e versões posteriores, você pode usar a classificação de configuração para especificar um catálogo de dados em outro. Conta da AWS Ao usar o console, você pode especificar o Catálogo de Dados usando **Opções avançadas** ou **Opções rápidas**.
**nota**
A opção de usar o AWS Glue Data Catalog também está disponível com o Zeppelin porque o Zeppelin é instalado com componentes do Spark.
------
#### [ Console ]
**Para especificar o AWS Glue Data Catalog como a metastore do Apache Hive com o novo console**
1. [Faça login no e abra Console de gerenciamento da AWS o console do Amazon EMR em https://console.aws.amazon.com /emr.](https://console.aws.amazon.com/emr)
1. Em **Amazon EMR no EC2**, no painel de navegação à esquerda, escolha **Clusters** e **Criar cluster**.
1. Em **Pacote de aplicações**, escolha **Spark** ou **Personalizar**. Se você personalizar o cluster, selecione Zeppelin ou Spark como uma das suas aplicações.
1. Em **Configurações do Catálogo de Dados do AWS Glue**, marque a caixa de seleção **Usar para metadados de tabelas do Spark**.
1. Escolha qualquer outra opção que se aplique ao cluster.
1. Para iniciar o cluster, escolha **Criar cluster**.
------
#### [ AWS CLI ]
**Para especificar o AWS Glue Data Catalog como o metastore do Apache Hive com o AWS CLI**
Para obter mais informações sobre como especificar uma classificação de configuração usando a AWS CLI API do Amazon EMR, consulte. [Configurar aplicações](emr-configure-apps.md)
+ Especifique o valor para `hive.metastore.client.factory.class` usando a classificação `spark-hive-site`, conforme mostrado neste exemplo:
```
[
{
"Classification": "spark-hive-site",
"Properties": {
"hive.metastore.client.factory.class": "com.amazonaws.glue.catalog.metastore.AWSGlueDataCatalogHiveClientFactory"
}
}
]
```
Para especificar um catálogo de dados em uma AWS conta diferente, adicione a `hive.metastore.glue.catalogid` propriedade conforme mostrado no exemplo a seguir. Substitua `acct-id` pela conta da AWS do Catálogo de Dados.
```
[
{
"Classification": "spark-hive-site",
"Properties": {
"hive.metastore.client.factory.class": "com.amazonaws.glue.catalog.metastore.AWSGlueDataCatalogHiveClientFactory",
"hive.metastore.glue.catalogid": "acct-id"
}
}
]
```
------
## Especificando o AWS Glue Data Catalog como o catálogo do Apache Iceberg
Você pode especificar o AWS Glue Data Catalog como a implementação do catálogo Apache Iceberg ou o endpoint do catálogo Apache Iceberg REST, usando a, a ou a API do Amazon EMR Console de gerenciamento da AWS, ou na configuração de tempo de execução AWS CLI da sessão do Spark. Ao usar a CLI ou a API, você usa a classificação de configuração do Spark para especificar o Catálogo de Dados. Para obter mais detalhes, consulte [Especificando o AWS Glue Data Catalog como o catálogo Apache Iceberg](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-spark-glue.html#emr-spark-glue-configure-iceberg).
## permissões do IAM
O perfil da instância EC2 de um cluster deve ter permissões do IAM para ações do AWS Glue. Além disso, se você habilitar a criptografia para objetos do AWS Glue Data Catalog, a função também deverá ter permissão para criptografar, descriptografar e gerar o AWS KMS key usado para criptografia.
### Permissões para ações do AWS Glue
Se você usar o perfil de instância padrão do EC2 para o Amazon EMR, nenhuma ação será necessária. A política `AmazonElasticMapReduceforEC2Role` gerenciada anexada ao `EMR_EC2_DefaultRole` permite todas as ações necessárias do AWS Glue. No entanto, se você especificar um perfil e permissões de instância EC2 personalizados, deverá configurar as ações apropriadas do AWS Glue. Use a política gerenciada `AmazonElasticMapReduceforEC2Role` como ponto de partida. Para obter mais informações, consulte [Perfil de serviço para instâncias do EC2 de cluster (perfil de instância do EC2)](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-iam-role-for-ec2.html) no *Guia de gerenciamento do Amazon EMR*.
### Permissões para criptografar e descriptografar o Glue Data Catalog AWS
O perfil de instância precisa de permissão para criptografar e descriptografar dados usando a chave. Você *não* precisa configurar essas permissões se as duas instruções a seguir se aplicarem:
+ Você ativa a criptografia para objetos do AWS Glue Data Catalog usando chaves gerenciadas para o AWS Glue.
+ Você usa um cluster que está no mesmo catálogo Conta da AWS de dados do AWS Glue.
Caso contrário, você deverá adicionar a seguinte instrução à política de permissões anexada ao perfil de instância do EC2.
Para obter mais informações sobre a criptografia do AWS Glue Data Catalog, consulte [Criptografando seu catálogo de dados](https://docs.aws.amazon.com/glue/latest/dg/encrypt-glue-data-catalog.html) no *AWS Glue Developer Guide*.
### Permissões baseadas em recursos
Se você usa o AWS Glue em conjunto com o Hive, o Spark ou o Presto no Amazon EMR AWS , o Glue oferece suporte a políticas baseadas em recursos para controlar o acesso aos recursos do catálogo de dados. Esses recursos incluem bancos de dados, tabelas, conexões e funções definidas pelo usuário. Para obter mais informações, consulte [Políticas baseadas em recursos no AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/glue-resource-policies.html) no *Guia do desenvolvedor do AWS Glue*.
Ao usar políticas baseadas em recursos para limitar o acesso ao AWS Glue a partir do Amazon EMR, o principal que você especifica na política de permissões deve ser o ARN da função associado ao perfil de instância do EC2 que é especificado quando um cluster é criado. Por exemplo, para uma política baseada em recursos anexada a um catálogo, você pode especificar o ARN da função para a função de serviço padrão para instâncias EC2 de cluster, *EMR\$1EC2\$1DefaultRole* como a`Principal`, usando o formato mostrado no exemplo a seguir:
```
arn:aws:iam::acct-id:role/EMR_EC2_DefaultRole
```
*acct-id*Pode ser diferente do ID da conta AWS Glue. Isso possibilita o acesso de clusters do EMR em outras contas. Você pode especificar várias entidades principais, cada uma de uma conta diferente.
## Considerações ao usar o AWS Glue Data Catalog
Considere os seguintes itens ao usar o AWS Glue Data Catalog como metastore do Apache Hive com o Spark:
+ Ter um banco de dados padrão sem um URI local causa falhas quando você cria uma tabela. Como alternativa, use a cláusula `LOCATION` para especificar o local do bucket, como `s3://amzn-s3-demo-bucket1`, ao usar `CREATE TABLE`. Ou crie tabelas em um banco de dados que não seja o banco de dados padrão.
+ Não há suporte para renomear tabelas de dentro do AWS Glue.
+ Quando você cria uma tabela do Hive sem especificar um `LOCATION`, os dados da tabela são armazenados no local especificado pela propriedade `hive.metastore.warehouse.dir`. Por padrão, esse é um local no HDFS. Se outro cluster precisar acessar a tabela, ele apresentará falha, a menos que tenha permissões adequadas para o cluster que criou a tabela. Além disso, como o armazenamento do HDFS é transitório, se o cluster for encerrado, os dados da tabela serão perdidos e a tabela precisará ser recriada. Recomendamos que você especifique a `LOCATION` no Amazon S3 ao criar uma tabela do Hive usando o Glue. AWS Como alternativa, você pode usar a classificação de configuração `hive-site` para especificar um local no Amazon S3 para `hive.metastore.warehouse.dir`, que se aplica a todas as tabelas do Hive. Se uma tabela for criada em um local do HDFS e o cluster que a criou ainda estiver em execução, você poderá atualizar o local da tabela para o Amazon S3 a partir AWS do Glue. Para obter mais informações, consulte Como [trabalhar com tabelas no console do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/console-tables.html) no *Guia do desenvolvedor do AWS Glue*.
+ Valores de partição contendo aspas e apóstrofos não são compatíveis, por exemplo, `PARTITION (owner="Doe's").`
+ [As estatísticas de coluna](https://cwiki.apache.org/confluence/display/Hive/StatsDev#StatsDev-ColumnStatistics) são têm suporte para o emr-5.31.0 e versões posteriores.
+ O uso da [autorização do Hive](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+Authorization) não é compatível. Como alternativa, considere usar as [Políticas baseadas em recursos do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/glue-resource-policies.html). Para obter mais informações, consulte [Usar políticas baseadas em recursos para o Amazon EMR Access to AWS Glue](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-iam-roles-glue.html) Data Catalog.
Considere o seguinte ao usar o AWS Glue Data Catalog como catálogo REST do Apache Iceberg com o Spark:
+ Se você usar o catálogo de sessões do Spark com o Iceberg, conforme descrito em [Diferenças de configuração quando você usa o Iceberg versus SparkCatalog SparkSessionCatalog](emr-iceberg-use-spark-cluster.md#emr-iceberg-spark-catalog), será necessário configurar o Catálogo de dados do AWS Glue como o metastore do Apache Hive, além de configurar o Catálogo de dados do AWS Glue como o catálogo REST do Apache Iceberg.
+ O endpoint IRC do AWS Glue Data Catalog suporta somente o esquema de autenticação Amazon SigV4. OAuth não é suportado. Para OAuth usuários, use o IAM Identity Center para configurar o acesso. Consulte [Conectar o Lake Formation ao Centro de Identidade do IAM](https://docs.aws.amazon.com/lake-formation/latest/dg/connect-lf-identity-center.html).
+ O catálogo REST do AWS Glue Iceberg não oferece suporte a todas as operações em código aberto.
# Trabalhando com uma hierarquia de vários catálogos no AWS Glue Data Catalog com o Spark no Amazon EMR
Você pode registrar seu cluster do Amazon EMR para acessar o AWS Glue Data Catalog, que disponibiliza tabelas e outros recursos de catálogo para vários consumidores. AWS O Glue Data Catalog oferece suporte a uma hierarquia de vários catálogos, que unifica seus dados nos data lakes do Amazon S3. Ele também fornece uma API de metastore do Hive e uma API REST de código aberto do Apache Iceberg para acessar os dados. Esses recursos estão disponíveis para o Amazon EMR e outros serviços, como o Amazon Athena e o Amazon Redshift.
## Como os recursos do catálogo são organizados
Ao criar recursos no AWS Glue Data Catalog, você pode acessá-los de qualquer mecanismo SQL compatível com a API REST Apache Iceberg ou o metastore Hive. AWS Lake Formation gerencia as permissões.
No AWS Glue Data Catalog, os dados são organizados em uma hierarquia lógica de catálogos, bancos de dados e tabelas:
+ **Catálogo**: um contêiner lógico que contém objetos de um armazenamento de dados, como esquemas ou tabelas.
+ **Catálogo para armazenar tabelas do Redshift Managed Storage (RMS)**: ao gerenciar catálogos para armazenar tabelas do RMS, você pode acessar essas tabelas usando o Iceberg.
+ **Banco de dados**: organiza objetos de dados, como tabelas e visualizações, em um catálogo.
+ **Tabelas e visualizações**: objetos de dados em um banco de dados que fornecem uma camada de abstração com um esquema compreensível. Elas fornecem uma camada para acessar dados subjacentes, que podem estar em vários formatos e em diferentes locais.
## Configurar um catálogo de dados para uso com o Amazon EMR
Para começar, você configura o catálogo para oferecer suporte a ferramentas do Amazon EMR. O AWS Glue Data Catalog oferece compatibilidade com o Hive metastore e com o Iceberg REST. APIs
**Configurar o Amazon EMR com um metastore Hive**
Para obter informações sobre como configurar isso, consulte [Suporte do AWS Glue Data Catalog para tarefas do Spark](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-data-catalog-hive.html) no Guia do usuário do AWS Glue. Este tópico descreve como configurar o AWS Glue Data Catalog como um metastore do Hive e disponibilizá-lo como um endpoint. Além disso, há documentação do Amazon EMR disponível que mostra como especificar o AWS Glue Data Catalog como metastore do Spark, em Use [the AWS Glue Data Catalog as the Apache](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-spark-glue.html) Hive metastore for Spark.
## Permissões para acessar recursos no AWS Glue Data Catalog
Esta seção descreve os requisitos da política do IAM para usar ferramentas do Amazon EMR com dados de catálogo. Depois de registrar seu cluster no AWS Glue Data Catalog, você precisa das seguintes permissões para descobrir a criação e as alterações no catálogo de dados criado posteriormente:
+ **cola: GetCatalog**
+ **cola: GetCatalogs**
+ **conjuntos: AssumeRole**
+ **conjuntos: TagSession**
+ **conjuntos: SetContext**
+ **conjuntos: SetSourceIdentity**
Na maioria dos casos, ao atribuir permissões, recomendamos criar um perfil do IAM e atribuir permissões a ele.
Além disso, para consultar os dados do catálogo, você deve definir permissões para o catálogo de dados usando o AWS Lake Formation. Para obter mais informações sobre como definir permissões para catálogos de dados no AWS Lake Formation, consulte [Conceder e revogar permissões em recursos do Catálogo de dados](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-catalog-permissions.html).
Depois de criar e configurar seu cluster e definir permissões em seus objetos de catálogo, você pode enviar trabalhos para consultar e processar dados.
## Configure o Spark para acessar uma hierarquia de vários catálogos no AWS Glue Data Catalog
Com o EMR 7.5, você pode configurar o Spark para usar a hierarquia de vários catálogos do AWS Glue. Uma hierarquia de vários catálogos permite:
+ Traga seus dados do Redshift Managed Storage (RMS), como tabelas, visualizações e visualizações materializadas de data warehouses existentes do Amazon Redshift, para o Glue Data Catalog. AWS Você pode consultar esses objetos usando o EMR no EC2 e o EMR Sem Servidor.
+ Crie catálogos RMS, AWS Glue Data Catalog e armazene dados no RMS usando o ZeroETL e consulte os dados com mecanismos de consulta compatíveis com o Iceberg.
+ Crie tabelas Iceberg gerenciadas no AWS Glue Data Catalog com gerenciamento de armazenamento completo que inclui compactação, instantâneos e retenção.
### Conectar-se a vários catálogos ao inicializar uma sessão do Spark
Os exemplos a seguir demonstram como usar o shell interativo do Spark, o envio do Spark ou os notebooks Amazon EMR para trabalhar AWS com a hierarquia de vários catálogos do Glue.
------
#### [ spark-shell ]
1. Conecte-se ao nó principal usando SSH. Para obter mais informações, consulte [Conectar-se ao nó principal usando SSH](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-connect-master-node-ssh.html) no *Guia de gerenciamento do Amazon EMR*.
1. Digite o seguinte comando para iniciar o shell do Spark. Para usar a PySpark concha, `spark-shell` substitua por`pyspark`.
```
spark-shell \
--conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.my_catalog.warehouse=s3://amzn-s3-demo-bucket/prefix/
--conf spark.sql.catalog.my_catalog.type=glue \
--conf spark.sql.catalog.my_catalog.glue.id=Glue RMS catalog ID \
--conf spark.sql.defaultCatalog=my_catalog \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
```
------
#### [ spark-submit ]
1. Conecte-se ao nó principal usando SSH. Para obter mais informações, consulte [Conectar-se ao nó principal usando SSH](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-connect-master-node-ssh.html) no *Guia de gerenciamento do Amazon EMR*.
1. Insira o comando a seguir para iniciar a sessão do Spark no Spark.
```
spark-submit \
--conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.my_catalog.warehouse=s3://amzn-s3-demo-bucket1/prefix \
--conf spark.sql.catalog.my_catalog.type=glue \
--conf spark.sql.catalog.my_catalog.glue.id=Glue RMS catalog ID \
--conf spark.sql.defaultCatalog=my_catalog \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
```
------
#### [ EMR Studio notebooks ]
Para inicializar uma sessão do Spark usando Cadernos do EMR Studio, configure a sessão do Spark usando o comando mágico `%%configure` no Caderno do Amazon EMR, como no exemplo a seguir. Para obter mais informações, consulte [Use EMR Notebooks magics](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-studio-magics.html#emr-magics) no *Guia de gerenciamento do Amazon EMR*.
```
%%configure -f{
"conf":{
"spark.sql.catalog.my_catalog":"org.apache.iceberg.spark.SparkCatalog",
"spark.sql.catalog.my_catalog.type":"glue",
"spark.sql.catalog.my_catalog.glue.id":"Glue RMS catalog ID",
"spark.sql.catalog.my_catalog.warehouse":"s3://amzn-s3-demo-bucket1/prefix/",
"spark.sql.defaultCatalog", "my_catalog",
"spark.sql.extensions":"org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions"
}
}
```
------
#### [ CLI ]
Para inicializar uma sessão do Spark usando a CLI, execute o exemplo a seguir. Para obter mais informações sobre como especificar uma classificação de configuração usando a AWS CLI API do Amazon EMR, [consulte](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-configure-apps.html) Configurar aplicativos.
```
[
{
"Classification": "spark-defaults",
"Properties": {
"spark.sql.catalog.my_catalog":"org.apache.iceberg.spark.SparkCatalog",
"spark.sql.catalog.my_catalog.type":"glue",
"spark.sql.catalog.my_catalog.glue.id":"Glue RMS catalog ID",
"spark.sql.catalog.my_catalog.warehouse":"s3://amzn-s3-demo-bucket1/prefix/",
"spark.sql.defaultCatalog", "my_catalog",
"spark.sql.extensions":"org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions"
}
}
]
```
------
#### Inicialize uma sessão do Spark no Redshift Managed Storage com o Glue Data Catalog AWS
O exemplo de comando a seguir inicializa uma sessão do Spark com o Catálogo de dados do AWS Glue.
```
spark-sql \
--conf spark.sql.catalog.rms=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.rms.type=glue \
--conf spark.sql.catalog.rms.glue.id=Glue RMS catalog ID \
--conf spark.sql.defaultCatalog=rms
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
```
O exemplo a seguir inicializa uma sessão do Spark usando a API REST Iceberg e o Redshift Managed Storage with Glue Data Catalog. AWS
```
spark-sql \
--conf spark.sql.catalog.rms=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.rms.type=rest \
--conf spark.sql.catalog.rms.warehouse=glue RMS catalog ID \
--conf spark.sql.catalog.rms.uri=Glue endpoint URI/iceberg \
--conf spark.sql.catalog.rms.rest.sigv4-enabled=true \
--conf spark.sql.catalog.rms.rest.signing-name=glue \
--conf spark.sql.defaultCatalog=rms \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
```
Para obter mais informações sobre como usar uma hierarquia de vários catálogos do AWS Glue com o Spark Iceberg, consulte [Usar um cluster Iceberg](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-iceberg-use-spark-cluster.html) com o Spark.
## Considerações e limitações de uma configuração de vários catálogos
+ Não há suporte para o uso de uma hierarquia de vários catálogos com o metastore do Apache Hive.
+ O uso de uma hierarquia de vários catálogos com o Apache Iceberg não oferece suporte para fallback para o metastore do Apache Hive durante o uso do `SparkSessionCatalog`.
+ Clusters do EMR no EC2 com o perfil de Runtime não oferecem suporte à hierarquia de vários catálogos.
+ O EMR em clusters EC2 habilitados sem suporte à hierarquia de AWS Lake Formation vários catálogos.
# Configurar o Spark
Você pode configurar o [Spark no Amazon EMR](https://aws.amazon.com/elasticmapreduce/details/spark/) com classificações de configuração. Para obter mais informações sobre classificações de configuração, consulte [Configurar aplicações](emr-configure-apps.md).
As classificações de configuração para o Spark no Amazon EMR incluem o seguinte:
+ **`spark`**: define a propriedade `maximizeResourceAllocation` como verdadeira ou falsa. Quando verdadeira, o Amazon EMR configura automaticamente as propriedades `spark-defaults` com base na configuração de hardware do cluster. Para obter mais informações, consulte [Usar o `maximizeResourceAllocation`](#emr-spark-maximizeresourceallocation).
+ **`spark-defaults`**: define valores no arquivo `spark-defaults.conf`. Para obter mais informações, consulte [Configuração do Spark](https://spark.apache.org/docs/latest/configuration.html) na documentação do Spark.
+ **`spark-env`**: define valores no arquivo `spark-env.sh`. Para obter mais informações, consulte [Variáveis de ambiente](https://spark.apache.org/docs/latest/configuration.html#environment-variables) na documentação do Spark.
+ **`spark-hive-site`**: define os valores no `hive-site.xml` para o Spark.
+ **`spark-log4j`**— (Amazon EMR versões 6.7.x e inferiores) Define valores no arquivo. `log4j.properties` Para obter mais informações, consulte o arquivo [log4j.properties.template](https://github.com/apache/spark/blob/branch-3.2/conf/log4j.properties.template) no GitHub.
+ **`spark-log4j2`**: (versões 6.8.0 e superiores do Amazon EMR) define valores no arquivo `log4j2.properties`. Para obter mais informações, consulte o arquivo [log4j2.properties.template](https://github.com/apache/spark/blob/v3.3.0/conf/log4j2.properties.template) no GitHub.
+ **`spark-metrics`**: define valores no arquivo `metrics.properties`. Para obter configurações e mais informações, consulte o arquivo [metrics.properties.template](https://github.com/apache/spark/blob/master/conf/metrics.properties.template) no Github e as [Métricas](https://spark.apache.org/docs/latest/monitoring.html#metrics) na documentação do Spark.
**nota**
Se você estiver migrando workloads do Spark para o Amazon EMR de outra plataforma, recomendamos que você teste suas workloads com o [Padrões do Spark definidos pelo Amazon EMR](#spark-defaults) antes de adicionar configurações personalizadas. A maioria dos clientes observa uma melhor performance com nossas configurações padrão.
**Topics**
+ [
## Padrões do Spark definidos pelo Amazon EMR
](#spark-defaults)
+ [
## Configurar a coleta de resíduos do Spark no Amazon EMR 6.1.0
](#spark-gc-config)
+ [
## Usar o `maximizeResourceAllocation`
](#emr-spark-maximizeresourceallocation)
+ [
## Configurar o comportamento de desativação de nós
](#spark-decommissioning)
+ [
## Variável de ThriftServer ambiente Spark
](#spark-thriftserver)
+ [
## Alterar as configurações padrão do Spark
](#spark-change-defaults)
+ [
## Migrar do Apache Log4j 1.x para Log4j 2.x
](#spark-migrate-logj42)
## Padrões do Spark definidos pelo Amazon EMR
A tabela a seguir mostra como o Amazon EMR define valores padrão no `spark-defaults` que afetam aplicações.
**Padrões do Spark definidos pelo Amazon EMR**
| Configuração | Description | Valor padrão |
| --- | --- | --- |
| spark.executor.memory | A quantidade de memória a ser usada por processo de executor. Por exemplo: `1g`, `2g`. | Essa configuração é determinada pelos tipos de instância core e de tarefa no cluster. |
| spark.executor.cores | O número de núcleos para uso em cada executor. | Essa configuração é determinada pelos tipos de instância core e de tarefa no cluster. |
| spark.dynamicAllocation.enabled | Quando verdadeira, use alocação dinâmica de recursos para aumentar e diminuir a escala verticalmente do número de executores registrados em uma aplicação com base na workload. | `true` (com as versões 4.4.0 e superiores do Amazon EMR) O serviço de shuffle do Spark é automaticamente configurado pelo Amazon EMR. |
| spark.sql.hive.advancedPartitionPredicatePushdown.enabled | Quando verdadeiro, o pushdown avançado de predicados de partição para o metastore do Hive é habilitado. | true |
| spark.sql.hive.stringLikePartitionPredicatePushdown.enabled | Envia os filtros `startsWith`, `contains` e `endsWith` para o metastore do Hive. O Glue não é compatível com o pushdown de predicados para `startsWith`, `contains` ou `endsWith`. Se você estiver usando o metastore do Glue e encontrar erros devido ao pushdown de predicados para essas funções, defina essa configuração como `false`. | true |
## Configurar a coleta de resíduos do Spark no Amazon EMR 6.1.0
Definir configurações personalizadas de coleta de resíduos com `spark.driver.extraJavaOptions` e `spark.executor.extraJavaOptions` resulta em falha na inicialização do driver ou do executor com o Amazon EMR 6.1 devido a uma configuração de coleta de resíduos conflitante com o Amazon EMR 6.1.0. Para o Amazon EMR 6.1.0, a configuração padrão de coleta de resíduos é definida por meio de `spark.driver.defaultJavaOptions` e `spark.executor.defaultJavaOptions`. Essa configuração só se aplica ao Amazon EMR 6.1.0. As opções da JVM não relacionadas à coleta de resíduos, como aquelas para configurar registro em log (`-verbose:class`), ainda podem ser configuradas por meio de `extraJavaOptions`. Para obter mais informações, consulte [Propriedades das aplicações do Spark](https://spark.apache.org/docs/latest/configuration.html#application-properties).
## Usar o `maximizeResourceAllocation`
Para configurar os executores para usarem o máximo de recursos possível em cada nó em um cluster, defina `maximizeResourceAllocation` como `true` na classificação de configuração do `spark`. O `maximizeResourceAllocation` é específico para o Amazon EMR. Quando você habilita `maximizeResourceAllocation`, o Amazon EMR calcula os recursos máximos de computação e memória disponíveis para um executor em uma instância no grupo de instâncias centrais. Em seguida, ele define as configurações `spark-defaults` correspondentes com base nos valores máximos calculados.
O Amazon EMR calcula os recursos máximos de computação e memória disponíveis para um executor com base em um tipo de instância da frota de instâncias centrais. Como cada frota de instâncias pode ter diferentes tipos e tamanhos de instância em uma frota, a configuração do executor usada pelo Amazon EMR pode não ser a melhor para os clusters, por isso não recomendamos utilizar as configurações padrão com a alocação máxima de recursos. Defina configurações personalizadas para os clusters da frota de instâncias.
**nota**
Você não deve usar a `maximizeResourceAllocation` opção em clusters com outros aplicativos distribuídos, como HBase o. O Amazon EMR usa configurações personalizadas do YARN para aplicações distribuídas, que podem entrar em conflito com `maximizeResourceAllocation` e causar falhas nas aplicações do Spark.
Veja a seguir um exemplo de classificação de configuração do Spark com `maximizeResourceAllocation` definido como `true`.
```
[
{
"Classification": "spark",
"Properties": {
"maximizeResourceAllocation": "true"
}
}
]
```
**Configurações configuradas em `spark-defaults` quando `maximizeResourceAllocation`está habilitado**
| Configuração | Description | Valor |
| --- | --- | --- |
| spark.default.parallelism | O número padrão de partições é RDDs retornado por transformações como join reduceByKey, e paralelize quando não definido pelo usuário. | 2X o número de cores de CPU disponíveis para contêineres do YARN. |
| spark.driver.memory | Quantidade de memória a ser usada para o processo do driver, ou seja, onde SparkContext é inicializado. (por exemplo, 1g, 2g). | A configuração é definida com base nos tipos de instância do cluster. No entanto, como a aplicação do driver do Spark pode ser executada na instância primária ou em uma das instâncias core (por exemplo, nos modos de cliente do YARN e de cluster, respectivamente), isso é definido com base no menor tipo de instância desses dois grupos de instâncias. |
| spark.executor.memory | Quantidade de memória para uso por processo de executor. (por exemplo, 1g, 2g) | A configuração é definida com base nos tipos de instância core e de tarefa do cluster. |
| spark.executor.cores | O número de núcleos para uso em cada executor. | A configuração é definida com base nos tipos de instância core e de tarefa do cluster. |
| spark.executor.instances | O número de executores. | A configuração é definida com base nos tipos de instância core e de tarefa do cluster. Defina a menos que `spark.dynamicAllocation.enabled` seja explicitamente definido como true ao mesmo tempo. |
## Configurar o comportamento de desativação de nós
Com as versões 5.9.0 e superiores do Amazon EMR, o Spark no Amazon EMR inclui um conjunto de recursos para ajudar a garantir que o Spark lide tranquilamente com o encerramento de nós devido a um redimensionamento manual ou a uma solicitação de política de ajuste de escala automática. O Amazon EMR implementa um mecanismo de lista de negação no Spark criado com base no mecanismo de desativação do YARN. Esse mecanismo ajuda a garantir que não haja novas tarefas programadas em um nó que esteja sendo desativado, permitindo ao mesmo tempo que tarefas que já estão em execução sejam concluídas. Além disso, há recursos para ajudar a recuperar trabalhos do Spark com mais rapidez se os shuffle blocks forem perdidos no encerramento de um nó. O processo de recálculo é acionado mais cedo e otimizado para recalcular com mais rapidez e menos tentativas de fase, e é possível evitar falhas nos trabalhos provenientes de falhas de busca que são causadas por shuffle blocks ausentes.
**Importante**
A configuração `spark.decommissioning.timeout.threshold` foi adicionada ao Amazon EMR versão 5.11.0 para melhorar a resiliência do Spark ao serem usadas instâncias spot. Nas versões anteriores, quando um nó usa uma instância spot e a instância é encerrada devido ao preço da oferta, o Spark pode não ser capaz de lidar com o encerramento com tranquilidade. Os trabalhos podem falhar e os novos cálculos de shuffle podem levar um tempo significativo. Por esse motivo, recomendamos o uso da versão 5.11.0, ou posterior, se você usar instâncias spot.
**Configurações de desativação de nós do Spark**
| Configuração | Description | Valor padrão |
| --- | --- | --- |
| `spark.blacklist.decommissioning.enabled` | Quando definido como `true`, o Spark coloca na lista de negação os nós que estão no estado `decommissioning` no YARN. O Spark não programa novas tarefas em executores que estejam em execução nesse nó. É permitido que as tarefas já em execução sejam concluídas. | `true` |
| `spark.blacklist.decommissioning.timeout` | O período em que um nó no estado `decommissioning` permanece na lista de negação. Por padrão, esse valor é definido como uma hora, que também é o padrão para `yarn.resourcemanager.decommissioning.timeout`. Para garantir que um nó permaneça na lista de negação por todo o período de desativação, defina esse valor como igual ou maior do que `yarn.resourcemanager.decommissioning.timeout`. Depois que o tempo limite da desativação expira, o nó muda para o estado `decommissioned`, e o Amazon EMR pode encerrar a instância do EC2 do nó. Se alguma tarefa ainda estiver em execução após o tempo limite expirar, ela será perdida ou eliminada e reprogramada em executores executados em outros nós. | `1h` |
| `spark.decommissioning.timeout.threshold` | Disponível nas versões 5.11.0 ou posteriores do Amazon EMR. Especificado em segundos. Quando um nó muda para o estado de desativação, se o host é desativado em um período igual ou menor que esse valor, o Amazon EMR não apenas insere o nó em uma lista de negação, mas também limpa o estado do host (conforme especificado por `spark.resourceManager.cleanupExpiredHost`) sem esperar que o nó mude para um estado de desativação. Isso permite que o Spark lide melhor com o encerramento de instâncias spot, pois as instâncias spot são desativadas dentro de um tempo de espera de 20 segundos, independentemente do valor do `yarn.resourcemager.decommissioning.timeout`, o que pode não dar aos outros nós tempo suficiente para que eles leiam arquivos embaralhados. | `20s` |
| `spark.resourceManager.cleanupExpiredHost` | Quando definido como `true`, o Spark cancela o registro de todos os dados em cache e os shuffle blocks armazenados nos executores nos nós que estejam no estado `decommissioned`. Isso acelera o processo de recuperação. | `true` |
| `spark.stage.attempt.ignoreOnDecommissionFetchFailure` | Quando definido como `true`, ajuda a evitar falhas do Spark nas fases e a falha no trabalho devido ao excesso de falhas de busca dos nós desativados. As buscas com falha de shuffle blocks de nó no estado `decommissioned` não são contabilizadas para o número máximo de falhas de busca consecutivas. | true |
## Variável de ThriftServer ambiente Spark
O Spark define a variável de ambiente da Porta do servidor Thrift do Hive, `HIVE_SERVER2_THRIFT_PORT`, como 10001.
## Alterar as configurações padrão do Spark
Você altera os padrões em `spark-defaults.conf` usando a classificação de configuração `spark-defaults` ou a configuração `maximizeResourceAllocation` na classificação de configuração `spark`.
Os procedimentos a seguir mostram como modificar as configurações usando a CLI ou o console.
**Criar um cluster com spark.executor.memory definido como 2g usando a CLI**
+ Crie um cluster com o Spark instalado e com `spark.executor.memory` definido como 2g usando o comando a seguir, que faz referência a um arquivo, `myConfig.json`, armazenado no Amazon S3.
```
aws emr create-cluster --release-label emr-7.12.0 --applications Name=Spark \
--instance-type m5.xlarge --instance-count 2 --service-role EMR_DefaultRole_V2 --ec2-attributes InstanceProfile=EMR_EC2_DefaultRole --configurations https://s3.amazonaws.com/amzn-s3-demo-bucket/myfolder/myConfig.json
```
**nota**
Os caracteres de continuação de linha do Linux (\$1) são incluídos para facilitar a leitura. Eles podem ser removidos ou usados em comandos do Linux. No Windows, remova-os ou substitua-os por um sinal de interpolação (^).
`myConfig.json`:
```
[
{
"Classification": "spark-defaults",
"Properties": {
"spark.executor.memory": "2G"
}
}
]
```
**Criar um cluster com spark.executor.memory definido como 2g usando o console**
1. Navegue até o novo console do Amazon EMR e selecione **Alternar para o console antigo** na navegação lateral. Para obter mais informações sobre o que esperar ao alternar para o console antigo, consulte [Usar o console antigo](https://docs.aws.amazon.com/emr/latest/ManagementGuide/whats-new-in-console.html#console-opt-in).
1. Escolha **Create cluster (Criar cluster)**, **Go to advanced options (Ir para opções avançadas)**.
1. Escolha **Spark**.
1. Em **Edit software settings (Editar configurações de software)**, deixe **Enter configuration (Inserir configuração)** selecionado e insira a seguinte configuração:
```
classification=spark-defaults,properties=[spark.executor.memory=2G]
```
1. Selecione outras opções, escolha **** e **Criar cluster**.
**Para definir maximizeResourceAllocation**
+ Crie um cluster com o Spark instalado e `maximizeResourceAllocation` definido como verdadeiro usando o AWS CLI, referenciando um arquivo`myConfig.json`, armazenado no Amazon S3.
```
aws emr create-cluster --release-label emr-7.12.0 --applications Name=Spark \
--instance-type m5.xlarge --instance-count 2 --service-role EMR_DefaultRole_V2 --ec2-attributes InstanceProfile=EMR_EC2_DefaultRole --configurations https://s3.amazonaws.com/amzn-s3-demo-bucket/myfolder/myConfig.json
```
**nota**
Os caracteres de continuação de linha do Linux (\$1) são incluídos para facilitar a leitura. Eles podem ser removidos ou usados em comandos do Linux. No Windows, remova-os ou substitua-os por um sinal de interpolação (^).
`myConfig.json`:
```
[
{
"Classification": "spark",
"Properties": {
"maximizeResourceAllocation": "true"
}
}
]
```
**nota**
Com as versões 5.21.0 e posteriores do Amazon EMR, você pode substituir as configurações de cluster e especificar classificações de configuração adicionais para cada grupo de instâncias em um cluster em execução. Você faz isso usando o console do Amazon EMR, o AWS Command Line Interface (AWS CLI) ou o AWS SDK. Para obter mais informações, consulte [Supplying a Configuration for an Instance Group in a Running Cluster](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-configure-apps-running-cluster.html).
## Migrar do Apache Log4j 1.x para Log4j 2.x
As versões 3.2.x e anteriores do [Apache Spark](https://aws.amazon.com/emr/features/spark/) usam o Apache Log4j 1.x herdado e o arquivo `log4j.properties` para configurar o Log4j nos processos do Spark. As versões 3.3.0 e posteriores do Apache Spark usam o Apache Log4j 2.x e o arquivo `log4j2.properties` para configurar o Log4j nos processos do Spark.
Se você tiver configurado o Apache Spark Log4j usando uma versão do Amazon EMR inferior à 6.8.0, deverá remover a classificação de configuração `spark-log4j` herdada e migrar para a classificação de configuração `spark-log4j2` e o formato da chave antes de poder atualizar para o Amazon EMR 6.8.0 ou posterior. A classificação `spark-log4j` herdada faz com que a criação do cluster apresente falha com um erro de `ValidationException` nas versões 6.8.0 e posteriores do Amazon EMR. Você não será cobrado por uma falha relacionada à incompatibilidade do Log4j, mas deverá remover a classificação de configuração `spark-log4j` extinta para continuar.
Para obter mais informações sobre a migração do Apache Log4j 1.x para o Log4j 2.x, consulte o [Guia de migração do Apache Log4j](https://logging.apache.org/log4j/2.x/manual/migration.html) e o [Modelo do Spark Log4j 2](https://github.com/apache/spark/blob/master/conf/log4j2.properties.template) no GitHub.
**nota**
Com o Amazon EMR, o Apache Spark usa um arquivo `log4j2.properties` em vez do arquivo .xml descrito no [Guia de migração do Apache Log4j](https://logging.apache.org/log4j/2.x/manual/migration.html). Além disso, não recomendamos o uso do método de ponte do Log4j 1.x para conversão para Log4j 2.x.
# O que é o agente de solução de problemas do Apache Spark para o Amazon EMR
## Introdução
O agente de solução de problemas do Apache Spark para Amazon EMR é um recurso de IA conversacional que simplifica a solução de problemas de aplicativos Apache Spark no Amazon EMR, Glue e Amazon Notebooks. AWS SageMaker A solução de problemas tradicional do Spark exige uma ampla análise manual de registros, métricas de desempenho e padrões de erro para identificar as causas principais e as correções de código. O agente simplifica esse processo por meio de solicitações em linguagem natural, análise automatizada da carga de trabalho e recomendações inteligentes de código.
Você pode usar o agente para solucionar problemas PySpark e falhas nos aplicativos Scala. O agente analisa seus trabalhos fracassados, identifica gargalos de desempenho e fornece recomendações práticas e correções de código, ao mesmo tempo em que oferece controle total sobre as decisões de implementação.
**nota**
O agente de solução de problemas do Apache Spark está disponível sem custo adicional como parte do Amazon EMR. O agente fornece somente análises e recomendações. Você paga somente pelos recursos do Amazon EMR que usa ao executar seus aplicativos para validar as correções recomendadas.
## Visão geral da arquitetura
O agente de solução de problemas tem três componentes principais: um assistente de IA compatível com MCP em seu ambiente de desenvolvimento para interação, o [MCP Proxy](https://github.com/aws/mcp-proxy-for-aws), AWS que gerencia a comunicação e a autenticação seguras entre seu cliente e os AWS serviços, e o servidor MCP remoto do Amazon SageMaker Unified Studio, `(preview)` que fornece ferramentas especializadas de solução de problemas do Spark para Amazon EMR, Glue e Amazon Notebooks. AWS SageMaker Este diagrama ilustra como você interage com o servidor MCP remoto do Amazon SageMaker Unified Studio por meio do seu assistente de IA.
![\[Arquitetura do agente de solução de problemas do Spark.\]](http://docs.aws.amazon.com/pt_br/emr/latest/ReleaseGuide/images/spark-troubleshooting-agent-architecture.png)
O assistente de IA orquestrará a solução de problemas usando ferramentas especializadas fornecidas pelo servidor MCP seguindo estas etapas:
+ **Extração de recursos e criação de contexto:** o agente coleta e analisa automaticamente os dados de telemetria do seu aplicativo Spark, incluindo registros do Spark History Server, configurações e rastreamentos de erros. Ele extrai as principais métricas de desempenho, padrões de utilização de recursos e assinaturas de falhas para criar um perfil de contexto abrangente para solução de problemas inteligente.
+ **Analisador de causas raiz e mecanismo de recomendação GenAI:** o agente aproveita os modelos de IA e a base de conhecimento do Spark para correlacionar os recursos extraídos e identificar as causas-raiz de problemas ou falhas de desempenho. Ele fornece informações de diagnóstico e análise do que deu errado na execução do aplicativo Spark.
+ **Recomendação de código GenAI Spark:** Com base na análise da causa raiz da etapa anterior, o agente analisa seus padrões de código existentes e identifica operações ineficientes que precisam de correções de código para falhas de aplicativos. Ele fornece recomendações práticas, incluindo modificações de código específicas, ajustes de configuração e melhorias arquitetônicas com exemplos concretos.
**Topics**
+ [
## Introdução
](#spark-troubleshooting-agent-intro)
+ [
## Visão geral da arquitetura
](#spark-troubleshooting-agent-architecture)
+ [
# Configuração do agente de solução de problemas
](spark-troubleshooting-agent-setup.md)
+ [
# Usando o agente de solução de problemas
](spark-troubleshooting-using-troubleshooting-agent.md)
+ [
# Características e capacidades
](spark-troubleshooting-features.md)
+ [
# Solução de problemas e perguntas e respostas
](spark-troubleshooting-agent-troubleshooting.md)
+ [
# Detalhes do fluxo de trabalho do agente de solução de problemas do Spark
](spark-troubleshooting-agent-workflow.md)
+ [
# Exemplos imediatos
](spark-troubleshooting-agent-prompt-examples.md)
+ [
# Configuração da função do IAM
](spark-troubleshooting-agent-iam-setup.md)
+ [
# Usando as ferramentas de solução de problemas do Spark
](spark-troubleshooting-agent-using-tools.md)
+ [
# Configurando endpoints VPC de interface para SageMaker Amazon Unified Studio MCP
](spark-troubleshooting-agent-vpc-endpoints.md)
+ [
# Processamento entre regiões para o agente de solução de problemas do Apache Spark
](spark-troubleshooting-cross-region-processing.md)
+ [
# Registro de chamadas MCP do Amazon SageMaker Unified Studio usando AWS CloudTrail
](spark-troubleshooting-cloudtrail-integration.md)
+ [
# Melhorias de serviço para agentes Apache Spark
](spark-agents-service-improvements.md)
# Configuração do agente de solução de problemas
**nota**
O agente de solução de problemas do Apache Spark usa inferência entre regiões para processar solicitações de linguagem natural e gerar respostas. Para obter mais detalhes, consulte[Processamento entre regiões para o agente de solução de problemas do Apache Spark](spark-troubleshooting-cross-region-processing.md). O servidor MCP do Amazon SageMaker Unified Studio está em versão prévia e está sujeito a alterações.
## Pré-requisitos
Antes de iniciarmos nosso processo de configuração para integração com o Kiro CLI, verifique se você tem o seguinte instalado em sua estação de trabalho:
+ [Instale a AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Instale o Python 3.10\$1](https://www.python.org/downloads/release/python-3100/)
+ [Instale o gerenciador de `uv` pacotes do](https://docs.astral.sh/uv/getting-started/installation/) [MCP Proxy](https://github.com/aws/mcp-proxy-for-aws?tab=readme-ov-file) para AWS
+ [Instale o Kiro CLI](https://kiro.dev/docs/cli/)
+ AWS credenciais locais configuradas (via [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html), variáveis de ambiente ou funções do IAM) - para operações locais, como upload de artefatos de trabalho atualizados para execução de trabalhos de validação do EMR.
## Recursos de configuração
Você pode usar um AWS CloudFormation modelo para configurar o recurso para o servidor MCP. Esses modelos são exemplos que você deve modificar para atender aos seus requisitos. O modelo cria os seguintes recursos para o processo de solução de problemas:
1. Função do IAM que tem permissões para chamar o MCP Server e permissões necessárias para o processo de solução de problemas da plataforma selecionada.
Escolha um dos botões **Launch Stack (Iniciar pilha)** na tabela a seguir. Isso inicia a pilha no AWS CloudFormation console na respectiva região.
| Região | início |
| --- | --- |
| Leste dos EUA (Ohio) | [https://console.aws.amazon.com/cloudformation/home?region=us-east-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-us-east-2.s3.us-east-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=us-east-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-us-east-2.s3.us-east-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) |
| Leste dos EUA (N. da Virgínia) | [https://console.aws.amazon.com/cloudformation/home?region=us-east-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-us-east-1.s3.us-east-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=us-east-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-us-east-1.s3.us-east-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) |
| Oeste dos EUA (Oregon) | [https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-us-west-2.s3.us-west-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-us-west-2.s3.us-west-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) |
| Ásia-Pacífico (Tóquio) | [https://console.aws.amazon.com/cloudformation/home?region=ap-northeast-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-northeast-1.s3.ap-northeast-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=ap-northeast-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-northeast-1.s3.ap-northeast-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) |
| Europa (Irlanda) | [https://console.aws.amazon.com/cloudformation/home?region=eu-west-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-west-1.s3.eu-west-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=eu-west-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-west-1.s3.eu-west-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) |
| Ásia-Pacífico (Singapura) | [https://console.aws.amazon.com/cloudformation/home?region=ap-southeast-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-southeast-1.s3.ap-southeast-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=ap-southeast-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-southeast-1.s3.ap-southeast-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) |
| Ásia-Pacífico (Sydney) | [https://console.aws.amazon.com/cloudformation/home?region=ap-southeast-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-southeast-2.s3.ap-southeast-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=ap-southeast-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-southeast-2.s3.ap-southeast-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) |
| Canadá (Central) | [https://console.aws.amazon.com/cloudformation/home?region=ca-central-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ca-central-1.s3.ca-central-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=ca-central-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ca-central-1.s3.ca-central-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) |
| América do Sul (São Paulo) | [https://console.aws.amazon.com/cloudformation/home?region=sa-east-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-sa-east-1.s3.sa-east-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=sa-east-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-sa-east-1.s3.sa-east-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) |
| Europa (Frankfurt) | [https://console.aws.amazon.com/cloudformation/home?region=eu-central-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-central-1.s3.eu-central-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=eu-central-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-central-1.s3.eu-central-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) |
| Europa (Estocolmo) | [https://console.aws.amazon.com/cloudformation/home?region=eu-north-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-north-1.s3.eu-north-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=eu-north-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-north-1.s3.eu-north-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) |
| Europa (Londres) | [https://console.aws.amazon.com/cloudformation/home?region=eu-west-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-west-2.s3.eu-west-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=eu-west-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-west-2.s3.eu-west-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) |
| Europa (Paris) | [https://console.aws.amazon.com/cloudformation/home?region=eu-west-3#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-west-3.s3.eu-west-3.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=eu-west-3#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-west-3.s3.eu-west-3.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) |
| Ásia-Pacífico (Seul) | [https://console.aws.amazon.com/cloudformation/home?region=ap-northeast-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-northeast-2.s3.ap-northeast-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=ap-northeast-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-northeast-2.s3.ap-northeast-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) |
| Ásia-Pacífico (Mumbai) | [https://console.aws.amazon.com/cloudformation/home?region=ap-south-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-south-1.s3.ap-south-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=ap-south-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-south-1.s3.ap-south-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) |
Vá até a página **Especificar detalhes da pilha** e insira o nome da **pilha**. Insira informações adicionais em **Parameters** (Parâmetros). Forneça as informações a seguir e continue criando a pilha.
+ **TroubleshootingRoleName**- Nome da função do IAM a ser criada para operações de solução de problemas
+ **Habilitar EMREC2** - Ative as permissões de solução de problemas do EMR-EC2 (padrão: true)
+ **Ativar EMRServerless** - Ative as permissões de solução de problemas sem servidor do EMR (padrão: true)
+ **EnableGlue**- Ative as permissões de solução de problemas do Glue (padrão: true)
+ **CloudWatchKmsKeyArn**- (Opcional) ARN da chave KMS existente para criptografia de CloudWatch registros (somente EMR Serverless, deixe em branco para criptografia padrão)
Você também pode baixar e revisar [o CloudFormation modelo](https://github.com/aws-samples/aws-emr-utilities/blob/03c20fece616de23ec0ea5389f0113a5bc65fc3a/utilities/apache-spark-agents/spark-troubleshooting-agent-cloudformation/spark-troubleshooting-mcp-setup.yaml), especificar as opções acima e iniciar o modelo sozinho com os comandos da CloudFormation CLI. Veja abaixo um exemplo:
```
# deploy the stack with CloudFormation CLI commands
aws cloudformation deploy \
--template-file spark-troubleshooting-mcp-setup.yaml \
--stack-name spark-troubleshooting-mcp-setup \
--region \
--capabilities CAPABILITY_NAMED_IAM \
--parameter-overrides \
TroubleshootingRoleName=spark-troubleshooting-role
# retrieve the 1-line instruction to set the local environment variables, which will be used for the following MCP server configuration
aws cloudformation describe-stacks \
--stack-name spark-troubleshooting-mcp-setup \
--region \
--query "Stacks[0].Outputs[?OutputKey=='ExportCommand'].OutputValue" \
--output text
```
Abra a guia Saídas (ou recupere do comando da CLI CloudFormation describe-stacks acima) e copie a instrução de 1 linha da saída para definir suas variáveis de ambiente e, em CloudFormation seguida, execute-a em seu ambiente local. Exemplo de instrução de 1 linha:
```
export SMUS_MCP_REGION= && export IAM_ROLE=arn:aws:iam::111122223333:role/spark-troubleshooting-role-xxxxxx
```
Em seguida, execute o seguinte comando localmente para definir o perfil do IAM e a configuração do servidor MCP:
```
# Step 1: Configure AWS CLI Profile
aws configure set profile.smus-mcp-profile.role_arn ${IAM_ROLE}
aws configure set profile.smus-mcp-profile.source_profile
aws configure set profile.smus-mcp-profile.region ${SMUS_MCP_REGION}
# Step 2: if you are using kiro CLI, use the following command to add the MCP configuration
# Add Spark Troubleshooting MCP Server
kiro-cli-chat mcp add \
--name "sagemaker-unified-studio-mcp-troubleshooting" \
--command "uvx" \
--args "[\"mcp-proxy-for-aws@latest\",\"https://sagemaker-unified-studio-mcp.${SMUS_MCP_REGION}.api.aws/spark-troubleshooting/mcp\", \"--service\", \"sagemaker-unified-studio-mcp\", \"--profile\", \"smus-mcp-profile\", \"--region\", \"${SMUS_MCP_REGION}\", \"--read-timeout\", \"180\"]" \
--timeout 180000 \
--scope global
# Add Spark Code Recommendation MCP Server
kiro-cli-chat mcp add \
--name "sagemaker-unified-studio-mcp-code-rec" \
--command "uvx" \
--args "[\"mcp-proxy-for-aws@latest\",\"https://sagemaker-unified-studio-mcp.${SMUS_MCP_REGION}.api.aws/spark-code-recommendation/mcp\", \"--service\", \"sagemaker-unified-studio-mcp\", \"--profile\", \"smus-mcp-profile\", \"--region\", \"${SMUS_MCP_REGION}\", \"--read-timeout\", \"180\"]" \
--timeout 180000 \
--scope global
```
Isso deve ser atualizado `~/.kiro/settings/mcp.json` para incluir a configuração do servidor MCP conforme abaixo.
```
{
"mcpServers": {
"sagemaker-unified-studio-mcp-troubleshooting": {
"type": "stdio",
"command": "uvx",
"args": [
"mcp-proxy-for-aws@latest",
"https://sagemaker-unified-studio-mcp.us-east-1.api.aws/spark-troubleshooting/mcp",
"--service",
"sagemaker-unified-studio-mcp",
"--profile",
"smus-mcp-profile",
"--region",
"us-east-1",
"--read-timeout",
"180"
],
"timeout": 180000,
"disabled": false
},
"sagemaker-unified-studio-mcp-code-rec": {
"type": "stdio",
"command": "uvx",
"args": [
"mcp-proxy-for-aws@latest",
"https://sagemaker-unified-studio-mcp.us-east-1.api.aws/spark-code-recommendation/mcp",
"--service",
"sagemaker-unified-studio-mcp",
"--profile",
"smus-mcp-profile",
"--region",
"us-east-1",
"--read-timeout",
"180"
],
"timeout": 180000,
"disabled": false
}
}
}
```
Consulte [Interfaces suportadas](spark-troubleshooting-using-troubleshooting-agent.md#supported-interfaces) a orientação de configuração para diferentes clientes MCP, como Kiro, Cline e. GitHub CoPilot
# Usando o agente de solução de problemas
## Modos de implantação suportados
O agente de solução de problemas do Apache Spark para Amazon EMR oferece suporte a recursos abrangentes de análise para cargas de trabalho do Spark com falha, incluindo diagnóstico automatizado de erros, identificação de gargalos de desempenho, recomendações de código e sugestões práticas para melhorar o desempenho do aplicativo no seguinte modo de implantação do Spark:
+ EMR no EC2
+ Tecnologia sem servidor do EMR
+ AWS Glue
Consulte [Características e capacidades](spark-troubleshooting-features.md) para entender os recursos, capacidades e limitações detalhados.
## Interfaces suportadas
### Solução de problemas de células nos Amazon SageMaker Notebooks
Uma demonstração da experiência de solução de problemas com Amazon SageMaker Notebooks. Para qualquer falha na célula do Notebook, você pode solicitar ao Amazon SageMaker Notebook Agent que solucione a falha para solicitar a análise, seguida pela possível correção do código, se o erro resultar do código, clicando no `Fix with AI` botão.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/btW8hwio0tE)
### Solução de problemas de aplicativos Glue e EMR Spark com o Kiro CLI
Inicie o Kiro CLI ou seu assistente de IA e verifique as ferramentas carregadas para o processo de solução de problemas.
```
...
sagemaker-unified-studio-mcp-code-rec (MCP)
- spark_code_recommendation not trusted
sagemaker-unified-studio-mcp-troubleshooting (MCP)
- analyze_spark_workload not trusted
...
```
Agora você está pronto para iniciar o fluxo de trabalho do agente de solução de problemas do Spark.
Uma demonstração da experiência de solução de problemas com o Kiro CLI. Você pode simplesmente iniciar o processo de solução de problemas com o seguinte prompt:
```
Analyze my Glue job. The job name is "xxx" and the job run id is "xxx"
```
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/YLwV_EenJXY)
### Integração com outros clientes MCP
A configuração descrita em também [Configuração do agente de solução de problemas](spark-troubleshooting-agent-setup.md) pode ser usada em outros clientes MCP e IDEs para se conectar ao servidor MCP gerenciado:
+ **Integração com o Cline** - Para usar o MCP Server com o Cline, modifique `cline_mcp_settings.json` e adicione a configuração acima. Consulte a [documentação da Cline](https://docs.cline.bot/mcp/configuring-mcp-servers) para obter mais informações sobre como gerenciar a configuração do MCP.
+ **Integração com o Claude Code** Para usar o MCP Server com o Claude Code, modifique o arquivo de configuração para incluir a configuração MCP. O caminho do arquivo varia de acordo com o sistema operacional. Consulte [ https://code.claude.com/docs/en/mcp](https://code.claude.com/docs/en/mcp) para obter uma configuração detalhada.
+ **Integração com o GitHub Copilot** - Para usar o servidor MCP com o GitHub Copilot, siga as instruções em [ https://docs.github.com/en/copilot/how-tos/provide-context/use-mcp/extend- copilot-chat-with-mcp](https://docs.github.com/en/copilot/how-tos/provide-context/use-mcp/extend-copilot-chat-with-mcp) para modificar o arquivo de configuração correspondente e siga as instruções de cada IDE para ativar a configuração.
# Características e capacidades
## Plataformas com suporte
+ **Linguagens**: aplicativos Python e Scala Spark
+ **Plataformas de destino**: Amazon EMR, EMR Serverless e Glue AWS
## Como funciona
Quando seu aplicativo Spark falhar, você pode usar o agente de solução de problemas para investigar automaticamente o que deu errado. Ele analisa seus registros de eventos, mensagens de erro e uso de recursos do Spark para identificar o problema exato, seja um executor do Spark com falta de memória, um erro de configuração ou um bug de código.
Quando você solicita que um prompt em linguagem natural analise sua carga de trabalho do Spark, o agente se conecta aos recursos da sua plataforma e extrai recursos (que incluem registros de eventos do Spark, planos de consulta, cronogramas do executor, rastreamentos de registros, configurações e métricas):
+ No EMR-EC2: ele se conecta à interface persistente do [EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/app-history-spark-UI.html) para o cluster
+ No Glue: ele cria o contexto da [interface do usuário do Spark](https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-jobs.html) do Glue Studio para o trabalho
+ [No EMR-Serverless: ele se conecta ao EMR-Serverless Spark History Server para o trabalho](https://docs.aws.amazon.com/emr-serverless/latest/APIReference/API_GetDashboardForJobRun.html)
+ O agente também analisa os rastreamentos da pilha de erros e os detalhes da configuração para fornecer informações práticas.
Para cargas de trabalho com falha, você obtém uma explicação clara da causa raiz e etapas específicas para corrigi-la. Se o agente detectar um problema relacionado ao código, ele fornecerá automaticamente recomendações de código para mostrar exatamente o que alterar em seu código. Você também pode solicitar sugestões em nível de código diretamente sempre que quiser, sem a análise completa.
## Regiões disponíveis
O agente de solução de problemas do Spark está disponível nas seguintes regiões:
+ **Ásia-Pacífico**: Tóquio (ap-northeast-1), Seul (ap-northeast-2), Cingapura (ap-southeast-1), Sydney (ap-southeast-2) e Mumbai (ap-southeast-1)
+ **América do** Norte: Canadá (ca-central-1)
+ **Europa**: Estocolmo (eu-north-1), Irlanda (eu-west-1), Londres (eu-west-2), Paris (eu-west-3) e Frankfurt (eu-central-1)
+ **América do Sul**: São Paulo (sa-east-1)
+ **Estados Unidos**: Virgínia do Norte (us-east-1), Ohio (us-east-2) e Oregon (us-east-2)
## Escopo da solução de problemas do Spark e dos requisitos do usuário
+ **Estados de carga de trabalho do Spark compatíveis**: as ferramentas só suportarão respostas para cargas de trabalho do Spark com falha.
+ **UI persistente do EMR:** ao analisar as cargas de trabalho do Amazon EMR-EC2, a ferramenta de análise tentará se conectar à interface persistente do EMR para recuperar as principais informações do Spark. [As considerações sobre a interface de usuário persistente do EMR estão documentadas aqui.](https://docs.aws.amazon.com/emr/latest/ManagementGuide/app-history-spark-UI.html#app-history-spark-UI-limitations)
+ **UI do Glue Studio Spark**: ao analisar as cargas de trabalho do AWS Glue, a ferramenta de análise tentará recuperar as principais informações do Spark analisando os registros de eventos do Spark do usuário no Amazon S3. O tamanho máximo permitido do registro de eventos do Spark está documentado [aqui](https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-jobs.html): 512 MB e 2 GB para registros contínuos.
+ **Recomendações de código:** Compatível somente com cargas de trabalho Amazon EMR-EC2 e AWS Glue para cargas de trabalho PySpark
+ **Recursos regionais:** o agente de solução de problemas do Spark é regional e usa os recursos subjacentes do EMR nessa região para o processo de solução de problemas. A solução de problemas entre regiões não é suportada.
# Solução de problemas e perguntas e respostas
## Solução de problemas
A mensagem de erro do Spark Troubleshooting Agent está disponível de maneiras diferentes para diferentes clientes MCP. Nesta página, listamos algumas orientações gerais para problemas comuns que você pode ver usando o agente de solução de problemas do Apache Spark para Amazon EMR.
Tópicos
+ [Erro: Falha ao carregar o servidor MCP](#mcp-server-failed-to-load)
+ [Observação: carregamento lento da ferramenta](#slow-tool-loading)
+ [Erro: falha na invocação da ferramenta com erro de limitação](#throttling-error)
+ [Erro: a ferramenta responde com erro do usuário](#user-error)
+ [Erro: a ferramenta responde com erro interno](#internal-error)
### Erro: Falha ao carregar o servidor MCP
+ Verifique se suas configurações de MCP estão configuradas corretamente.
+ **Valide a sintaxe JSON:**
+ Certifique-se de que seu JSON seja válido sem erros de sintaxe
+ Verifique se há vírgulas, aspas ou colchetes ausentes
+ Verifique suas AWS credenciais locais e verifique se a política da função MCP IAM está configurada corretamente.
+ Execute /mcp para verificar a disponibilidade do servidor MCP para o caso `Kiro-CLI`
### Observação: carregamento lento da ferramenta
+ As ferramentas podem levar alguns segundos para serem carregadas na primeira tentativa de iniciar o servidor.
+ Se as ferramentas não aparecerem, tente reiniciar o bate-papo.
+ Execute `/tools` o comando para verificar a disponibilidade da ferramenta.
+ Execute `/mcp` se o servidor for iniciado sem erros.
### Erro: falha na invocação da ferramenta com erro de limitação
+ Se você atingir seu limite de serviço, aguarde alguns segundos para emitir uma invocação de ferramenta caso veja a exceção de limitação.
### Erro: a ferramenta responde com erro do usuário
+ AccessDeniedException - verifique a mensagem de erro e corrija o problema de permissão.
+ InvalidInputException - verifique a mensagem de erro e corrija os parâmetros de entrada da ferramenta.
+ ResourceNotFoundException - verifique a mensagem de erro e corrija o parâmetro de entrada para referência do recurso.
### Erro: a ferramenta responde com erro interno
+ Se você ver`The service is handling high-volume requests`, tente novamente invocar a ferramenta em alguns segundos.
+ Se você ver`INTERNAL SERVICE EXCEPTION`, documente o ID da análise, o nome da ferramenta, qualquer mensagem de erro disponível no registro do mcp ou na resposta da ferramenta e o histórico de conversas higienizado opcional e entre em contato com o suporte. AWS
## Perguntas e respostas
### 1. Devo habilitar a configuração de “confiança” para as ferramentas por padrão?
Não ative a configuração “confiança” por padrão para todas as chamadas de ferramentas inicialmente e opere em um ambiente de compilação com versão git ao aceitar recomendações de código. Analise a execução de cada ferramenta para entender quais mudanças estão sendo feitas.
### 2. Quais são os exemplos comuns de instruções para aproveitar as ferramentas de solução de problemas?
Consulte [Exemplos imediatos](spark-troubleshooting-agent-prompt-examples.md) para obter exemplos imediatos sobre como aproveitar as ferramentas de solução de problemas.
### 3. Quais dados são transmitidos ao LLM e como são tratados?
Os dados e arquivos do cliente permanecem na AWS região escolhida e não são transmitidos entre regiões. Quando o agente opera em uma região que usa inferência global entre regiões do Amazon Bedrock, o serviço pode encaminhar solicitações para a região mais próxima com capacidade disponível, dependendo da demanda. Nesses casos, somente os metadados extraídos dos registros do cliente e os resultados de inferência processados são transmitidos, não os dados ou arquivos subjacentes do cliente. Todos os dados são mascarados com PII antes de serem enviados ao LLM para processamento, independentemente de a inferência ocorrer na mesma região ou ser roteada para outra região. Para obter mais detalhes sobre como a inferência entre regiões funciona e quais regiões são afetadas, consulte. [Processamento entre regiões para o agente de solução de problemas do Apache Spark](spark-troubleshooting-cross-region-processing.md)
# Detalhes do fluxo de trabalho do agente de solução de problemas do Spark
Para iniciar o processo de solução de problemas, você precisará acessar seus identificadores de aplicativos Spark com falha em execução em plataformas compatíveis (EMR-EC2, EMR Serverless, Glue ou Amazon Data Notebooks). AWS SageMaker O aplicativo deve ter registros acessíveis, Spark History Server e detalhes de configuração. Certifique-se de ter as permissões necessárias para acessar os recursos da plataforma e os metadados do aplicativo. Depois que esses requisitos forem estabelecidos, você poderá enviar uma solicitação como a seguinte para iniciar o fluxo de trabalho de solução de problemas:
```
Analyze my EMR step execution failure, EMR id with cluster id
```
Nesse momento, o agente orquestrará a solução de problemas usando ferramentas especializadas. O fluxo de trabalho segue estas etapas:
1. **Extração de recursos e criação de contexto**: o agente coleta e analisa automaticamente os dados de telemetria do seu aplicativo Spark, incluindo registros do History Server, configurações e rastreamentos de erros. Você verá a ferramenta reunindo informações sobre métricas de desempenho, padrões de utilização de recursos e assinaturas de falhas.
1. **Análise e identificação da causa raiz**: o agente aproveita os modelos de IA e a base de conhecimento do Spark para correlacionar os recursos extraídos e identificar as causas-raiz de problemas ou falhas de desempenho. Você receberá:
+ **Analysis Insights**: detalhes técnicos sobre o que o agente descobriu e analisou.
+ **Causa raiz**: explicação clara do que deu errado e por quê.
+ **Avaliação inicial**: se o problema estiver relacionado ao código, à configuração ou aos recursos, algumas orientações e análises gerais serão fornecidas para mitigação.
1. **Recomendações de código** (se aplicável): se a análise identificar problemas relacionados ao código com base na classificação do erro, o agente pode sugerir o uso da ferramenta de recomendação de código para fornecer recomendações específicas para implementar a correção de código recomendada com o before/after código exato junto com as substituições sugeridas.
O processo de solução de problemas é iterativo: você pode continuar a conversa para se aprofundar em problemas específicos; você também pode usar as ferramentas de forma interativa em nosso desenvolvimento de código Spark local para resolver bugs de código ou melhorar seu código continuamente.
# Exemplos imediatos
Aqui está uma lista de exemplos imediatos que podem ser usados na experiência de solução de problemas.
## 1. Solucionar problemas de falha na execução do trabalho do Spark
Solução de problemas do EMR no EC2:
```
Troubleshoot my EMR-EC2 step with id s-xxxxxxxxxxxx on cluster j-xxxxxxxxxxxxx
```
Solução de problemas do Glue Job:
```
Troubleshoot my Glue job with job run id jr_xxxxxxxxxxxxxxxxxxxxxxxxxxxx and job name test_job
```
Solução de problemas do EMR Serverless:
```
Troubleshoot my EMR-Serverless job run with application id 00xxxxxxxx and job run id 00xxxxxxxx
```
## 2. Solicitação de recomendação de correção de código
Solicite a recomendação de correção de código para o EMR no trabalho do EC2:
```
Recommend code fix for my EMR-EC2 step with id s-STEP_ID on cluster j-CLUSTER_ID
```
Solicite a recomendação de correção do código para o Glue job:
```
Recommend code fix for my Glue job with job run id jr_JOB_RUN_ID and job name test_job
```
# Configuração da função do IAM
A CloudFormation pilha nas Instruções de configuração automatiza a configuração da função do IAM para você. Se você quiser executá-lo manualmente, siga as instruções abaixo:
## Configuração da função do IAM para o servidor MCP
Para acessar o servidor MCP gerenciado do SMUS, é necessária uma função do IAM com a seguinte política em linha:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "AllowUseSagemakerUnifiedStudioMcpServer",
"Effect": "Allow",
"Action": [
"sagemaker-unified-studio-mcp:InvokeMcp",
"sagemaker-unified-studio-mcp:CallReadOnlyTool",
"sagemaker-unified-studio-mcp:CallPrivilegedTool"
],
"Resource": [
"*"
]
}
]
}
```
Nas próximas etapas, criaremos um perfil para essa função. Qualquer conta que assuma essa função para obter as credenciais deve ser adicionada à política de assumir função.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "AllowAccountToAssumeRole",
"Effect": "Allow",
"Principal": { "AWS": "arn:aws:iam:::root" },
"Action": "sts:AssumeRole"
}
]
}
```
## Permissões adicionais por modo de implantação (EMR-EC2/EMR-S/Glue)
### Aplicativos do EMR-EC2
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "EMREC2ReadAccess",
"Effect": "Allow",
"Action": [
"elasticmapreduce:DescribeCluster",
"elasticmapreduce:DescribeStep",
"elasticmapreduce:ListSteps",
"elasticmapreduce:ListClusters",
"elasticmapreduce:DescribeJobFlows"
],
"Resource": [
"*"
]
},
{
"Sid": "EMRS3LogAccess",
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:ListBucket"
],
"Resource": "*"
},
{
"Sid": "EMRPersistentApp",
"Effect": "Allow",
"Action": [
"elasticmapreduce:CreatePersistentAppUI",
"elasticmapreduce:DescribePersistentAppUI",
"elasticmapreduce:GetPersistentAppUIPresignedURL"
],
"Resource": [
"*"
]
}
]
}
```
### Glue Jobs
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "GlueReadAccess",
"Effect": "Allow",
"Action": [
"glue:GetJob",
"glue:GetJobRun",
"glue:GetJobRuns",
"glue:GetJobs",
"glue:BatchGetJobs"
],
"Resource": [
"arn:aws:glue:*::job/*"
]
},
{
"Sid": "GlueCloudWatchLogsAccess",
"Effect": "Allow",
"Action": [
"logs:GetLogEvents",
"logs:FilterLogEvents"
],
"Resource": [
"arn:aws:logs:*::log-group:/aws/glue/*"
]
},
{
"Sid": "GlueSparkWebUI",
"Effect": "Allow",
"Action": [
"glue:RequestLogParsing",
"glue:GetLogParsingStatus",
"glue:GetEnvironment",
"glue:GetStage",
"glue:GetStages",
"glue:GetStageFiles",
"glue:BatchGetStageFiles",
"glue:GetStageAttempt",
"glue:GetStageAttemptTaskList",
"glue:GetStageAttemptTaskSummary",
"glue:GetExecutors",
"glue:GetExecutorsThreads",
"glue:GetStorage",
"glue:GetStorageUnit",
"glue:GetQueries",
"glue:GetQuery",
"glue:GetDashboardUrl"
],
"Resource": [
"arn:aws:glue:*::job/*"
]
},
{
"Sid": "GluePassRoleAccess",
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": "*",
"Condition": {
"StringLike": {
"iam:PassedToService": "glue.amazonaws.com"
}
}
}
]
}
```
### Aplicativos EMR sem servidor
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "EMRServerlessReadAccess",
"Effect": "Allow",
"Action": [
"emr-serverless:GetJobRun",
"emr-serverless:GetApplication",
"emr-serverless:ListApplications",
"emr-serverless:ListJobRuns",
"emr-serverless:ListJobRunAttempts",
"emr-serverless:GetDashboardForJobRun",
"emr-serverless:ListTagsForResource"
],
"Resource": [
"*"
]
},
{
"Sid": "EMRServerlessCloudWatchLogsAccess",
"Effect": "Allow",
"Action": [
"logs:GetLogEvents",
"logs:FilterLogEvents"
],
"Resource": [
"arn:aws:logs:*::log-group:/aws/emr-serverless/*"
]
},
{
"Sid": "EMRServerlessS3LogsAccess",
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:ListBucket"
],
"Resource": "*"
}
]
}
```
### Permissões do KMS - Registros CloudWatch
Se os CloudWatch registros forem criptografados com uma CMK, adicione a política a seguir para que o serviço possa ler os registros do aplicativo EMR-Serverless.
```
{
"Effect": "Allow",
"Action": [
"kms:Decrypt",
"kms:DescribeKey"
],
"Resource": "arn:aws:kms:::key/"
}
```
# Usando as ferramentas de solução de problemas do Spark
## Ferramentas de solução de problemas disponíveis
O serviço MCP fornece ferramentas diferentes para o agente de solução de problemas do Spark. As principais ferramentas são as seguintes:
| Nome da ferramenta | Categoria da ferramenta | Description |
| --- | --- | --- |
| carga de trabalho analyze\$1spark\$1 | Análise da causa raiz | Fornece solução de problemas detalhada para cargas de trabalho do Apache Spark com falha |
| spark\$1code\$1recommendation | Recomendação de correção de código | Fornece recomendações de código do Apache Spark para trabalhos com falha |
# Configurando endpoints VPC de interface para SageMaker Amazon Unified Studio MCP
Você pode estabelecer uma conexão privada entre sua VPC e o serviço MCP do Amazon SageMaker Unified Studio criando uma interface *VPC* endpoint. Os endpoints de interface são alimentados pela [Amazon VPC](https://aws.amazon.com/vpc/), que permite que você acesse de forma privada o servidor MCP em sua VPC sem um gateway de internet, dispositivo NAT, conexão VPN ou conexão. As instâncias em sua VPC não precisam de endereços IP públicos para se comunicar com o serviço MCP, e o tráfego entre sua VPC e o serviço MCP não sai da rede Amazon.
Cada endpoint de interface é representado por uma ou mais [interfaces de rede elástica](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html) em suas sub-redes VPC. Para obter mais informações, consulte [Interface VPC endpoints](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html) no Guia do usuário da Amazon *VPC*.
## Etapa 1: Criar uma interface VPC endpoint para o Amazon SageMaker Unified Studio MCP
Você pode criar um VPC endpoint para o serviço MCP do Amazon SageMaker Unified Studio usando o console Amazon VPC ou o. AWS CLI Para obter mais informações, consulte [Criar um endpoint de interface](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html#create-interface-endpoint) no *Guia do usuário da Amazon VPC*.
Crie um VPC endpoint para o Amazon SageMaker Unified Studio MCP usando o seguinte nome de serviço:
+ com.amazonaws. **. sagemaker-unified-studio-mcp
Se você habilitar o DNS privado para o endpoint, poderá fazer solicitações de API para o Amazon SageMaker Unified Studio MCP usando seu nome DNS padrão para a região, por exemplo, `sagemaker-unified-studio-mcp.us-east-1.api.aws`
Para mais informações, consulte [Acessar um serviço por um endpoint de interface](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html#access-service-though-endpoint) no *Guia do usuário da Amazon VPC*.
## Etapa 2: Criar uma política de VPC endpoint para o Amazon SageMaker Unified Studio MCP
Você pode anexar uma política de endpoint ao seu VPC endpoint que controla o acesso ao SageMaker Amazon Unified Studio MCP. Essa política especifica as seguintes informações:
+ A entidade principal que pode realizar ações.
+ As ações que podem ser realizadas.
+ Os recursos aos quais as ações podem ser aplicadas.
Para mais informações, consulte [Controlar o acesso a serviços com VPC endpoints](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints-access.html) no *Guia do usuário da Amazon VPC*.
### Exemplo: política de VPC endpoint para permitir que MCP acesse uma função específica do IAM
Veja a seguir um exemplo de uma política de endpoint para acesso MCP do Amazon SageMaker Unified Studio. Quando anexada a um endpoint, essa política concede acesso às ações MCP listadas do Amazon SageMaker Unified Studio para uma função específica do IAM principal em todos os recursos.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::ACCOUNT-ID:role/YourRoleName"
},
"Action": [
"sagemaker-unified-studio-mcp:InvokeMcp",
"sagemaker-unified-studio-mcp:CallReadOnlyTool",
"sagemaker-unified-studio-mcp:CallPrivilegedTool"
],
"Resource": "*"
}
]
}
```
## Etapa 3: testar sua VPC
O `curl` comando valida a conectividade de end-to-end rede da sua rede VPC (EC2) com o VPC endpoint fazendo uma solicitação. HTTP/HTTPS Uma resposta curl recebendo uma mensagem de volta do servidor MCP confirma que o caminho completo da rede está funcionando.
### Método 1: com o DNS privado ativado (recomendado)
```
curl https://sagemaker-unified-studio-mcp.us-east-1.api.aws/spark-troubleshooting/mcp
```
### Método 2: Sem o DNS privado ativado
```
curl -k https://vpce-0069xxxx-ejwhxxx.sagemaker-unified-studio-mcp.us-east-1.vpce.amazonaws.com/spark-troubleshooting/mcp
```
**nota**
O `-k` sinalizador ignora a verificação do certificado SSL devido à incompatibilidade do nome do host entre o nome DNS do VPC endpoint e o nome comum (CN) do certificado.
Em ambos os casos, o comando curl retorna uma resposta:`{"Message":"...."}`. Retornar com uma mensagem verifica a conectividade bem-sucedida do caminho de rede com o VPC endpoint do serviço MCP.
## Etapa 4: começar a usar o endpoint MCP VPC
Depois de verificar a conexão, você pode seguir as etapas para configurar o MCP em[Configuração do agente de solução de problemas](spark-troubleshooting-agent-setup.md). Basta usar o endpoint VPC privado em sua configuração de MCP.
# Processamento entre regiões para o agente de solução de problemas do Apache Spark
O agente de solução de problemas do Apache Spark usa inferência entre regiões para processar solicitações de linguagem natural e gerar respostas. Com a inferência entre regiões, o agente encaminha automaticamente sua solicitação de inferência para otimizar o desempenho, maximizando os recursos computacionais disponíveis e a disponibilidade do modelo, além de fornecer a melhor experiência ao cliente. O tipo de inferência entre regiões usada depende da região em que você executa o Apache Spark Troubleshooting Agent. Na maioria das regiões, o agente seleciona a região ideal em sua geografia para processar suas solicitações de inferência. No entanto, em algumas regiões, uma solicitação de inferência feita pelo agente é roteada com segurança para todos os recursos computacionais disponíveis em todas as regiões comerciais globais. AWS
## Inferência entre regiões
O agente de solução de problemas do Apache Spark é desenvolvido pelo Amazon Bedrock e usa inferência entre regiões para distribuir o tráfego em diferentes AWS regiões para aprimorar o desempenho e a confiabilidade da inferência do modelo de linguagem grande (LLM).
Embora a inferência entre regiões não mude onde seu aplicativo Spark ou sua experiência de solução de problemas estão hospedados ou seus dados são armazenados, seus prompts de entrada e resultados de saída podem ser transmitidos para regiões diferentes para processamento de inferência. Todos os dados são transmitidos criptografados pela rede segura da Amazon.
Não há custo adicional para usar a inferência entre regiões.
## Regiões suportadas para inferência entre regiões
**Regiões usando inferência geográfica entre regiões**
Para a maioria das regiões, as solicitações de inferência entre regiões são mantidas em AWS regiões que fazem parte da mesma geografia em que você executa o agente de solução de problemas do Apache Spark. Por exemplo, uma solicitação feita pelo agente na região Leste dos EUA (Norte da Virgínia) é encaminhada somente para AWS regiões dentro da geografia dos Estados Unidos da América. A tabela a seguir descreve para quais regiões suas solicitações podem ser encaminhadas, dependendo da geografia de origem da solicitação:
| Geografia suportada | Regiões de inferência |
| --- | --- |
| Estados Unidos | Leste dos EUA (Norte da Virgínia) (us-east-1), Oeste dos EUA (Oregon) (us-west-2), Leste dos EUA (Ohio) (us-east-2), Oeste dos EUA (Norte da Califórnia) (us-west-1) |
| Europa | Europa (Frankfurt) (eu-central-1), Europa (Irlanda) (eu-west-1), Europa (Paris) (eu-west-3), Europa (Estocolmo) (eu-north-1), Europa (Londres) (eu-west-2) |
| Ásia-Pacífico | Ásia-Pacífico (Tóquio) (ap-northeast-1), Ásia-Pacífico (Seul) (ap-northeast-2), Ásia-Pacífico (Mumbai) (ap-south-1) |
### Regiões usando inferência global entre regiões
**Importante**
As seguintes AWS regiões usam inferência global entre regiões. Quando você usa o agente de solução de problemas do Apache Spark nessas regiões, suas solicitações podem ser transmitidas globalmente para outras AWS regiões para processamento de inferência para otimizar o desempenho e a disponibilidade:
América do Sul (São Paulo) (sa-east-1)
Ásia-Pacífico (Singapura) (ap-southeast-1)
Ásia-Pacífico (Sydney) (ap-southeast-2)
Canadá (Central) (ca-central-1)
# Registro de chamadas MCP do Amazon SageMaker Unified Studio usando AWS CloudTrail
O Amazon SageMaker Unified Studio MCP Server está integrado com AWS CloudTrail, um serviço que fornece um registro das ações realizadas por um usuário, função ou AWS serviço no Amazon SageMaker Unified Studio MCP Server. CloudTrail captura todas as chamadas de API para o Amazon SageMaker Unified Studio MCP Server como eventos. As chamadas capturadas incluem chamadas para o Amazon SageMaker Unified Studio MCP Server e chamadas de código para outras AWS operações durante a execução da ferramenta a partir do SageMaker Unified Studio MCP Server. Se você criar uma trilha, poderá habilitar a entrega contínua de CloudTrail eventos para um bucket do Amazon S3, incluindo eventos para o Amazon SageMaker Unified Studio MCP Server. Se você não configurar uma trilha, ainda poderá ver os eventos mais recentes no CloudTrail console no **Histórico de eventos**. Usando as informações coletadas por CloudTrail, você pode determinar a solicitação que foi feita ao Amazon SageMaker Unified Studio MCP Server, o endereço IP a partir do qual a solicitação foi feita, quem fez a solicitação, quando ela foi feita e detalhes adicionais.
Para saber mais sobre isso CloudTrail, consulte o [Guia AWS CloudTrail do usuário](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/).
## Informações do Amazon SageMaker Unified Studio MCP Server em CloudTrail
CloudTrail é ativado em sua AWS conta quando você cria a conta. Quando a atividade ocorre no Amazon SageMaker Unified Studio MCP Server, essa atividade é registrada em um CloudTrail evento junto com outros eventos de AWS serviço no **histórico** de eventos. Você pode visualizar, pesquisar e baixar eventos recentes em sua AWS conta. Para obter mais informações, consulte [Visualização de eventos com histórico de CloudTrail eventos](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/view-cloudtrail-events.html).
Para um registro contínuo dos eventos em sua AWS conta, incluindo eventos do SageMaker Unified Studio MCP Server, crie uma trilha. Uma trilha permite CloudTrail entregar arquivos de log para um bucket do Amazon S3. Por padrão, quando você cria uma trilha no console, a trilha se aplica a todas as AWS regiões. A trilha registra eventos de todas as regiões na AWS partição e entrega os arquivos de log ao bucket do Amazon S3 que você especificar. Além disso, você pode configurar outros AWS serviços para analisar e agir com base nos dados de eventos coletados nos CloudTrail registros. Para saber mais, consulte:
+ [Visão geral da criação de uma trilha](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail.html)
+ [CloudTrail serviços e integrações suportados](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-aws-service-specific-topics.html)
+ [Configurando notificações do Amazon SNS para CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/configure-sns-notifications-for-cloudtrail.html)
+ [Recebendo arquivos de CloudTrail log de várias regiões](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/receive-cloudtrail-log-files-from-multiple-regions.html) e [Recebendo arquivos de CloudTrail log de várias contas](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-receive-logs-from-multiple-accounts.html)
Todas as invocações da ferramenta SageMaker Unified Studio MCP Server e chamadas de API para AWS serviços durante as execuções da ferramenta são registradas por. CloudTrail Por exemplo, chamadas para as diferentes ferramentas e chamadas AWS de serviço feitas a partir das ferramentas geram entradas nos arquivos de CloudTrail log.
Cada entrada de log ou evento contém informações sobre quem gerou a solicitação. As informações de identidade ajudam a determinar:
+ Se a solicitação foi feita com credenciais de usuário-raiz ou usuário do IAM.
+ Se a solicitação foi feita com credenciais de segurança temporárias de um perfil ou de um usuário federado.
+ Se a solicitação foi feita por outro AWS serviço.
Para obter mais informações, consulte [Elemento userIdentity do CloudTrail ](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-user-identity.html).
## Entendendo as entradas do arquivo de log do Amazon SageMaker Unified Studio MCP Server
Uma trilha é uma configuração que permite a entrega de eventos como arquivos de log para um bucket do Amazon S3 que você especificar. CloudTrail os arquivos de log contêm uma ou mais entradas de log. Um evento representa uma única solicitação de qualquer fonte e inclui informações sobre a ação solicitada, a data e a hora da ação, os parâmetros da solicitação e assim por diante. CloudTrail os arquivos de log não são um rastreamento de pilha ordenado das chamadas públicas de API, portanto, eles não aparecem em nenhuma ordem específica.
O exemplo a seguir mostra uma entrada de CloudTrail registro que demonstra a `CallTool` ação.
```
{
"eventVersion": "1.09",
"userIdentity": {
...
},
"eventTime": "...",
"eventSource": "sagemaker-unified-studio-mcp.amazonaws.com",
"eventName": "CallPrivilegedTool",
"awsRegion": "us-east-1",
"sourceIPAddress": "...",
"userAgent": "...",
"requestParameters": {
"id": 1,
"method": "tools/call",
"params": {
"name": "generate_spark_upgrade_plan",
"arguments": "***",
"_meta": {
"progressToken": 1
}
},
"jsonrpc": "2.0"
},
"responseElements": {
"result": {
"content": "***",
"structuredContent": "***",
"isError": false
},
"id": 1,
"jsonrpc": "2.0"
},
"requestID": "12345678-1234-1234-1234-123456789012",
"eventID": "87654321-4321-4321-4321-210987654321",
"readOnly": false,
"eventType": "AwsMcpEvent",
"managementEvent": true,
"recipientAccountId": "123456789012",
"eventCategory": "Management"
}
```
O exemplo a seguir mostra uma entrada de CloudTrail registro que demonstra a `AddJobFlowSteps` ação do Amazon SageMaker Unified Studio MCP durante a invocação de uma ferramenta de upgrade.
```
{
"eventVersion": "1.11",
"userIdentity": {
"type": "AssumedRole",
"principalId": "...",
"arn": "...",
"accountId": "123456789012",
"accessKeyId": "...",
"sessionContext": {
...
},
"invokedBy": "sagemaker-unified-studio-mcp.amazonaws.com"
},
"eventTime": "...",
"eventSource": "elasticmapreduce.amazonaws.com",
"eventName": "AddJobFlowSteps",
"awsRegion": "us-east-1",
"sourceIPAddress": "sagemaker-unified-studio-mcp.amazonaws.com",
"userAgent": "sagemaker-unified-studio-mcp.amazonaws.com",
"requestParameters": {
"jobFlowId": "j-2PY4KXXXXXX63",
"steps": [
...
]
},
"responseElements": {
"stepIds": [
...
]
},
"requestID": "12345678-1234-1234-1234-123456789013",
"eventID": "87654321-4321-4321-4321-210987654322",
"readOnly": false,
"eventType": "AwsApiCall",
"managementEvent": true,
"recipientAccountId": "123456789012",
"sharedEventID": "12345678-1234-1234-1234-123456789012",
"vpcEndpointId": "sagemaker-unified-studio-mcp.amazonaws.com",
"vpcEndpointAccountId": "sagemaker-unified-studio-mcp.amazonaws.com",
"eventCategory": "Management"
}
```
# Melhorias de serviço para agentes Apache Spark
O agente Apache Spark para Amazon EMR pode usar conteúdo, por exemplo, para ajudar o agente a fornecer melhores respostas a perguntas comuns, corrigir problemas operacionais ou para depuração.
## Conteúdo que AWS pode ser usado para melhoria do serviço
+ Suas solicitações em linguagem natural e respostas geradas pelos agentes do Apache Spark para Amazon EMR, Glue e Amazon Notebooks AWS SageMaker
## Conteúdo que AWS não é usado para melhorar o serviço
+ Código que você mesmo escreve para os aplicativos Spark
+ SageMaker Contexto e metadados do notebook
+ Dados do seu AWS Glue Data Catalog ou de outras fontes de dados
Somente funcionários da Amazon terão acesso aos dados. Sua confiança, privacidade e segurança do conteúdo do cliente são nossa maior prioridade e garantem que nosso uso esteja em conformidade com nossos compromissos com você. Para obter mais informações, consulte Perguntas frequentes sobre a privacidade de dados da .
## Como optar por não participar
Para cancelar a coleta de dados para os agentes do Apache Spark, configure uma política de exclusão de serviços de IA em Organizations AWS for Amazon SageMaker Unified Studio MCP Service. Para obter mais informações, consulte [Políticas de exclusão dos serviços de IA](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_ai-opt-out.html) no *Guia do usuário do AWS Organizations*.
Quando você configura uma política de exclusão de serviços de IA, ela tem os seguintes efeitos:
+ AWS excluirá os dados coletados e armazenados para melhoria do serviço antes de sua exclusão (se houver).
+ Depois de optar por não participar, não AWS coletará nem armazenará mais esses dados.
+ AWS não usará mais seu conteúdo para melhorar o serviço.
# Otimizar a performance do Spark
O Amazon EMR fornece vários atributo de otimização de performance para o Spark. Este tópico explica detalhadamente cada recurso de otimização.
Para obter mais informações sobre como definir a configuração do Spark, consulte [Configurar o Spark](emr-spark-configure.md).
## Execução adaptável de consultas
A execução adaptável de consultas é uma estrutura para a reotimização de planos de consulta com base nas estatísticas de runtime. Desde o Amazon EMR 5.30.0, as otimizações da execução adaptável de consultas do Apache Spark 3 descritas a seguir estão disponíveis no Runtime do Amazon EMR para Apache Spark 2.
+ Conversão adaptável de junções
+ Aglutinação adaptável de partições aleatórias
**Conversão adaptável de junções**
A conversão adaptativa de junções melhora o desempenho da consulta ao converter sort-merge-join operações em broadcast-hash-joins operações com base nos tamanhos de tempo de execução dos estágios da consulta. Broadcast-hash-joinstendem a ter um melhor desempenho quando um lado da junção é pequeno o suficiente para transmitir com eficiência sua saída para todos os executores, evitando assim a necessidade de trocar aleatoriamente e classificar os dois lados da junção. A conversão adaptativa de junções amplia a variedade de casos em que o Spark funciona automaticamente. broadcast-hash-joins
Esse recurso está habilitado por padrão. Ele pode ser desabilitado pela definição de `spark.sql.adaptive.enabled` como `false`, o que também desabilita a estrutura adaptável de execução de consultas. O Spark decide converter a em a broadcast-hash-join quando sort-merge-join a estatística do tamanho do tempo de execução de um dos lados da junção não excede`spark.sql.autoBroadcastJoinThreshold`, cujo padrão é 10.485.760 bytes (10 MiB).
**Aglutinação adaptável de partições aleatórias**
A aglutinação adaptável de partições aleatórias melhora a performance das consultas ao aglutinar pequenas partições aleatórias contíguas para evitar a sobrecarga de ter muitas tarefas pequenas. Isso permite que você configure antecipadamente um número maior de partições aleatórias iniciais que, em seguida, são reduzidas em runtime para um tamanho desejado, aumentando as probabilidades da existência de partições aleatórias distribuídas mais uniformemente.
Esse atributo é habilitado por padrão, a menos que `spark.sql.shuffle.partitions` seja definido explicitamente. Ele pode ser habilitado pela definição de `spark.sql.adaptive.coalescePartitions.enabled` como `true`. O número inicial de partições aleatórias e o tamanho da partição de destino podem ser ajustados com o uso das propriedades `spark.sql.adaptive.coalescePartitions.minPartitionNum` e `spark.sql.adaptive.advisoryPartitionSizeInBytes`, respectivamente. Consulte a tabela a seguir para obter mais detalhes sobre as propriedades do Spark relacionadas a esse atributo.
**Propriedades da partição de aglutinação adaptável do Spark**
| Propriedade | Valor padrão | Description |
| --- | --- | --- |
| `spark.sql.adaptive.coalescePartitions.enabled` | verdadeiro, a menos que `spark.sql.shuffle.partitions` seja explicitamente definido | Quando verdadeiro e spark.sql.adaptive.enabled é verdadeiro, o Spark aglutina partições aleatórias contíguas de acordo com o tamanho de destino (especificado por `spark.sql.adaptive.advisoryPartitionSizeInBytes`), para evitar muitas tarefas pequenas. |
| `spark.sql.adaptive.advisoryPartitionSizeInBytes` | 64 MB | O tamanho do comunicado, em bytes, da partição aleatória durante a aglutinação. Essa configuração só tem efeito quando `spark.sql.adaptive.enabled` e `spark.sql.adaptive.coalescePartitions.enabled` são ambos `true`. |
| `spark.sql.adaptive.coalescePartitions.minPartitionNum` | 25 | O número mínimo de partições aleatórias após a aglutinação. Essa configuração só tem efeito quando `spark.sql.adaptive.enabled` e `spark.sql.adaptive.coalescePartitions.enabled` são ambos `true`. |
| `spark.sql.adaptive.coalescePartitions.initialPartitionNum` | 1000 | O número inicial de partições aleatórias antes da aglutinação. Essa configuração só tem efeito quando `spark.sql.adaptive.enabled` e `spark.sql.adaptive.coalescePartitions.enabled` são ambos `true`. |
## Corte de partição dinâmico
O corte de partição dinâmico melhora o desempenho da tarefa selecionando as partições específicas com mais precisão em uma tabela que precisa ser lida e processada em uma consulta específica. Reduzindo a quantidade de dados que são lidos e processados, um tempo significativo é economizado na execução da tarefa. Com o Amazon EMR 5.26.0, esse atributo é habilitado por padrão. Com o Amazon EMR 5.24.0 e 5.25.0, é possível habilitar esse atributo ao definir a propriedade `spark.sql.dynamicPartitionPruning.enabled` do Spark no próprio Spark ou ao criar clusters.
**Propriedades do corte de partição dinâmico do Spark**
| Propriedade | Valor padrão | Description |
| --- | --- | --- |
| `spark.sql.dynamicPartitionPruning.enabled` | `true` | Quando verdadeiro, habilite o corte de partição dinâmico. |
| `spark.sql.optimizer.dynamicPartitionPruning.enforceBroadcastReuse` | `true` | Quando `true`, o Spark conduz uma verificação defensiva antes da execução da consulta para garantir que a reutilização de trocas de transmissão em filtros de corte dinâmico não seja interrompida por regras de preparação posteriores, como regras colunares definidas pelo usuário. Quando a reutilização é interrompida e essa configuração é `true`, o Spark remove os filtros de corte dinâmico afetados para evitar problemas de performance e correção. Podem surgir problemas de correção quando a troca de transmissão do filtro de corte dinâmico produz resultados diferentes e inconsistentes da troca de transmissão da operação de junção correspondente. A definição dessa configuração como `false` deve ser feita com cuidado; ela permite contornar cenários, como quando a reutilização é interrompida por regras colunares definidas pelo usuário. Quando a execução adaptável de consultas está habilitada, a reutilização da transmissão sempre é imposta. |
Essa otimização melhora as capacidades existentes do Spark 2.4.2, que tem suporte apenas à redução de predicados estáticos que podem ser resolvidos na hora do planejamento.
Veja a seguir exemplos de redução de predicados estáticos no Spark 2.4.2.
```
partition_col = 5
partition_col IN (1,3,5)
partition_col between 1 and 3
partition_col = 1 + 3
```
O corte de partição dinâmico permite que o mecanismo do Spark deduza dinamicamente no runtime quais partições precisam ser lidas e quais podem ser eliminadas com segurança. Por exemplo, a consulta a seguir envolve duas tabelas: a tabela `store_sales` contém as vendas totais de todas as lojas e é particionada por região, e a tabela `store_regions` contém um mapeamento de regiões por país. As tabelas contêm dados sobre as lojas que estão distribuídas pelo mundo, mas estão consultado dados somente para a América do Norte.
```
select ss.quarter, ss.region, ss.store, ss.total_sales
from store_sales ss, store_regions sr
where ss.region = sr.region and sr.country = 'North America'
```
Sem o corte de partição dinâmico, essa consulta lerá todas as regiões antes de filtrar o subconjunto de regiões que corresponde aos resultados da subconsulta. Com o corte de partição dinâmico, essa consulta lerá e processará apenas as partições para as regiões retornadas na subconsulta. Isso economiza tempo e recursos ao ler menos dados do armazenamento e processar menos registros.
## Nivelamento de subconsultas escalares
Esta otimização melhora o desempenho de consultas que têm subconsultas escalares na mesma tabela. Com o Amazon EMR 5.26.0, esse atributo é habilitado por padrão. Com o Amazon EMR 5.24.0 e 5.25.0, é possível habilitá-lo definindo a propriedade `spark.sql.optimizer.flattenScalarSubqueriesWithAggregates.enabled` do Spark no próprio Spark ou ao criar clusters. Quando essa propriedade é definida como true, o otimizador de consultas nivela as subconsultas escalares que usam a mesma relação, quando possível. As subconsultas escalares são niveladas enviando qualquer predicado presente na subconsulta para as funções agregadas e executando uma agregação, com todas as funções agregadas, por relação.
Veja a seguir um exemplo de consulta que se beneficia dessa otimização.
```
select (select avg(age) from students /* Subquery 1 */
where age between 5 and 10) as group1,
(select avg(age) from students /* Subquery 2 */
where age between 10 and 15) as group2,
(select avg(age) from students /* Subquery 3 */
where age between 15 and 20) as group3
```
A otimização reescreve a consulta anterior como:
```
select c1 as group1, c2 as group2, c3 as group3
from (select avg (if(age between 5 and 10, age, null)) as c1,
avg (if(age between 10 and 15, age, null)) as c2,
avg (if(age between 15 and 20, age, null)) as c3 from students);
```
Observe que a consulta regravada lê a tabela do estudante somente uma vez, e os predicados das três subconsultas são enviados para a função `avg`.
## DISTINCT antes de INTERSECT
Esta otimização otimiza junções usando INTERSECT. Com o Amazon EMR 5.26.0, esse atributo é habilitado por padrão. Com o Amazon EMR 5.24.0 e 5.25.0, é possível habilitá-lo definindo a propriedade `spark.sql.optimizer.distinctBeforeIntersect.enabled` do Spark no próprio Spark ou ao criar clusters. As consultas que usam INTERSECT são automaticamente convertidas para usar uma junção Left-Semi Join. Quando essa propriedade é definida como verdadeira, o otimizador de consultas envia o operador DISTINCT para os filhos de INTERSECT se detectar que o operador DISTINCT pode fazer com que a junção semi esquerda seja a em vez de a. BroadcastHashJoin SortMergeJoin
Veja a seguir um exemplo de consulta que se beneficia dessa otimização.
```
(select item.brand brand from store_sales, item
where store_sales.item_id = item.item_id)
intersect
(select item.brand cs_brand from catalog_sales, item
where catalog_sales.item_id = item.item_id)
```
Sem habilitar essa propriedade `spark.sql.optimizer.distinctBeforeIntersect.enabled`, a consulta será regravada do modo a seguir.
```
select distinct brand from
(select item.brand brand from store_sales, item
where store_sales.item_id = item.item_id)
left semi join
(select item.brand cs_brand from catalog_sales, item
where catalog_sales.item_id = item.item_id)
on brand <=> cs_brand
```
Quando você habilita essa propriedade `spark.sql.optimizer.distinctBeforeIntersect.enabled`, a consulta pode ser regravada do modo a seguir.
```
select brand from
(select distinct item.brand brand from store_sales, item
where store_sales.item_id = item.item_id)
left semi join
(select distinct item.brand cs_brand from catalog_sales, item
where catalog_sales.item_id = item.item_id)
on brand <=> cs_brand
```
## Junção com filtro Bloom
Essa otimização pode melhorar o desempenho de algumas junções ao fazer uma pré-filtragem de um lado de uma junção usando um [filtro Bloom](https://en.wikipedia.org/wiki/Bloom_filter) gerado pelos valores do outro lado da junção. Com o Amazon EMR 5.26.0, esse atributo é habilitado por padrão. Com o Amazon EMR 5.25.0, é possível habilitar esse atributo definindo a propriedade `spark.sql.bloomFilterJoin.enabled` do Spark como `true` no próprio Spark ou ao criar clusters.
Veja a seguir um exemplo de consulta que podem se beneficiar de um filtro Bloom.
```
select count(*)
from sales, item
where sales.item_id = item.id
and item.category in (1, 10, 16)
```
Quando esse recurso está habilitado, o filtro Bloom é criado de todos os IDs de itens cuja categoria está no conjunto de categorias que está sendo consultado. Ao verificar a tabela de vendas, o filtro Bloom é usado para determinar quais são as vendas de itens que definitivamente não estão no conjunto definido pelo filtro Bloom. Assim, o filtro pode excluir essas vendas identificadas o mais cedo possível.
## Reordenação de junção otimizada
Essa otimização pode melhorar o desempenho de consultas reordenando junções que envolvem tabelas com filtros. Com o Amazon EMR 5.26.0, esse atributo é habilitado por padrão. Com o Amazon EMR 5.25.0, é possível habilitar esse atributo definindo o parâmetro de configuração `spark.sql.optimizer.sizeBasedJoinReorder.enabled` do Spark como verdadeiro. O comportamento padrão no Spark é unir tabelas da esquerda para a direita, conforme listado na consulta. Essa estratégia pode perder oportunidades de executar junções menores com filtros primeiro a fim de beneficiar junções mais caras posteriormente.
O exemplo de consulta a seguir relata todos os itens devolvidos de todas as lojas de um país. Sem a reordenação de junção otimizada, o Spark une as duas tabelas grandes `store_sales` e `store_returns` primeiro, depois, as une a `store` e, por fim, a `item`.
```
select ss.item_value, sr.return_date, s.name, i.desc,
from store_sales ss, store_returns sr, store s, item i
where ss.id = sr.id and ss.store_id = s.id and ss.item_id = i.id
and s.country = 'USA'
```
Com reordenação de junção otimizada o Spark une `store_sales` a `store` primeiro, pois `store` tem um filtro e é menor que `store_returns` e `broadcastable`. Em seguida, o Spark une a `store_returns` e, por fim, a `item`. Se `item` tivesse um filtro e fosse possível de ser transmitido, ele também se qualificaria para a reordenação, resultando em `store_sales` se unindo a `store`, depois a `item` e, por fim, a `store_returns`.
# Armazenamento em Cache de Fragmentos Resultantes do Spark
As versões 6.6.0 e superiores do Amazon EMR incluem o recurso opcional Armazenamento em Cache de Fragmentos Resultantes, que automaticamente armazena em cache os fragmentos resultantes. Esses fragmentos resultantes são partes dos resultados de subárvores de consultas que são armazenadas em um bucket do Amazon S3 de sua escolha. Os fragmentos resultantes da consulta armazenados são reutilizados em execuções de consultas subsequentes, resultando em consultas mais rápidas.
O Armazenamento em Cache de Fragmentos Resultantes analisa as consultas do Spark e armazena em cache os fragmentos resultantes elegíveis no local especificado do S3. Em execuções subsequentes da consulta, os fragmentos resultantes utilizáveis da consulta são automaticamente detectados e obtidos no S3. O Armazenamento em Cache de Fragmentos Resultantes difere do Armazenamento em Cache de Conjuntos Resultantes, em que as consultas subsequentes precisam corresponder exatamente à consulta original para retornar os resultados do cache. Quando usado para consultas repetidamente direcionadas a um subconjunto estático dos dados, o Armazenamento em Cache de Fragmentos Resultantes acelera significativamente a performance.
Considere a consulta a seguir, que conta pedidos até o ano de 2022:
```
select
l_returnflag,
l_linestatus,
count(*) as count_order
from
lineitem
where
l_shipdate <= current_date
and year(l_shipdate) == '2022'
group by
l_returnflag,
l_linestatus
```
Com o passar do tempo, essa consulta precisa ser executada todos os dias para informar o total de vendas do ano. Sem o Armazenamento em Cache de Fragmentos Resultantes, os resultados de todos os dias do ano precisam ser recalculados todos os dias. A consulta ficará mais lenta com o tempo e será mais lenta no final do ano, quando todos os 365 dias de resultados precisarão ser recalculados.
Ao ativar o Armazenamento em Cache de Fragmentos Resultantes, você usa os resultados de todos os dias anteriores do ano com base no cache. A cada dia, o atributo deve recalcular apenas um dia de resultados. Depois que o atributo computa o fragmento resultante, o atributo armazena o fragmento em cache. Como resultado, os tempos de consultas habilitadas para cache são curtos e permanecem constantes para cada consulta subsequente.
## Habilitar o Armazenamento em Cache de Fragmentos Resultantes do Spark
Para habilitar o Armazenamento em Cache de Fragmentos Resultantes do Spark, execute as seguintes etapas:
1. Crie um bucket de cache no Amazon S3 e autorize o read/write acesso ao EMRFS. Para obter mais informações, consulte [Autorizar acesso aos dados do EMRFS no Amazon S3](emr-plan-credentialsprovider.md).
1. Defina a configuração do Spark no Amazon EMR para habilitar o recurso.
```
spark.subResultCache.enabled = true
spark.subResultCache.fs.root.path = s3://&example-s3-bucket;/cache_dir/
```
1. Habilite o gerenciamento do ciclo de vida do S3 para que o bucket limpe automaticamente os arquivos de cache.
1. Opcionalmente, configure as maxBufferSize propriedades reductionRationThreshold e para ajustar ainda mais o recurso.
```
spark.sql.subResultCache.reductionRatioThreshold
spark.sql.subResultCache.maxBufferSize
```
## Considerações ao usar o Armazenamento em Cache de Fragmentos Resultantes
A economia de custos obtida quando você usa resultados já armazenados em cache no Amazon S3 em vez de recalculá-los aumenta com o número de vezes que os mesmos resultados armazenados em cache podem ser usados. Consultas com verificações de grandes tabelas seguidas por filtros ou agregações de hash que reduzem o tamanho do resultado em um fator de pelo menos 8 (ou seja, uma proporção de pelo menos 8:1 em tamanho de entrada:resultados) serão as que mais se beneficiarão desse atributo. Quanto maior a taxa de redução entre a entrada e os resultados, maior a relação custo-benefício. Consultas com taxas de redução menores, mas que contêm etapas computacionais caras entre a verificação da tabela e o filtro ou as agregações, também serão beneficiadas, desde que o custo de produzir os resultados seja maior do que o custo de buscá-los no Amazon S3. Por padrão, o Armazenamento em Cache de Fragmentos Resultantes só entra em vigor quando detecta que uma taxa de redução será de pelo menos 8:1.
Quando suas consultas reutilizam repetidamente os resultados armazenados em cache, os benefícios desse atributo são maiores. Consultas em janelas contínuas e incrementais são bons exemplos. Por exemplo, uma consulta de janela contínua de 30 dias que já foi executada por 29 dias precisaria extrair apenas 1/30 dos dados de destino de sua fonte de entrada original e usaria fragmentos de resultados armazenados em cache nos 29 dias anteriores. Uma consulta de janela incremental se beneficiaria ainda mais, já que o início da janela permanece fixo: em cada invocação da consulta, uma porcentagem menor do processamento exigirá a leitura da fonte de entrada.
Veja a seguir considerações adicionais sobre o uso do Armazenamento em Cache de Fragmentos Resultantes:
+ As consultas que não têm como alvo os mesmos dados com os mesmos fragmentos de consulta terão uma baixa taxa de acertos de cache e, portanto, não se beneficiarão desse atributo.
+ Consultas com taxas de redução baixas que não contêm etapas de computação caras resultarão em resultados armazenados em cache que são aproximadamente tão caros de ler quanto de processar inicialmente.
+ A primeira consulta sempre demonstrará uma pequena regressão devido ao custo de gravação no cache.
+ O atributo Armazenamento em Cache de Fragmentos Resultantes funciona exclusivamente com arquivos Parquet. Arquivos em outros formatos não são compatíveis.
+ Os buffers do atributo Armazenamento em Cache de Fragmentos Resultantes só tentarão armazenar em cache verificações com tamanhos de divisão de arquivos de 128 MB ou mais. Com a configuração padrão do Spark, o Armazenamento em Cache de Fragmentos Resultantes será desabilitado se o tamanho da verificação (tamanho total de todos os arquivos que estão sendo verificados) dividido pelo número de núcleos do executor for menor que 128 MB. Quando qualquer uma das configurações do Spark listadas abaixo for definida, o tamanho da divisão de arquivos será:
```
min(maxPartitionBytes, max(openCostInBytes, scan size / minPartitionNum))
```
+ spark.sql. leafNodeDefaultParalelismo (o valor padrão é spark.default.parallelism)
+ spark.sql.files. minPartitionNum (o valor padrão é spark.sql. leafNodeDefaultParalelismo)
+ spark.sql.files. openCostInBytes
+ spark.sql.files. maxPartitionBytes
+ O atributo Armazenamento em Cache de Fragmentos Resultantes realiza o armazenamento em cache na granularidade da partição de Resilient Distributed Dataset (RDD - conjunto de dados resilientes e distribuídos). A taxa de redução descrita anteriormente, cujo padrão é 8:1, é avaliada por partição de RDD. Workloads com taxas de redução por RDD maiores e menores que 8:1 podem ter benefícios menores de performance do que workloads com taxas de redução por RDD consistentemente menores que 8:1.
+ O atributo Armazenamento em Cache de Fragmentos Resultantes usa um buffer de gravação de 16 MB por padrão para cada partição RDD armazenada em cache. Se mais de 16 MB forem armazenados em cache por partição RDD, o custo de determinar que uma gravação não é possível pode resultar em uma regressão de desempenho.
+ Embora, por padrão, o Armazenamento em Cache de Fragmentos Resultantes não tente armazenar em cache os resultados da partição de RDD com uma taxa de redução menor que 8:1 e limite seu buffer de gravação em 16 MB, esses dois valores podem ser ajustados por meio das seguintes configurações:
```
spark.sql.subResultCache.reductionRatioThreshold (default: 8.0)
spark.sql.subResultCache.maxBufferSize (default: 16MB, max: 64MB)
```
+ Vários clusters usando a mesma versão do Amazon EMR podem compartilhar o mesmo local de cache. Para garantir a exatidão dos resultados, o Armazenamento em Cache de Fragmentos Resultantes não usará resultados de cache gravados por diferentes versões do Amazon EMR.
+ O cache de fragmentos de resultados será desativado automaticamente para casos de uso do Spark Streaming ou quando RecordServer o Apache Ranger for usado. AWS Lake Formation
+ O cache do fragmento resultante read/writes usa buckets EMRFS /S3A e Amazon S3. Há suporte para criptografia CSE (apenas com EMRFS)/SSE S3/SSE KMS. Para contextualizar, o S3A fornece uma implementação do Hadoop para permitir que um cluster leia e grave dados de e para o Amazon S3. Observe que o suporte para S3A está disponível com o EMR-7.4.0 e superior.
# Uso do RAPIDS Accelerator do NVIDIA para Apache Spark
Com as versões 6.2.0 e posteriores do Amazon EMR, você pode usar o plug-in [RAPIDS Accelerator para Apache Spark](https://docs.nvidia.com/spark-rapids/user-guide/latest/overview.html) do NVIDIA para acelerar o Spark usando tipos de instância de unidade de processamento gráfico (GPU) do EC2. O RAPIDS Accelerator acelerará, por meio da GPU, seus pipelines de ciência de dados do Apache Spark 3.0 sem alterações no código, bem como o processamento de dados e o treinamento de modelos, enquanto reduz substancialmente os custos de infraestrutura.
As seções a seguir orientam você na configuração do cluster do EMR para usar o plug-in Spark-RAPIDS para Spark.
## Selecionar tipos de instância
Para usar o plug-in Spark-RAPIDS da Nvidia para Spark, os grupos de instâncias core e de tarefas devem usar tipos de instâncias de GPU do EC2 que atendam aos [requisitos de hardware](https://nvidia.github.io/spark-rapids/) do Spark-RAPIDS. Para ver uma lista completa dos tipos de instâncias de GPU compatíveis com o Amazon EMR, consulte [Tipos de instâncias compatíveis](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-supported-instance-types.html) no *Guia de gerenciamento do Amazon EMR*. O tipo de instância do grupo primário de instâncias pode ser do tipo GPU ou não GPU, mas os tipos de instâncias ARM não são compatíveis.
## Definir as configurações da aplicação para o cluster
**1. Permitir que o Amazon EMR instale os plug-ins no novo cluster**
Para instalar plug-ins, forneça a seguinte configuração ao criar o cluster:
```
{
"Classification":"spark",
"Properties":{
"enableSparkRapids":"true"
}
}
```
**2. Configurar o YARN para usar a GPU**
Para obter detalhes sobre como usar a GPU no YARN, consulte [Using GPU on YARN](https://hadoop.apache.org/docs/r3.2.1/hadoop-yarn/hadoop-yarn-site/UsingGpus.html) na documentação do Apache Hadoop. Os seguintes exemplos são de configurações do YARN para as versões 6.x e 7.x do Amazon EMR:
------
#### [ Amazon EMR 7.x ]
**Exemplo de configuração do YARN para o Amazon EMR 7.x**
```
{
"Classification":"yarn-site",
"Properties":{
"yarn.nodemanager.resource-plugins":"yarn.io/gpu",
"yarn.resource-types":"yarn.io/gpu",
"yarn.nodemanager.resource-plugins.gpu.allowed-gpu-devices":"auto",
"yarn.nodemanager.resource-plugins.gpu.path-to-discovery-executables":"/usr/bin",
"yarn.nodemanager.linux-container-executor.cgroups.mount":"true",
"yarn.nodemanager.linux-container-executor.cgroups.mount-path":"/spark-rapids-cgroup",
"yarn.nodemanager.linux-container-executor.cgroups.hierarchy":"yarn",
"yarn.nodemanager.container-executor.class":"org.apache.hadoop.yarn.server.nodemanager.LinuxContainerExecutor"
}
},{
"Classification":"container-executor",
"Properties":{
},
"Configurations":[
{
"Classification":"gpu",
"Properties":{
"module.enabled":"true"
}
},
{
"Classification":"cgroups",
"Properties":{
"root":"/spark-rapids-cgroup",
"yarn-hierarchy":"yarn"
}
}
]
}
```
------
#### [ Amazon EMR 6.x ]
**Exemplo de configuração do YARN para o Amazon EMR 6.x**
```
{
"Classification":"yarn-site",
"Properties":{
"yarn.nodemanager.resource-plugins":"yarn.io/gpu",
"yarn.resource-types":"yarn.io/gpu",
"yarn.nodemanager.resource-plugins.gpu.allowed-gpu-devices":"auto",
"yarn.nodemanager.resource-plugins.gpu.path-to-discovery-executables":"/usr/bin",
"yarn.nodemanager.linux-container-executor.cgroups.mount":"true",
"yarn.nodemanager.linux-container-executor.cgroups.mount-path":"/sys/fs/cgroup",
"yarn.nodemanager.linux-container-executor.cgroups.hierarchy":"yarn",
"yarn.nodemanager.container-executor.class":"org.apache.hadoop.yarn.server.nodemanager.LinuxContainerExecutor"
}
},{
"Classification":"container-executor",
"Properties":{
},
"Configurations":[
{
"Classification":"gpu",
"Properties":{
"module.enabled":"true"
}
},
{
"Classification":"cgroups",
"Properties":{
"root":"/sys/fs/cgroup",
"yarn-hierarchy":"yarn"
}
}
]
}
```
------
**3. Configurar o Spark para usar o RAPIDS**
Veja as configurações necessárias para habilitar o Spark para usar o plugin RAPIDS:
```
{
"Classification":"spark-defaults",
"Properties":{
"spark.plugins":"com.nvidia.spark.SQLPlugin",
"spark.executor.resource.gpu.discoveryScript":"/usr/lib/spark/scripts/gpu/getGpusResources.sh",
"spark.executor.extraLibraryPath":"/usr/local/cuda/targets/x86_64-linux/lib:/usr/local/cuda/extras/CUPTI/lib64:/usr/local/cuda/compat/lib:/usr/local/cuda/lib:/usr/local/cuda/lib64:/usr/lib/hadoop/lib/native:/usr/lib/hadoop-lzo/lib/native:/docker/usr/lib/hadoop/lib/native:/docker/usr/lib/hadoop-lzo/lib/native"
}
}
```
[XGBoost4A biblioteca J-Spark](https://xgboost.readthedocs.io/en/latest/jvm/xgboost4j_spark_tutorial.html) na XGBoost documentação também está disponível quando o plug-in Spark RAPIDS está habilitado em seu cluster. Você pode usar a seguinte configuração para se integrar XGBoost ao seu trabalho do Spark:
```
{
"Classification":"spark-defaults",
"Properties":{
"spark.submit.pyFiles":"/usr/lib/spark/jars/xgboost4j-spark_3.0-1.4.2-0.3.0.jar"
}
}
```
Para conhecer configurações adicionais do Spark que você pode usar para ajustar um cluster do EMR acelerado por GPU, consulte o [Guia de ajuste do acelerador Rapids para Apache Spark](https://docs.nvidia.com/spark-rapids/user-guide/latest/tuning-guide.html) na documentação do Nvidia.github.io.
**4. Configurar o YARN Capacity Scheduler**
`DominantResourceCalculator` deve estar configurado para permitir a programação e o isolamento da GPU. Para obter mais informações, consulte [Usar GPU no YARN](https://hadoop.apache.org/docs/r3.2.1/hadoop-yarn/hadoop-yarn-site/UsingGpus.html) na documentação do Apache Hadoop.
```
{
"Classification":"capacity-scheduler",
"Properties":{
"yarn.scheduler.capacity.resource-calculator":"org.apache.hadoop.yarn.util.resource.DominantResourceCalculator"
}
}
```
**5. Criação de um arquivo JSON para incluir as configurações**
Você pode criar um arquivo JSON que contenha sua configuração para usar o plug-in RAPIDS no cluster do Spark. Você fornece o arquivo posteriormente ao executar o cluster.
Você pode armazenar o arquivo localmente ou no S3. Para obter mais informações sobre como fornecer configurações de aplicações para os clusters, consulte [Configurar aplicações](emr-configure-apps.md).
Use os exemplos de arquivos a seguir como modelos para criar suas próprias configurações.
------
#### [ Amazon EMR 7.x ]
**Arquivo de exemplo `my-configurations.json` para o Amazon EMR 7.x**
```
[
{
"Classification":"spark",
"Properties":{
"enableSparkRapids":"true"
}
},
{
"Classification":"yarn-site",
"Properties":{
"yarn.nodemanager.resource-plugins":"yarn.io/gpu",
"yarn.resource-types":"yarn.io/gpu",
"yarn.nodemanager.resource-plugins.gpu.allowed-gpu-devices":"auto",
"yarn.nodemanager.resource-plugins.gpu.path-to-discovery-executables":"/usr/bin",
"yarn.nodemanager.linux-container-executor.cgroups.mount":"true",
"yarn.nodemanager.linux-container-executor.cgroups.mount-path":"/spark-rapids-cgroup",
"yarn.nodemanager.linux-container-executor.cgroups.hierarchy":"yarn",
"yarn.nodemanager.container-executor.class":"org.apache.hadoop.yarn.server.nodemanager.LinuxContainerExecutor"
}
},
{
"Classification":"container-executor",
"Properties":{
},
"Configurations":[
{
"Classification":"gpu",
"Properties":{
"module.enabled":"true"
}
},
{
"Classification":"cgroups",
"Properties":{
"root":"/spark-rapids-cgroup",
"yarn-hierarchy":"yarn"
}
}
]
},
{
"Classification":"spark-defaults",
"Properties":{
"spark.plugins":"com.nvidia.spark.SQLPlugin",
"spark.executor.resource.gpu.discoveryScript":"/usr/lib/spark/scripts/gpu/getGpusResources.sh",
"spark.executor.extraLibraryPath":"/usr/local/cuda/targets/x86_64-linux/lib:/usr/local/cuda/extras/CUPTI/lib64:/usr/local/cuda/compat/lib:/usr/local/cuda/lib:/usr/local/cuda/lib64:/usr/lib/hadoop/lib/native:/usr/lib/hadoop-lzo/lib/native:/docker/usr/lib/hadoop/lib/native:/docker/usr/lib/hadoop-lzo/lib/native",
"spark.submit.pyFiles":"/usr/lib/spark/jars/xgboost4j-spark_3.0-1.4.2-0.3.0.jar",
"spark.rapids.sql.concurrentGpuTasks":"1",
"spark.executor.resource.gpu.amount":"1",
"spark.executor.cores":"2",
"spark.task.cpus":"1",
"spark.task.resource.gpu.amount":"0.5",
"spark.rapids.memory.pinnedPool.size":"0",
"spark.executor.memoryOverhead":"2G",
"spark.locality.wait":"0s",
"spark.sql.shuffle.partitions":"200",
"spark.sql.files.maxPartitionBytes":"512m"
}
},
{
"Classification":"capacity-scheduler",
"Properties":{
"yarn.scheduler.capacity.resource-calculator":"org.apache.hadoop.yarn.util.resource.DominantResourceCalculator"
}
}
]
```
------
#### [ Amazon EMR 6.x ]
**Arquivo de exemplo `my-configurations.json` para o Amazon EMR 6.x**
```
[
{
"Classification":"spark",
"Properties":{
"enableSparkRapids":"true"
}
},
{
"Classification":"yarn-site",
"Properties":{
"yarn.nodemanager.resource-plugins":"yarn.io/gpu",
"yarn.resource-types":"yarn.io/gpu",
"yarn.nodemanager.resource-plugins.gpu.allowed-gpu-devices":"auto",
"yarn.nodemanager.resource-plugins.gpu.path-to-discovery-executables":"/usr/bin",
"yarn.nodemanager.linux-container-executor.cgroups.mount":"true",
"yarn.nodemanager.linux-container-executor.cgroups.mount-path":"/sys/fs/cgroup",
"yarn.nodemanager.linux-container-executor.cgroups.hierarchy":"yarn",
"yarn.nodemanager.container-executor.class":"org.apache.hadoop.yarn.server.nodemanager.LinuxContainerExecutor"
}
},
{
"Classification":"container-executor",
"Properties":{
},
"Configurations":[
{
"Classification":"gpu",
"Properties":{
"module.enabled":"true"
}
},
{
"Classification":"cgroups",
"Properties":{
"root":"/sys/fs/cgroup",
"yarn-hierarchy":"yarn"
}
}
]
},
{
"Classification":"spark-defaults",
"Properties":{
"spark.plugins":"com.nvidia.spark.SQLPlugin",
"spark.executor.resource.gpu.discoveryScript":"/usr/lib/spark/scripts/gpu/getGpusResources.sh",
"spark.executor.extraLibraryPath":"/usr/local/cuda/targets/x86_64-linux/lib:/usr/local/cuda/extras/CUPTI/lib64:/usr/local/cuda/compat/lib:/usr/local/cuda/lib:/usr/local/cuda/lib64:/usr/lib/hadoop/lib/native:/usr/lib/hadoop-lzo/lib/native:/docker/usr/lib/hadoop/lib/native:/docker/usr/lib/hadoop-lzo/lib/native",
"spark.submit.pyFiles":"/usr/lib/spark/jars/xgboost4j-spark_3.0-1.4.2-0.3.0.jar",
"spark.rapids.sql.concurrentGpuTasks":"1",
"spark.executor.resource.gpu.amount":"1",
"spark.executor.cores":"2",
"spark.task.cpus":"1",
"spark.task.resource.gpu.amount":"0.5",
"spark.rapids.memory.pinnedPool.size":"0",
"spark.executor.memoryOverhead":"2G",
"spark.locality.wait":"0s",
"spark.sql.shuffle.partitions":"200",
"spark.sql.files.maxPartitionBytes":"512m"
}
},
{
"Classification":"capacity-scheduler",
"Properties":{
"yarn.scheduler.capacity.resource-calculator":"org.apache.hadoop.yarn.util.resource.DominantResourceCalculator"
}
}
]
```
------
## Adicionar uma ação de bootstrap para o cluster
Para obter mais informações sobre como fornecer scripts de ação de bootstrap ao criar o cluster, consulte [Bootstrap action basics](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-bootstrap.html#bootstrapUses) no *Guia de gerenciamento do Amazon EMR*.
Os seguintes exemplos de scripts mostram como criar um arquivo de ação de bootstrap para o Amazon EMR 6.x e 7.x:
------
#### [ Amazon EMR 7.x ]
**Arquivo de exemplo `my-bootstrap-action.sh` para o Amazon EMR 7.x**
Para usar o YARN no gerenciamento de recursos de GPU com as versões 7.x do Amazon EMR, você deve montar o CGroup v1 manualmente no seu cluster. Isso pode ser feito com um script de ação de bootstrap, conforme mostrado neste exemplo.
```
#!/bin/bash
set -ex
sudo mkdir -p /spark-rapids-cgroup/devices
sudo mount -t cgroup -o devices cgroupv1-devices /spark-rapids-cgroup/devices
sudo chmod a+rwx -R /spark-rapids-cgroup
```
------
#### [ Amazon EMR 6.x ]
**Arquivo de exemplo `my-bootstrap-action.sh` para o Amazon EMR 6.x**
Nas versões 6.x do Amazon EMR, você deve abrir as permissões do CGroup para o YARN no seu cluster. Isso pode ser feito com um script de ação de bootstrap, conforme mostrado neste exemplo.
```
#!/bin/bash
set -ex
sudo chmod a+rwx -R /sys/fs/cgroup/cpu,cpuacct
sudo chmod a+rwx -R /sys/fs/cgroup/devices
```
------
## Iniciar o cluster
A última etapa é iniciar o cluster com as configurações de cluster mencionadas acima. Veja um exemplo de comando para executar um cluster pela CLI do Amazon EMR:
```
aws emr create-cluster \
--release-label emr-7.12.0 \
--applications Name=Hadoop Name=Spark \
--service-role EMR_DefaultRole_V2 \
--ec2-attributes KeyName=my-key-pair,InstanceProfile=EMR_EC2_DefaultRole \
--instance-groups InstanceGroupType=MASTER,InstanceCount=1,InstanceType=m4.4xlarge \
InstanceGroupType=CORE,InstanceCount=1,InstanceType=g4dn.2xlarge \
InstanceGroupType=TASK,InstanceCount=1,InstanceType=g4dn.2xlarge \
--configurations file:///my-configurations.json \
--bootstrap-actions Name='My Spark Rapids Bootstrap action',Path=s3://amzn-s3-demo-bucket/my-bootstrap-action.sh
```
# Acessar o shell do Spark
O shell do Spark é baseado no Scala REPL (Read-Eval-Print-Loop). Ele permite criar programas Spark interativamente e enviar trabalhos à estrutura. Você pode acessar o shell do Spark conectando-se ao nó primário com SSH e invocando `spark-shell`. Para obter informações sobre a conexão ao nó primário, consulte [Connect to the primary node using SSH](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-connect-master-node-ssh.html) no *Guia de gerenciamento do Amazon EMR*. Os exemplos a seguir usam logs de acesso do Servidor HTTP Apache armazenados no Amazon S3.
**nota**
O bucket nesses exemplos está disponível para clientes que podem acessar a região Leste dos EUA (Norte da Virgínia).
Por padrão, o shell do Spark cria seu próprio [SparkContext](https://spark.apache.org/docs/1.3.1/api/scala/index.html#org.apache.spark.SparkContext)objeto chamado`sc`. Você pode usar esse contexto se for necessário no REPL. sqlContexttambém está disponível na concha e é uma [HiveContext](https://spark.apache.org/docs/latest/api/scala/index.html#org.apache.spark.sql.hive.HiveContext).
**Example Usar o shell do Spark para contar as ocorrências de uma string em um arquivo armazenado no Amazon S3**
Este exemplo usa `sc` para ler um arquivo de texto armazenado no Amazon S3.
```
scala> sc
res0: org.apache.spark.SparkContext = org.apache.spark.SparkContext@404721db
scala> val textFile = sc.textFile("s3://elasticmapreduce/samples/hive-ads/tables/impressions/dt=2009-04-13-08-05/ec2-0-51-75-39.amazon.com.rproxy.govskope.ca-2009-04-13-08-05.log")
```
O Spark cria o textFile e a [estrutura de dados](https://spark.apache.org/docs/latest/programming-guide.html#resilient-distributed-datasets-rdds) associada. Em seguida, o exemplo conta o número de linhas no arquivo de log com a string "cartoonnetwork.com":
```
scala> val linesWithCartoonNetwork = textFile.filter(line => line.contains("cartoonnetwork.com")).count()
linesWithCartoonNetwork: org.apache.spark.rdd.RDD[String] = MapPartitionsRDD[2] at filter at :23
scala> linesWithCartoonNetwork
res2: Long = 9
```
**Example Usar o shell do Spark baseado em Python para contar as ocorrências de uma string em um arquivo armazenado no Amazon S3**
O Spark também inclui um shell baseado em Python, `pyspark`, que você pode usar para gerar protótipos de programas Spark escritos em Python. Assim como com`spark-shell`, invoque `pyspark` no nó primário; ele também tem o mesmo [SparkContext](https://spark.apache.org/docs/latest/api/python/reference/api/pyspark.SparkContext.html#pyspark.SparkContext)objeto.
```
>>> sc
>>> textfile = sc.textFile("s3://elasticmapreduce/samples/hive-ads/tables/impressions/dt=2009-04-13-08-05/ec2-0-51-75-39.amazon.com.rproxy.govskope.ca-2009-04-13-08-05.log")
```
O Spark cria o textFile e a [estrutura de dados](https://spark.apache.org/docs/latest/programming-guide.html#resilient-distributed-datasets-rdds) associada. Em seguida, o exemplo conta o número de linhas no arquivo de log com a string "cartoonnetwork.com".
```
>>> linesWithCartoonNetwork = textfile.filter(lambda line: "cartoonnetwork.com" in line).count()
15/06/04 17:12:22 INFO lzo.GPLNativeCodeLoader: Loaded native gpl library from the embedded binaries
15/06/04 17:12:22 INFO lzo.LzoCodec: Successfully loaded & initialized native-lzo library [hadoop-lzo rev EXAMPLE]
15/06/04 17:12:23 INFO fs.EmrFileSystem: Consistency disabled, using com.amazon.ws.emr.hadoop.fs.s3n.S3NativeFileSystem as filesystem implementation
>>> linesWithCartoonNetwork
9
```
# Use o Amazon SageMaker Spark para aprendizado de máquina
Quando você usa as versões 5.11.0 e posteriores do Amazon EMR, o componente `aws-sagemaker-spark-sdk` é instalado com o Spark. [Esse componente instala o Amazon SageMaker Spark e as dependências associadas para a integração do Spark com a Amazon. SageMaker](https://aws.amazon.com/sagemaker/) Observe que o componente `aws-sagemaker-spark-sdk` não está disponível no Amazon EMR 7.x ou superior. Você pode usar o Amazon SageMaker Spark para criar pipelines de aprendizado de máquina (ML) do Spark usando os estágios da Amazon. SageMaker *Para obter mais informações, consulte o [README do Amazon SageMaker Spark](https://github.com/aws/sagemaker-spark/blob/master/README.md) sobre GitHub e como [usar o Apache Spark com a Amazon SageMaker no Amazon Developer](https://docs.aws.amazon.com/sagemaker/latest/dg/apache-spark.html) Guide. SageMaker *
# Escrever uma aplicação do Spark
Aplicativos [Spark](https://aws.amazon.com/big-data/what-is-spark/) podem ser escritos em Scala, Java ou Python. Existem vários exemplos de aplicações do Spark no tópico [Spark examples](https://spark.apache.org/examples.html) da documentação do Apache Spark. O exemplo "Estimating Pi" é mostrado abaixo em três aplicativos com suporte nativo. Você também pode ver exemplos completos em `$SPARK_HOME/examples` e em [GitHub](https://github.com/apache/spark/tree/master/examples/src/main). Para obter mais informações sobre como criar JARs para o Spark, consulte o tópico [Início rápido](https://spark.apache.org/docs/latest/quick-start.html) na documentação do Apache Spark.
## Scala
Para evitar problemas de compatibilidade com o Scala, sugerimos que você use as dependências do Spark para a versão correta do Scala ao compilar uma aplicação do Spark para um cluster do Amazon EMR. A versão do Scala que você deve usar depende da versão do Spark instalada no cluster. Por exemplo, a versão 5.30.1 do Amazon EMR usa o Spark 2.4.5, que é criado com o Scala 2.11. Se o cluster usa a versão 5.30.1 do Amazon EMR, use as dependências do Spark para o Scala 2.11. Para obter mais informações sobre as versões do Scala usadas pelo Spark, consulte a [documentação do Apache Spark](https://spark.apache.org/documentation.html).
```
package org.apache.spark.examples
import scala.math.random
import org.apache.spark._
/** Computes an approximation to pi */
object SparkPi {
def main(args: Array[String]) {
val conf = new SparkConf().setAppName("Spark Pi")
val spark = new SparkContext(conf)
val slices = if (args.length > 0) args(0).toInt else 2
val n = math.min(100000L * slices, Int.MaxValue).toInt // avoid overflow
val count = spark.parallelize(1 until n, slices).map { i =>
val x = random * 2 - 1
val y = random * 2 - 1
if (x*x + y*y < 1) 1 else 0
}.reduce(_ + _)
println("Pi is roughly " + 4.0 * count / n)
spark.stop()
}
}
```
## Java
```
package org.apache.spark.examples;
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.Function;
import org.apache.spark.api.java.function.Function2;
import java.util.ArrayList;
import java.util.List;
/**
* Computes an approximation to pi
* Usage: JavaSparkPi [slices]
*/
public final class JavaSparkPi {
public static void main(String[] args) throws Exception {
SparkConf sparkConf = new SparkConf().setAppName("JavaSparkPi");
JavaSparkContext jsc = new JavaSparkContext(sparkConf);
int slices = (args.length == 1) ? Integer.parseInt(args[0]) : 2;
int n = 100000 * slices;
List l = new ArrayList(n);
for (int i = 0; i < n; i++) {
l.add(i);
}
JavaRDD dataSet = jsc.parallelize(l, slices);
int count = dataSet.map(new Function() {
@Override
public Integer call(Integer integer) {
double x = Math.random() * 2 - 1;
double y = Math.random() * 2 - 1;
return (x * x + y * y < 1) ? 1 : 0;
}
}).reduce(new Function2() {
@Override
public Integer call(Integer integer, Integer integer2) {
return integer + integer2;
}
});
System.out.println("Pi is roughly " + 4.0 * count / n);
jsc.stop();
}
}
```
## Python
```
import argparse
import logging
from operator import add
from random import random
from pyspark.sql import SparkSession
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
def calculate_pi(partitions, output_uri):
"""
Calculates pi by testing a large number of random numbers against a unit circle
inscribed inside a square. The trials are partitioned so they can be run in
parallel on cluster instances.
:param partitions: The number of partitions to use for the calculation.
:param output_uri: The URI where the output is written, typically an Amazon S3
bucket, such as 's3://example-bucket/pi-calc'.
"""
def calculate_hit(_):
x = random() * 2 - 1
y = random() * 2 - 1
return 1 if x**2 + y**2 < 1 else 0
tries = 100000 * partitions
logger.info(
"Calculating pi with a total of %s tries in %s partitions.", tries, partitions
)
with SparkSession.builder.appName("My PyPi").getOrCreate() as spark:
hits = (
spark.sparkContext.parallelize(range(tries), partitions)
.map(calculate_hit)
.reduce(add)
)
pi = 4.0 * hits / tries
logger.info("%s tries and %s hits gives pi estimate of %s.", tries, hits, pi)
if output_uri is not None:
df = spark.createDataFrame([(tries, hits, pi)], ["tries", "hits", "pi"])
df.write.mode("overwrite").json(output_uri)
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument(
"--partitions",
default=2,
type=int,
help="The number of parallel partitions to use when calculating pi.",
)
parser.add_argument(
"--output_uri", help="The URI where output is saved, typically an S3 bucket."
)
args = parser.parse_args()
calculate_pi(args.partitions, args.output_uri)
```
# Melhorar a performance do Spark com Amazon S3
O Amazon EMR oferece atributos para ajudar na otimização da performance ao usar o Spark para consultar, ler e gravar dados salvos no Amazon S3.
O [S3 Select](https://aws.amazon.com/blogs/aws/s3-glacier-select/) pode melhorar a performance de consultas para arquivos CSV e JSON em algumas aplicações ao enviar o processamento para o Amazon S3.
O committer otimizado para EMRFS S3 é uma alternativa à [OutputCommitter](https://hadoop.apache.org/docs/current/api/org/apache/hadoop/mapreduce/OutputCommitter.html)classe, que usa o recurso de uploads de várias partes do EMRFS para melhorar o desempenho ao gravar arquivos Parquet no Amazon S3 usando Spark e conjuntos de dados. DataFrames
**Topics**
+ [
# Usar o S3 Select com Spark para melhorar a performance das consultas
](emr-spark-s3select.md)
+ [
# EMR Spark MagicCommitProtocol
](emr-spark-magic-commit-protocol.md)
+ [
# Usar o confirmador otimizado para EMRFS S3
](emr-spark-s3-optimized-committer.md)
+ [
# Use o protocolo de confirmação otimizada para EMRFS S3
](emr-spark-s3-optimized-commit-protocol.md)
+ [
# Tentar novamente solicitações do Amazon S3 com EMRFS
](emr-spark-emrfs-retry.md)
# Usar o S3 Select com Spark para melhorar a performance das consultas
**Importante**
O Amazon S3 Select não está mais disponível para novos clientes. Os clientes existentes do Amazon S3 Select podem continuar usando o recurso normalmente. [Saiba mais](https://aws.amazon.com/blogs/storage/how-to-optimize-querying-your-data-in-amazon-s3/)
Com as versões 5.17.0 e posteriores do Amazon EMR, você pode usar o [S3 Select](https://aws.amazon.com/blogs/aws/s3-glacier-select/) com Spark no Amazon EMR. O *S3 Select* possibilita que as aplicações recuperem apenas um subconjunto dos dados de um objeto. Para o Amazon EMR, o trabalho computacional de filtrar grandes conjuntos de dados para processamento é enviado do cluster para o Amazon S3, o que pode melhorar a performance em algumas aplicações e reduz o volume de dados transferidos entre o Amazon EMR e o Amazon S3.
O S3 Select é compatível com arquivos CSV e JSON usando os valores `s3selectCSV` e `s3selectJSON` para especificar o formato de dados. Para ter mais informações e exemplos, consulte [Especificar o S3 Select no seu código](#emr-spark-s3select-specify).
## O S3 Select é adequado para minha aplicação?
Recomendamos que você avalie seus aplicativos com e sem o S3 Selecione para ver se o uso pode ser adequado para o aplicativo.
Use as seguintes diretrizes para determinar se o seu aplicativo é adequado para o uso do S3 Select:
+ Sua consulta filtra mais de metade do conjunto de dados original.
+ Sua conexão de rede entre o Amazon S3 e o cluster do Amazon EMR tem boa velocidade de transferência e largura de banda disponível. O Amazon S3 não compacta respostas HTTP. Portanto, é provável que o tamanho da resposta aumente para arquivos de entrada compactados.
## Considerações e limitações
+ A criptografia do lado do servidor do Amazon S3 com chaves de criptografia fornecidas pelo cliente (SSE-C) e a criptografia do lado do cliente não são compatíveis.
+ A propriedade `AllowQuotedRecordDelimiters` não é compatível. Se essa propriedade for especificada, a consulta falhará.
+ Somente arquivos CSV e JSON no formato UTF-8 são compatíveis. Não CSVs há suporte para várias linhas.
+ Somente arquivos descompactados ou gzip são compatíveis.
+ As opções CSV e JSON do Spark, como `nanValue`, `positiveInf`, `negativeInf` e opções relacionadas a registros corrompidos (por exemplo, modo dropmalformed e failfast) não são compatíveis.
+ O uso de vírgulas (,) em casas decimais não é compatível. Por exemplo, `10,000` não é compatível, mas `10000` é.
+ Caracteres de comentário na última linha não são compatíveis.
+ Linhas vazias no final de um arquivo não são processadas.
+ Os seguintes filtros não são enviados para o Amazon S3:
+ Funções agregadas, como `COUNT()` e `SUM()`.
+ Filtros que `CAST()` um atributo. Por exemplo, .`CAST(stringColumn as INT) = 1`
+ Filtros com um atributo que é um objeto ou complexo. Por exemplo, .`intArray[1] = 1, objectColumn.objectNumber = 1`
+ Filtros para os quais o valor não é um valor literal. Por exemplo, `intColumn1 = intColumn2`.
+ Somente [tipos de dados compatíveis com o S3 Select](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-glacier-select-sql-reference-data-types.html) são compatíveis com as limitações documentadas.
## Especificar o S3 Select no seu código
Os exemplos a seguir demonstram como especificar o S3 Select para CSV usando Scala, SQL, R e. PySpark Você pode usar o S3 Select para JSON da mesma forma. Para obter uma lista de opções, os valores padrão e limitações, consulte [Opções](#emr-spark-s3select-specify-options).
------
#### [ PySpark ]
```
spark
.read
.format("s3selectCSV") // "s3selectJson" for Json
.schema(...) // optional, but recommended
.options(...) // optional
.load("s3://path/to/my/datafiles")
```
------
#### [ R ]
```
read.df("s3://path/to/my/datafiles", "s3selectCSV", schema, header = "true", delimiter = "\t")
```
------
#### [ Scala ]
```
spark
.read
.format("s3selectCSV") // "s3selectJson" for Json
.schema(...) // optional, but recommended
.options(...) // optional. Examples:
// .options(Map("quote" -> "\'", "header" -> "true")) or
// .option("quote", "\'").option("header", "true")
.load("s3://path/to/my/datafiles")
```
------
#### [ SQL ]
```
CREATE TEMPORARY VIEW MyView (number INT, name STRING) USING s3selectCSV OPTIONS (path "s3://path/to/my/datafiles", header "true", delimiter "\t")
```
------
### Opções
As seguintes opções estão disponíveis ao usar `s3selectCSV` e `s3selectJSON`. Se não for especificado, os valores padrão serão usados.
#### Opções com o S3selectCSV
| Opção | Padrão | Usage |
| --- | --- | --- |
| `compression` | `"none"` | Indica se a compactação é usada. `"gzip"` é a única configuração compatível além de `"none"`. |
| `delimiter` | "," | Especifica o delimitador de campo. |
| `quote` | `'\"'` | Especifica o caractere de aspas. Não há suporte para a especificação de uma string vazia e isso resulta em um erro de XML malformado. |
| `escape` | `'\\'` | Especifica o caractere de escape. |
| `header` | `"false"` | `"false"` especifica que não há cabeçalho. `"true"` especifica que o cabeçalho está na primeira linha. Somente cabeçalhos na primeira linha são suportados e linhas vazias antes de um cabeçalho não são compatíveis. |
| comment | `"#"` | Especifica o caractere de comentário. O indicador de comentários não pode ser desativado. Em outras palavras, um valor de `\u0000` não é suportado. |
| `nullValue` | "" | |
#### Opções com S3selectJSON
| Opção | Padrão | Usage |
| --- | --- | --- |
| `compression` | `"none"` | Indica se a compactação é usada. `"gzip"` é a única configuração compatível além de `"none"`. |
| `multiline` | "falso" | `"false"` especifica que o JSON está no formato `LINES` do S3 Select, o que significa que cada linha nos dados de entrada contém um único objeto JSON. `"true"` especifica que o JSON está no formato `DOCUMENT` do S3 Select, o que significa que um objeto JSON podem abranger várias linhas nos dados de entrada. |
# EMR Spark MagicCommitProtocol
Do EMR 6.15.0 em diante, MagicCommitProtocol torna-se o padrão FileCommitProtocol para o Spark ao utilizar o sistema de arquivos S3A.
## MagicCommitProtocol
MagicCommitProtocol É uma implementação alternativa do [FileCommitProtocol](https://dlcdn.apache.org/spark/docs/2.4.2/api/java/org/apache/spark/internal/io/FileCommitProtocol.html)que é otimizada para gravar arquivos com o EMR Spark no Amazon S3 ao usar o sistema de arquivos S3A. Este protocolo visa melhorar a performance da aplicação, evitando o uso de operações de renomeação no Amazon S3 durante as fases de commit de trabalhos e tarefas.
Essa MagicCommitProtocol é a FileCommitProtocol implementação padrão usada pelo Spark em execução no Amazon Elastic Map Reduce (EMR) quando o sistema de arquivos S3A é utilizado. O usa MagicCommitProtocol internamente o [MagicV2Committer](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/s3a-magicv2-committer.html) para realizar as gravações de arquivos no Amazon S3.
Para operações de inserção estática, MagicCommitProtocol ele grava os arquivos no local de saída do trabalho durante a fase de confirmação da tarefa. Por outro lado, para operações de substituição de inserção dinâmica, os arquivos gravados por tentativas de tarefas aparecem apenas no local de saída do trabalho após a confirmação do trabalho. Isso é feito exportando os metadados de confirmação de volta para o driver do Spark na chamada de confirmação da tarefa.
## Habilitando MagicCommitProtocol
O MagicCommitProtocol é habilitado por padrão para o Spark executado no Amazon Elastic Map Reduce (EMR) ao usar o sistema de arquivos S3A.
Para usar o sistema de arquivos S3A, você pode:
1. Usar o esquema de arquivos como `s3a://` ao definir a tabela, a partição ou o diretório.
1. Defina a configuração `fs.s3.impl=org.apache.hadoop.fs.s3a.S3AFileSystem` em core-site.xml.
## Desativando o MagicCommitProtocol
1. Você pode definir `spark.sql.execution.datasources.SQLEmrOptimizedCommitProtocol.leverageMagicCommitProtocol` como “false” com codificação rígida em um `SparkConf`, transmitindo-o como um parâmetro `--conf` no shell Spark ou nas ferramentas `spark-submit` e `spark-sql` ou em `conf/spark-defaults.conf`. Para obter mais informações, consulte [Configuração do Spark](https://spark.apache.org/docs/latest/configuration.html) na documentação do Apache Spark.
O exemplo a seguir mostra como desabilitar MagicCommitProtocol durante a execução de um `spark-sql` comando.
```
spark-sql \
--conf spark.sql.execution.datasources.SQLEmrOptimizedCommitProtocol.leverageMagicCommitProtocol=false \
-e "INSERT OVERWRITE TABLE target_table SELECT * FROM source_table;"
```
1. Use a classificação de configuração `spark-defaults` para definir a propriedade `spark.sql.execution.datasources.SQLEmrOptimizedCommitProtocol.leverageMagicCommitProtocol` como false. Para obter mais informações, consulte [Configure applications](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-configure-apps.html).
## MagicCommitProtocol considerações
+ Para inserção de partição estática, nos executores do Spark, o MagicCommitProtocol consome uma pequena quantidade de memória para cada arquivo gravado por uma tentativa de tarefa até que a tarefa seja confirmada ou abortada. Na maioria dos trabalhos, a quantidade de memória consumida é insignificante. Não há necessidade de memória extra no driver Spark
+ Para inserção dinâmica de partições, nos drivers do Spark, é MagicCommitProtocol necessária memória para armazenar informações de metadados de cada arquivo confirmado até que o trabalho seja confirmado ou abortado. Na maioria dos trabalhos, a configuração padrão de memória do driver do Spark é insignificante.
Para trabalhos que têm tarefas de execução prolongada que gravam um grande número de arquivos, a memória que o confirmador consome pode ser perceptível e precisar de ajustes na memória alocada para executores do Spark. Você pode ajustar a memória usando a `spark.driver.memory` propriedade dos drivers do Spark e a `spark.executor.memory` propriedade dos executores do Spark. Como diretriz, uma única tarefa gravando 100.000 arquivos normalmente exigiria 200 MB adicionais de memória. Para obter mais informações, consulte [Propriedades da aplicação](https://spark.apache.org/docs/latest/configuration.html#application-properties) na documentação de configuração do Apache Spark.
# Usar o confirmador otimizado para EMRFS S3
O committer otimizado para EMRFS S3 é uma [OutputCommitter](https://hadoop.apache.org/docs/current/api/org/apache/hadoop/mapreduce/OutputCommitter.html)implementação alternativa que é otimizada para gravar arquivos no Amazon S3 ao usar o EMRFS. O confirmador otimizado para EMRFS S3 melhora a performance da aplicação ao evitar operações de listar e renomear no Amazon S3 durante o trabalho e fases de confirmação da tarefa. O confirmador está disponível com as versões 5.19.0 e posteriores do Amazon EMR e é habilitado por padrão nas versões 5.20.0 e posteriores do Amazon EMR. O committer é usado para trabalhos do Spark que usam Spark ou conjuntos de dados DataFrames. Desde o Amazon EMR 6.4.0, esse confirmador pode ser usado para todos os formatos comuns, incluindo parquet, ORC e formatos baseados em texto (incluindo CSV e JSON). Para versões anteriores ao Amazon EMR 6.4.0, somente o formato Parquet é compatível. Há circunstâncias em que o committer não é usado. Para obter mais informações, consulte [Requisitos do confirmador otimizado para EMRFS S3](emr-spark-committer-reqs.md).
**Topics**
+ [
# Requisitos do confirmador otimizado para EMRFS S3
](emr-spark-committer-reqs.md)
+ [
# O confirmador otimizado para EMRFS S3 e carregamentos multipart
](emr-spark-committer-multipart.md)
+ [
# Considerações sobre ajuste de tarefas
](emr-spark-committer-tuning.md)
+ [
# Ative o confirmador otimizado para EMRFS S3 para o Amazon EMR 5.19.0
](emr-spark-committer-enable.md)
# Requisitos do confirmador otimizado para EMRFS S3
O committer otimizado para EMRFS S3 é usado quando as seguintes condições são atendidas:
+ Você executa trabalhos do Spark que usam o Spark ou conjuntos de dados para gravar arquivos no Amazon S3. DataFrames Desde o Amazon EMR 6.4.0, esse confirmador pode ser usado para todos os formatos comuns, incluindo parquet, ORC e formatos baseados em texto (incluindo CSV e JSON). Para versões anteriores ao Amazon EMR 6.4.0, somente o formato Parquet é compatível.
+ Carregamentos multipart estão habilitados no Amazon EMR. Esse é o padrão. Para obter mais informações, consulte [O confirmador otimizado para EMRFS S3 e carregamentos multipart](emr-spark-committer-multipart.md).
+ O suporte a formato de arquivo integrado do Spark é usado. O suporte a formato de arquivo integrado é usado nas seguintes circunstâncias:
+ Para tabelas do Hive Metastore, quando `spark.sql.hive.convertMetastoreParquet` é definido como `true` para tabelas do Parquet ou `spark.sql.hive.convertMetastoreOrc` é definido como `true` para tabelas do Orc com as versões 6.4.0 ou superiores do Amazon EMR. Essas são as configurações padrão.
+ Quando os trabalhos são gravados em fontes de dados ou tabelas do Parquet, por exemplo, a tabela de destino é criada com a cláusula `USING parquet`.
+ Quando os trabalhos gravam em tabelas Parquet de metastore do Hive não particionadas. O suporte ao Parquet incorporado do Spark oferece suporte a tabelas particionadas do Hive, o que é uma limitação conhecida. Para obter mais informações, consulte [Conversão da tabela Parquet do Hive metastore](https://spark.apache.org/docs/latest/sql-data-sources-parquet.html#hive-metastore-parquet-table-conversion) no Apache Spark e no Guia de conjuntos de dados. DataFrames
+ As operações de trabalhos do Spark que gravam em um local de partição padrão, como `${table_location}/k1=v1/k2=v2/`, usam o confirmador. O confirmador não será usado se uma operação de trabalho gravar em um local de partição personalizado, por exemplo, se o local de uma partição personalizado for definido usando o comando `ALTER TABLE SQL`.
+ Os valores a seguir para o Spark devem ser usados:
+ A propriedade `spark.sql.parquet.fs.optimized.committer.optimization-enabled` deve ser definida como `true`. Essa é a configuração padrão com as versões 5.20.0 e posteriores do Amazon EMR. Com o Amazon EMR 5.19.0, o valor padrão é `false`. Para obter informações sobre como configurar esse valor, consulte [Ative o confirmador otimizado para EMRFS S3 para o Amazon EMR 5.19.0](emr-spark-committer-enable.md).
+ Se você está gravando em tabelas da metastore do Hive não particionadas, somente os formatos de arquivo Parquet e Orc são compatíveis. `spark.sql.hive.convertMetastoreParquet` deve ser definido como `true` se você está gravando em tabelas da metastore do Hive não particionadas em Paquet. `spark.sql.hive.convertMetastoreOrc` deve ser definido como `true` se estiver gravando em tabelas da metastore do Hive não particionadas em Orc. Essas são as configurações padrão.
+ `spark.sql.parquet.output.committer.class` deve ser definido como `com.amazon.emr.committer.EmrOptimizedSparkSqlParquetOutputCommitter`. Essa é a configuração padrão.
+ `spark.sql.sources.commitProtocolClass` deve ser definido como `org.apache.spark.sql.execution.datasources.SQLEmrOptimizedCommitProtocol` ou `org.apache.spark.sql.execution.datasources.SQLHadoopMapReduceCommitProtocol`. `org.apache.spark.sql.execution.datasources.SQLEmrOptimizedCommitProtocol` é a configuração padrão para as versões 5.30.0 e superiores do Amazon EMR série 5.x e para as versões 6.2.0 e superiores do Amazon EMR série 6.x. `org.apache.spark.sql.execution.datasources.SQLHadoopMapReduceCommitProtocol` é a configuração padrão para as versões anteriores do Amazon EMR.
+ Se os trabalhos do Spark substituírem os conjuntos de dados Parquet por colunas de partição dinâmica, as opções de gravação `partitionOverwriteMode` e `spark.sql.sources.partitionOverwriteMode` deverão ser definidas como `static`. Essa é a configuração padrão.
**nota**
A opção de gravação `partitionOverwriteMode` foi introduzida no Spark 2.4.0. Para a versão 2.3.2 do Spark, incluída com a versão 5.19.0 do Amazon EMR, defina a propriedade `spark.sql.sources.partitionOverwriteMode`.
## Ocasiões em que o confirmador otimizado para EMRFS S3 não é usado
Geralmente, o confirmador otimizado para EMRFS S3 não é usado nas situações a seguir.
****
| Situação | Por que o confirmador não é usado |
| --- | --- |
| Quando você grava no HDFS | O confirmador só permite gravação no Amazon S3 com o uso do EMRFS. |
| Quando você usa o sistema de arquivos S3A | O confirmador só é compatível com o EMRFS. |
| Quando você usa MapReduce nossa API RDD do Spark | O committer só oferece suporte ao uso de SparkSQL ou Dataset DataFrame. APIs |
Os exemplos do Scala a seguir demonstram algumas situações adicionais que impedem que o confirmador otimizado para EMRFS S3 seja usado por completo (o primeiro exemplo) e em parte (o segundo exemplo).
**Example – Modo de substituição de partição dinâmica**
O exemplo do Scala a seguir instrui o Spark a usar um algoritmo de confirmação diferente, o que impede totalmente o uso do confirmador otimizado para EMRFS S3. O código define a propriedade `partitionOverwriteMode` como `dynamic` para subtituir somente as partições nas quais você está gravando dados. Em seguida, as colunas de partição dinâmica são especificadas por `partitionBy` e o modo de gravação é definido como `overwrite`.
```
val dataset = spark.range(0, 10)
.withColumn("dt", expr("date_sub(current_date(), id)"))
dataset.write.mode("overwrite")
.option("partitionOverwriteMode", "dynamic")
.partitionBy("dt")
.parquet("s3://amzn-s3-demo-bucket1/output")
```
Você deve definir todas as três configurações para evitar o uso do confirmador otimizado para EMRFS S3. Quando você faz isso, o Spark executa um algoritmo de confirmação diferente, especificado no protocolo de confirmação do Spark. Para versões do Amazon EMR 5.x anteriores à 5.30.0 e para versões do Amazon EMR 6.x anteriores à 6.2.0, o protocolo de confirmação usa o diretório de teste do Spark, que é um diretório temporário criado no local de saída que começa com `.spark-staging`. O algoritmo renomeia sequencialmente diretórios de partição, o que pode afetar negativamente a performance. Para obter mais informações sobre as versões 5.30.0 e posteriores e 6.2.0 e posteriores do Amazon EMR, consulte. [Use o protocolo de confirmação otimizada para EMRFS S3](emr-spark-s3-optimized-commit-protocol.md)
O algoritmo no Spark 2.4.0 segue estas etapas:
1. As tentativas de tarefa gravam a saída nos diretórios de partição do diretório de teste do Spark, por exemplo, `${outputLocation}/spark-staging-${jobID}/k1=v1/k2=v2/`.
1. Para cada partição gravada, a tentativa de tarefa acompanha os caminhos de partição relativos, por exemplo, `k1=v1/k2=v2`.
1. Quando uma tarefa é concluída com êxito, ela fornece o driver com todos os caminhos de partição relativos que ela controlou.
1. Depois que todas as tarefas forem concluídas, a fase de confirmação do trabalho coletará todos os diretórios da partição que as tentativas de tarefas bem-sucedidas gravaram no diretório de preparação do Spark. O Spark renomeia sequencialmente cada um desses diretórios para o local de saída final usando as operações para renomear a árvore de diretórios.
1. O diretório de preparação é excluído antes de a fase de confirmação de trabalho ser concluída.
**Example – Local de partição personalizado**
Neste exemplo, o código Scala insere em duas partições. Uma partição tem um local de partição personalizado. A outra partição usa o local de partição padrão. O committer otimizado para EMRFS S3 é usado somente para gravar a saída da tarefa na partição que usa o local de partição padrão.
```
val table = "dataset"
val location = "s3://bucket/table"
spark.sql(s"""
CREATE TABLE $table (id bigint, dt date)
USING PARQUET PARTITIONED BY (dt)
LOCATION '$location'
""")
// Add a partition using a custom location
val customPartitionLocation = "s3://bucket/custom"
spark.sql(s"""
ALTER TABLE $table ADD PARTITION (dt='2019-01-28')
LOCATION '$customPartitionLocation'
""")
// Add another partition using default location
spark.sql(s"ALTER TABLE $table ADD PARTITION (dt='2019-01-29')")
def asDate(text: String) = lit(text).cast("date")
spark.range(0, 10)
.withColumn("dt",
when($"id" > 4, asDate("2019-01-28")).otherwise(asDate("2019-01-29")))
.write.insertInto(table)
```
O código Scala cria os seguintes objetos do Amazon S3:
```
custom/part-00001-035a2a9c-4a09-4917-8819-e77134342402.c000.snappy.parquet
custom_$folder$
table/_SUCCESS
table/dt=2019-01-29/part-00000-035a2a9c-4a09-4917-8819-e77134342402.c000.snappy.parquet
table/dt=2019-01-29_$folder$
table_$folder$
```
Ao gravar em partições em locais personalizados, o Spark usa um algoritmo de confirmação semelhante ao exemplo anterior, que é descrito abaixo. Como no exemplo anterior, o algoritmo resulta em renomeações sequenciais, o que pode afetar negativamente a performance.
1. Ao gravar a saída em uma partição em um local personalizado, as tarefas gravam em um arquivo no diretório de preparação do Spark, que é criado no local de saída final. O nome do arquivo inclui um UUID aleatório para evitar colisões de nomes de arquivos. A tentativa de tarefa controla cada arquivo junto com o caminho de saída final desejado.
1. Quando uma tarefa é concluída com êxito, ela fornece o driver com os arquivos e os caminhos desejados de saída final.
1. Depois que todas as tarefas forem concluídas, a fase de confirmação do trabalho renomeará sequencialmente todos os arquivos que foram gravados para partições em locais personalizados em seus caminhos de saída final.
1. O diretório de preparação é excluído antes de a fase de confirmação de trabalho ser concluída.
# O confirmador otimizado para EMRFS S3 e carregamentos multipart
Para usar o confirmador otimizado para EMRFS S3, uploads de várias partes devem estar habilitados no Amazon EMR. Multipart uploads são habilitados por padrão. Você pode habilitá-los novamente, se necessário. Para obter mais informações, consulte [Configure multipart upload for Amazon S3](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-upload-s3.html#Config_Multipart) (Configurar o carregamento fracionado no Amazon S3) no *Guia de gerenciamento do Amazon EMR*.
O EMRFS S3 Optimized Committer usa as características semelhantes a transações de multipart uploads para garantir que os arquivos gravados por tentativas de tarefas aparecem apenas no local de saída do trabalho após a confirmação da tarefa. Ao usar uploads de várias partes dessa forma, o committer melhora o desempenho da confirmação da tarefa em relação à versão 2 do FileOutputCommitter algoritmo padrão. Ao usar o EMRFS S3 Optimized Committer, há algumas diferenças fundamentais de comportamento em relação ao comportamento tradicional de multipart uploads a considerar:
+ Os multipart uploads são sempre executados, independentemente do tamanho do arquivo. Isso é diferente do comportamento padrão do EMRFS, em que a propriedade `fs.s3n.multipart.uploads.split.size` controla o tamanho do arquivo no qual multipart uploads são acionados.
+ Os multipart uploads são deixados incompletos por um período mais longo até que a tarefa seja confirmada ou cancelada. Isso é diferente do comportamento padrão do EMRFS no qual um multipart upload é concluído quando uma tarefa é concluída ao gravar um determinado arquivo.
Devido a essas diferenças, se uma JVM do executor do Spark apresenta falha ou é eliminada enquanto as tarefas estão executando e gravando dados no Amazon S3, é mais provável que os carregamentos multipart partes sejam abandonados. Por esse motivo, quando você usa o EMRFS S3 Optimized Committer, certifique-se de seguir as melhores práticas para gerenciar multipart uploads com falha. Para obter mais informações, consulte [Práticas recomendadas](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-upload-s3.html#emr-bucket-bestpractices) para trabalhar com buckets do Amazon S3 no *Guia de gerenciamento do Amazon EMR*.
# Considerações sobre ajuste de tarefas
O EMRFS S3 Optimized Committer consome uma pequena quantidade de memória para cada arquivo gravado por uma tentativa de tarefa até que a tarefa seja confirmada ou cancelada. Na maioria dos trabalhos, a quantidade de memória consumida é insignificante. Para trabalhos que têm tarefas de longa execução que gravam um grande número de arquivos, a memória que o committer consome pode ser perceptível e exigem ajustes na memória alocada para executores do Spark. É possível ajustar a memória do executor usando a propriedade `spark.executor.memory`. Como diretriz, uma única tarefa gravando 100.000 arquivos normalmente exigiria 100 MB adicionais de memória. Para obter mais informações, consulte [Propriedades da aplicação](https://spark.apache.org/docs/latest/configuration.html#application-properties) na documentação de configuração do Apache Spark.
# Ative o confirmador otimizado para EMRFS S3 para o Amazon EMR 5.19.0
Se você estiver usando o Amazon EMR 5.19.0, poderá definir manualmente a propriedade `spark.sql.parquet.fs.optimized.committer.optimization-enabled` como `true` quando criar um cluster ou no Spark, se estiver usando o Amazon EMR.
## Habilitar o confirmador otimizado para EMRFS S3 quando criar um cluster
Use a classificação de configuração `spark-defaults` para definir a propriedade `spark.sql.parquet.fs.optimized.committer.optimization-enabled` como `true`. Para obter mais informações, consulte [Configurar aplicações](emr-configure-apps.md).
## Habilitar o confirmador otimizado para EMRFS S3 no Spark
Você pode definir `spark.sql.parquet.fs.optimized.committer.optimization-enabled` como `true` codificando-o em um `SparkConf`, transmitindo-o como um parâmetro `--conf` no shell Spark ou nas ferramentas `spark-submit` e `spark-sql` ou em `conf/spark-defaults.conf`. Para obter mais informações, consulte [Configuração do Spark](https://spark.apache.org/docs/latest/configuration.html) na documentação do Apache Spark.
O exemplo a seguir mostra como habilitar o committer ao executar um comando spark-sql.
```
spark-sql \
--conf spark.sql.parquet.fs.optimized.committer.optimization-enabled=true \
-e "INSERT OVERWRITE TABLE target_table SELECT * FROM source_table;"
```
# Use o protocolo de confirmação otimizada para EMRFS S3
O protocolo de confirmação otimizado para S3 do EMRFS é uma [FileCommitProtocol](https://spark.apache.org/docs/2.2.0//api/java/org/apache/spark/internal/io/FileCommitProtocol.html)implementação alternativa otimizada para gravar arquivos com a substituição de partição dinâmica do Spark no Amazon S3 ao usar o EMRFS. O protocolo melhora a performance da aplicação ao evitar operações de renomeação no Amazon S3 durante a fase de confirmação do trabalho de substituição de partição dinâmica do Spark.
Observe que [EMRFS S3-optimized committer](emr-spark-s3-optimized-committer.html) também melhora o a performance ao evitar operações de renomeação. No entanto, ele não funciona para casos de substituição de partição dinâmica, embora as melhorias no protocolo de confirmação sejam direcionados apenas a casos de substituição de partição dinâmica.
O confirmador está disponível com as versões 5.30.0 e posteriores e 6.2.0 e posteriores do Amazon EMR e é habilitado por padrão. O Amazon EMR adicionou uma melhoria no paralelismo a partir da versão 5.31.0. O protocolo é usado para trabalhos do Spark que usam Spark ou conjuntos de DataFrames dados. Há circunstâncias em que o protocolo de confirmação não é usado. Para obter mais informações, consulte [Requisitos do protocolo de confirmação otimizado para EMRFS S3](emr-spark-committer-reqs.md).
**Topics**
+ [
# Requisitos do protocolo de confirmação otimizado para EMRFS S3
](emr-spark-commit-protocol-reqs.md)
+ [
# O protocolo de confirmação otimizado para EMRFS S3 e carregamentos multipart
](emr-spark-commit-protocol-multipart.md)
+ [
# Considerações sobre ajuste de tarefas
](emr-spark-commit-protocol-tuning.md)
# Requisitos do protocolo de confirmação otimizado para EMRFS S3
O protocolo de confirmação otimizado para EMRFS S3 é usado quando as seguintes condições são atendidas:
+ Você executa trabalhos do Spark que usam o Spark ou conjuntos de dados para substituir tabelas particionadas. DataFrames
+ Você executa trabalhos do Spark cujo modo de substituição de partição é `dynamic`.
+ Carregamentos multipart estão habilitados no Amazon EMR. Esse é o padrão. Para obter mais informações, consulte [O protocolo de confirmação otimizado para EMRFS S3 e carregamentos multipart](emr-spark-commit-protocol-multipart.md).
+ O cache do sistema de arquivos para o EMRFS está habilitado. Esse é o padrão. Verifique se a configuração `fs.s3.impl.disable.cache` está definida como `false`.
+ O suporte integrado de fonte de dados do Spark é usado. O suporte integrado ao Parquet é usado nas seguintes circunstâncias:
+ Quando os trabalhos gravam em fontes de dados ou tabelas integradas.
+ Quando os trabalhos gravam em tabelas do Parquet do metastore do Hive. Isso acontece quando `spark.sql.hive.convertInsertingPartitionedTable` e `spark.sql.hive.convertMetastoreParquet` são definidos como verdadeiros. Essas são as configurações padrão.
+ Quando os trabalhos gravam na tabela do ORC do metastore do Hive. Isso acontece quando `spark.sql.hive.convertInsertingPartitionedTable` e `spark.sql.hive.convertMetastoreOrc` são definidos como `true`. Essas são as configurações padrão.
+ As operações de trabalhos do Spark que gravam em um local de partição padrão, por exemplo, `${table_location}/k1=v1/k2=v2/`, usam o confirmador. O protocolo não será usado se uma operação de trabalho gravar em um local de partição personalizado, por exemplo, se o local de uma partição personalizado for definido usando o comando `ALTER TABLE SQL`.
+ Os valores a seguir para o Spark devem ser usados:
+ `spark.sql.sources.commitProtocolClass` deve ser definido como `org.apache.spark.sql.execution.datasources.SQLEmrOptimizedCommitProtocol`. Essa é a configuração padrão para as versões 5.30.0 e superiores e 6.2.0 e superiores do Amazon EMR.
+ A opção de gravação `partitionOverwriteMode` ou `spark.sql.sources.partitionOverwriteMode` deve ser definida como `dynamic`. A configuração padrão é `static`.
**nota**
A opção de gravação `partitionOverwriteMode` foi introduzida no Spark 2.4.0. Para a versão 2.3.2 do Spark, incluída com a versão 5.19.0 do Amazon EMR, defina a propriedade `spark.sql.sources.partitionOverwriteMode`.
+ Se os trabalhos do Spark substituírem a tabela do Parquet do metastore do Hive, `spark.sql.hive.convertMetastoreParquet`, `spark.sql.hive.convertInsertingPartitionedTable` e `spark.sql.hive.convertMetastore.partitionOverwriteMode` deverão ser configurados como `true`. Existem as configurações padrão.
+ Se os trabalhos do Spark substituírem a tabela do ORC do metastore do Hive, `spark.sql.hive.convertMetastoreOrc`, `spark.sql.hive.convertInsertingPartitionedTable` e `spark.sql.hive.convertMetastore.partitionOverwriteMode` deverão ser configurados como `true`. Existem as configurações padrão.
**Example – Modo de substituição de partição dinâmica**
Neste exemplo do Scala, a otimização é acionada. Primeiro, você define a propriedade `partitionOverwriteMode` como `dynamic`. Isso só substitui as partições nas quais você está gravando dados. Em seguida, você especifica as colunas de partição dinâmica com `partitionBy` e define o modo de gravação como `overwrite`.
```
val dataset = spark.range(0, 10)
.withColumn("dt", expr("date_sub(current_date(), id)"))
dataset.write.mode("overwrite") // "overwrite" instead of "insert"
.option("partitionOverwriteMode", "dynamic") // "dynamic" instead of "static"
.partitionBy("dt") // partitioned data instead of unpartitioned data
.parquet("s3://amzn-s3-demo-bucket1/output") // "s3://" to use Amazon EMR file system, instead of "s3a://" or "hdfs://"
```
## Quando o protocolo de confirmação otimizado para EMRFS S3 não é usado
Geralmente, o protocolo de confirmação otimizado para EMRFS S3 funciona da mesma forma que o protocolo de confirmação padrão do Spark de código aberto, `org.apache.spark.sql.execution.datasources.SQLHadoopMapReduceCommitProtocol`. A otimização não ocorrerá nas situações a seguir.
****
| Situação | Por que o protocolo de confirmação não é usado |
| --- | --- |
| Quando você grava no HDFS | O protocolo de confirmação só permite gravação no Amazon S3 com o uso do EMRFS. |
| Quando você usa o sistema de arquivos S3A | O protocolo de confirmação só é compatível com EMRFS. |
| Quando você usa MapReduce nossa API RDD do Spark | O protocolo de confirmação só oferece suporte ao uso de SparkSQL ou Dataset DataFrame. APIs |
| Quando a substituição da partição dinâmica não é acionada | O protocolo de confirmação só otimiza os casos de substituição de partição dinâmica. Para outros casos, consulte [Usar o confirmador otimizado para EMRFS S3](emr-spark-s3-optimized-committer.md). |
Os exemplos de Scala a seguir demonstram algumas situações adicionais que o protocolo de confirmação otimizado para EMRFS S3 delega para `SQLHadoopMapReduceCommitProtocol`.
**Example – Modo de substituição de partição dinâmica com local de partição personalizado**
Neste exemplo, os programas Scala sobrescrevem duas partições no modo de substituição dinâmica de partição. Uma partição tem um local de partição personalizado. A outra partição usa o local de partição padrão. O protocolo de confirmação otimizado para EMRFS S3 só melhora a partição que usa o local de partição padrão.
```
val table = "dataset"
val inputView = "tempView"
val location = "s3://bucket/table"
spark.sql(s"""
CREATE TABLE $table (id bigint, dt date)
USING PARQUET PARTITIONED BY (dt)
LOCATION '$location'
""")
// Add a partition using a custom location
val customPartitionLocation = "s3://bucket/custom"
spark.sql(s"""
ALTER TABLE $table ADD PARTITION (dt='2019-01-28')
LOCATION '$customPartitionLocation'
""")
// Add another partition using default location
spark.sql(s"ALTER TABLE $table ADD PARTITION (dt='2019-01-29')")
def asDate(text: String) = lit(text).cast("date")
spark.range(0, 10)
.withColumn("dt",
when($"id" > 4, asDate("2019-01-28")).otherwise(asDate("2019-01-29")))
.createTempView(inputView)
// Set partition overwrite mode to 'dynamic'
spark.sql(s"SET spark.sql.sources.partitionOverwriteMode=dynamic")
spark.sql(s"INSERT OVERWRITE TABLE $table SELECT * FROM $inputView")
```
O código Scala cria os seguintes objetos do Amazon S3:
```
custom/part-00001-035a2a9c-4a09-4917-8819-e77134342402.c000.snappy.parquet
custom_$folder$
table/_SUCCESS
table/dt=2019-01-29/part-00000-035a2a9c-4a09-4917-8819-e77134342402.c000.snappy.parquet
table/dt=2019-01-29_$folder$
table_$folder$
```
Gravar em locais de partição personalizados em versões anteriores do Spark pode resultar em perda de dados. Neste exemplo, a partição `dt='2019-01-28'` seria perdida. Para obter mais detalhes, consulte [SPARK-35106](https://issues.apache.org/jira/browse/SPARK-35106). Isso foi corrigido nas versões 5.33.0 e posteriores do Amazon EMR, excluindo 6.0.x e 6.1.x.
Ao gravar em partições em locais personalizados, o Spark usa um algoritmo de confirmação semelhante ao exemplo anterior, que é descrito abaixo. Como no exemplo anterior, o algoritmo resulta em renomeações sequenciais, o que pode afetar negativamente a performance.
O algoritmo no Spark 2.4.0 segue estas etapas:
1. Ao gravar a saída em uma partição em um local personalizado, as tarefas gravam em um arquivo no diretório de preparação do Spark, que é criado no local de saída final. O nome do arquivo inclui um UUID aleatório para evitar colisões de nomes de arquivos. A tentativa de tarefa controla cada arquivo junto com o caminho de saída final desejado.
1. Quando uma tarefa é concluída com êxito, ela fornece o driver com os arquivos e os caminhos desejados de saída final.
1. Depois que todas as tarefas forem concluídas, a fase de confirmação do trabalho renomeará sequencialmente todos os arquivos que foram gravados para partições em locais personalizados em seus caminhos de saída final.
1. O diretório de preparação é excluído antes de a fase de confirmação de trabalho ser concluída.
# O protocolo de confirmação otimizado para EMRFS S3 e carregamentos multipart
Para usar a otimização para substituição de partições dinâmicas no protocolo de confirmação otimizado para EMRFS S3, os carregamentos multipart devem ser habilitados no Amazon EMR. Multipart uploads são habilitados por padrão. Você pode habilitá-los novamente, se necessário. Para obter mais informações, consulte [Configure multipart upload for Amazon S3](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-upload-s3.html#Config_Multipart) (Configurar o carregamento fracionado no Amazon S3) no *Guia de gerenciamento do Amazon EMR*.
Durante a substituição de partições dinâmicas, o protocolo de confirmação otimizado para EMRFS S3 usa as características semelhantes a transações de carregamentos multipart para garantir que os arquivos gravados por tentativas de tarefas apareçam apenas no local de saída do trabalho após a confirmação do trabalho. Ao usar carregamentos multipart dessa maneira, o protocolo de confirmação melhora a performance de confirmação de trabalhos em relação ao padrão `SQLHadoopMapReduceCommitProtocol`. Quando o protocolo de confirmação otimizado para EMRFS S3 é usado, há algumas diferenças fundamentais com relação ao comportamento tradicional de carregamentos multipart a serem consideradas:
+ Os multipart uploads são sempre executados, independentemente do tamanho do arquivo. Isso é diferente do comportamento padrão do EMRFS, em que a propriedade `fs.s3n.multipart.uploads.split.size` controla o tamanho do arquivo no qual multipart uploads são acionados.
+ Os multipart uploads são deixados incompletos por um período mais longo até que a tarefa seja confirmada ou cancelada. Isso é diferente do comportamento padrão do EMRFS no qual um multipart upload é concluído quando uma tarefa é concluída ao gravar um determinado arquivo.
Devido a essas diferenças, se uma JVM do executor do Spark apresenta falha ou é eliminada enquanto as tarefas estão executando e gravando dados no Amazon S3 ou se uma JVM do executor do Spark apresenta falha ou é eliminada enquanto um trabalho está sendo executado, é mais provável que os carregamentos multipart sejam abandonados. Por esse motivo, quando você usa o protocolo de confirmação otimizado para EMRFS S3, não deixe de seguir as práticas recomendadas para gerenciar carregamentos multipart que apresentaram falha. Para obter mais informações, consulte [Práticas recomendadas](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-upload-s3.html#emr-bucket-bestpractices) para trabalhar com buckets do Amazon S3 no *Guia de gerenciamento do Amazon EMR*.
# Considerações sobre ajuste de tarefas
Em executores do Spark, o protocolo de confirmação otimizado para EMRFS S3 consome uma pequena quantidade de memória para cada arquivo gravado por uma tentativa de tarefa até que a tarefa seja confirmada ou cancelada. Na maioria dos trabalhos, a quantidade de memória consumida é insignificante.
Nos drivers do Spark, o protocolo de confirmação otimizado para EMRFS S3 exige memória para armazenar informações de metadados de cada arquivo confirmado até que o trabalho seja confirmado ou cancelado. Na maioria dos trabalhos, a configuração padrão de memória do driver do Spark é insignificante.
Para trabalhos que têm tarefas de execução prolongada que gravam um grande número de arquivos, a memória que o confirmador consome pode ser perceptível e precisar de ajustes na memória alocada para executores do Spark. Você pode ajustar a memória usando a `spark.driver.memory` propriedade dos drivers do Spark e a `spark.executor.memory` propriedade dos executores do Spark. Como diretriz, uma única tarefa gravando 100.000 arquivos normalmente exigiria 100 MB adicionais de memória. Para obter mais informações, consulte [Propriedades da aplicação](https://spark.apache.org/docs/latest/configuration.html#application-properties) na documentação de configuração do Apache Spark.
# Tentar novamente solicitações do Amazon S3 com EMRFS
Este tópico fornece informações sobre as estratégias de novas tentativas que você pode usar ao fazer solicitações ao Amazon S3 com o EMRFS. Quando a taxa de solicitação aumenta, o S3 tenta escalar para suportar a nova taxa. Durante esse processo, o S3 pode controlar a utilização das solicitações e retornar um erro `503 Slow Down`. Para melhorar a taxa de sucesso das solicitações do S3, você pode ajustar sua estratégia de novas tentativas configurando propriedades na sua configuração `emrfs-site`.
Você pode ajustar sua estratégia de novas tentativas das maneiras a seguir.
+ Aumente o limite máximo de novas tentativas para a estratégia padrão de novas tentativas de recuo exponencial.
+ Habilite e configure a estratégia de novas tentativas de additive-increase/multiplicative-decrease (AIMD - aumento aditivo/diminuição multiplicativa). O AIMD é compatível com versões 6.4.0 e posteriores do Amazon EMR.
## Usar a estratégia padrão de recuo exponencial
Por padrão, o EMRFS usa uma estratégia de recuo exponencial para tentar novamente solicitações do Amazon S3. O limite padrão de novas tentativas do EMRFS é 15. Para evitar um erro `503 Slow Down` do S3, você pode aumentar o limite de novas tentativas ao criar um novo cluster, em um cluster em execução ou no runtime da aplicação.
Para aumentar o limite de novas tentativas, você deve alterar o valor de `fs.s3.maxRetries` na sua configuração `emrfs-site`. O exemplo de configuração a seguir define `fs.s3.maxRetries` como um valor personalizado de 30.
```
[
{
"Classification": "emrfs-site",
"Properties": {
"fs.s3.maxRetries": "30"
}
}
]
```
Para obter mais informações sobre como trabalhar com objetos de configuração, consulte [Configurar aplicações](emr-configure-apps.md).
## Usar a estratégia de novas tentativas do AIMD
Com as versões 6.4.0 e posteriores do Amazon EMR, o EMRFS é compatível com uma estratégia alternativa de novas tentativas baseada em um modelo de aumento aditivo/diminuição multiplicativa (AIMD). A estratégia de novas tentativa do AIMD é especialmente útil quando você trabalha com grandes clusters do Amazon EMR.
O AIMD calcula uma taxa de solicitação personalizada usando dados sobre solicitações recentes bem-sucedidas. Essa estratégia diminui o número de solicitações submetidas a controle de utilização e o total de tentativas necessárias por solicitação.
Para habilitar a estratégia de novas tentativas do AIMD, você deve definir a propriedade `fs.s3.aimd.enabled` como `true` em sua configuração `emrfs-site`, como no exemplo a seguir.
```
[
{
"Classification": "emrfs-site",
"Properties": {
"fs.s3.aimd.enabled": "true"
}
}
]
```
Para obter mais informações sobre como trabalhar com objetos de configuração, consulte [Configurar aplicações](emr-configure-apps.md).
## Configurações avançadas de novas tentativas do AIMD
Você pode configurar as propriedades listadas na tabela a seguir para refinar o comportamento de novas tentativas quando usar a estratégia de novas tentativas do AIMD. Para a maioria dos casos de uso, recomendamos que você use os valores padrão.
**Propriedades avançadas da estratégia de novas tentativas do AIMD**
| Propriedade | Valor padrão | Description |
| --- | --- | --- |
| fs.s3.aimd.increaseIncrement | 0.1 | Controla a rapidez com que a taxa de solicitações aumenta quando solicitações consecutivas são bem-sucedidas. |
| fs.s3.aimd.reductionFactor | 2 | Controla a rapidez com que a taxa de solicitação diminui quando o Amazon S3 retorna uma resposta 503. O fator padrão de 2 reduz a taxa de solicitação pela metade. |
| fs.s3.aimd.minRate | 0.1 | Define o limite inferior da taxa de solicitações quando as solicitações sofrem controle de utilização sustentado pelo S3. |
| fs.s3.aimd.initialRate | 5500 | Define a taxa de solicitação inicial, que sofre alterações de acordo com os valores que você especifica para fs.s3.aimd.increaseIncrement e fs.s3.aimd.reductionFactor.A taxa inicial também é usada para solicitações GET e é escalada proporcionalmente (3500/5500) para solicitações PUT. |
| fs.s3.aimd.adjustWindow | 2 | Controla a frequência com que a taxa de solicitação é ajustada, medida em número de respostas. |
| fs.s3.aimd.maxAttempts | 100 | Define o número máximo de tentativas para testar uma solicitação. |
# Adicionar uma etapa do Spark
Você pode usar etapas do Amazon EMR para enviar trabalhos à estrutura do Spark instalada em um cluster do EMR. Para obter mais informações, consulte [Etapas](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-overview.html#emr-overview-data-processing) no Guia de gerenciamento do Amazon EMR. No console e na CLI, você faz isso usando uma etapa de aplicativo Spark, que executa o script `spark-submit` como um etapa em seu nome. Com a API, você pode usar uma etapa para invocar `spark-submit` usando `command-runner.jar`.
Para obter mais informações sobre como enviar aplicações ao Spark, consulte o tópico [Submitting applications](https://spark.apache.org/docs/latest/submitting-applications.html) na documentação do Apache Spark.
**Para enviar uma etapa do Spark usando o console**
1. [Abra o console do Amazon EMR em https://console.aws.amazon.com /emr.](https://console.aws.amazon.com/emr/)
1. Em **Cluster List (Lista de clusters)**, escolha o nome do cluster.
1. Role até a seção **Steps (Etapas)** e expanda-a. Em seguida, escolha **Add step (Adicionar etapa)**.
1. Na caixa de diálogo **Add Step (Adicionar etapa)**:
+ Para **Step type (Tipo de etapa)**, escolha **Spark application (Aplicativo Spark)**.
+ Para **Name (Nome)**, aceite o nome padrão (aplicativo Spark) ou digite um novo nome.
+ Em **Deploy mode (Modo de implantação)**, escolha o modo de **Client (Cliente)** ou de **Cluster**. O modo de cliente inicia o programa de driver na instância primária do cluster, enquanto o modo de cluster inicia o programa de driver no cluster. Para o modo de cliente, a saída do log do driver aparece nos logs de etapa, enquanto para o modo de cluster, a saída do log do driver aparece nos logs do primeiro recipiente YARN. Para obter mais informações, consulte [Cluster mode overview](https://spark.apache.org/docs/latest/cluster-overview.html) na documentação do Apache Spark.
+ Especifique as **Spark-submit options (opções de Spark-submit)** desejadas. Para obter mais informações sobre as opções de `spark-submit`, consulte [Launching applications with spark-submit](https://spark.apache.org/docs/latest/submitting-applications.html#launching-applications-with-spark-submit).
+ Para **Application location (Local do aplicativo)**, especifique o local ou o caminho do URI do S3 do aplicativo.
+ Para **Arguments (Argumentos)**, deixe o campo em branco.
+ Para **Action on failure (Ação na falha)**, aceite a opção padrão **Continue (Continuar)**.
1. Escolha **Adicionar**. A etapa é exibida no console com o status Pendente.
1. O status da etapa muda de **Pending (Pendente)** para **Running (Em execução)** e depois para **Completed (Concluído)** conforme ela é executada. Para atualizar o status, escolha o ícone **Refresh (Atualizar)** acima da coluna **Actions (Ações)**.
1. Os resultados da etapa estão localizados na página Detalhes do cluster do console do Amazon EMR ao lado da etapa em **Arquivos de log** se você tem o registro em log configurado. Opcionalmente, você pode encontrar informações de etapas no bucket de logs configurado ao executar o cluster.
**Para enviar trabalhos para o Spark usando o AWS CLI**
Envie uma etapa ao criar o cluster ou use o subcomando `aws emr add-steps` em um cluster existente.
1. Use `create-cluster`, conforme mostrado no exemplo a seguir.
**nota**
Os caracteres de continuação de linha do Linux (\$1) são incluídos para facilitar a leitura. Eles podem ser removidos ou usados em comandos do Linux. No Windows, remova-os ou substitua-os por um sinal de interpolação (^).
```
aws emr create-cluster --name "Add Spark Step Cluster" --release-label emr-7.12.0 --applications Name=Spark \
--ec2-attributes KeyName=myKey --instance-type m5.xlarge --instance-count 3 \
--steps Type=Spark,Name="Spark Program",ActionOnFailure=CONTINUE,Args=[--class,org.apache.spark.examples.SparkPi,/usr/lib/spark/examples/jars/spark-examples.jar,10] --use-default-roles
```
Como opção, você pode usar `command-runner.jar` conforme mostrado no exemplo a seguir.
```
aws emr create-cluster --name "Add Spark Step Cluster" --release-label emr-7.12.0 \
--applications Name=Spark --ec2-attributes KeyName=myKey --instance-type m5.xlarge --instance-count 3 \
--steps Type=CUSTOM_JAR,Name="Spark Program",Jar="command-runner.jar",ActionOnFailure=CONTINUE,Args=[spark-example,SparkPi,10] --use-default-roles
```
**nota**
Os caracteres de continuação de linha do Linux (\$1) são incluídos para facilitar a leitura. Eles podem ser removidos ou usados em comandos do Linux. No Windows, remova-os ou substitua-os por um sinal de interpolação (^).
1. Como alternativa, adicione etapas a um cluster já em execução. Use `add-steps`.
```
aws emr add-steps --cluster-id j-2AXXXXXXGAPLF --steps Type=Spark,Name="Spark Program",ActionOnFailure=CONTINUE,Args=[--class,org.apache.spark.examples.SparkPi,/usr/lib/spark/examples/jars/spark-examples.jar,10]
```
Como opção, você pode usar `command-runner.jar` conforme mostrado no exemplo a seguir.
```
aws emr add-steps --cluster-id j-2AXXXXXXGAPLF --steps Type=CUSTOM_JAR,Name="Spark Program",Jar="command-runner.jar",ActionOnFailure=CONTINUE,Args=[spark-example,SparkPi,10]
```
**Enviar trabalhos ao Spark usando o SDK para Java**
1. O exemplo a seguir mostra como adicionar uma etapa a um cluster com o Spark usando Java.
```
AWSCredentials credentials = new BasicAWSCredentials(accessKey, secretKey);
AmazonElasticMapReduce emr = new AmazonElasticMapReduceClient(credentials);
StepFactory stepFactory = new StepFactory();
AmazonElasticMapReduceClient emr = new AmazonElasticMapReduceClient(credentials);
AddJobFlowStepsRequest req = new AddJobFlowStepsRequest();
req.withJobFlowId("j-1K48XXXXXXHCB");
List stepConfigs = new ArrayList();
HadoopJarStepConfig sparkStepConf = new HadoopJarStepConfig()
.withJar("command-runner.jar")
.withArgs("spark-submit","--executor-memory","1g","--class","org.apache.spark.examples.SparkPi","/usr/lib/spark/examples/jars/spark-examples.jar","10");
StepConfig sparkStep = new StepConfig()
.withName("Spark Step")
.withActionOnFailure("CONTINUE")
.withHadoopJarStep(sparkStepConf);
stepConfigs.add(sparkStep);
req.withSteps(stepConfigs);
AddJobFlowStepsResult result = emr.addJobFlowSteps(req);
```
1. Visualize os resultados da etapa examinando os logs da etapa. Você pode fazer isso no Console de gerenciamento da AWS caso de ter ativado o registro, escolhendo **Etapas**, selecionando sua etapa e, em **Arquivos de log**, escolhendo `stdout` ou`stderr`. Para ver os logs disponíveis, escolha **View Logs (Exibir logs)**.
## Substituir as definições de configuração padrão do Spark
Você pode querer substituir valores de configuração padrão do Spark para cada aplicativo. Você pode fazer isso ao enviar aplicativos usando uma etapa, que transmite essencialmente opções para `spark-submit`. Por exemplo, você pode querer alterar a memória alocada para um processo de executor modificando `spark.executor.memory`. Você poderia fornecer à opção `--executor-memory` um argumento semelhante ao seguinte:
```
spark-submit --executor-memory 1g --class org.apache.spark.examples.SparkPi /usr/lib/spark/examples/jars/spark-examples.jar 10
```
Da mesma forma, você pode ajustar `--executor-cores` e `--driver-memory`. Em uma etapa, você forneceria os seguintes argumentos para a etapa:
```
--executor-memory 1g --class org.apache.spark.examples.SparkPi /usr/lib/spark/examples/jars/spark-examples.jar 10
```
Você também pode ajustar as configurações que não possam não ter uma opção interna usando `--conf`. Para obter mais informações sobre outras configurações que são ajustáveis, consulte o tópico [Dynamically loading Spark properties](https://spark.apache.org/docs/latest/configuration.html#dynamically-loading-spark-properties) na documentação do Apache Spark.
# Visualizar o histórico de aplicações do Spark
Você pode visualizar detalhes da interface de usuário do Spark, da aplicação YARN e do Tez usando a guia **Interfaces de usuário da aplicação** da página de detalhes de um cluster no console. As interfaces de usuário (IUs) das aplicações do Amazon EMR facilitam a solução de problemas e a análise de trabalhos ativos e do histórico de trabalhos.
Para obter mais informações, consulte [Visualizar histórico de aplicações](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-cluster-application-history.html) no *Guia de gerenciamento do Amazon EMR*.
# Acesse a web do Spark UIs
Você pode visualizar a web do Spark UIs seguindo os procedimentos para criar um túnel SSH ou criar um proxy na seção [Connect to the cluster](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-connect-master-node.html) no Amazon EMR Management Guide e, em seguida, navegando até o YARN do seu cluster. ResourceManager Escolha o link em **Tracking UI (Interface do usuário de rastreamento)** para o seu aplicativo. Se seu aplicativo estiver em execução, você verá **ApplicationMaster**. Isso o levará à interface do usuário web do aplicativo principal na porta 20888 onde o driver está localizado. O driver pode estar localizado no nó primário do cluster se você executa no modo de cliente YARN. Se você estiver executando um aplicativo no modo de cluster do YARN, o driver está localizado no do aplicativo no cluster. ApplicationMaster Se seu aplicativo tiver sido concluído, você verá o **Histórico**, que o levará ao número da porta da HistoryServer interface do usuário do Spark em 18080 do nó primário do cluster EMR. Isso é para aplicativos que já foram concluídos. Você também pode navegar até a HistoryServer interface do usuário do Spark diretamente em http: //:18080/*master-public-dns-name*.
Com as versões 5.25.0 ou posteriores do Amazon EMR, você pode acessar a interface de usuário do servidor de histórico do Spark no console sem configurar um proxy da Web por meio de uma conexão SSH. Para obter mais informações, consulte [View Persistent Application User Interfaces](https://docs.aws.amazon.com/emr/latest/ManagementGuide/app-history-spark-UI.html).
# Uso do conector do Amazon Kinesis Data Streams para streaming estruturado do Spark
As versões 7.1.0 e posteriores do Amazon EMR incluem um conector do Amazon Kinesis Data Streams para streaming estruturado do Spark na imagem de lançamento. Com esse conector, você pode usar o Spark no Amazon EMR para processar dados armazenados no Amazon Kinesis Data Streams. O conector é compatível com os tipos de consumidor de `GetRecords` (throughput compartilhado) e `SubscribeToShard` (fan-out aprimorado). Essa integração é baseada no [https://github.com/awslabs/spark-sql-kinesis-connector](https://github.com/awslabs/spark-sql-kinesis-connector). Para obter detalhes sobre como começar a usar o conector, consulte o [README](https://github.com/awslabs/spark-sql-kinesis-connector/blob/main/README.md).
O exemplo a seguir demonstra como usar o conector para iniciar uma aplicação do Spark com o Amazon EMR
```
spark-submit my_kinesis_streaming_script.py
```
# Usar a integração do Amazon Redshift para Apache Spark com o Amazon EMR
Com as versões 6.4.0 e posteriores do Amazon EMR, cada imagem de versão inclui um conector entre o [Apache Spark](https://aws.amazon.com/emr/features/spark/) e o Amazon Redshift. Com esse conector, você pode usar o Spark no Amazon EMR para processar dados armazenados no Amazon Redshift. Para as versões 6.4.0 a 6.8.0 do Amazon EMR, a integração é baseada no [conector de código aberto `spark-redshift`](https://github.com/spark-redshift-community/spark-redshift#readme). Para as versões 6.9.0 e posteriores do Amazon EMR, a [integração do Amazon Redshift para Apache Spark](https://docs.aws.amazon.com/redshift/latest/mgmt/spark-redshift-connector.html) foi migrada da versão comunitária para uma integração nativa.
**Topics**
+ [
# Inicialização de uma aplicação do Spark usando a integração do Amazon Redshift para Apache Spark
](emr-spark-redshift-launch.md)
+ [
# Autenticação com a integração do Amazon Redshift para Apache Spark
](emr-spark-redshift-auth.md)
+ [
# Leitura e gravação de e para o Amazon Redshift
](emr-spark-redshift-readwrite.md)
+ [
# Considerações e limitações ao usar o conector do Spark
](emr-spark-redshift-considerations.md)
# Inicialização de uma aplicação do Spark usando a integração do Amazon Redshift para Apache Spark
Para as versões 6.4 a 6.9 do Amazon EMR, você deve usar a opção `--jars` ou `--packages` para especificar quais dos seguintes arquivos JAR você deseja usar. A opção `--jars` especifica dependências armazenadas localmente, no HDFS ou usando HTTP/S. Para ver outros locais de arquivos compatíveis com a opção `--jars`, consulte [Gerenciamento avançado de dependências](https://spark.apache.org/docs/latest/submitting-applications.html#advanced-dependency-management) na documentação do Spark. A opção `--packages` especifica dependências armazenadas no repositório público Maven.
+ `spark-redshift.jar`
+ `spark-avro.jar`
+ `RedshiftJDBC.jar`
+ `minimal-json.jar`
As versões 6.10.0 e superiores do Amazon EMR não exigem a dependência `minimal-json.jar` e, por padrão, instalam automaticamente as outras dependências em cada cluster. Os exemplos a seguir mostram como iniciar uma aplicação do Spark com a integração do Amazon Redshift para Apache Spark.
------
#### [ Amazon EMR 6.10.0 \$1 ]
O exemplo a seguir mostra como iniciar uma aplicação do Spark com o conector `spark-redshift` com as versões 6.10 e superiores do Amazon EMR.
```
spark-submit my_script.py
```
------
#### [ Amazon EMR 6.4.0 - 6.9.x ]
Para iniciar uma aplicação do Spark com o conector `spark-redshift` nas versões 6.4 a 6.9 do Amazon EMR, você deve usar a opção `--jars` ou `--packages`, conforme mostrado no exemplo a seguir. Observe que os caminhos listados com a opção `--jars` são os caminhos padrão para os arquivos JAR.
```
spark-submit \
--jars /usr/share/aws/redshift/jdbc/RedshiftJDBC.jar,/usr/share/aws/redshift/spark-redshift/lib/spark-redshift.jar,/usr/share/aws/redshift/spark-redshift/lib/spark-avro.jar,/usr/share/aws/redshift/spark-redshift/lib/minimal-json.jar \
my_script.py
```
------
# Autenticação com a integração do Amazon Redshift para Apache Spark
## Usando AWS Secrets Manager para recuperar credenciais e conectar-se ao Amazon Redshift
O exemplo de código a seguir mostra como você pode usar AWS Secrets Manager para recuperar credenciais para se conectar a um cluster do Amazon Redshift com a interface PySpark do Apache Spark em Python.
```
from pyspark.sql import SQLContext
import boto3
sc = # existing SparkContext
sql_context = SQLContext(sc)
secretsmanager_client = boto3.client('secretsmanager')
secret_manager_response = secretsmanager_client.get_secret_value(
SecretId='string',
VersionId='string',
VersionStage='string'
)
username = # get username from secret_manager_response
password = # get password from secret_manager_response
url = "jdbc:redshift://redshifthost:5439/database?user=" + username + "&password=" + password
# Read data from a table
df = sql_context.read \
.format("io.github.spark_redshift_community.spark.redshift") \
.option("url", url) \
.option("dbtable", "my_table") \
.option("tempdir", "s3://path/for/temp/data") \
.load()
```
## Usar o IAM para recuperar credenciais e conectar-se ao Amazon Redshift
Você pode usar a versão 2 do driver JDBC fornecido pelo Amazon Redshift para se conectar ao Amazon Redshift com o conector do Spark. Para usar AWS Identity and Access Management (IAM), [configure seu URL do JDBC para usar a autenticação do IAM](https://docs.aws.amazon.com/redshift/latest/mgmt/generating-iam-credentials-configure-jdbc-odbc.html). Para se conectar a um cluster do Redshift pelo Amazon EMR, você deve dar ao perfil do IAM as permissões para recuperar credenciais temporárias do IAM. Atribua as permissões ao perfil do IAM para que ele possa recuperar credenciais e executar operações do Amazon S3.
+ [Redshift: GetClusterCredentials](https://docs.aws.amazon.com/redshift/latest/APIReference/API_GetClusterCredentials.html) (para clusters provisionados do Amazon Redshift)
+ [Redshift: DescribeClusters](https://docs.aws.amazon.com/redshift/latest/APIReference/API_DescribeClusters.html) (para clusters provisionados do Amazon Redshift)
+ [Redshift: GetWorkgroup](https://docs.aws.amazon.com/redshift-serverless/latest/APIReference/API_GetWorkgroup.html) (para grupos de trabalho sem servidor do Amazon Redshift)
+ [Redshift: GetCredentials](https://docs.aws.amazon.com/redshift-serverless/latest/APIReference/API_GetCredentials.html) (para grupos de trabalho sem servidor do Amazon Redshift)
+ [s3: GetBucket](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_GetBucket.html)
+ [s3: GetBucketLocation](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketLocation.html)
+ [s3: GetObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html)
+ [s3: PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)
+ [s3: GetBucketLifecycleConfiguration](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketLifecycleConfiguration.html)
Para obter mais informações sobre `GetClusterCredentials`, consulte [Políticas de recursos para `GetClusterCredentials`](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-identity-based.html#redshift-policy-resources.getclustercredentials-resources).
Você também deve garantir que o Amazon Redshift possa assumir o perfil do IAM durante as operações `COPY` e `UNLOAD`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"sts:AssumeRole"
],
"Resource": "arn:aws:iam::123456789012:role/RedshiftServiceRole",
"Sid": "AllowSTSAssumerole"
}
]
}
```
------
O exemplo a seguir usa a autenticação do IAM entre o Spark e o Amazon Redshift:
```
from pyspark.sql import SQLContext
import boto3
sc = # existing SparkContext
sql_context = SQLContext(sc)
url = "jdbc:redshift:iam://redshift-host:redshift-port/db-name"
iam_role_arn = "arn:aws:iam::account-id:role/role-name"
# Read data from a table
df = sql_context.read \
.format("io.github.spark_redshift_community.spark.redshift") \
.option("url", url) \
.option("aws_iam_role", iam_role_arn) \
.option("dbtable", "my_table") \
.option("tempdir", "s3a://path/for/temp/data") \
.mode("error") \
.load()
```
# Leitura e gravação de e para o Amazon Redshift
Os exemplos de código a seguir são usados PySpark para ler e gravar dados de amostra de e para um banco de dados do Amazon Redshift com API de fonte de dados e usando o SparkSQL.
------
#### [ Data source API ]
Use PySpark para ler e gravar dados de amostra de e para um banco de dados do Amazon Redshift com a API de fonte de dados.
```
import boto3
from pyspark.sql import SQLContext
sc = # existing SparkContext
sql_context = SQLContext(sc)
url = "jdbc:redshift:iam://redshifthost:5439/database"
aws_iam_role_arn = "arn:aws:iam::accountID:role/roleName"
df = sql_context.read \
.format("io.github.spark_redshift_community.spark.redshift") \
.option("url", url) \
.option("dbtable", "tableName") \
.option("tempdir", "s3://path/for/temp/data") \
.option("aws_iam_role", "aws_iam_role_arn") \
.load()
df.write \
.format("io.github.spark_redshift_community.spark.redshift") \
.option("url", url) \
.option("dbtable", "tableName_copy") \
.option("tempdir", "s3://path/for/temp/data") \
.option("aws_iam_role", "aws_iam_role_arn") \
.mode("error") \
.save()
```
------
#### [ SparkSQL ]
Use PySpark para ler e gravar dados de amostra de e para um banco de dados do Amazon Redshift com o SparkSQL.
```
import boto3
import json
import sys
import os
from pyspark.sql import SparkSession
spark = SparkSession \
.builder \
.enableHiveSupport() \
.getOrCreate()
url = "jdbc:redshift:iam://redshifthost:5439/database"
aws_iam_role_arn = "arn:aws:iam::accountID:role/roleName"
bucket = "s3://path/for/temp/data"
tableName = "tableName" # Redshift table name
s = f"""CREATE TABLE IF NOT EXISTS {tableName} (country string, data string)
USING io.github.spark_redshift_community.spark.redshift
OPTIONS (dbtable '{tableName}', tempdir '{bucket}', url '{url}', aws_iam_role '{aws_iam_role_arn}' ); """
spark.sql(s)
columns = ["country" ,"data"]
data = [("test-country","test-data")]
df = spark.sparkContext.parallelize(data).toDF(columns)
# Insert data into table
df.write.insertInto(tableName, overwrite=False)
df = spark.sql(f"SELECT * FROM {tableName}")
df.show()
```
------
# Considerações e limitações ao usar o conector do Spark
+ Recomendamos que você ative o SSL para a conexão JDBC do Spark no Amazon EMR ao Amazon Redshift.
+ Recomendamos que você gerencie as credenciais do cluster do Amazon Redshift no AWS Secrets Manager como uma prática recomendada. Consulte [Usando AWS Secrets Manager para recuperar credenciais para se conectar ao Amazon Redshift para](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-secrets-manager-integration.html) ver um exemplo.
+ Recomendamos que você transmita um perfil do IAM com o parâmetro `aws_iam_role` para o parâmetro de autenticação do Amazon Redshift.
+ O URI `tempdir` aponta para um local do Amazon S3. Esse diretório temporário não é limpo automaticamente e, portanto, pode incorrer em custos adicionais.
+ Considere as seguintes recomendações para o Amazon Redshift:
+ Recomendamos bloquear o acesso público ao cluster do Amazon Redshift.
+ Recomendamos ativar o [registro em log de auditoria do Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/db-auditing.html).
+ Recomendamos que você ative a [Criptografia em repouso do Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/security-server-side-encryption.html).
+ Considere as seguintes recomendações para o Amazon S3:
+ Recomendamos que você [bloqueie o acesso público aos buckets do Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-control-block-public-access.html).
+ Recomendamos que você use [criptografia no lado do servidor do Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html) para criptografar os buckets do Amazon S3 usados.
+ Recomendamos que você use as [políticas de ciclo de vida do Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) para definir as regras de retenção para o bucket do Amazon S3.
+ O Amazon EMR sempre verifica o código importado do código aberto para a imagem. Por motivos de segurança, não oferecemos suporte aos seguintes métodos de autenticação do Spark para o Amazon S3:
+ Definindo chaves de AWS acesso na classificação `hadoop-env` de configuração
+ Codificação de chaves de AWS acesso no URI `tempdir`
Para obter mais informações sobre como usar o conector e os parâmetros compatíveis, consulte os seguintes recursos:
+ [Integração do Amazon Redshift para Apache Spark](https://docs.aws.amazon.com/redshift/latest/mgmt/spark-redshift-connector.html) no *Guia de gerenciamento do Amazon Redshift*.
+ O [repositório da comunidade `spark-redshift`](https://github.com/spark-redshift-community/spark-redshift#readme) no GitHub.
# Histórico de versões do Spark
A tabela a seguir informa a versão do Spark incluída em cada versão do Amazon EMR e os componentes instalados com a aplicação. Para obter as versões dos componentes em cada versão, consulte a seção Versão de componentes da sua versão em [Versões 7.x do Amazon EMR](emr-release-7x.md), [Versões de lançamento 6.x do Amazon EMR](emr-release-6x.md) ou [Versões de lançamento 5.x do Amazon EMR](emr-release-5x.md).
**Importante**
[[A versão 2.3.1 do Apache Spark, disponível desde a versão 5.16.0 do Amazon EMR, aborda CVE-2018-8024](https://nvd.nist.gov/vuln/detail/CVE-2018-1334) e CVE-2018-1334](https://nvd.nist.gov/vuln/detail/CVE-2018-8024). Recomendamos que você migre as versões anteriores do Spark para a versão 2.3.1 ou posteriores.
**Informações das versões do Spark**
| Rótulo de versão do Amazon EMR | Versão do Spark | Componentes instalados com o Spark |
| --- | --- | --- |
| emr-7.12.0 | 3.5.6-amzn-1 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-hdfs-zkfc, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-7.11.0 | 3.5.6-amzn-0 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-hdfs-zkfc, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-7.10.0 | 3.5.5-amzn-1 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-7.9.0 | 3.5.5-amzn-0 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-7.8.0 | 3.5.4-amzn-0 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-7.7.0 | 3.5.3-amzn-1 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-7.6.0 | 3.5.3-amzn-0 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-7.5.0 | 3.5.2-amzn-1 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-7.4.0 | 3.5.2-amzn-0 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-7.3.0 | 3.5.1-amzn-1 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-7.2.0 | 3.5.1-amzn-0 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.36.2 | 2.4.8-amzn-2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-7.1.0 | 3.5.0-amzn-1 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-7.0.0 | 3.5.0-amzn-0 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.15.0 | 3.4.1-amzn-2 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.14.0 | 3.4.1-amzn-1 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.13.0 | 3.4.1-amzn-0 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.12.0 | 3.4.0-amzn-0 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.11.1 | 3.3.2-amzn-0.1 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.11.0 | 3.3.2-amzn-0 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.10.1 | 3.3.1-amzn-0.1 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.10.0 | 3.3.1-amzn-0 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.9.1 | 3.3.0-amzn-1.1 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.9.0 | 3.3.0-amzn-1 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.8.1 | 3.3.0-amzn-0.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.8.0 | 3.3.0-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.7.0 | 3.2.1-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.36.1 | 2.4.8-amzn-2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.36.0 | 2.4.8-amzn-2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.6.0 | 3.2.0-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.35.0 | 2.4.8-amzn-1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.5.0 | 3.1.2-amzn-1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.4.0 | 3.1.2-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.3.1 | 3.1.1-amzn-0.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.3.0 | 3.1.1-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.2.1 | 3.0.1-amzn-0.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.2.0 | 3.0.1-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.1.1 | 3.0.0-amzn-0.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.1.0 | 3.0.0-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.0.1 | 2.4.4 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-6.0.0 | 2.4.4 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.34.0 | 2.4.8-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.33.1 | 2.4.7-amzn-1.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.33.0 | 2.4.7-amzn-1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.32.1 | 2.4.7-amzn-0.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.32.0 | 2.4.7-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.31.1 | 2.4.6-amzn-0.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.31.0 | 2.4.6-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.30.2 | 2.4.5-amzn-0.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.30.1 | 2.4.5-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.30.0 | 2.4.5-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-notebook-env, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.29.0 | 2.4.4 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.28.1 | 2.4.4 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.28.0 | 2.4.4 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.27.1 | 2.4.4 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.27.0 | 2.4.4 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.26.0 | 2.4.3 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.25.0 | 2.4.3 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.24.1 | 2.4.2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.24.0 | 2.4.2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.23.1 | 2.4.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.23.0 | 2.4.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.22.0 | 2.4.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.21.2 | 2.4.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.21.1 | 2.4.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.21.0 | 2.4.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.20.1 | 2.4.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.20.0 | 2.4.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.19.1 | 2.3.2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.19.0 | 2.3.2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.18.1 | 2.3.2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.18.0 | 2.3.2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.17.2 | 2.3.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.17.1 | 2.3.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.17.0 | 2.3.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.16.1 | 2.3.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.16.0 | 2.3.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.15.1 | 2.3.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.15.0 | 2.3.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.14.2 | 2.3.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.14.1 | 2.3.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.14.0 | 2.3.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.13.1 | 2.3.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.13.0 | 2.3.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.12.3 | 2.2.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.12.2 | 2.2.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.12.1 | 2.2.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.12.0 | 2.2.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.11.4 | 2.2.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.11.3 | 2.2.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.11.2 | 2.2.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.11.1 | 2.2.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.11.0 | 2.2.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.10.1 | 2.2.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.10.0 | 2.2.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.9.1 | 2.2.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.9.0 | 2.2.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.8.3 | 2.2.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.8.2 | 2.2.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.8.1 | 2.2.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.8.0 | 2.2.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.7.1 | 2.1.1 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.7.0 | 2.1.1 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.6.1 | 2.1.1 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.6.0 | 2.1.1 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.5.4 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.5.3 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.5.2 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.5.1 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.5.0 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.4.1 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.4.0 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.3.2 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.3.1 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.3.0 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.2.3 | 2.0.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.2.2 | 2.0.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.2.1 | 2.0.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.2.0 | 2.0.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.1.1 | 2.0.1 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.1.0 | 2.0.1 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.0.3 | 2.0.1 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.0.2 | 2.0.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.0.1 | 2.0.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-5.0.0 | 2.0.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.9.6 | 1.6.3 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.9.5 | 1.6.3 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.9.4 | 1.6.3 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.9.3 | 1.6.3 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.9.2 | 1.6.3 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.9.1 | 1.6.3 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.8.5 | 1.6.3 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.8.4 | 1.6.3 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.8.3 | 1.6.3 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.8.2 | 1.6.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.8.1 | 1.6.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.8.0 | 1.6.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.7.4 | 1.6.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.7.3 | 1.6.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.7.2 | 1.6.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.7.1 | 1.6.1 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.7.0 | 1.6.1 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.6.1 | 1.6.1 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.6.0 | 1.6.1 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.5.0 | 1.6.1 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.4.0 | 1.6.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.3.0 | 1.6.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.2.0 | 1.5.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.1.0 | 1.5.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
| emr-4.0.0 | 1.4.1 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave |
# Usando visualizações materializadas com o Amazon EMR
O Amazon EMR versão 7.12.0 e posterior oferece suporte à criação e ao gerenciamento de visualizações materializadas do Apache Iceberg no Glue Data Catalog. AWS Uma visão materializada é uma tabela gerenciada que armazena o resultado pré-computado de uma consulta SQL no formato Apache Iceberg e é atualizada incrementalmente à medida que as tabelas de origem subjacentes mudam. Você pode usar visões materializadas para simplificar os pipelines de transformação de dados e acelerar o desempenho das consultas para workloads de analytics complexas.
Quando você cria uma visualização materializada usando o Spark no Amazon EMR, a definição e os metadados da visualização são armazenados no Glue Data Catalog. AWS Os resultados pré-computados são armazenados como tabelas Apache Iceberg em buckets do Amazon S3 Tables ou buckets de uso geral do Amazon S3 em sua conta. AWS O AWS Glue Data Catalog monitora automaticamente as tabelas de origem e atualiza as visualizações materializadas usando a infraestrutura de computação gerenciada.
**Topics**
+ [
## Como as visualizações materializadas funcionam com o Amazon EMR
](#emr-spark-materialized-views-how-it-works)
+ [
## Pré-requisitos
](#emr-spark-materialized-views-prerequisites)
+ [
## Configurar o Spark para usar visões materializadas
](#emr-spark-materialized-views-configure)
+ [
## Criar visualizações materializadas
](#emr-spark-materialized-views-create)
+ [
## Consultar visões materializadas
](#emr-spark-materialized-views-query)
+ [
## Atualizar visões materializadas
](#emr-spark-materialized-views-refresh)
+ [
## Gerenciar visões materializadas
](#emr-spark-materialized-views-manage)
+ [
## Permissões para visões materializadas
](#emr-spark-materialized-views-permissions)
+ [
## Monitorar operações de visão materializada
](#emr-spark-materialized-views-monitoring)
+ [
## Exemplo: concluir fluxo de trabalho
](#emr-spark-materialized-views-example)
+ [
## Considerações e limitações
](#emr-spark-materialized-views-limitations)
## Como as visualizações materializadas funcionam com o Amazon EMR
As visualizações materializadas se integram ao Amazon EMR por meio do suporte Iceberg do Apache Spark. Ao configurar sua sessão do Spark para usar o AWS Glue Data Catalog, você pode criar visualizações materializadas usando a sintaxe SQL padrão. O otimizador do Spark pode reescrever automaticamente as consultas para usar visões materializadas quando elas oferecem melhor desempenho, eliminando a necessidade de modificar manualmente o código da aplicação.
O AWS Glue Data Catalog trata de todos os aspectos operacionais da manutenção da visualização materializada, incluindo:
+ Detecção das alterações nas tabelas de origem usando a camada de metadados do Apache Iceberg
+ Agendamento e execução de operações de atualização usando a computação gerenciada do Spark
+ Determinação se deve realizar uma atualização completa ou incremental com base nas alterações de dados
+ Armazenamento de resultados pré-computados no formato Apache Iceberg para acesso por vários mecanismos
Você pode consultar visualizações materializadas do Amazon EMR usando as mesmas interfaces Spark SQL que você usa para tabelas regulares. Os dados pré-computados também podem ser acessados de outros serviços, incluindo Amazon Athena e Amazon Redshift.
## Pré-requisitos
Para usar visualizações materializadas com o Amazon EMR, você precisa:
+ Uma AWS conta
+ Um cluster do Amazon EMR executando a versão 7.12.0 ou posterior
+ Tabelas de origem no formato Apache Iceberg registradas no AWS Glue Data Catalog
+ AWS Permissões do Lake Formation configuradas para tabelas de origem e bancos de dados de destino
+ Um bucket S3 Tables ou um bucket S3 de uso geral registrado no AWS Lake Formation para armazenar dados de visualização materializada
## Configurar o Spark para usar visões materializadas
Para criar e gerenciar visualizações materializadas, configure sua sessão do Spark com as extensões e configurações de catálogo necessárias do Iceberg. A configuração varia dependendo se suas tabelas de origem e visualizações materializadas usam buckets S3 Tables ou buckets S3 de uso geral.
### Configuração para tabelas S3
Ao usar buckets de tabelas do S3 para visualizações materializadas, configure referências de catálogo separadas para suas tabelas de origem e visualizações materializadas:
```
spark-sql \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions \
--conf spark.sql.catalog.glue_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.glue_catalog.type=glue \
--conf spark.sql.catalog.glue_catalog.warehouse=s3://amzn-s3-demo-bucket/warehouse \
--conf spark.sql.catalog.glue_catalog.glue.region=us-east-1 \
--conf spark.sql.catalog.glue_catalog.glue.id=111122223333 \
--conf spark.sql.catalog.glue_catalog.glue.account-id=111122223333 \
--conf spark.sql.catalog.glue_catalog.glue.lakeformation-enabled=true \
--conf spark.sql.catalog.s3t_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.s3t_catalog.type=glue \
--conf spark.sql.catalog.s3t_catalog.glue.id=111122223333:s3tablescatalog/my-table-bucket \
--conf spark.sql.catalog.s3t_catalog.glue.account-id=111122223333 \
--conf spark.sql.catalog.s3t_catalog.glue.lakeformation-enabled=true \
--conf spark.sql.catalog.s3t_catalog.warehouse=s3://amzn-s3-demo-bucket/mv-warehouse \
--conf spark.sql.catalog.s3t_catalog.glue.region=us-east-1 \
--conf spark.sql.defaultCatalog=s3t_catalog \
// turn on automatic query rewrite (optional)
--conf spark.sql.optimizer.answerQueriesWithMVs.enabled=true
```
### Configuração para buckets de uso geral do S3
Ao usar buckets de uso geral do S3, configure uma única referência de catálogo:
```
spark-sql \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions \
--conf spark.sql.catalog.glue_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.glue_catalog.type=glue \
--conf spark.sql.catalog.glue_catalog.warehouse=s3://amzn-s3-demo-bucket/warehouse \
--conf spark.sql.catalog.glue_catalog.glue.region=us-east-1 \
--conf spark.sql.catalog.glue_catalog.glue.id=111122223333 \
--conf spark.sql.catalog.s3t_catalog.glue.account-id=111122223333 \
--conf spark.sql.catalog.s3t_catalog.glue.lakeformation-enabled=true \
--conf spark.sql.defaultCatalog=glue_catalog \
// turn on automatic query rewrite (optional)
--conf spark.sql.optimizer.answerQueriesWithMVs.enabled=true
```
### Habilitar a atualização incremental
Para ativar a otimização incremental da atualização, adicione as seguintes propriedades de configuração à sua sessão do Spark:
```
spark-sql \
--conf spark.sql.optimizer.incrementalMVRefresh.enabled=true \
```
### Parâmetros de configuração
Os seguintes parâmetros de configuração controlam o comportamento da visão materializada:
+ `spark.sql.extensions`: permite extensões de sessão do Iceberg Spark necessárias para o suporte à visão materializada.
+ `spark.sql.optimizer.answerQueriesWithMVs.enabled`: permite reescrita automática de consultas para usar visões materializadas. Defina como true para ativar essa otimização.
+ `spark.sql.optimizer.incrementalMVRefresh.enabled`: permite a otimização incremental da atualização. Defina como true para processar somente os dados alterados durante as operações de atualização.
## Criar visualizações materializadas
Você cria visualizações materializadas usando a instrução SQL CREATE MATERIALIZED VIEW. A definição da visão especifica a lógica de transformação como uma consulta SQL que faz referência a uma ou mais tabelas de origem.
### DLLs
**Criar visualização**
```
{ CREATE OR REPLACE MATERIALIZED VIEW | CREATE MATERIALIZED VIEW [ IF NOT EXISTS ] }
view_identifier
[ view_clauses ]
[ schedule_clauses ]
AS [ select_statement ]
view_clauses =
{ [ LOCATION location ] |
[ PARTITIONED BY (col [, ...]) ] |
[ COMMENT view_comment ] |
[ SCHEDULE [ REFRESH ] schedule_clause ] }
schedule_clause =
{ EVERY number { HOUR | HOURS | DAY | DAYS | WEEK | WEEKS } }
```
**nota**
As view\$1clauses devem aparecer antes do select\$1statement.
### Criando uma visão materializada básica
O exemplo a seguir cria uma visualização materializada que agrega dados de pedidos por cliente, usa nomes de tabela totalmente qualificados com convenção de nomenclatura de três partes na definição da exibição:
```
CREATE MATERIALIZED VIEW customer_orders
AS
SELECT
customer_name,
COUNT(*) as order_count,
SUM(amount) as total_amount
FROM glue_catalog.sales.orders
GROUP BY customer_name;
```
### Criar uma visão materializada com atualização automática
Para configurar a atualização automática, especifique uma agenda de atualização ao criar a exibição usando nomes de tabela totalmente qualificados com convenção de nomenclatura de três partes na definição da exibição:
```
CREATE MATERIALIZED VIEW customer_orders
SCHEDULE REFRESH EVERY 1 HOUR
AS
SELECT
customer_name,
COUNT(*) as order_count,
SUM(amount) as total_amount
FROM glue_catalog.sales.orders
GROUP BY customer_name;
```
### Criar uma visão materializada com referências de catálogos cruzados
Quando suas tabelas de origem estiverem em um catálogo diferente da visão materializada, use nomes de tabela totalmente qualificados com convenção de nomenclatura em três partes, tanto no nome da visão quanto na definição da visão:
```
CREATE MATERIALIZED VIEW s3t_catalog.analytics.customer_summary
AS
SELECT
customer_name,
COUNT(*) as order_count,
SUM(amount) as total_amount
FROM glue_catalog.sales.orders
GROUP BY customer_name;
```
## Consultar visões materializadas
Depois de criar uma visualização materializada, você pode consultá-la como qualquer outra tabela usando instruções SQL SELECT padrão:
```
SELECT * FROM customer_orders;
```
### Reescrita automática de consultas
Quando a reescrita automática de consultas está habilitada, o otimizador do Spark analisa suas consultas e usa automaticamente visões materializadas quando elas podem melhorar o desempenho. Por exemplo, se você executar a seguinte consulta:
```
SELECT
customer_name,
COUNT(*) as order_count,
SUM(amount) as total_amount
FROM orders
GROUP BY customer_name;
```
O otimizador do Spark reescreve automaticamente essa consulta para usar a visão materializada customer\$1orders em vez de processar a tabela de pedidos base, desde que a visão materializada seja atual.
### Verificar a reescrita automática de consulta
Para verificar se uma consulta usa a reescrita automática de consultas, use o comando EXPLAIN EXTENDED:
```
EXPLAIN EXTENDED
SELECT customer_name, COUNT(*) as order_count, SUM(amount) as total_amount
FROM orders
GROUP BY customer_name;
```
No plano de execução, procure o nome da visualização materializada na BatchScan operação. Se o plano mostrar BatchScan glue\$1catalog.analytics.customer\$1orders em vez de glue\$1catalog.sales.orders, a consulta foi reescrita automaticamente para usar a BatchScan visualização materializada.
**nota**
A reescrita automática de consultas requer tempo para que o cache de metadados do Spark seja preenchido após a criação de uma visualização materializada. Normalmente, esse processo é concluído em 30 segundos.
## Atualizar visões materializadas
Você pode atualizar as visões materializadas usando dois métodos: atualização completa ou atualização incremental. A atualização completa recalcula toda a visão materializada de todos os dados da tabela base, enquanto a atualização incremental processa somente os dados que foram alterados desde a última atualização.
### Atualização manual completa
Para realizar uma atualização completa de uma visão materializada:
```
REFRESH MATERIALIZED VIEW customer_orders FULL;
```
Depois de executar esse comando, consulte a visualização materializada para verificar os resultados atualizados:
```
SELECT * FROM customer_orders;
```
### Atualização incremental manual
Para realizar uma atualização incremental, certifique-se de que a atualização incremental esteja ativada na configuração da sua sessão do Spark e, em seguida, execute:
```
REFRESH MATERIALIZED VIEW customer_orders;
```
O AWS Glue Data Catalog determina automaticamente se a atualização incremental é aplicável com base na definição da visualização e na quantidade de dados alterados. Se a atualização incremental não for possível, a operação retornará à atualização completa.
### Verificar execução da atualização incremental
Para confirmar que a atualização incremental foi executada com êxito, você pode verificar as propriedades da `lastRefreshType` tabela executando os seguintes comandos:
```
SHOW TBLPROPERTIES ("lastRefreshType")
```
Além disso, isso também pode ser feito ativando o registro de depuração modificando a configuração do registro do Spark:
1. Abra o arquivo de configuração do Spark log4j:
```
sudo vim /usr/lib/spark/conf/log4j2.properties
```
1. Adicione as seguintes configurações do registrador:
```
logger.spark.name = org.apache.spark.sql
logger.spark.level = debug
logger.inmemcache.name = org.apache.spark.sql.InMemMvMetadataCache
logger.inmemcache.level = off
```
1. Depois de executar uma operação de atualização, procure a seguinte mensagem na saída do Spark:
```
DEBUG RefreshMaterializedViewExec: Executed Incremental Refresh
```
## Gerenciar visões materializadas
O Amazon EMR fornece comandos SQL para gerenciar o ciclo de vida das visualizações materializadas.
### Descrever uma visão materializada
Para visualizar metadados sobre uma visão materializada, incluindo sua definição, status de atualização e data e hora da última atualização:
```
DESCRIBE EXTENDED customer_orders;
```
### Alterar uma visão materializada
Para modificar o cronograma de atualização de uma visão materializada existente:
```
ALTER MATERIALIZED VIEW customer_orders
ADD SCHEDULE REFRESH EVERY 2 HOURS;
```
Para remover a atualização automática:
```
ALTER MATERIALIZED VIEW customer_orders
DROP SCHEDULE;
```
### Eliminar uma visão materializada
Para excluir uma visão materializada:
```
DROP MATERIALIZED VIEW customer_orders;
```
Esse comando remove a definição de visualização materializada do AWS Glue Data Catalog e exclui os dados subjacentes da tabela Iceberg do seu bucket do S3.
## Permissões para visões materializadas
Para criar e gerenciar visualizações materializadas, você deve configurar as permissões do AWS Lake Formation. O perfil do IAM que cria a visão materializada (o perfil definidor) requer permissões específicas nas tabelas de origem e nos bancos de dados de destino.
### Permissões necessárias para o perfil de definidor
O perfil deve ter as seguintes permissões:
+ Nas tabelas de origem: permissões SELECT ou ALL sem filtros de linha, coluna ou célula
+ No banco de dados de destino: permissão CREATE\$1TABLE
+ Sobre o AWS Glue Data Catalog — GetTable e permissões de CreateTable API
Quando você cria uma visão materializada, o ARN do perfil definidor é armazenado na definição da visão. O AWS Glue Data Catalog assume essa função ao executar operações de atualização automática. Se o perfil do definidor perder o acesso às tabelas de origem, as operações de atualização falharão até que as permissões sejam restauradas.
### Conceder acesso às visões materializadas
Para conceder a outros usuários acesso para consultar uma visualização materializada, use o AWS Lake Formation para conceder a permissão SELECT na tabela de visualização materializada. Os usuários podem consultar a visão materializada sem precisar de acesso direto às tabelas de origem subjacentes.
Para obter informações detalhadas sobre como configurar as permissões do Lake Formation, consulte Conceder e revogar permissões nos recursos do Catálogo de Dados no Guia do Desenvolvedor do AWS Lake Formation.
## Monitorar operações de visão materializada
O AWS Glue Data Catalog publica métricas e registros para operações materializadas de atualização de visualizações na Amazon. CloudWatch Você pode monitorar o status da atualização, a duração e o volume de dados processados por meio de CloudWatch métricas.
### Visualizando métricas de atualização
Para visualizar métricas de atualização de visualizações materializadas:
1. Abra o CloudWatch console.
1. Escolha Métricas no painel de navegação.
1. Selecione o namespace Glue.
1. Filtre as métricas pelo nome da visualização materializada.
### Definir alarmes
Para receber notificações quando as operações de atualização falharem ou excederem a duração esperada, crie CloudWatch alarmes nas métricas de visualização materializada. Você também pode configurar EventBridge as regras da Amazon para acionar respostas automatizadas para atualizar eventos.
## Exemplo: concluir fluxo de trabalho
O exemplo a seguir demonstra um fluxo de trabalho completo para criar e usar uma visão materializada no Amazon EMR.
1. Conecte-se ao nó primário do cluster EMR usando SSH.
1. Crie uma tabela base com dados de amostra:
```
spark-sql \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions \
--conf spark.sql.catalog.glue_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.glue_catalog.type=glue \
--conf spark.sql.catalog.glue_catalog.warehouse=s3://amzn-s3-demo-bucket/warehouse \
--conf spark.sql.catalog.glue_catalog.glue.region=us-east-1 \
--conf spark.sql.catalog.glue_catalog.glue.id=111122223333 \
--conf spark.sql.catalog.glue_catalog.glue.account-id=111122223333 \
--conf spark.sql.catalog.glue_catalog.glue.lakeformation-enabled=true \
--conf spark.sql.defaultCatalog=glue_catalog \
--conf spark.sql.optimizer.answerQueriesWithMVs.enabled=true
CREATE DATABASE IF NOT EXISTS sales;
USE sales;
CREATE TABLE orders (
id INT,
customer_name STRING,
amount DECIMAL(10,2),
order_date DATE
);
INSERT INTO orders VALUES
(1, 'John Doe', 150.00, DATE('2024-01-15')),
(2, 'Jane Smith', 200.50, DATE('2024-01-16')),
(3, 'Bob Johnson', 75.25, DATE('2024-01-17'));
```
1. Crie uma visão materializada:
```
CREATE MATERIALIZED VIEW customer_summary
AS
SELECT
customer_name,
COUNT(*) as order_count,
SUM(amount) as total_amount
FROM glue_catalog.sales.orders
GROUP BY customer_name;
```
1. Consulte a visão materializada:
```
SELECT * FROM customer_summary;
```
1. Insira dados adicionais na tabela base:
```
INSERT INTO orders VALUES
(4, 'Jane Smith', 350.00, DATE('2024-01-18')),
(5, 'Bob Johnson', 100.25, DATE('2024-01-19'));
```
1. Atualize a visão materializada.
```
REFRESH MATERIALIZED VIEW customer_summary FULL;
```
1. Verifique os resultados atualizados:
```
SELECT * FROM customer_summary;
```
## Considerações e limitações
Considere o seguinte ao usar visualizações materializadas com o Amazon EMR:
+ As visualizações materializadas exigem o Amazon EMR versão 7.12.0 ou posterior.
+ As tabelas de origem devem ser tabelas Apache Iceberg registradas no AWS Glue Data Catalog. Tabelas do Apache Hive, do Apache Hudi e do Delta Lake da Linux Foundation não são compatíveis no lançamento.
+ As tabelas de origem devem residir na mesma AWS região e AWS conta da visualização materializada.
+ Todas as tabelas de origem devem ser governadas pelo AWS Lake Formation. Permissões somente do IAM e acesso híbrido não são compatíveis.
+ As visualizações materializadas não podem referenciar visualizações do AWS Glue Data Catalog, visualizações de vários dialetos ou outras visualizações materializadas como tabelas de origem.
+ O perfil definidor das visões deve ter acesso total de leitura (permissão SELECT ou ALL) em todas as tabelas de origem sem a aplicação de filtros de linha, coluna ou célula.
+ Com o tempo, as visões materializadas se tornam consistentes com as tabelas de origem. Durante a janela de atualização, as consultas podem retornar dados obsoletos. Execute a atualização manual para obter consistência imediata.
+ O intervalo mínimo de atualização automática é uma hora.
+ A atualização incremental oferece suporte a um subconjunto restrito de operações SQL. A definição da visualização deve ser um único bloco SELECT-FROM-WHERE-GROUP BY-HAVING e não pode conter operações de conjunto, subconsultas, a palavra-chave DISTINCT em funções SELECT ou agregadas, funções de janela ou junções que não sejam INNER JOIN.
+ A atualização incremental não oferece suporte a funções definidas pelo usuário ou a determinadas funções integradas. Somente um subconjunto das funções integradas do Spark SQL é compatível.
+ A reescrita automática de consultas considera somente visões materializadas cujas definições pertencem a um subconjunto SQL restrito semelhante às restrições de atualização incremental.
+ As operações de atualização completa substituem a tabela inteira e tornam os snapshots anteriores indisponíveis.
+ Identificadores contendo caracteres especiais que não sejam caracteres alfanuméricos e sublinhados não são compatíveis nas consultas CREATE MATERIALIZED VIEW.
+ As colunas de visualização materializada que começam com o prefixo \$1\$1ivm são reservadas para uso do sistema. AWS reserva o direito de modificar ou remover essas colunas em versões futuras.
+ As cláusulas SORT BY, LIMIT, OFFSET, CLUSTER BY e ORDER BY não são compatíveis com as definições de visão materializada.
+ Tabelas de origem entre regiões e entre contas não são compatíveis.
+ Funções não determinísticas, como rand() ou current\$1timestamp(), não são compatíveis nas definições de visão materializada.