Ausführung mit modularer Parquet-Verschlüsselung

Modulare Parquet-Verschlüsselung ist nur in Spark-Notebooks verfügbar, die in einer IBM Analytics Engine-Serviceinstanz ausgeführt werden. Modulare Parquet-Verschlüsselung wird in Notebooks, die in einer Spark-Umgebung ausgeführt werden, nicht unterstützt.

Wenn Sie die modulare Parquet-Verschlüsselung aktivieren möchten, legen Sie die folgenden Spark-Klassenpfadeigenschaften fest, um auf die Parquet-JAR-Dateien, die die modulare Parquet-Verschlüsselung implementieren, und auf die JAR-Datei für Schlüsselmanagement zu verweisen:

1. Navigieren Sie zu Ambari > Spark > Config -> Custom spark2-default.

2. Fügen Sie die beiden folgenden Parameter hinzu, um explizit auf die Position der JAR-Dateien zu verweisen. Sie müssen die Pfade so anpassen, dass die tatsächliche Version der JAR-Dateien im Cluster verwendet wird.

   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
   

Obligatorische Parameter

Die folgenden Parameter sind zum Schreiben verschlüsselter Daten erforderlich:

• Liste zu verschlüsselnder Spalten einschließlich Masterverschlüsselungsschlüsseln:

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

• Fußzeilenschlüssel:

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

  Beispiel:

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

  Wichtig:

  Wenn weder der Parameter encryption.column.keys noch der Parameter encryption.footer.key gesetzt ist, wird die Datei nicht verschlüsselt. Wenn nur einer dieser Parameter gesetzt ist, wird eine Ausnahmebedingung ausgelöst, da diese Parameter für verschlüsselte Dateien obligatorisch sind.

Optionale Parameter

Die folgenden optionalen Parameter können beim Schreiben verschlüsselter Daten verwendet werden:

• Verschlüsselungsalgorithmus AES-GCM-CTR

  Die modulare Parquet-Verschlüsselung verwendet standardmäßig den Algorithmus AES-GCM, der vollständigen Schutz vor Manipulation von Daten und Metadaten in Parquet-Dateien bietet. Da Spark 2.3.0 jedoch in Java 8 ausgeführt wird, das die AES-Beschleunigung der CPU-Hardware nicht unterstützt (diese Unterstützung wurde erst in Java 9 hinzugefügt), kann der Aufwand für die Überprüfung der Datenintegrität in bestimmten Situationen den Verarbeitungsdurchsatz beeinflussen.

  Um dies zu kompensieren, können Sie die Unterstützung für die Datenintegritätsprüfung ausschalten und die verschlüsselten Dateien mit dem alternativen Algorithmus AES-GCM-CTR schreiben, der nur die Integrität der Metadatenabschnitte und nicht die der Datenabschnitte verifiziert und dadurch im Vergleich zum Algorithmus AES-GCM einen geringeren Systemaufwand erfordert.

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

• Fußzeile im einfachen Textmodus für traditionelle Reader

  Standardmäßig wird das Parquet-Hauptmetadatenmodul (die Dateifußzeile) verschlüsselt, um das Dateischema und die Liste der sensiblen Spalten zu verbergen. Sie können jedoch entscheiden, die Dateifußzeilen nicht zu verschlüsseln, um anderen Spark- und Parquet-Readern (die die modulare Parquet-Verschlüsselung noch nicht unterstützen) das Lesen der unverschlüsselten Spalten in den verschlüsselten Dateien zu ermöglichen. Setzen Sie den folgenden Parameter, um die Fußzeilenverschlüsselung zu inaktivieren:

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

  Wichtig:

  Der Parameter encryption.footer.key muss auch im Fußzeilenmodus für einfachen Text angegeben werden. Die Fußzeile ist zwar nicht verschlüsselt, aber der Schlüssel wird zum Signieren des Fußzeileninhalts verwendet. Neue Reader könnten also seine Integrität prüfen. Das Hinzufügen der Fußzeilensignatur hat keine Auswirkungen auf traditionelle Reader.

Verwendungsbeispiele

Die folgenden Beispielcode-Snippets für Python zeigen, wie Datenrahmen erstellt, in verschlüsselte Parquet-Dateien geschrieben und aus verschlüsselten Parquet-Dateien gelesen werden.

• Python: Schreiben verschlüsselter Daten

  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: Lesen verschlüsselter Daten

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

Der Inhalt der Python Jobdatei InMemoryKMS.py lautet wie folgt:

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

Interna der Handhabung von Chiffrierschlüsseln

Beim Schreiben einer Parquet-Datei wird für jede verschlüsselte Spalte und für die Fußzeile ein zufälliger Datenchiffrierschlüssel (DEK, Data Encryption Key) generiert. Diese Schlüssel werden verwendet, um die Daten- und Metadatenmodule in der Parquet-Datei zu verschlüsseln.

Der Datenchiffrierschlüssel wird dann mit einem Schlüsselchiffrierschlüssel (KEK, Key Encrytion Key) verschlüsselt, der auch innerhalb von Spark/Parquet für jeden Masterschlüssel generiert wird. Der Schlüsselchiffrierschlüssel wird lokal mit dem Masterchiffrierschlüssel verschlüsselt.

Verschlüsselte Chiffrierschlüssel für Daten und Schlüssel werden zusammen mit der Masterschlüssel-ID in den Metadaten der Parquet-Datei gespeichert. Jeder Schlüsselchiffrierschlüssel hat eine eindeutige (lokal als sicherer zufälliger 16-Byte-Wert generierte) ID, die auch in den Metadaten der Datei gespeichert wird.

Beim Lesen einer Parquet-Datei werden die ID des Masterchiffrierschlüssels und des verschlüsselten Schlüsselchiffrierschlüssels sowie der verschlüsselte Datenchiffrierschlüssel aus den Dateimetadaten extrahiert.

Der Schlüsselchiffrierschlüssel wird lokal mit dem Masterchiffrierschlüssel entschlüsselt. Anschließend wird der Datenchiffrierschlüssel lokal mit dem Schlüsselchiffrierschlüssel entschlüsselt.

Weitere Informationen

• Modulare Parquet-Verschlüsselung