Consultar o Amazon Redshift usando o Azure Databricks

Você pode ler e gravar tabelas do Amazon Redshift com o Azure Databricks.

A fonte de dados do Databricks Redshift usa Amazon S3 para transferir dados de forma eficiente para dentro e fora do Redshift e utiliza JDBC para disparar automaticamente os comandos apropriados COPY e UNLOAD no Redshift.

Uso

Os exemplos a seguir demonstram a conexão com o driver do Redshift. Substitua os valores do parâmetro url se estiver usando o driver JDBC do PostgreSQL.

Depois de configurar suas credenciais do AWS, você pode usar a fonte de dados com a API de fonte de dados do Spark em Python, SQL, R ou Scala.

Python

# Read data from a table using Databricks Runtime 10.4 LTS and below
df = (spark.read
  .format("redshift")
  .option("dbtable", table_name)
  .option("tempdir", "s3a://<bucket>/<directory-path>")
  .option("url", "jdbc:redshift://<database-host-url>")
  .option("user", username)
  .option("password", password)
  .option("forward_spark_s3_credentials", True)
  .load()
)

# Read data from a table using Databricks Runtime 11.3 LTS and above
df = (spark.read
  .format("redshift")
  .option("host", "hostname")
  .option("port", "port") # Optional - will use default port 5439 if not specified.
  .option("user", "username")
  .option("password", "password")
  .option("database", "database-name")
  .option("dbtable", "schema-name.table-name") # if schema-name is not specified, default to "public".
  .option("tempdir", "s3a://<bucket>/<directory-path>")
  .option("forward_spark_s3_credentials", True)
  .load()
)

# Read data from a query
df = (spark.read
  .format("redshift")
  .option("query", "select x, count(*) <your-table-name> group by x")
  .option("tempdir", "s3a://<bucket>/<directory-path>")
  .option("url", "jdbc:redshift://<database-host-url>")
  .option("user", username)
  .option("password", password)
  .option("forward_spark_s3_credentials", True)
  .load()
)

# After you have applied transformations to the data, you can use
# the data source API to write the data back to another table

# Write back to a table
(df.write
  .format("redshift")
  .option("dbtable", table_name)
  .option("tempdir", "s3a://<bucket>/<directory-path>")
  .option("url", "jdbc:redshift://<database-host-url>")
  .option("user", username)
  .option("password", password)
  .mode("error")
  .save()
)

# Write back to a table using IAM Role based authentication
(df.write
  .format("redshift")
  .option("dbtable", table_name)
  .option("tempdir", "s3a://<bucket>/<directory-path>")
  .option("url", "jdbc:redshift://<database-host-url>")
  .option("user", username)
  .option("password", password)
  .option("aws_iam_role", "arn:aws:iam::123456789000:role/redshift_iam_role")
  .mode("error")
  .save()
)

SQL

Leia dados usando o SQL no Databricks Runtime 10.4 LTS e abaixo:

DROP TABLE IF EXISTS redshift_table;
CREATE TABLE redshift_table
USING redshift
OPTIONS (
  dbtable '<table-name>',
  tempdir 's3a://<bucket>/<directory-path>',
  url 'jdbc:redshift://<database-host-url>',
  user '<username>',
  password '<password>',
  forward_spark_s3_credentials 'true'
);
SELECT * FROM redshift_table;

Leia dados usando o SQL no Databricks Runtime 11.3 LTS e acima:

DROP TABLE IF EXISTS redshift_table;
CREATE TABLE redshift_table
USING redshift
OPTIONS (
  host '<hostname>',
  port '<port>', /* Optional - will use default port 5439 if not specified. *./
  user '<username>',
  password '<password>',
  database '<database-name>'
  dbtable '<schema-name>.<table-name>', /* if schema-name not provided, default to "public". */
  tempdir 's3a://<bucket>/<directory-path>',
  forward_spark_s3_credentials 'true'
);
SELECT * FROM redshift_table;

