Simplifique e acelere os aplicativos do Apache Spark nos dados do Amazon Redshift com a integração do Amazon Redshift para o Apache Spark

Republicado por Platão

seguidores: 0

Os clientes usam Amazon RedShift para executar suas análises críticas de negócios em petabytes de dados estruturados e semiestruturados. O Apache Spark é uma estrutura popular que você pode usar para criar aplicativos para casos de uso como ETL (extrair, transformar e carregar), análises interativas e aprendizado de máquina (ML). O Apache Spark permite que você crie aplicativos em várias linguagens, como Java, Scala e Python, acessando os dados em seu data warehouse do Amazon Redshift.

A integração do Amazon Redshift para Apache Spark ajuda os desenvolvedores a criar e executar aplicativos Apache Spark com facilidade nos dados do Amazon Redshift. Os desenvolvedores podem usar análises da AWS e serviços de ML, como Amazon EMR, Cola AWS e Amazon Sage Maker para criar sem esforço aplicativos Apache Spark que leem e gravam em seu data warehouse Amazon Redshift. Você pode fazer isso sem comprometer o desempenho de seus aplicativos ou a consistência transacional de seus dados.

Nesta postagem, discutimos por que a integração do Amazon Redshift para Apache Spark é crítica e eficiente para análises e ML. Além disso, discutimos casos de uso que usam a integração do Amazon Redshift com o Apache Spark para gerar impacto nos negócios. Por fim, mostramos exemplos passo a passo de como usar esse conector oficial da AWS em um aplicativo Apache Spark.

Integração do Amazon Redshift para Apache Spark

A integração do Amazon Redshift para Apache Spark minimiza o processo complicado e muitas vezes manual de configurar um conector spark-redshift (versão da comunidade) e reduz o tempo necessário para se preparar para análises e tarefas de ML. Você só precisa especificar a conexão com seu data warehouse e pode começar a trabalhar com dados do Amazon Redshift de seus aplicativos baseados no Apache Spark em minutos.

Você pode usar vários recursos de empilhamento para operações como classificação, agregação, limite, junção e funções escalares para que apenas os dados relevantes sejam movidos do data warehouse do Amazon Redshift para o aplicativo Apache Spark de consumo. Isso permite que você melhore o desempenho de seus aplicativos. Os administradores do Amazon Redshift podem identificar facilmente o SQL gerado a partir de aplicativos baseados em Spark. Neste post, mostramos como você pode descobrir o SQL gerado pelo trabalho do Apache Spark.

Além disso, a integração do Amazon Redshift para Apache Spark usa o formato de arquivo Parquet ao preparar os dados em um diretório temporário. O Amazon Redshift usa a instrução SQL UNLOAD para armazenar esses dados temporários em Serviço de armazenamento simples da Amazon (Amazônia S3). O aplicativo Apache Spark recupera os resultados do diretório temporário (armazenado no formato de arquivo Parquet), o que melhora o desempenho.

Você também pode ajudar a tornar seus aplicativos mais seguros utilizando Gerenciamento de acesso e identidade da AWS (IAM) para se conectar ao Amazon Redshift.

A integração do Amazon Redshift para Apache Spark é construída sobre o conector spark-redshift (versão da comunidade) e o aprimora para desempenho e segurança, ajudando você a obter um desempenho de aplicativo até 10 vezes mais rápido.

Casos de uso para integração do Amazon Redshift com o Apache Spark

Para nosso caso de uso, a liderança da empresa baseada em produtos deseja saber as vendas de cada produto em vários mercados. Como as vendas da empresa flutuam dinamicamente, tornou-se um desafio para a liderança acompanhar as vendas em vários mercados. No entanto, as vendas gerais estão diminuindo e a liderança da empresa deseja descobrir quais mercados não estão tendo bom desempenho para poder direcionar campanhas de promoção para esses mercados.

Para vendas em vários mercados, os dados de vendas do produto, como pedidos, transações e dados de remessa, estão disponíveis no Amazon S3 no data lake. A equipe de engenharia de dados pode usar o Apache Spark com Amazon EMR ou AWS Glue para analisar esses dados no Amazon S3.

