Uruchamianie z szyfrowaniem modułowym Parquet

Modułowe szyfrowanie Parquet jest dostępne tylko w notatnikach Spark, które są uruchamiane w instancji usługi IBM Analytics Engine . Szyfrowanie modułowe Parquet nie jest obsługiwane w notatnikach działających w środowisku Spark.

Aby włączyć szyfrowanie modułowe Parquet, należy ustawić następujące właściwości ścieżki klasy Spark tak, aby wskazywały na pliki JAR Parquet, które implementują szyfrowanie modułowe Parquet, oraz na plik JAR zarządzania kluczami:

1. Przejdź do opcji Ambari > Spark > Config-> Custom spark2-default.

2. Dodaj następujące dwa parametry, aby jawnie wskazać położenie plików JAR. Upewnij się, że ścieżki są edytowane w celu użycia rzeczywistej wersji plików jar w klastrze.

   spark.driver.extraClassPath=/home/common/lib/parquetEncryption/ibm-parquet-kms-<latestversion>-jar-with-dependencies.jar:/home/common/lib/parquetEncryption/parquet-format-<latestversion>.jar:/home/common/lib/parquetEncryption/parquet-hadoop-<latestversion>.jar
   
   spark.executor.extraClassPath=/home/common/lib/parquetEncryption/ibm-parquet-<latestversion>-jar-with-dependencies.jar:/home/common/lib/parquetEncryption/parquet-format-<latestversion>.jar:/home/common/lib/parquetEncryption/parquet-hadoop-<latestversion>.jar
   

Parametry obowiązkowe

Do zapisu zaszyfrowanych danych wymagane są następujące parametry:

• Lista kolumn do zaszyfrowania z głównymi kluczami szyfrowania:

  parameter name: "encryption.column.keys"
  parameter value: "<master key ID>:<column>,<column>;<master key ID>:<column>,.."
  

• Klucz stopki:

  parameter name: "encryption.footer.key"
  parameter value: "<master key ID>"
  

  Na przykład:

  dataFrame.write
  .option("encryption.footer.key" , "k1")
  .option("encryption.column.keys" , "k2:SSN,Address;k3:CreditCard")
  .parquet("<path to encrypted files>")
  

  Ważne:

  Jeśli nie ustawiono parametru encryption.column.keys ani parametru encryption.footer.key , plik nie zostanie zaszyfrowany. Jeśli ustawiony jest tylko jeden z tych parametrów, zgłaszany jest wyjątek, ponieważ parametry te są obowiązkowe dla zaszyfrowanych plików.

Parametry opcjonalne

Podczas zapisywania zaszyfrowanych danych można użyć następujących parametrów opcjonalnych:

• Algorytm szyfrowania AES-GCM-CTR

  Domyślnie szyfrowanie modułowe Parquet wykorzystuje algorytm AES-GCM , który zapewnia pełną ochronę przed manipulowaniem danymi i metadanymi w plikach Parquet. Jednak ponieważ produkt Spark 2.3.0 działa w środowisku Java 8, które nie obsługuje akceleracji AES w sprzęcie CPU (zostało to dodane tylko w środowisku Java 9), narzut związany z weryfikacją integralności danych może w pewnych sytuacjach mieć wpływ na przepustowość obciążenia.

  Aby to skompensować, można wyłączyć obsługę weryfikacji integralności danych i zapisać zaszyfrowane pliki przy użyciu alternatywnego algorytmu AES-GCM-CTR, który weryfikuje integralność tylko części metadanych, a nie części danych, i ma niższy narzut przepustowości w porównaniu z algorytmem AES-GCM .

  parameter name: "encryption.algorithm"
  parameter value: "AES_GCM_CTR_V1"
  

• Tryb stopki zwykłego tekstu dla starszych czytelników

  Domyślnie główny moduł metadanych Parquet (stopka pliku) jest szyfrowany w celu ukrycia schematu pliku i listy kolumn objętych szczególną ochroną. Można jednak zdecydować, aby nie szyfrować stopek plików, aby umożliwić innym czytnikom Spark i Parquet (które nie obsługują jeszcze szyfrowania modułowego Parquet) odczytywanie niezaszyfrowanych kolumn w zaszyfrowanych plikach. Aby wyłączyć szyfrowanie stopki, należy ustawić następujący parametr:

  parameter name: "encryption.plaintext.footer"
  parameter value: "true"
  

  Ważne:

  Parametr encryption.footer.key musi być również określony w trybie stopki zwykłego tekstu. Chociaż stopka nie jest zaszyfrowana, klucz jest używany do podpisywania treści stopki, co oznacza, że nowe czytelniki mogą sprawdzić jej integralność. Dodanie podpisu stopki nie ma wpływu na wcześniejsze programy czytające.