Gravar dados usando SQL:

DROP TABLE IF EXISTS redshift_table;
CREATE TABLE redshift_table_new
USING redshift
OPTIONS (
  dbtable '<new-table-name>',
  tempdir 's3a://<bucket>/<directory-path>',
  url 'jdbc:redshift://<database-host-url>',
  user '<username>',
  password '<password>',
  forward_spark_s3_credentials 'true'
) AS
SELECT * FROM table_name;

A API do SQL dá suporte apenas à criação de novas tabelas e não à substituição ou acréscimo.

R

Leia os dados usando o R no Databricks Runtime 10.4 LTS e abaixo:

df <- read.df(
   NULL,
   "com.databricks.spark.redshift",
   tempdir = "s3a://<your-bucket>/<your-directory-path>",
   dbtable = "<your-table-name>",
   url = "jdbc:redshift://<the-rest-of-the-connection-string>")

Leia dados usando o R no Databricks Runtime 11.3 LTS e superior:

df <- read.df(
  NULL,
  "redshift",
  host = "hostname",
  port = "port",
  user = "username",
  password = "password",
  database = "database-name",
  dbtable = "schema-name.table-name",
  tempdir = "s3a://<your-bucket>/<your-directory-path>",
  forward_spark_s3_credentials = "true",
  dbtable = "<your-table-name>")

Scala (linguagem de programação)

// Read data from a table using Databricks Runtime 10.4 LTS and below
val df = spark.read
  .format("redshift")
  .option("dbtable", table_name)
  .option("tempdir", "s3a://<bucket>/<directory-path>")
  .option("url", "jdbc:redshift://<database-host-url>")
  .option("user", username)
  .option("password", password)
  .option("forward_spark_s3_credentials", True)
  .load()

// Read data from a table using Databricks Runtime 11.3 LTS and above
val df = spark.read
  .format("redshift")
  .option("host", "hostname")
  .option("port", "port") /* Optional - will use default port 5439 if not specified. */
  .option("user", "username")
  .option("password", "password")
  .option("database", "database-name")
  .option("dbtable", "schema-name.table-name") /* if schema-name is not specified, default to "public". */
  .option("tempdir", "s3a://<bucket>/<directory-path>")
  .option("forward_spark_s3_credentials", true)
  .load()

// Read data from a query
val df = spark.read
  .format("redshift")
  .option("query", "select x, count(*) <your-table-name> group by x")
  .option("tempdir", "s3a://<bucket>/<directory-path>")
  .option("url", "jdbc:redshift://<database-host-url>")
  .option("user", username)
  .option("password", password)
  .option("forward_spark_s3_credentials", True)
  .load()

// After you have applied transformations to the data, you can use
// the data source API to write the data back to another table

// Write back to a table
df.write
  .format("redshift")
  .option("dbtable", table_name)
  .option("tempdir", "s3a://<bucket>/<directory-path>")
  .option("url", "jdbc:redshift://<database-host-url>")
  .option("user", username)
  .option("password", password)
  .mode("error")
  .save()

// Write back to a table using IAM Role based authentication
df.write
  .format("redshift")
  .option("dbtable", table_name)
  .option("tempdir", "s3a://<bucket>/<directory-path>")
  .option("url", "jdbc:redshift://<database-host-url>")
  .option("user", username)
  .option("password", password)
  .option("aws_iam_role", "arn:aws:iam::123456789000:role/redshift_iam_role")
  .mode("error")
  .save()

Recomendações para trabalhar com o Redshift

A execução da consulta pode extrair grandes quantidades de dados para S3. Se você planeja executar várias consultas em relação aos mesmos dados no Redshift, o Databricks recomenda salvar os dados extraídos usando o Delta Lake.

Configuração

Autenticação no S3 e no Redshift