Os dados de inventário estão disponíveis no Amazon Redshift. Da mesma forma, a equipe de engenharia de dados pode analisar esses dados com o Apache Spark usando o Amazon EMR ou um trabalho do AWS Glue usando a integração do Amazon Redshift para Apache Spark para realizar agregações e transformações. O conjunto de dados agregado e transformado pode ser armazenado de volta no Amazon Redshift usando a integração do Amazon Redshift para Apache Spark.

O uso de uma estrutura distribuída como Apache Spark com a integração do Amazon Redshift para Apache Spark pode fornecer visibilidade em todo o data lake e data warehouse para gerar insights de vendas. Esses insights podem ser disponibilizados para as partes interessadas e linha de usuários de negócios no Amazon Redshift para tomar decisões informadas para executar promoções direcionadas para os segmentos de mercado de baixa receita.

Além disso, podemos usar a integração do Amazon Redshift com o Apache Spark nos seguintes casos de uso:

Um cliente do Amazon EMR ou do AWS Glue executando trabalhos do Apache Spark deseja transformar dados e gravá-los no Amazon Redshift como parte de seu pipeline ETL
Um cliente de ML usa Apache Spark com SageMaker para engenharia de recursos para acessar e transformar dados no Amazon Redshift
Um cliente do Amazon EMR, AWS Glue ou SageMaker usa o Apache Spark para análise interativa de dados com dados no Amazon Redshift de notebooks

Exemplos de integração do Amazon Redshift para Apache Spark em um aplicativo Apache Spark

Nesta postagem, mostramos as etapas para conectar o Amazon Redshift do Amazon EMR em Amazon Elastic Compute Nuvem (Amazônia EC2), Amazon EMR sem servidore AWS Glue usando um script comum. No exemplo de código a seguir, geramos um relatório que mostra as vendas trimestrais do ano de 2008. Para fazer isso, unimos duas tabelas do Amazon Redshift usando um Apache Spark DataFrame, executamos um pushdown de predicado, agregamos e classificamos os dados e escrevemos a transformação dados de volta para o Amazon Redshift. O script usa PySpark

O roteiro usa Autenticação baseada em IAM para Amazon Redshift. As funções do IAM usadas pelo Amazon EMR e AWS Glue devem ter as permissões apropriadas para autenticar o Amazon Redshift e acesso a um bucket S3 para armazenamento temporário de dados.

A política de exemplo a seguir permite que a função do IAM chame o GetClusterCredentials operações:

{ "Version": "2012-10-17", "Statement": { "Effect": "Allow", "Action": "redshift:GetClusterCredentials", "Resource": "arn:aws:redshift:<aws_region_name>:xxxxxxxxxxxx:dbuser:*/temp_*" }
}

A política de exemplo a seguir permite acesso a um bucket do S3 para armazenamento temporário de dados:

{ "Version": "2012-10-17", "Statement": [ { "Sid": "VisualEditor0", "Effect": "Allow", "Action": [ "s3:PutObject", "s3:GetObject", "s3:ListBucket" ], "Resource": "arn:aws:s3:::<s3_bucket_name>" } ]
}

O roteiro completo é o seguinte:

