Wykonywanie zapytań w usłudze Amazon Redshift przy użyciu usługi Azure Databricks

Tabele można odczytywać i zapisywać w usłudze Amazon Redshift za pomocą usługi Azure Databricks.

Źródło danych Databricks Redshift używa Amazon S3 do wydajnego przesyłania danych do i z Redshift i używa JDBC do automatycznego uruchamiania odpowiednich COPY i UNLOAD poleceń na Redshift.

Użycie

W poniższych przykładach pokazano nawiązywanie połączenia ze sterownikiem Redshift. Zastąp wartości parametrów url , jeśli używasz sterownika JDBC postgreSQL.

Po skonfigurowaniu poświadczeń AWS możesz użyć źródła danych z interfejsem API źródła danych Spark w języku Python, SQL, R lub 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

Odczytywanie danych przy użyciu języka SQL w środowisku Databricks Runtime 10.4 LTS i poniżej:

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;

Odczytywanie danych przy użyciu języka SQL w środowisku Databricks Runtime 11.3 LTS i nowszych wersjach:

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;

Zapisywanie danych przy użyciu języka 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;

Interfejs API SQL obsługuje tylko tworzenie nowych tabel, a nie zastępowanie ani dołączanie.

R

Odczytywanie danych przy użyciu języka R w środowisku Databricks Runtime 10.4 LTS i poniżej:

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

Odczytywanie danych przy użyciu języka R w środowisku Databricks Runtime 11.3 LTS lub nowszym:

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

Skala

// 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()

Zalecenia dotyczące pracy z rozwiązaniem Redshift

Wykonywanie zapytań może wyodrębniać duże ilości danych do S3. Jeśli planujesz wykonać kilka zapytań względem tych samych danych w usłudze Redshift, usługa Databricks zaleca zapisanie wyodrębnionych danych przy użyciu usługi Delta Lake.

Konfiguracja

Uwierzytelnianie w usługach S3 i Redshift

Źródło danych obejmuje kilka połączeń sieciowych przedstawionych na poniższym diagramie:

                            ┌───────┐
       ┌───────────────────>│  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)

Źródło danych odczytuje i zapisuje dane w S3 podczas przesyłania danych do i z Redshift. W związku z tym wymaga poświadczeń platformy AWS z dostępem do odczytu i zapisu do zasobnika S3 (określonego przy użyciu parametru tempdir konfiguracji).

W poniższych sekcjach opisano opcje konfiguracji uwierzytelniania każdego połączenia:

• Sterownik Spark do usługi Redshift
• Spark do S3
• Redshift do S3

Sterownik Spark do usługi Redshift

Sterownik Platformy Spark łączy się z usługą Redshift za pośrednictwem interfejsu JDBC przy użyciu nazwy użytkownika i hasła. Usługa Redshift nie obsługuje używania ról IAM do uwierzytelniania tego połączenia. Domyślnie to połączenie korzysta z szyfrowania SSL; Aby uzyskać więcej informacji, zobacz Szyfrowanie.

Spark do S3

S3 działa jako pośrednik w przechowywaniu danych zbiorczych podczas odczytywania lub zapisywania w usłudze Redshift. Platforma Spark łączy się z usługą S3, używając zarówno interfejsów systemu plików Hadoop, jak również bezpośrednio klienta S3 pakietu Amazon Java SDK.

• Ustaw klucze w usłudze Hadoop conf: możesz określić klucze platformy AWS przy użyciu właściwości konfiguracji usługi Hadoop. Jeśli konfiguracja tempdir wskazuje na system plików s3a://, możesz ustawić właściwości fs.s3a.access.key i fs.s3a.secret.key w pliku konfiguracji XML Hadoop lub wywołać sc.hadoopConfiguration.set(), aby skonfigurować globalną konfigurację Hadoop w Spark. Jeśli używasz s3n:// systemu plików, możesz podać starsze klucze konfiguracji, jak pokazano w poniższym przykładzie.

  Skala

  Jeśli na przykład używasz s3a systemu plików, dodaj:

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

  W przypadku starszego s3n systemu plików dodaj:

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

  Python

  Następujące polecenie korzysta z niektórych wewnętrznych elementów platformy Spark, ale powinno współpracować ze wszystkimi wersjami PySpark i prawdopodobnie nie zmieni się w przyszłości:

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