A fonte de dados envolve várias conexões de rede, ilustradas no diagrama a seguir:

                            ┌───────┐
       ┌───────────────────>│  S3   │<─────────────────┐
       │    IAM or keys     └───────┘    IAM or keys   │
       │                        ^                      │
       │                        │ IAM or keys          │
       v                        v               ┌──────v────┐
┌────────────┐            ┌───────────┐         │┌──────────┴┐
│  Redshift  │            │  Spark    │         ││   Spark   │
│            │<──────────>│  Driver   │<────────>| Executors │
└────────────┘            └───────────┘          └───────────┘
               JDBC with                  Configured
               username /                     in
               password                     Spark
        (SSL enabled by default)

A fonte de dados lê e grava dados no S3 ao transferir dados de/para o Redshift. Como resultado, ele requer credenciais do AWS com acesso de leitura e gravação a um bucket S3 (especificado usando o tempdir parâmetro de configuração).

As seções a seguir descrevem as opções de configuração de autenticação de cada conexão:

• Driver do Spark para Redshift
• Spark para S3
• Redshift para S3

Driver do Spark para Redshift

O driver spark se conecta ao Redshift via JDBC usando um nome de usuário e senha. O Redshift não dá suporte ao uso de funções IAM para autenticar essa conexão. Por padrão, essa conexão usa criptografia SSL; para obter mais detalhes, consulte Criptografia.

Spark para S3

O S3 atua como um intermediário para armazenar dados em massa ao ler ou gravar no Redshift. O Spark conecta-se ao S3 usando as interfaces do Hadoop FileSystem e usando diretamente o cliente S3 do SDK do Amazon Java.

• Definir chaves na configuração do Hadoop: Você pode especificar chaves AWS usando propriedades de configuração do Hadoop. Se a configuração tempdir apontar para um sistema de arquivos s3a://, você pode definir as propriedades fs.s3a.access.key e fs.s3a.secret.key em um arquivo de configuração XML do Hadoop ou chamar sc.hadoopConfiguration.set() para configurar a configuração global do Hadoop no Spark. Se você usar um s3n:// sistema de arquivos, poderá fornecer as chaves de configuração herdadas, conforme mostrado no exemplo a seguir.

  Scala (linguagem de programação)

  Por exemplo, se você estiver usando o s3a sistema de arquivos, adicione:

  sc.hadoopConfiguration.set("fs.s3a.access.key", "<your-access-key-id>")
  sc.hadoopConfiguration.set("fs.s3a.secret.key", "<your-secret-key>")
  

  Para o sistema de arquivos herdado s3n , adicione:

  sc.hadoopConfiguration.set("fs.s3n.awsAccessKeyId", "<your-access-key-id>")
  sc.hadoopConfiguration.set("fs.s3n.awsSecretAccessKey", "<your-secret-key>")
  

  Python

  O comando a seguir depende de alguns internos do Spark, mas deve funcionar com todas as versões do PySpark e é improvável que mude no futuro:

    sc._jsc.hadoopConfiguration().set("fs.s3a.access.key", "<your-access-key-id>")
    sc._jsc.hadoopConfiguration().set("fs.s3a.secret.key", "<your-secret-key>")
  

Redshift para S3

Defina a opção forward_spark_s3_credentials para true encaminhar automaticamente as credenciais de chave do AWS que o Spark está usando para se conectar ao S3 via JDBC para o Redshift. A consulta JDBC insere essas credenciais, portanto, o Databricks recomenda fortemente que você habilite a criptografia SSL da conexão JDBC.

Encriptação