from pyspark.sql import SparkSession
from pyspark.sql.functions import col # Initiate Apache Spark session
spark = SparkSession .builder .appName("SparkRedshiftConnector") .enableHiveSupport() .getOrCreate() # Set connection options for Amazon Redshift
jdbc_iam_url = "jdbc:redshift:iam://redshift-spark-connector-1.xxxxxxxxxxx.<aws_region_name>.redshift.amazonaws.com:5439/sample_data_dev"
temp_dir = 's3://<s3_bucket_name>/redshift-temp-dir/'
aws_role = 'arn:aws:iam::xxxxxxxxxxxx:role/redshift-s3' # Set query group for the query. More details on Amazon Redshift WLM https://docs.aws.amazon.com/redshift/latest/dg/cm-c-executing-queries.html
queryGroup = "emr-redshift"
jdbc_iam_url_withQueryGroup = jdbc_iam_url+'?queryGroup='+queryGroup # Set User name for the query
userName = 'awsuser'
jdbc_iam_url_withUserName = jdbc_iam_url_withQueryGroup+';user='+userName # Define the Amazon Redshift context
redshiftOptions = { "url": jdbc_iam_url_withUserName, "tempdir": temp_dir, "aws_iam_role" : aws_role
} # Create the sales DataFrame from Amazon Redshift table using io.github.spark_redshift_community.spark.redshift class
sales_df = ( spark.read .format("io.github.spark_redshift_community.spark.redshift") .options(**redshiftOptions) .option("dbtable", "tickit.sales") .load()
) # Create the date Data Frame from Amazon Redshift table
date_df = ( spark.read .format("io.github.spark_redshift_community.spark.redshift") .options(**redshiftOptions) .option("dbtable", "tickit.date") .load()
) # Assign a Data Frame to the above output which will be written back to Amazon Redshift
output_df= sales_df.join(date_df, sales_df.dateid == date_df.dateid, 'inner').where( col("year") == 2008).groupBy("qtr").sum("qtysold").select( col("qtr"), col("sum(qtysold)")).sort(["qtr"], ascending=[1]).withColumnRenamed("sum(qtysold)","total_quantity_sold") # Display the output
output_df.show() ## Lets drop the queryGroup for easy validation of push down queries
# Set User name for the query
userName = 'awsuser'
jdbc_iam_url_withUserName = jdbc_iam_url+'?user='+userName # Define the Amazon Redshift context
redshiftWriteOptions = { "url": jdbc_iam_url_withUserName, "tempdir": temp_dir, "aws_iam_role" : aws_role
} # Write the Data Frame back to Amazon Redshift
output_df.write .format("io.github.spark_redshift_community.spark.redshift") .mode("overwrite") .options(**redshiftWriteOptions) .option("dbtable", "tickit.test") .save()

Se você planeja usar o script anterior em seu ambiente, certifique-se de substituir os valores das seguintes variáveis pelos valores apropriados para seu ambiente: jdbc_iam_url, temp_dir e aws_role.

Na próxima seção, percorremos as etapas para executar esse script para agregar um conjunto de dados de amostra disponibilizado no Amazon Redshift.

Pré-requisitos

Antes de começarmos, verifique se os seguintes pré-requisitos foram atendidos:

Implante recursos usando o AWS CloudFormation

Conclua as etapas a seguir para implantar a pilha do CloudFormation:

Entre no Console de gerenciamento da AWS, em seguida, inicie a pilha do CloudFormation:

Você também pode baixe o modelo do CloudFormation para criar os recursos mencionados neste post por meio de infraestrutura como código (IaC). Use este modelo ao iniciar uma nova pilha do CloudFormation.

Role até a parte inferior da página para selecionar Reconheço que o AWS CloudFormation pode criar recursos do IAM para Empresa, Em seguida, escolha Criar pilha.

O processo de criação da pilha leva de 15 a 20 minutos para ser concluído. O modelo CloudFormation cria os seguintes recursos:

- Um Amazon VPC com as sub-redes necessárias, tabelas de rotas e gateway NAT
- Um bucket S3 com o nome redshift-spark-databucket-xxxxxxx (observe que xxxxxxx é uma string aleatória para tornar o nome do bucket exclusivo)
- Um cluster do Amazon Redshift com dados de amostra carregados no banco de dados dev e o usuário principal redshiftmasteruser. Para o propósito desta postagem no blog, redshiftmasteruser com permissões administrativas é usado. No entanto, é recomendável usar um usuário com controle de acesso refinado no ambiente de produção.
- Uma função do IAM a ser usada para o Amazon Redshift com a capacidade de solicitar credenciais temporárias do banco de dados de desenvolvimento do cluster do Amazon Redshift
- Estúdio Amazon EMR com as funções IAM necessárias
- Versão 6.9.0 do Amazon EMR em um cluster EC2 com as funções IAM necessárias
- Um aplicativo Amazon EMR Serverless versão 6.9.0
- Uma conexão do AWS Glue e o trabalho do AWS Glue versão 4.0
- A Caderno Jupyter para executar usando o Amazon EMR Studio usando o Amazon EMR em um cluster do EC2
- Um script PySpark para ser executado usando o Amazon EMR Studio e o Amazon EMR Serverless