Redshift do S3

Ustaw opcję forward_spark_s3_credentials na true, aby automatycznie przekazywać poświadczenia klucza AWS używane przez Spark do nawiązywania połączenia z usługą S3 za pośrednictwem JDBC do Redshift. Zapytanie JDBC osadza te poświadczenia, dlatego usługa Databricks zdecydowanie zaleca włączenie szyfrowania SSL połączenia JDBC.

Szyfrowanie

• Zabezpieczanie JDBC: jeśli w adresie URL JDBC nie ma żadnych ustawień związanych z protokołem SSL, źródło danych domyślnie włącza szyfrowanie SSL, a także sprawdza, czy serwer Redshift jest godny zaufania (czyli sslmode=verify-full). Gdy certyfikat serwera jest potrzebny po raz pierwszy, jest on automatycznie pobierany z serwerów Amazon. W przypadku awarii plik certyfikatu wstępnie powiązanego jest używany jako rezerwowy. Dotyczy to zarówno sterowników Redshift, jak i PostgreSQL JDBC.

  Jeśli wystąpią problemy z tą funkcją lub jeśli chcesz po prostu wyłączyć protokół SSL, możesz wywołać .option("autoenablessl", "false") na swoim DataFrameReader lub DataFrameWriter.

  Jeśli chcesz określić niestandardowe ustawienia związane z protokołem SSL, możesz postępować zgodnie z instrukcjami w dokumentacji Redshift: Używanie certyfikatów SSL i serwera w języku Java oraz opcje konfiguracji sterownika JDBC. Wszelkie opcje związane z protokołem SSL dostępne w JDBC url używanym ze źródłem danych mają pierwszeństwo (oznacza to, że automatyczna konfiguracja nie zostanie wyzwolona).

• Szyfrowanie danych UNLOAD przechowywanych w usłudze S3 (dane przechowywane podczas odczytu z redshift): zgodnie z dokumentacją Redshift dotyczącą zwalniania danych do S3", "UNLOAD automatycznie szyfruje pliki danych przy użyciu szyfrowania po stronie serwera Amazon S3 (SSE-S3)."

  Usługa Redshift obsługuje również szyfrowanie po stronie klienta przy użyciu klucza niestandardowego (zobacz: Zwalnianie zaszyfrowanych plików danych), ale źródło danych nie ma możliwości określenia wymaganego klucza symetrycznego.

• Szyfrowanie danych COPY przechowywanych w usłudze S3 (dane przechowywane podczas zapisywania w usłudze Redshift): Zgodnie z dokumentacją redshift dotyczącą ładowania zaszyfrowanych plików danych z usługi Amazon S3:

Możesz użyć COPY polecenia , aby załadować pliki danych, które zostały przekazane do usługi Amazon S3 przy użyciu szyfrowania po stronie serwera z kluczami szyfrowania zarządzanymi przez platformę AWS (SSE-S3 lub SSE-KMS), szyfrowaniem po stronie klienta lub obydwoma. FUNKCJA COPY nie obsługuje szyfrowania po stronie serwera Amazon S3 przy użyciu klucza dostarczonego przez klienta (SSE-C).

Parametry

Mapa parametrów lub OPCJE podane w usłudze Spark SQL obsługują następujące ustawienia:

Dodatkowe opcje konfiguracji

Konfigurowanie maksymalnego rozmiaru kolumn ciągu

Podczas tworzenia tabel Redshift zachowaniem domyślnym jest utworzenie TEXT kolumn dla kolumn ciągu. Redshift przechowuje kolumny TEXT jako VARCHAR(256), więc te kolumny mają maksymalny rozmiar 256 znaków (źródło).