• Protegendo jdbc: a menos que quaisquer configurações relacionadas a SSL estejam presentes na URL JDBC, a fonte de dados por padrão habilita a criptografia SSL e também verifica se o servidor Redshift é confiável (ou seja, sslmode=verify-full). Para isso, um certificado de servidor é baixado automaticamente dos servidores Amazon na primeira vez que é necessário. Caso isso falhe, um arquivo de certificado pré-empacotado é usado como um fallback. Isso vale tanto para o Redshift quanto para os drivers JDBC do PostgreSQL.

  Caso haja algum problema com esse recurso ou você simplesmente queira desabilitar o SSL, você pode chamar .option("autoenablessl", "false") seu DataFrameReader ou DataFrameWriter.

  Se você quiser especificar configurações personalizadas relacionadas a SSL, siga as instruções na documentação do Redshift: Usando SSL e Certificados de Servidor em Java e Opções de Configuração do Driver JDBC. Quaisquer opções relacionadas a SSL presentes no JDBC url usado com a fonte de dados terão precedência (ou seja, a configuração automática não será ativada).

• Criptografar dados UNLOAD armazenados em S3 (dados armazenados ao ler do Redshift): de acordo com a documentação do Redshift sobre o Descarregamento de Dados para S3, "UNLOAD criptografa automaticamente arquivos de dados usando a criptografia do lado do servidor do Amazon S3 (SSE-S3)."

  O Redshift também dá suporte à criptografia do lado do cliente com uma chave personalizada (veja: Descarregando arquivos de dados criptografados), mas a fonte de dados não tem a capacidade de especificar a chave simétrica necessária.

• Criptografando dados COPY armazenados em S3 (dados armazenados ao gravar no Redshift): de acordo com a documentação do Redshift sobre Carregar Arquivos de Dados Criptografados do Amazon S3:

Você pode usar o COPY comando para carregar arquivos de dados que foram carregados no Amazon S3 usando criptografia do lado do servidor com chaves de criptografia gerenciadas pelo AWS (SSE-S3 ou SSE-KMS), criptografia do lado do cliente ou ambas. O COPY não dá suporte à criptografia do lado do servidor do Amazon S3 com uma chave fornecida pelo cliente (SSE-C).

Parâmetros

O mapa de parâmetros ou OPÇÕES fornecido no SQL do Spark dá suporte às seguintes configurações:

Opções de configuração adicionais

Configurando o tamanho máximo das colunas de cadeia de caracteres

Ao criar tabelas do Redshift, o comportamento padrão é criar TEXT colunas para colunas de cadeia de caracteres. O Redshift armazena TEXT colunas como VARCHAR(256), portanto, essas colunas têm um tamanho máximo de 256 caracteres (origem).

Para dar suporte a colunas maiores, você pode usar o maxlength campo de metadados de coluna para especificar o comprimento máximo de colunas de cadeia de caracteres individuais. Isso também é útil para implementar otimizações de desempenho de economia de espaço declarando colunas com um comprimento máximo menor do que o padrão.

Python

df = ... # the dataframe you'll want to write to Redshift

# Specify the custom width of each column
columnLengthMap = {
  "language_code": 2,
  "country_code": 2,
  "url": 2083,
}

# Apply each column metadata customization
for (colName, length) in columnLengthMap.iteritems():
  metadata = {'maxlength': length}
  df = df.withColumn(colName, df[colName].alias(colName, metadata=metadata))

df.write \
  .format("com.databricks.spark.redshift") \
  .option("url", jdbcURL) \
  .option("tempdir", s3TempDirectory) \
  .option("dbtable", sessionTable) \
  .save()

Scala (linguagem de programação)

Aqui está um exemplo de atualização dos campos de metadados de várias colunas usando a API Scala do Spark:

import org.apache.spark.sql.types.MetadataBuilder

// Specify the custom width of each column
val columnLengthMap = Map(
  "language_code" -> 2,
  "country_code" -> 2,
  "url" -> 2083
)

var df = ... // the dataframe you'll want to write to Redshift

// Apply each column metadata customization
columnLengthMap.foreach { case (colName, length) =>
  val metadata = new MetadataBuilder().putLong("maxlength", length).build()
  df = df.withColumn(colName, df(colName).as(colName, metadata))
}

df.write
  .format("com.databricks.spark.redshift")
  .option("url", jdbcURL)
  .option("tempdir", s3TempDirectory)
  .option("dbtable", sessionTable)