Após a conclusão da criação da pilha, escolha o nome da pilha redshift-spark e navegue para o Saídas

Utilizamos esses valores de saída posteriormente neste post.

Nas próximas seções, mostramos as etapas para a integração do Amazon Redshift para Apache Spark do Amazon EMR no Amazon EC2, Amazon EMR Serverless e AWS Glue.

Use a integração do Amazon Redshift com o Apache Spark no Amazon EMR no EC2

A partir da versão 6.9.0 e superior do Amazon EMR, o conector que usa a integração do Amazon Redshift para Apache Spark e o driver JDBC do Amazon Redshift estão disponíveis localmente no Amazon EMR. Esses arquivos estão localizados no /usr/share/aws/redshift/ diretório. No entanto, nas versões anteriores do Amazon EMR, o comunidade versão do spark-redshift conector está disponível.

O exemplo a seguir mostra como conectar o Amazon Redshift usando um kernel PySpark por meio de um Estúdio Amazon EMR caderno. A pilha CloudFormation criou Amazon EMR Studio, Amazon EMR em um cluster EC2 e um notebook Jupyter disponível para execução. Para passar por este exemplo, conclua as seguintes etapas:

Baixe o notebook Jupyter disponibilizado no bucket S3 para você:
- Nas saídas da pilha do CloudFormation, procure o valor para EMRStudioNotebook, que deve apontar para o redshift-spark-emr.ipynb notebook disponível no bucket S3.
- Escolha o link ou abra o link em uma nova guia copiando a URL do notebook.
- Depois de abrir o link, baixe o notebook escolhendo Baixar, que salvará o arquivo localmente em seu computador.

Acesse o Amazon EMR Studio escolhendo ou copiando o link fornecido nas saídas da pilha do CloudFormation para a chave EMRStudioURL.
No painel de navegação, escolha Espaços de trabalho.
Escolha Criar espaço de trabalho.
Forneça um nome para o espaço de trabalho, por exemplo redshift-spark.
Expandir o Configuração avançada selecione e selecione Anexar espaço de trabalho a um cluster EMR.
Debaixo Anexar a um cluster EMR, escolha o cluster EMR com o nome emrCluster-Redshift-Spark.
Escolha Criar espaço de trabalho.
Depois que o espaço de trabalho do Amazon EMR Studio for criado e estiver no status Anexado, você poderá acessar o espaço de trabalho escolhendo o nome do espaço de trabalho.

Isso deve abrir o espaço de trabalho em uma nova guia. Observe que, se você tiver um bloqueador de pop-up, talvez seja necessário permitir que o Workspace abra ou desative o bloqueador de pop-up.

No Amazon EMR Studio Workspace, agora carregamos o notebook Jupyter que baixamos anteriormente.

Escolha Escolher arquivo para navegar em seu sistema de arquivos local e fazer upload do notebook Jupyter (redshift-spark-emr.ipynb).
Escolha (clique duas vezes) o redshift-spark-emr.ipynb notebook dentro do espaço de trabalho para abrir o notebook.

O notebook fornece os detalhes das diferentes tarefas que executa. Observe que na seção Defina as variáveis para se conectar ao cluster do Amazon Redshift, você não precisa atualizar os valores para jdbc_iam_url, temp_dir e aws_role porque eles são atualizados para você pelo AWS CloudFormation. O AWS CloudFormation também executou as etapas mencionadas no Pré-requisitos seção do caderno.

Agora você pode começar a executar o notebook.

Execute as células individuais selecionando-as e escolhendo Jogar.

