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

Conexões do Redshift

Você pode usar o AWS Glue para Spark para ler e gravar tabelas nos bancos de dados do Amazon Redshift. Ao se conectar aos bancos de dados do Amazon Redshift, o AWS Glue move dados pelo Amazon S3 para obter o throughput máximo usando os comandos COPY e UNLOAD do Amazon Redshift SQL. No AWS Glue 4.0 e posteriores, você pode usar a integração do Amazon Redshift para Apache Spark para ler e gravar com otimizações e atributos específicos do Amazon Redshift além dos disponíveis ao fazer a conexão por meio das versões anteriores.

Saiba como o AWS Glue está tornando mais fácil do que nunca para os usuários do Amazon Redshift migrar para o AWS Glue para integração de dados e ETL com tecnologia sem servidor.

Configurar conexões do Redshift

Para usar clusters do Amazon Redshift no AWS Glue, você precisará de alguns pré-requisitos:

Configurar perfis do IAM

Configurar o perfil para o cluster do Amazon Redshift

O cluster do Amazon Redshift precisa poder ler e gravar no Amazon S3 para se integrar com os trabalhos do AWS Glue. Para permitir isso, você pode associar perfis do IAM ao cluster do Amazon Redshift ao qual você deseja se conectar. Seu perfil deve ter uma política que permita ler e gravar no diretório temporário do Amazon S3. Seu perfil deve ter uma relação de confiança que permita ao serviço redshift.amazonaws.com AssumeRole.

Configurar o perfil para o trabalho do AWS Glue

O trabalho do AWS Glue precisa de um perfil para acessar o bucket do Amazon S3. Você não precisa de permissões do IAM para o cluster do Amazon Redshift, seu acesso é controlado pela conectividade no Amazon VPC e por suas credenciais do banco de dados.

Configurar a Amazon VCP

Configurar o AWS Glue

Você precisará criar uma conexão do catálogo de dados do AWS Glue que forneça informações de conexão com a Amazon VPC.

Exemplo: leitura de tabelas do Amazon Redshift

Você pode ler nos clusters do Amazon Redshift e ambientes do Amazon Redshift sem servidor.

Pré-requisitos: uma tabela do Amazon Redshift que você deseja ler. Siga as etapas da seção anterior Configurar conexões do Redshift e, depois disso, você deverá ter o URI do Amazon S3 para um diretório temporário, temp-s3-dir, e um perfil do IAM, rs-role-name, (na conta role-account-id).

Using the Data Catalog

Pré-requisitos adicionais: um banco de dados e uma tabela do catálogo de dados para a tabela do Amazon Redshift que você deseja ler. Para obter mais informações sobre o catálogo de dados, consulte Descoberta e catalogação de dados no AWS Glue. Depois de criar uma entrada para a tabela do Amazon Redshift, você identificará sua conexão com um redshift-dc-database-name e redshift-table-name.

Configuração: nas opções de função, você identificará a tabela do catálogo de dados com os parâmetros database e table_name. Você identificará seu diretório temporário do Amazon S3 com redshift_tmp_dir. Você também fornecerá rs-role-name usando a chave aws_iam_role no parâmetro additional_options.

 glueContext.create_dynamic_frame.from_catalog(
    database = "redshift-dc-database-name", 
    table_name = "redshift-table-name", 
    redshift_tmp_dir = args["temp-s3-dir"], 
    additional_options = {"aws_iam_role": "arn:aws:iam::role-account-id:role/rs-role-name"}) 
        

Connecting directly

Pré-requisitos adicionais: você precisará do nome da sua tabela do Amazon Redshift (redshift-table-name). Você precisará das informações da conexão JDBC para o cluster do Amazon Redshift que armazena essa tabela. Você fornecerá suas informações de conexão com host, porta, redshift-database-name, nome de usuário e senha.

Você pode recuperar suas informações de conexão no console do Amazon Redshift ao trabalhar com clusters do Amazon Redshift. Ao usar o Amazon Redshift sem servidor, consulte Conectar-se ao Amazon Redshift Serverless na documentação do Amazon Redshift.

Configuração: nas opções de função, você identificará os parâmetros url, dbtable, user e password. Você identificará seu diretório temporário do Amazon S3 com redshift_tmp_dir. Você pode especificar seu perfil do IAM usando aws_iam_role quando você usa from_options. A sintaxe é semelhante à conexão por meio do catálogo de dados, mas você coloca os parâmetros no mapa de connection_options.

Não é um prática recomendável codificar senhas em scripts do AWS Glue. Considere armazenar suas senhas do AWS Secrets Manager e recuperá-las no seu script com o SDK for Python (Boto3).

my_conn_options = {  
    "url": "jdbc:redshift://host:port/redshift-database-name",
    "dbtable": "redshift-table-name",
    "user": "username",
    "password": "password",
    "redshiftTmpDir": args["temp-s3-dir"],
    "aws_iam_role": "arn:aws:iam::account id:role/rs-role-name"
}

df = glueContext.create_dynamic_frame.from_options("redshift", my_conn_options)
        