.save()

Definir um tipo de coluna personalizado

Se você precisar definir manualmente um tipo de coluna, poderá usar os metadados de redshift_type coluna. Por exemplo, se você deseja substituir o Spark SQL Schema -> Redshift SQL correspondente de tipo para atribuir um tipo de coluna definido pelo usuário, faça o seguinte:

Python

# Specify the custom type of each column
columnTypeMap = {
  "language_code": "CHAR(2)",
  "country_code": "CHAR(2)",
  "url": "BPCHAR(111)",
}

df = ... # the dataframe you'll want to write to Redshift

# Apply each column metadata customization
for colName, colType in columnTypeMap.items():
  metadata = {'redshift_type': colType}
  df = df.withColumn(colName, df[colName].alias(colName, metadata=metadata))

Scala (linguagem de programação)

import org.apache.spark.sql.types.MetadataBuilder

// Specify the custom type of each column
val columnTypeMap = Map(
  "language_code" -> "CHAR(2)",
  "country_code" -> "CHAR(2)",
  "url" -> "BPCHAR(111)"
)

var df = ... // the dataframe you'll want to write to Redshift

// Apply each column metadata customization
columnTypeMap.foreach { case (colName, colType) =>
  val metadata = new MetadataBuilder().putString("redshift_type", colType).build()
  df = df.withColumn(colName, df(colName).as(colName, metadata))
}

Configurar a codificação de coluna

Ao criar uma tabela, use o encoding campo de metadados de coluna para especificar uma codificação de compactação para cada coluna (consulte documentos da Amazon para codificações disponíveis).

Definindo descrições em colunas

O Redshift permite que as colunas tenham descrições anexadas que devem aparecer na maioria das ferramentas de consulta (usando o COMMENT comando). Você pode definir o description campo de metadados de coluna para especificar uma descrição para colunas individuais.

Rebaixamento de consultas no Redshift

O otimizador do Spark envia os seguintes operadores para o Redshift:

• Filter
• Project
• Sort
• Limit
• Aggregation
• Join

Dentro Project e Filter, ele dá suporte às seguintes expressões:

• A maioria dos operadores lógicos boolianos
• Comparações
• Operadores aritméticos básicos
• Conversões numéricas e de cadeia de caracteres
• A maioria das funções de cadeia de caracteres
• Subconsultas escalares, se puderem ser enviadas inteiramente para o Redshift.

No interior Aggregation, ele dá suporte às seguintes funções de agregação:

• AVG
• COUNT
• MAX
• MIN
• SUM
• STDDEV_SAMP
• STDDEV_POP
• VAR_SAMP
• VAR_POP

combinado com a cláusula DISTINCT, quando aplicável.

No interior Join, ele dá suporte aos seguintes tipos de junções:

• INNER JOIN
• LEFT OUTER JOIN
• RIGHT OUTER JOIN
• LEFT SEMI JOIN
• LEFT ANTI JOIN
• Subconsultas que são reescritas em Join pelo otimizador, sendo por exemplo WHERE EXISTS, WHERE NOT EXISTS

A técnica de pushdown é mais benéfica em consultas com LIMIT. Uma consulta como SELECT * FROM large_redshift_table LIMIT 10 poderia levar muito tempo, pois a tabela inteira seria primeiro UNLOADed para S3 como um resultado intermediário. Com o recurso de pushdown, o LIMIT é executado no Redshift. Em consultas com agregações, empurrar a agregação para baixo no Redshift também ajuda a reduzir a quantidade de dados que precisam ser transferidos.

O pushdown de consulta para o Redshift é habilitado por padrão. Ele pode ser desabilitado definindo spark.databricks.redshift.pushdown como false. Mesmo quando desabilitado, o Spark ainda envia filtros para baixo e executa a eliminação de coluna no Redshift.

Instalação do driver do Redshift