Przykłady składni

Poniższe przykładowe fragmenty kodu dla języka Python przedstawiają sposób tworzenia ramek danych, zapisywania do zaszyfrowanych plików parquet i odczytywania z zaszyfrowanych plików parquet.

• Python: Zapisywanie zaszyfrowanych danych:

  from pyspark.sql import Row
  
  squaresDF = spark.createDataFrame(
      sc.parallelize(range(1, 6))
      .map(lambda i: Row(int_column=i, square_int_column=i ** 2)))
  
  sc._jsc.hadoopConfiguration().set("encryption.key.list",
      "key1: AAECAwQFBgcICQoLDA0ODw==, key2: AAECAAECAAECAAECAAECAA==")
  sc._jsc.hadoopConfiguration().set("encryption.column.keys",
      "key1:square_int_column")
  sc._jsc.hadoopConfiguration().set("encryption.footer.key", "key2")
  
  encryptedParquetPath = "squares.parquet.encrypted"
  squaresDF.write.parquet(encryptedParquetPath)
  

• Python: Odczyt zaszyfrowanych danych:

  sc._jsc.hadoopConfiguration().set("encryption.key.list",
      "key1: AAECAwQFBgcICQoLDA0ODw==, key2: AAECAAECAAECAAECAAECAA==")
  
  encryptedParquetPath = "squares.parquet.encrypted"
  parquetFile = spark.read.parquet(encryptedParquetPath)
  parquetFile.show()
  

Zawartość pliku zadania Python InMemoryKMS.py jest następująca:

from pyspark.sql import SparkSession
from pyspark import SparkContext
from pyspark.sql import Row

if __name__ == "__main__":
    spark = SparkSession \
        .builder \
        .appName("InMemoryKMS") \
        .getOrCreate()
    sc = spark.sparkContext
    ##KMS operation
    print("Setup InMemoryKMS")
    hconf = sc._jsc.hadoopConfiguration()
    encryptedParquetFullName = "testparquet.encrypted"
    print("Write Encrypted Parquet file")
    hconf.set("encryption.key.list", "key1: AAECAwQFBgcICQoLDA0ODw==, key2: AAECAAECAAECAAECAAECAA==")
    btDF = spark.createDataFrame(sc.parallelize(range(1, 6)).map(lambda i: Row(ssn=i,  value=i ** 2)))
    btDF.write.mode("overwrite").option("encryption.column.keys", "key1:ssn").option("encryption.footer.key", "key2").parquet(encryptedParquetFullName)
    print("Read Encrypted Parquet file")
    encrDataDF = spark.read.parquet(encryptedParquetFullName)
    encrDataDF.createOrReplaceTempView("bloodtests")
    queryResult = spark.sql("SELECT ssn, value FROM bloodtests")
    queryResult.show(10)
    sc.stop()
    spark.stop()

Wewnętrzne funkcje obsługi kluczy szyfrowania

Podczas zapisywania pliku Parquet dla każdej zaszyfrowanej kolumny i stopki generowany jest losowy klucz szyfrowania danych (DEK). Klucze te są używane do szyfrowania danych i modułów metadanych w pliku Parquet.

Klucz szyfrowania danych jest następnie szyfrowany kluczem szyfrowania klucza (KEK), który jest również generowany w środowisku Spark/Parquet dla każdego klucza głównego. Klucz szyfrowania klucza jest szyfrowany lokalnie przy użyciu głównego klucza szyfrowania (MEK).

Zaszyfrowane klucze szyfrowania danych i klucze szyfrowania kluczy są przechowywane w metadanych pliku Parquet wraz z tożsamością klucza głównego. Każdy klucz szyfrowania klucza ma unikalną tożsamość (wygenerowaną lokalnie jako zabezpieczona losowa wartość 16-bajtowa), również zapisaną w metadanych pliku.

Podczas odczytywania pliku Parquet identyfikator głównego klucza szyfrowania (MEK) i zaszyfrowanego klucza szyfrowania (KEK) z jego identyfikatorem oraz zaszyfrowany klucz szyfrowania danych (DEK) są wyodrębniane z metadanych pliku.

Klucz szyfrowania klucza jest deszyfrowany lokalnie przy użyciu głównego klucza szyfrowania. Następnie klucz szyfrowania danych (DEK) jest deszyfrowany lokalnie przy użyciu klucza szyfrowania kluczy (KEK).

Więcej inform.

• Szyfrowanie modułowe Parquet