Aby obsługiwać większe kolumny, możesz użyć maxlength pola metadanych kolumny, aby określić maksymalną długość poszczególnych kolumn ciągu. Jest to również przydatne w przypadku implementowania optymalizacji wydajności oszczędzania miejsca przez deklarowanie kolumn o mniejszej maksymalnej długości niż domyślna.

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

Skala

Oto przykład aktualizowania pól metadanych różnych kolumn przy użyciu API Scala platformy 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()

Ustawianie niestandardowego typu kolumny

Jeśli musisz ręcznie ustawić typ kolumny, możesz użyć redshift_type metadanych kolumny. Jeśli na przykład chcesz zmodyfikować dopasowanie typu Spark SQL Schema -> Redshift SQL w celu przypisania użytkownikowi zdefiniowanego typu kolumny, możesz zrobić następująco:

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

Skala

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

Konfigurowanie kodowania kolumn

Podczas tworzenia tabeli użyj encoding pola metadanych kolumny, aby określić kodowanie kompresji dla każdej kolumny (zobacz Dokumentację amazon dla dostępnych kodowań).

Ustawianie opisów kolumn

Narzędzie Redshift umożliwia dołączanie do kolumn opisów, które powinny być wyświetlane w większości narzędzi zapytań (przy użyciu COMMENT polecenia). Możesz ustawić description pole metadanych kolumny, aby określić opis poszczególnych kolumn.

Przenoszenie zapytania do Redshift

Optymalizator platformy Spark wypycha następujące operatory w dół do rozwiązania Redshift:

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

W Project i Filter obsługuje następujące wyrażenia:

• Większość operatorów logiki Boola
• Porównania
• Podstawowe operacje arytmetyczne
• Rzutowanie liczbowe i ciągowe
• Większość funkcji ciągów
• Podzapytania skalarne, jeśli można je całkowicie przenieść do Redshift.

W programie Aggregation obsługiwane są następujące funkcje agregacji:

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

w połączeniu z klauzulą DISTINCT , jeśli ma to zastosowanie.

W Join programie obsługiwane są następujące typy sprzężeń:

• INNER JOIN
• LEFT OUTER JOIN
• RIGHT OUTER JOIN
• LEFT SEMI JOIN
• LEFT ANTI JOIN
• Podzapytania, które są przepisywane na Join przez optymalizator, np. WHERE EXISTS, WHERE NOT EXISTS

Wypychanie może być najbardziej korzystne w zapytaniach z LIMIT. Zapytanie, takie jak SELECT * FROM large_redshift_table LIMIT 10, może trwać bardzo długo, ponieważ cała tabela zostanie najpierw wyładowana do S3 jako wynik pośredni. Po wypchnięciu element jest wykonywany w rozwiązaniu LIMIT Redshift. W zapytaniach z agregacjami wypychanie agregacji w dół do usługi Redshift pomaga również zmniejszyć ilość danych, które należy przenieść.

Przekazywanie zapytań do Redshift jest domyślnie włączone. Można go wyłączyć, ustawiając wartość spark.databricks.redshift.pushdownfalse. Nawet w przypadku wyłączenia platforma Spark nadal wypycha filtry i wykonuje eliminację kolumn do rozwiązania Redshift.

Instalacja sterownika Redshift

Źródło danych Redshift wymaga również sterownika JDBC zgodnego z redshift. Ponieważ usługa Redshift jest oparta na systemie bazy danych PostgreSQL, możesz użyć sterownika JDBC PostgreSQL dołączonego do środowiska Databricks Runtime lub zalecanego sterownika Redshift JDBC firmy Amazon. Do korzystania ze sterownika JDBC postgreSQL nie jest wymagana instalacja. Wersja sterownika JDBC postgreSQL zawarta w każdej wersji środowiska Databricks Runtime jest wymieniona w informacjach o wersji środowiska Databricks Runtime.

Aby ręcznie zainstalować sterownik Redshift JDBC:

1. Pobierz sterownik z firmy Amazon.
2. Przekaż sterownik do obszaru roboczego usługi Azure Databricks. Zobacz Instalowanie bibliotek.
3. Zainstaluj bibliotekę w klastrze.

Gwarancje transakcyjne

W tej sekcji opisano transakcyjne gwarancje źródła danych Redshift dla platformy Spark.

Ogólne informacje o Redshift i S3

Aby uzyskać ogólne informacje na temat gwarancji transakcyjnych Redshift, zobacz rozdział Zarządzanie współbieżnymi operacjami zapisu w dokumentacji Redshift. W skrócie, Redshift zapewnia serializowalną izolację zgodnie z dokumentacją polecenia Redshift BEGIN:

[chociaż] można użyć dowolnego z czterech poziomów izolacji transakcji, Amazon Redshift przetwarza wszystkie poziomy izolacji jako serializowalne.

Zgodnie z dokumentacją Redshift:

Usługa Amazon Redshift obsługuje domyślne zachowanie automatycznego zatwierdzania, w którym każde osobno wykonywane polecenie SQL jest zatwierdzane indywidualnie.

W związku z tym poszczególne polecenia, takie jak COPY i UNLOAD są niepodzielne i transakcyjne, podczas gdy jawne BEGIN i END powinny być konieczne tylko do wymuszania niepodzielności wielu poleceń lub zapytań.

Podczas odczytywania i zapisywania w usłudze Redshift źródło danych odczytuje i zapisuje dane w usłudze S3. Platforma Spark i Redshift tworzą partycjonowane dane wyjściowe i przechowują je w wielu plikach w usłudze S3. Zgodnie z dokumentacją Modelu spójności danych Amazon S3, operacje listowania zasobników S3 są ostatecznie spójne, więc pliki muszą podjąć specjalne środki, aby uniknąć brakujących lub niekompletnych danych ze względu na tę właściwość spójności ostatecznej.

Gwarancje źródła danych Redshift dla platformy Spark

Dołączanie do istniejącej tabeli

Podczas wstawiania wierszy do Redshift, źródło danych używa polecenia COPY i wskazuje manifesty, aby chronić przed pewnymi ostatecznie spójnymi operacjami w S3. W związku z tym spark-redshift dołączenia do istniejących tabel mają te same właściwości atomowe i transakcyjne co standardowe polecenia Redshift COPY.

Tworzenie nowej tabeli (SaveMode.CreateIfNotExists)

Tworzenie nowej tabeli jest procesem dwuetapowym, składającym CREATE TABLE się z polecenia, po którym następuje polecenie COPY w celu dołączenia początkowego zestawu wierszy. Obie operacje są wykonywane w tej samej transakcji.

Zastąp istniejącą tabelę

Domyślnie źródło danych używa transakcji do wykonywania zastąpić, które są implementowane przez usunięcie tabeli docelowej, utworzenie nowej pustej tabeli i dołączenie do niej wierszy.

Jeśli przestarzałe ustawienie usestagingtable zostanie ustawione na false, źródło danych zatwierdza polecenie DELETE TABLE przed dodaniem wierszy do nowej tabeli, poświęcając niepodzielność operacji zastępowania, ale zmniejszając ilość miejsca przejściowego, którego Redshift potrzebuje w trakcie operacji zastępowania.

Zapytanie tabeli Redshift

Zapytania używają polecenia Redshift UNLOAD do wykonywania zapytania i zapisywania jego wyników w usłudze S3, a także używają manifestów do ochrony przed pewnymi ostatecznie spójnymi operacjami S3. W związku z tym zapytania ze źródła danych Redshift dla platformy Spark powinny mieć takie same właściwości spójności jak zwykłe zapytania Redshift.

Typowe problemy i rozwiązania

Zasobnik S3 i klaster Redshift znajdują się w różnych regionach platformy AWS

Domyślnie kopie S3 <—> Redshift nie działają, jeśli zasobnik S3 i klaster Redshift znajdują się w różnych regionach platformy AWS.