A fonte de dados do Redshift também requer um driver JDBC compatível com o Redshift. Como o Redshift é baseado no sistema de banco de dados PostgreSQL, você pode usar o driver JDBC do PostgreSQL incluído no Databricks Runtime ou no driver JDBC do Redshift recomendado pela Amazon. Nenhuma instalação é necessária para usar o driver JDBC do PostgreSQL. A versão do driver JDBC do PostgreSQL incluída em cada versão do Databricks Runtime está listada nas notas de versão do Databricks Runtime.

Para instalar manualmente o driver JDBC do Redshift:

1. Baixe o driver da Amazon.
2. Carregue o driver no espaço de trabalho do Azure Databricks. Consulte Instalar bibliotecas.
3. Instale a biblioteca no cluster.

Garantias transacionais

Esta seção descreve as garantias transacionais da fonte de dados do Redshift para Spark.

Visão geral sobre as propriedades do Redshift e do S3

Para obter informações gerais sobre garantias transacionais do Redshift, consulte o capítulo Gerenciando operações de gravação simultâneas na documentação do Redshift. Em poucas palavras, o Redshift fornece isolamento serializável de acordo com a documentação do comando BEGIN do Redshift:

embora você possa usar qualquer um dos quatro níveis de isolamento de transação, Amazon Redshift processa todos os níveis de isolamento de forma serializável.

De acordo com a documentação do Redshift:

O Amazon Redshift dá suporte a um comportamento de confirmação automática padrão no qual cada comando SQL executado separadamente é confirmado individualmente.

Assim, comandos individuais como COPY e UNLOAD são atômicos e transacionais, enquanto os comandos explícitos BEGIN e END só devem ser necessários para impor a atomicidade de vários comandos ou consultas.

Ao ler e gravar no Redshift, a fonte de dados lê e grava dados no S3. O Spark e o Redshift produzem saída particionada e a armazenam em vários arquivos no S3. De acordo com a documentação do Modelo de Consistência de Dados do Amazon S3, as operações de listagem de bucket S3 são eventualmente consistentes, portanto, os arquivos devem tomar medidas especiais para evitar dados ausentes ou incompletos devido a essa característica de consistência eventual.

Garantias da fonte de dados do Redshift para Spark

Acrescentar a uma tabela existente

Ao inserir linhas no Redshift, a fonte de dados usa o comando COPY e especifica manifestos para se proteger contra determinadas operações S3 eventualmente consistentes. Como resultado, spark-redshift adições às tabelas existentes possuem as mesmas propriedades atômicas e transacionais que os comandos regulares do Redshift COPY.

Criar uma nova tabela (SaveMode.CreateIfNotExists)

A criação de uma nova tabela é um processo de duas etapas, consistindo em um CREATE TABLE comando seguido por um comando COPY para acrescentar o conjunto inicial de linhas. Ambas as operações são executadas na mesma transação.

Sobrescrever uma tabela existente

Por padrão, a fonte de dados usa transações para executar substituições, que são implementadas excluindo a tabela de destino, criando uma nova tabela vazia e acrescentando linhas a ela.

Se a configuração obsoleta usestagingtable estiver definida como false, a fonte de dados executa o comando DELETE TABLE antes de acrescentar linhas à nova tabela, o que sacrifica a atomicidade da operação de substituição, ao mesmo tempo que reduz a quantidade de espaço de staging que o Redshift precisa durante a substituição.

Consultar tabela do Redshift

As consultas usam o comando UNLOAD do Redshift para executar uma consulta e salvar seus resultados em S3 e usar manifestos para se proteger contra determinadas operações S3 eventualmente consistentes. Como resultado, as consultas da fonte de dados do Redshift para Spark devem ter as mesmas propriedades de consistência que as consultas regulares do Redshift.

Problemas comuns e soluções

O bucket S3 e o cluster redshift estão em diferentes regiões do AWS

Por padrão, as cópias do S3 <–> Redshift não funcionarão se o bucket S3 e o cluster redshift estiverem em diferentes regiões do AWS.

