Modulare Parquet-Verschlüsselung in Hive

PDFRSS

Die modulare Verschlüsselung von Parquet bietet Zugriffskontrolle und Verschlüsselung auf Spaltenebene, um den Datenschutz und die Datenintegrität für Daten zu verbessern, die im Parquet-Dateiformat gespeichert sind. Dieses Feature ist in Amazon EMR Hive ab Version 6.6.0 verfügbar.

Bisher unterstützte Lösungen für Sicherheit und Integrität, die das Verschlüsseln von Dateien oder das Verschlüsseln der Speicherebene beinhalten, werden im Verwaltungshandbuch für Amazon EMR unter Verschlüsselungsoptionen beschrieben. Diese Lösungen können für Parquet-Dateien verwendet werden, aber die Nutzung der neuen Features des integrierten Parquet-Verschlüsselungsmechanismus ermöglicht einen detaillierten Zugriff auf die Spaltenebene sowie Verbesserungen in Bezug auf Leistung und Sicherheit. Weitere Informationen zu diesem Feature finden Sie auf der Apache-Github-Seite Parquet Modular Encryption.

Benutzer geben Konfigurationen mithilfe von Hadoop-Konfigurationen an Parquet-Leser und -Writer weiter. Die detaillierten Konfigurationen für Benutzer, um Reader und Writer so zu konfigurieren, dass sie die Verschlüsselung aktivieren und erweiterte Features umschalten, sind unter PARQUET-1854: Eigenschaftsgesteuerte Schnittstelle zu Parquet Encryption Management dokumentiert

Verwendungsbeispiele

Das folgende Beispiel behandelt das Erstellen und Schreiben in eine Hive-Tabelle mit AWS KMS , die zur Verwaltung von Verschlüsselungsschlüsseln verwendet wird.

1. Implementieren Sie a KmsClient für den AWS KMS Dienst, wie im Dokument PARQUET-1373: Encryption Key Management Tools beschrieben. Das folgende Beispiel zeigt einen Implementierungsausschnitt.

   package org.apache.parquet.crypto.keytools;
   
   import com.amazonaws.AmazonClientException;
   import com.amazonaws.AmazonServiceException;
   import com.amazonaws.regions.Regions;
   import com.amazonaws.services.kms.AWSKMS;
   import com.amazonaws.services.kms.AWSKMSClientBuilder;
   import com.amazonaws.services.kms.model.DecryptRequest;
   import com.amazonaws.services.kms.model.EncryptRequest;
   import com.amazonaws.util.Base64;
   import org.apache.hadoop.conf.Configuration;
   import org.apache.parquet.crypto.KeyAccessDeniedException;
   import org.apache.parquet.crypto.ParquetCryptoRuntimeException;
   import org.apache.parquet.crypto.keytools.KmsClient;
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   
   import java.nio.ByteBuffer;
   import java.nio.charset.Charset;
   import java.nio.charset.StandardCharsets;
   
   public class AwsKmsClient implements KmsClient {
   
       private static final AWSKMS AWSKMS_CLIENT = AWSKMSClientBuilder
               .standard()
               .withRegion(Regions.US_WEST_2)
               .build();
       public static final Logger LOG = LoggerFactory.getLogger(AwsKmsClient.class);
   
       private String kmsToken;
       private Configuration hadoopConfiguration;
   
       @Override
       public void initialize(Configuration configuration, String kmsInstanceID, String kmsInstanceURL, String accessToken) throws KeyAccessDeniedException {
           hadoopConfiguration = configuration;
           kmsToken = accessToken;
   
       }
   
       @Override
       public String wrapKey(byte[] keyBytes, String masterKeyIdentifier) throws KeyAccessDeniedException {
           String value = null;
           try {
               ByteBuffer plaintext = ByteBuffer.wrap(keyBytes);
   
               EncryptRequest req = new EncryptRequest().withKeyId(masterKeyIdentifier).withPlaintext(plaintext);
               ByteBuffer ciphertext = AWSKMS_CLIENT.encrypt(req).getCiphertextBlob();
   
               byte[] base64EncodedValue = Base64.encode(ciphertext.array());
               value = new String(base64EncodedValue, Charset.forName("UTF-8"));
           } catch (AmazonClientException ae) {
               throw new KeyAccessDeniedException(ae.getMessage());
           }
           return value;
       }
   
       @Override
       public byte[] unwrapKey(String wrappedKey, String masterKeyIdentifier) throws KeyAccessDeniedException {
           byte[] arr = null;
           try {
               ByteBuffer ciphertext  = ByteBuffer.wrap(Base64.decode(wrappedKey.getBytes(StandardCharsets.UTF_8)));
               DecryptRequest request = new DecryptRequest().withKeyId(masterKeyIdentifier).withCiphertextBlob(ciphertext);
               ByteBuffer decipheredtext = AWSKMS_CLIENT.decrypt(request).getPlaintext();
               arr = new byte[decipheredtext.remaining()];
               decipheredtext.get(arr);
           } catch (AmazonClientException ae) {
               throw new KeyAccessDeniedException(ae.getMessage());
           }
           return arr;
       }
   }
                   