Jeśli spróbujesz odczytać tabelę Redshift, gdy zasobnik S3 znajduje się w innym regionie, może zostać wyświetlony błąd, taki jak:

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

Podobnie próba zapisu w usłudze Redshift przy użyciu zasobnika S3 w innym regionie może spowodować następujący błąd:

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

• Zapisy: Polecenie Redshift COPY obsługuje jawną specyfikację regionu zasobnika S3, dzięki czemu zapisy w usłudze Redshift działają prawidłowo w tych przypadkach przez dodanie region 'the-region-name' do ustawienia extracopyoptions. Na przykład, jeśli masz wiadro w regionie Wschodnie Stany USA (Wirginia) i korzystasz z interfejsu API Scala, użyj:

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

  Możesz też użyć ustawienia awsregion.

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

• Odczyty: Polecenie Redshift UNLOAD obsługuje również jawną specyfikację regionu zasobnika S3. Aby odczyty działały prawidłowo, dodaj region do ustawienia awsregion.

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

Błąd uwierzytelniania podczas używania hasła ze znakami specjalnymi w adresie URL JDBC

Jeśli podajesz nazwę użytkownika i hasło jako część adresu URL JDBC, a hasło zawiera znaki specjalne, takie jak ;, ?lub &, może zostać wyświetlony następujący wyjątek:

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

Jest to spowodowane tym, że znaki specjalne w nazwie użytkownika lub haśle nie są poprawnie zamieniane przez sterownik JDBC. Pamiętaj, aby określić nazwę użytkownika i hasło, korzystając z odpowiednich opcji user DataFrame i password. Aby uzyskać więcej informacji, zobacz Parametry.

Długotrwałe zapytanie platformy Spark zawiesza się w nieskończoność, mimo że jest wykonywana odpowiednia operacja Redshift

Jeśli odczytujesz lub zapisujesz duże ilości danych do i z Redshift, zapytanie Spark może zawieszać się w nieskończoność, mimo że strona Monitorowania AWS Redshift pokazuje, że odpowiednia LOAD operacja lub UNLOAD została ukończona i że klaster jest w stanie bezczynności. Jest to spowodowane przekroczeniem limitu czasu połączenia między usługą Redshift i platformą Spark. Aby tego uniknąć, upewnij się, że flaga tcpKeepAlive JDBC jest włączona i TCPKeepAliveMinutes jest ustawiona na niską wartość (na przykład 1).

Aby uzyskać dodatkowe informacje, zobacz Amazon Redshift JDBC Driver Configuration (Konfiguracja sterownika JDBC firmy Amazon Redshift).

Sygnatura czasowa z semantykami strefy czasowej

Podczas odczytywania danych zarówno typom danych Redshift TIMESTAMP , jak i TIMESTAMPTZ są przypisywane typy danych platformy Spark TimestampType, a wartości są konwertowane na uniwersalny czas koordynowany (UTC) i przechowywane jako znacznik czasu UTC. W przypadku redshift TIMESTAMPprzyjmuje się lokalną strefę czasową, ponieważ wartość nie ma żadnych informacji o strefie czasowej. Podczas zapisywania danych do tabeli Redshift, Spark TimestampType jest mapowany na typ danych Redshift TIMESTAMP.

Przewodnik migracji

Źródło danych wymaga teraz jawnego ustawienia forward_spark_s3_credentials przed przekazaniem poświadczeń Spark S3 do Redshift. Ta zmiana nie ma wpływu, jeśli używasz mechanizmów uwierzytelniania aws_iam_role lub temporary_aws_*. Jeśli jednak polegasz na wcześniejszym domyślnym zachowaniu, musisz teraz jawnie ustawić forward_spark_s3_credentials na true, aby kontynuować korzystanie z dotychczasowego mechanizmu uwierzytelniania Redshift do S3. Aby zapoznać się z omówieniem trzech mechanizmów uwierzytelniania i ich kompromisów w zakresie zabezpieczeń, zobacz sekcję Authenticating to S3 and Redshift (Uwierzytelnianie do usług S3 i Redshift ) tego dokumentu.