Se você tentar ler uma tabela do Redshift quando o bucket S3 estiver em uma região diferente, poderá ver um erro como:

ERROR: S3ServiceException:The S3 bucket addressed by the query is in a different region from this cluster.,Status 301,Error PermanentRedirect.

Da mesma forma, tentar gravar no Redshift usando um bucket S3 em uma região diferente pode causar o seguinte erro:

error:  Problem reading manifest file - S3ServiceException:The S3 bucket addressed by the query is in a different region from this cluster.,Status 301,Error PermanentRedirect

• Escreve: O comando Redshift COPY dá suporte à indicação explícita da região do bucket S3, para que você possa fazer as gravações no Redshift funcionarem corretamente nesses casos adicionando region 'the-region-name' à configuração extracopyoptions. Por exemplo, com um bucket na região Leste dos EUA (Virgínia) e a API Scala, use:

  .option("extracopyoptions", "region 'us-east-1'")
  

  Como alternativa, você pode usar a awsregion configuração:

  .option("awsregion", "us-east-1")
  

• Lê: O comando UNLOAD do Redshift também dá suporte à especificação explícita da região do bucket S3. Você pode fazer com que as leituras funcionem corretamente ao adicionar a região à configuração awsregion:

  .option("awsregion", "us-east-1")
  

Erro de autenticação ao usar uma senha com caracteres especiais na URL JDBC

Se você estiver fornecendo o nome de usuário e a senha como parte da url JDBC e a senha contiver caracteres especiais, como ;, ?ou &, você poderá ver a seguinte exceção:

java.sql.SQLException: [Amazon](500310) Invalid operation: password authentication failed for user 'xyz'

Isso é causado por caracteres especiais no nome de usuário ou senha que não são tratados corretamente pelo driver JDBC. Certifique-se de especificar o nome de usuário e a senha usando as opções de DataFrame correspondentes user e password. Para obter mais informações, confira Parâmetros.

A consulta Spark de longa execução fica eternamente pendente, mesmo após a conclusão da operação correspondente no Redshift.

Se você estiver lendo ou gravando grandes quantidades de dados de e para o Redshift, sua consulta Spark pode ficar pendente indefinidamente, mesmo que a página de monitoramento do Redshift da AWS mostre que a operação correspondente LOAD ou UNLOAD foi concluída e que o cluster está ocioso. Isso é causado pela conexão entre o redshift e o tempo limite do Spark. Para evitar isso, verifique se o tcpKeepAlive sinalizador JDBC está habilitado e TCPKeepAliveMinutes está definido como um valor baixo (por exemplo, 1).

Para obter informações adicionais, consulte Configuração do JDBC Driver do Amazon Redshift.

Marca temporal com semântica de fuso horário

Ao ler dados, os tipos de dados do Redshift TIMESTAMP e TIMESTAMPTZ são mapeados para o Spark TimestampType, e um valor é convertido para Tempo Universal Coordenado (UTC) e armazenado como o carimbo de data/hora UTC. Para um Redshift TIMESTAMP, o fuso horário local é assumido, pois o valor não tem nenhuma informação de fuso horário. Ao gravar dados em uma tabela do Redshift, um Spark TimestampType é mapeado para o tipo de dados do Redshift TIMESTAMP .

Guia de migração

A fonte de dados agora exige que você defina forward_spark_s3_credentials explicitamente antes que as credenciais do Spark S3 sejam encaminhadas para o Redshift. Essa mudança não terá impacto se você usar os mecanismos de autenticação aws_iam_role ou temporary_aws_*. No entanto, se você se baseou no comportamento padrão antigo, agora deve definir forward_spark_s3_credentials explicitamente como true para continuar usando o mecanismo de autenticação anterior do Redshift para S3. Para obter uma discussão sobre os três mecanismos de autenticação e suas compensações de segurança, consulte a seção Autenticação para S3 e Redshift deste documento.