2. Erstellen Sie Ihre AWS KMS Verschlüsselungsschlüssel für die Fußzeile sowie für die Spalten, auf die Ihre IAM-Rollen Zugriff haben, wie unter Schlüssel erstellen im Entwicklerhandbuch beschrieben.AWS Key Management Service Die Standard-IAM-Rolle ist EMR_ECS_Default.

3. Fügen Sie in der Hive-Anwendung auf einem Amazon-EMR-Cluster den obigen Client mithilfe der ADD JAR-Anweisung hinzu, wie in der Apache-Hive-Resources-Dokumentation beschrieben. Nachfolgend finden Sie eine Beispielanweisung:

   ADD JAR 's3://location-to-custom-jar';

   Eine alternative Methode besteht darin, das JAR mithilfe einer Bootstrap-Aktion zur auxlib-Datei von Hive hinzuzufügen. Im Folgenden finden Sie eine Beispielzeile, die der Boostrap-Aktion hinzugefügt werden soll:

   aws s3 cp 's3://location-to-custom-jar' /usr/lib/hive/auxlib 

4. Legen Sie die folgenden Konfigurationen fest:

   set parquet.crypto.factory.class=org.apache.parquet.crypto.keytools.PropertiesDrivenCryptoFactory;
   set parquet.encryption.kms.client.class=org.apache.parquet.crypto.keytools.AwsKmsClient;

5. Erstellen Sie eine Hive-Tabelle im Parquet-Format, geben Sie die AWS KMS Schlüssel in SERDEPROPERTIES an und fügen Sie einige Daten ein:

   CREATE TABLE my_table(name STRING, credit_card STRING)
   ROW FORMAT SERDE 'org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe’
   WITH SERDEPROPERTIES (
     'parquet.encryption.column.key’=<aws-kms-key-id-for-column-1>: credit_card’,
     'parquet.encryption.footer.key’='<aws-kms-key-id-for-footer>’)
   STORED AS parquet
   LOCATION “s3://<bucket/<warehouse-location>/my_table”;
   
   INSERT INTO my_table SELECT 
   java_method ('org.apache.commons.lang.RandomStringUtils','randomAlphabetic',5) as name,
   java_method ('org.apache.commons.lang.RandomStringUtils','randomAlphabetic',10) as credit_card
   from (select 1) x lateral view posexplode(split(space(100),' ')) pe as i,x;
   
   select * from my_table;

6. Stellen Sie sicher, dass Sie die Daten nicht lesen können, wenn Sie am selben Speicherort eine externe Tabelle ohne Zugriff auf AWS KMS Schlüssel erstellen (z. B. wenn der Zugriff auf die IAM-Rolle verweigert wurde).

   CREATE EXTERNAL TABLE ext_table (name STRING, credit_card STRING)
   ROW FORMAT SERDE 'org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe’
   STORED AS parquet
   LOCATION “s3://<bucket>/<warehouse-location>/my_table”;
   
   SELECT * FROM ext_table;

7. Die letzte Anweisung sollte die folgende Ausnahme auslösen:

   Failed with exception java.io.IOException:org.apache.parquet.crypto.KeyAccessDeniedException: Footer key: access denied