Você também pode usar a combinação de teclas de Shift + Enter or Shift+Retorno. Como alternativa, você pode executar todas as células escolhendo Executar todas as células na Execute menu.

Encontre a operação de pushdown de predicado executada no cluster do Amazon Redshift pela integração do Amazon Redshift para Apache Spark.

Também podemos ver os dados temporários armazenados no Amazon S3 no formato Parquet otimizado. A saída pode ser vista ao executar a célula na seção Obtenha a última consulta executada no Amazon Redshift.

Para validar a tabela criada pelo trabalho do Amazon EMR no Amazon EC2, navegue até o console do Amazon Redshift e escolha o cluster redshift-spark-redshift-cluster na Painel de clusters provisionados Disputas de Comerciais.
Nos detalhes do cluster, no Dados de consulta menu, escolha Consulta no editor de consultas v2.
Escolha o cluster no painel de navegação e conecte-se ao cluster do Amazon Redshift quando ele solicitar autenticação.
Selecionar Credenciais temporárias.
Escolha banco de dados, entrar dev.
Escolha nome de usuário, entrar redshiftmasteruser.
Escolha Salvar.
No painel de navegação, expanda o cluster redshift-spark-redshift-cluster, expanda o banco de dados dev, expanda tickit, e expandir Tabelas para listar todas as tabelas dentro do esquema tickit.

Você deve encontrar a tabela test_emr.

Escolha (clique com o botão direito do mouse) a tabela test_emr, Em seguida, escolha Selecione a tabela para consultar a tabela.
Escolha Execute para executar a instrução SQL.

Use a integração do Amazon Redshift com o Apache Spark no Amazon EMR Serverless

A versão 6.9.0 e superior do Amazon EMR fornece a integração do Amazon Redshift para Apache Spark JARs (gerenciados pelo Amazon Redshift) e Amazon Redshift JDBC JARs localmente no Amazon EMR Serverless também. Esses arquivos estão localizados no /usr/share/aws/redshift/ diretório. No exemplo a seguir, usamos o script Python disponibilizado no bucket S3 pela pilha CloudFormation que criamos anteriormente.

Nas saídas da pilha do CloudFormation, anote o valor para EMRServerlessExecutionScript, que é o local do script Python no bucket do S3.
Observe também o valor de EMRServerlessJobExecutionRole, que é a função do IAM a ser usada na execução do trabalho sem servidor do Amazon EMR.
Acesse o Amazon EMR Studio escolhendo ou copiando o link fornecido nas saídas da pilha do CloudFormation para a chave EMRStudioURL.
Escolha Aplicações para Serverless no painel de navegação.

Você encontrará um aplicativo EMR criado pela pilha CloudFormation com o nome emr-spark-redshift.

Escolha o nome do aplicativo para enviar um trabalho.
Escolha Enviar trabalho.
Debaixo Detalhes do trabalho, Por Nome, digite um nome identificável para o trabalho.
Escolha Função de tempo de execução, escolha a função do IAM que você anotou na saída da pilha do CloudFormation anteriormente.
Escolha Local do script, forneça o caminho para o script Python que você anotou anteriormente na saída da pilha do CloudFormation.
Expandir a seção Propriedades do Spark e escolha o Editar no texto

Digite o seguinte valor na caixa de texto, que fornece o caminho para o redshift-connector, driver JDBC do Amazon Redshift, spark-avro JAR, e minimal-json Arquivos JAR:

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

Escolha Enviar trabalho.
Aguarde até que o trabalho seja concluído e o status de execução seja exibido como RESULTADOS.
Navegue até o editor de consultas do Amazon Redshift para ver se a tabela foi criada com sucesso.
Verifique as consultas pushdown executadas para o grupo de consultas do Amazon Redshift emr-serverless-redshift. Você pode executar a seguinte instrução SQL no banco de dados dev:
```
SELECT query_text FROM SYS_QUERY_HISTORY WHERE query_label = 'emr-serverless-redshift' ORDER BY start_time DESC LIMIT 1
```