Exemplo: gravaçr em tabelas do Amazon Redshift

Você pode ler dos clusters do Amazon Redshift e em ambientes do Amazon Redshift sem servidor.

Pré-requisitos: um cluster do Amazon Redshift e siga as etapas da seção anterior. Configurar conexões do Redshift. Depois disso, você deverá ter o URI do Amazon S3 para um diretório temporário, temp-s3-dir e um perfil do IAM, rs-role-name, (na conta role-account-id). Você também precisará de um DynamicFrame cujo conteúdo você deseja gravar no banco de dados.

Using the Data Catalog

Pré-requisitos adicionais: um banco de dados do catálogo de dados para o cluster do Amazon Redshift no qual que você deseja gravar. Para obter mais informações sobre o catálogo de dados, consulte Descoberta e catalogação de dados no AWS Glue. Você identificará sua conexão com redshift-dc-database-name e a tabela de destino com redshift-table-name.

Configuração: nas opções de função, você identificará o banco de dados do catálogo de dados com o parâmetros database e depois fornecerá a tabela com table_name. Você identificará seu diretório temporário do Amazon S3 com redshift_tmp_dir. Você também fornecerá rs-role-name usando a chave aws_iam_role no parâmetro additional_options.

 glueContext.write_dynamic_frame.from_catalog(
    frame = input dynamic frame, 
    database = "redshift-dc-database-name", 
    table_name = "redshift-table-name", 
    redshift_tmp_dir = args["temp-s3-dir"], 
    additional_options = {"aws_iam_role": "arn:aws:iam::account-id:role/rs-role-name"}) 
        

Connecting through a AWS Glue connection

Você pode se conectar ao Amazon Redshift diretamente usando o método write_dynamic_frame.from_options. Porém, em vez de inserir os detalhes da conexão diretamente no script, você pode referenciar os detalhes da conexão armazenados em uma conexão do catálogo de dados com o método from_jdbc_conf. Você pode fazer isso sem fazer crawling ou criar tabelas do catálogo de dados para o banco de dados. Para obter mais informações sobre as conexões do catálogo de dados, consulte Conectar a dados.

Pré-requisitos adicionais: uma conexão do catálogo de dados para seu banco de dados, uma tabela do Amazon Redshift que você deseja ler

Configuração: você identificará sua conexão do catálogo de dados com dc-connection-name. Você identificará seu banco de dados e tabela do Amazon Redshift com redshift-table-name e redshift-database-name. Você fornecerá as informações de conexão do catálogo de dados com catalog_connection e as informações do Amazon Redshift com dbtable e database. A sintaxe é semelhante à conexão por meio do catálogo de dados, mas você coloca os parâmetros no mapa de connection_options.

my_conn_options = {
    "dbtable": "redshift-table-name",
    "database": "redshift-database-name",
    "aws_iam_role": "arn:aws:iam::role-account-id:role/rs-role-name"
}

glueContext.write_dynamic_frame.from_jdbc_conf(
    frame = input dynamic frame, 
    catalog_connection = "dc-connection-name", 
    connection_options = my_conn_options, 
    redshift_tmp_dir = args["temp-s3-dir"])
	
        

Referência da opções de conexão do Amazon Redshift

As opções básicas de conexão usadas em todas as conexões JDBC do AWS Glue para configurar informações como url, user e password são consistentes em todos os tipos de JDBC. Para obter mais informações sobre os parâmetros padrão de JDBC consulte Referência de opções de conexão JDBC.

O tipo de conexão do Amazon Redshift tem algumas opções adicionais de conexão:

Opções adicionais de conexão disponíveis no AWS Glue 4.0+

Você também pode transmitir opções para o novo conector do Amazon Redshift por meio das opções de conexão do AWS Glue. Para obter uma lista completa das opções de conectores compatíveis, consulte a seção de Parâmetros do Spark SQL em Amazon Redshift integration for Apache Spark (Integração do Amazon Redshift for Apache Spark).

Para sua conveniência, reiteramos algumas novas opções aqui:

Esses novos parâmetros podem ser usados como se segue.

Novas opções para melhoria de performance

O novo conector introduz algumas novas opções de melhoria de performance:

Para obter informações sobre como usar essas opções, consulte Amazon Redshift integration for Apache Spark (Integração do Amazon Redshift for Apache Spark). Recomendamos que você não ative o autopushdown.s3_result_cache quando tiver operações mistas de leitura e gravação, pois os resultados em cache podem conter informações obsoletas. A opção unload_s3_format é definida como PARQUET por padrão para o comando UNLOAD, para melhorar a performance e reduzir o custo de armazenamento. Para usar o comportamento padrão do comando UNLOAD, redefina a opção como TEXT.

Nova opção de criptografia para leitura