Você pode ver que a consulta pushdown e os resultados de retorno são armazenados no formato de arquivo Parquet no Amazon S3.

Use a integração do Amazon Redshift com o Apache Spark no AWS Glue

A partir do AWS Glue versão 4.0 e superior, os trabalhos do Apache Spark que se conectam ao Amazon Redshift podem usar a integração do Amazon Redshift para Apache Spark e o driver JDBC do Amazon Redshift. Os trabalhos existentes do AWS Glue que já usam o Amazon Redshift como origem ou destino podem ser atualizados para o AWS Glue 4.0 para aproveitar esse novo conector. O modelo do CloudFormation fornecido com esta postagem cria os seguintes recursos do AWS Glue:

Conexão AWS Glue para Amazon Redshift – A conexão para estabelecer conexão do AWS Glue para o Amazon Redshift usando a integração do Amazon Redshift para Apache Spark
Função do IAM anexada ao trabalho do AWS Glue – A função IAM para gerenciar permissões para executar o trabalho do AWS Glue
Trabalho do AWS Glue – O script para o trabalho do AWS Glue realizando transformações e agregações usando a integração do Amazon Redshift para Apache Spark

O exemplo a seguir usa a conexão do AWS Glue anexada ao trabalho do AWS Glue com PySpark e inclui as seguintes etapas:

No console AWS Glue, escolha Coneções no painel de navegação.
Debaixo Coneções, escolha a conexão AWS Glue para Amazon Redshift criada pelo modelo CloudFormation.
Verifique os detalhes da conexão.

Agora você pode reutilizar essa conexão em um trabalho ou em vários trabalhos.

No conectores página, escolha o trabalho do AWS Glue criado pela pilha do CloudFormation em seus trabalhos, ou acesse o trabalho do AWS Glue usando o URL fornecido para a chave GlueJob na saída da pilha do CloudFormation.
Acesse e verifique o script para o trabalho do AWS Glue.
No Detalhes do trabalho guia, certifique-se de que Versão de cola está definido para Cola 4.0.

Isso garante que o trabalho use a versão mais recente redshift-spark conector.

Expandir Propriedades avançadas e na Coneções seção, verifique se a conexão criada pela pilha do CloudFormation está anexada.
Verifique os parâmetros de trabalho adicionados para o trabalho do AWS Glue. Esses valores também estão disponíveis na saída para a pilha do CloudFormation.
Escolha Salvar e depois Execute.

Você pode visualizar o status da execução do job no Execute aba.

Depois que a execução do trabalho for concluída com êxito, você poderá verificar a saída da tabela test-glue criada pelo trabalho do AWS Glue.
Verificamos as consultas pushdown executadas para o grupo de consultas do Amazon Redshift glue-redshift. Você pode executar a seguinte instrução SQL no banco de dados dev:
```
SELECT query_text FROM SYS_QUERY_HISTORY WHERE query_label = 'glue-redshift' ORDER BY start_time DESC LIMIT 1
```

Melhores práticas

Tenha em mente as seguintes práticas recomendadas:

Considere usar a integração do Amazon Redshift para Apache Spark do Amazon EMR em vez de usar o redshift-spark conector (versão da comunidade) para seus novos trabalhos do Apache Spark.
Se você tiver trabalhos existentes do Apache Spark usando o redshift-spark conector (versão da comunidade), considere atualizá-los para usar a integração do Amazon Redshift para Apache Spark
A integração do Amazon Redshift para Apache Spark aplica automaticamente predicado e pushdown de consulta para otimizar o desempenho. Recomendamos o uso de funções suportadas (autopushdown) em sua consulta. A integração do Amazon Redshift para Apache Spark transformará a função em uma consulta SQL e executará a consulta no Amazon Redshift. Essa otimização resulta na recuperação dos dados necessários, para que o Apache Spark possa processar menos dados e ter melhor desempenho.
- Considere o uso de funções pushdown agregadas como avg, count, max, min e sum para recuperar dados filtrados para processamento de dados.
- Considere o uso de operadores pushdown booleanos como in, isnull, isnotnull, contains, endswith e startswith para recuperar dados filtrados para processamento de dados.
- Considere o uso de operadores pushdown lógicos como and, or e not (ou !) para recuperar dados filtrados para processamento de dados.
Recomenda-se passar uma função IAM usando o parâmetro aws_iam_role para a autenticação do Amazon Redshift de seu aplicativo Apache Spark no Amazon EMR ou AWS Glue. A função do IAM deve ter as permissões necessárias para recuperar credenciais temporárias do IAM para autenticação no Amazon Redshift, conforme mostrado na seção “Exemplos de integração do Amazon Redshift para Apache Spark em um aplicativo Apache Spark” deste blog.
Com esse recurso, você não precisa manter seu nome de usuário e senha do Amazon Redshift no gerenciador de segredos e no banco de dados do Amazon Redshift.
O Amazon Redshift usa a instrução SQL UNLOAD para armazenar esses dados temporários no Amazon S3. O aplicativo Apache Spark recupera os resultados do diretório temporário (armazenado no formato de arquivo Parquet). Esse diretório temporário no Amazon S3 não é limpo automaticamente e, portanto, pode adicionar custos adicionais. Recomendamos usar Políticas de ciclo de vida do Amazon S3 para definir as regras de retenção para o bucket S3.
É recomendável ativar Log de auditoria do Amazon Redshift para registrar as informações sobre conexões e atividades do usuário em seu banco de dados.
É recomendável ativar Criptografia em repouso do Amazon Redshift para criptografar seus dados conforme o Amazon Redshift os grava em seus datacenters e descriptografá-los para você quando você os acessa.
É recomendável atualizar para o AWS Glue v4.0 e superior para usar a integração do Amazon Redshift para Apache Spark, que está disponível imediatamente. A atualização para esta versão do AWS Glue usará automaticamente esse recurso.
É recomendável atualizar para o Amazon EMR v6.9.0 e superior para usar a integração do Amazon Redshift para Apache Spark. Você não precisa gerenciar nenhum driver ou arquivo JAR explicitamente.
Considere o uso de notebooks do Amazon EMR Studio para interagir com seus dados do Amazon Redshift em seu aplicativo Apache Spark.
Considere usar o AWS Glue Studio para criar trabalhos do Apache Spark usando uma interface visual. Você também pode alternar para escrever código Apache Spark em Scala ou PySpark no AWS Glue Studio.

limpar

Conclua as etapas a seguir para limpar os recursos que são criados como parte do modelo do CloudFormation para garantir que você não seja cobrado pelos recursos se não for mais usá-los:

Interrompa o aplicativo Amazon EMR Serverless:
- Acesse o Amazon EMR Studio escolhendo ou copiando o link fornecido nas saídas da pilha do CloudFormation para a chave EMRStudioURL.
- Escolha Aplicações para Serverless no painel de navegação.

Você encontrará um aplicativo EMR criado pela pilha CloudFormation com o nome emr-spark-redshift.

- Se o status do aplicativo for Parado, você poderá passar para as próximas etapas. No entanto, se o status do aplicativo for Iniciado, escolha o nome do aplicativo e escolha Interromper aplicação e Interromper aplicação novamente para confirmar.

Exclua o espaço de trabalho do Amazon EMR Studio:
- Acesse o Amazon EMR Studio escolhendo ou copiando o link fornecido nas saídas da pilha do CloudFormation para a chave EMRStudioURL.
- Escolha Espaços de trabalho no painel de navegação.
- Selecione o espaço de trabalho que você criou e escolha Apagar, Em seguida, escolha Apagar novamente para confirmar.
Exclua a pilha do CloudFormation:

- No console do AWS CloudFormation, navegue até a pilha que você criou anteriormente.
- Escolha o nome da pilha e, em seguida, escolha Apagar para remover a pilha e excluir os recursos criados como parte desta postagem.
- Na tela de confirmação, escolha Excluir pilha.

Conclusão