Por padrão, os dados na pasta temporária usada pelo AWS Glue ao ler dados da tabela do Amazon Redshift são criptografados usando a criptografia SSE-S3. Para usar as chaves gerenciadas pelo cliente do AWS Key Management Service (AWS KMS) para criptografar dados, você pode configurar ("sse_kms_key" → kmsKey) em que ksmKey é a ID da chave do AWS KMS, em vez da opção de configuração antiga ("extraunloadoptions" → s"ENCRYPTED KMS_KEY_ID '$kmsKey'") no AWS Glue versão 3.0.

datasource0 = glueContext.create_dynamic_frame.from_catalog(
  database = "database-name", 
  table_name = "table-name", 
  redshift_tmp_dir = args["TempDir"],
  additional_options = {"sse_kms_key":"<KMS_KEY_ID>"}, 
  transformation_ctx = "datasource0"
)

Compatibilidade com a URL JDBC baseada no IAM

O novo conector é compatível com uma URL JDBC baseada no IAM para que você não precise passar um usuário/senha ou um segredo. Com uma URL JDBC baseada no IAM, o conector usa o perfil de runtime de trabalho para acessar a fonte de dados do Amazon Redshift.

Etapa 1: anexar a seguinte política mínima exigida ao perfil de runtime AWS Glue.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "VisualEditor0",
            "Effect": "Allow",
            "Action": "redshift:GetClusterCredentials",
            "Resource": [
                "arn:aws:redshift:<region>:<account>:dbgroup:<cluster name>/*",
                "arn:aws:redshift:*:<account>:dbuser:*/*",
                "arn:aws:redshift:<region>:<account>:dbname:<cluster name>/<database name>"
            ]
        },
        {
            "Sid": "VisualEditor1",
            "Effect": "Allow",
            "Action": "redshift:DescribeClusters",
            "Resource": "*"
        }
    ]
}

Etapa 2: usar a URL do JDBC baseado em IAM como se segue. Especifique uma nova opção DbUser com o nome de usuário do Amazon Redshift com o qual você está se conectando.

conn_options = {
     // IAM-based JDBC URL
    "url": "jdbc:redshift:iam://<cluster name>:<region>/<database name>",
    "dbtable": dbtable,
    "redshiftTmpDir": redshiftTmpDir,
    "aws_iam_role": aws_iam_role,
    "DbUser": "<Redshift User name>" // required for IAM-based JDBC URL
    }

redshift_write = glueContext.write_dynamic_frame.from_options(
    frame=dyf,
    connection_type="redshift",
    connection_options=conn_options
)

redshift_read = glueContext.create_dynamic_frame.from_options(
    connection_type="redshift",
    connection_options=conn_options
)

Migrar do AWS Glue versão 3.0 para a versão 4.0

No AWS Glue 4.0, trabalhos de ETL têm acesso a um novo conector do Amazon Redshift Spark e um novo driver JDBC com opções e configurações diferentes. O novo conector e o novo driver do Amazon Redshift foram criados pensando em performance e mantêm a consistência transacional dos dados. Esses produtos estão documentados na documentação do Amazon Redshift. Para obter mais informações, consulte:

Restrição de nomes e identificadores de tabelas/colunas

O novo conector e driver do Amazon Redshift Spark têm um requisito mais restrito para o nome da tabela do Redshift. Para obter mais informações, consulte Nomes e identificadores para definir o nome da tabela do Amazon Redshift. O fluxo de trabalho de marcadores de trabalho pode não funcionar com um nome de tabela que não corresponda às regras e com determinados caracteres, como espaço.

Se você tiver tabelas antigas com nomes que não estão em conformidade com as regras de nomes e identificadores e tiver problemas com marcadores (trabalhos que reprocessam dados de tabelas antigas do Amazon Redshift), recomendamos que você renomeie as tabelas. Para obter mais informações, consulte Exemplos de ALTER TABLE.

Alteração de tempformat padrão no Dataframe

O conector Spark versão 3.0 da AWS Glue usa como padrão o tempformat para CSV ao gravar no Amazon Redshift. Para ser consistente, no AWS Glue versão 3.0, o DynamicFrame ainda tem como padrão que o tempformat use CSV. Se você já usou APIs de Dataframe do Spark diretamente com o conector do Amazon Redshift Spark, você pode definir explicitamente o tempformat como CSV nas opções DataframeReader/Writer. Caso contrário, o padrão para tempformat é AVRO no novo conector Spark.

Alteração de comportamento: mapeie o tipo de dados REAL do Amazon Redshift para o tipo de dados do FLOAT do Spark, em vez de DOUBLE

No AWS Glue versão 3.0, o Amazon Redshift REAL é convertido em um tipo DOUBLE do Spark. O novo conector do Amazon Redshift Spark atualizou o comportamento para que o tipo REAL do Amazon Redshift seja convertido para o tipo FLOAT do Spark e vice-versa. Se você tiver um caso de uso antigo em que ainda desejar que o tipo REAL do Amazon Redshift seja mapeado para um tipo DOUBLE do Spark, poderá usar a seguinte solução alternativa:

Exemplo de código:

dyf_cast = dyf.apply_mapping([('a', 'long', 'a', 'long'), ('b', 'float', 'b', 'double')])