Nesta postagem, explicamos como você pode usar a integração do Amazon Redshift para Apache Spark para criar e implantar aplicativos com Amazon EMR no Amazon EC2, Amazon EMR Serverless e AWS Glue para aplicar automaticamente predicado e pushdown de consulta para otimizar o desempenho da consulta de dados no Amazon Redshift. É altamente recomendável usar a integração do Amazon Redshift para Apache Spark para uma conexão perfeita e segura com o Amazon Redshift de seu Amazon EMR ou AWS Glue.

Aqui está o que alguns de nossos clientes têm a dizer sobre a integração do Amazon Redshift para Apache Spark:

“Fortalecemos nossos engenheiros para criar seus pipelines de dados e aplicativos com o Apache Spark usando Python e Scala. Queríamos uma solução personalizada que simplificasse as operações e fosse entregue com mais rapidez e eficiência para nossos clientes, e é isso que obtemos com a nova integração do Amazon Redshift para Apache Spark.”

— Consultoria Huron

“A GE Aerospace usa análises da AWS e Amazon Redshift para permitir insights de negócios críticos que impulsionam importantes decisões de negócios. Com o suporte para cópia automática do Amazon S3, podemos criar pipelines de dados mais simples para mover dados do Amazon S3 para o Amazon Redshift. Isso acelera a capacidade de nossas equipes de produtos de dados de acessar dados e fornecer informações aos usuários finais. Gastamos mais tempo agregando valor por meio de dados e menos tempo em integrações.”

—GE Aeroespacial

“Nosso foco é fornecer acesso de autoatendimento aos dados para todos os nossos usuários do Goldman Sachs. Por meio do Legend, nossa plataforma de gerenciamento e governança de dados de código aberto, permitimos que os usuários desenvolvam aplicativos centrados em dados e obtenham insights orientados por dados enquanto colaboramos em todo o setor de serviços financeiros. Com a integração do Amazon Redshift para Apache Spark, nossa equipe de plataforma de dados poderá acessar os dados do Amazon Redshift com etapas manuais mínimas, permitindo ETL de código zero que aumentará nossa capacidade de tornar mais fácil para os engenheiros se concentrarem no aperfeiçoamento de seu fluxo de trabalho como eles coletam informações completas e oportunas. Esperamos ver uma melhoria no desempenho dos aplicativos e segurança aprimorada, pois nossos usuários agora podem acessar facilmente os dados mais recentes no Amazon Redshift.”

—Goldman Sachs

Sobre os autores

Gagan Brahmi é um Arquiteto de Soluções Especialista Sênior focado em análise de big data e plataforma AI/ML na Amazon Web Services. Gagan tem mais de 18 anos de experiência em tecnologia da informação. Ele ajuda os clientes a arquitetar e criar soluções baseadas em nuvem altamente escaláveis, de alto desempenho e seguras na AWS. Em seu tempo livre, ele passa tempo com sua família e explora novos lugares.

Vivek Gautama é arquiteto de dados com especialização em data lakes na AWS Professional Services. Ele trabalha com clientes corporativos criando produtos de dados, plataformas analíticas e soluções na AWS. Quando não está construindo e projetando data lakes, Vivek é um entusiasta da gastronomia que também gosta de explorar novos destinos de viagem e fazer caminhadas.

Naresh Gautama é um líder de análise de dados e IA/ML na AWS com 20 anos de experiência, que gosta de ajudar os clientes a arquitetar análises de dados altamente disponíveis, de alto desempenho e econômicas e soluções de IA/ML para capacitar os clientes com tomadas de decisão baseadas em dados . Em seu tempo livre, gosta de meditar e cozinhar.

Beaux Sharifi é um engenheiro de desenvolvimento de software da equipe de drivers do Amazon Redshift, onde lidera o desenvolvimento da integração do Amazon Redshift com o conector Apache Spark. Ele tem mais de 20 anos de experiência na criação de plataformas baseadas em dados em vários setores. Nas horas vagas, gosta de ficar com a família e surfar.