Bangun aplikasi analitik data besar Apache Spark yang terdistribusi dan aman ujung ke ujung berbasis BigDL PPML pada instans TDX - Elastic Compute Service

Jalankan aplikasi Apache Spark terdistribusi dan aman ujung ke ujung pada instans g8i yang diaktifkan Intel^® TDX dengan BigDL PPML untuk enkripsi data, komputasi aman, dan perlindungan privasi.

Latar Belakang

Saat perusahaan memindahkan data dan sumber daya komputasi ke cloud, melindungi privasi dan kerahasiaan data menjadi tantangan kritis bagi aplikasi analitik data besar dan AI.

BigDL PPML dapat digunakan untuk menjalankan aplikasi standar data besar dan AI (seperti Apache Spark, Apache Flink, TensorFlow, dan PyTorch) pada instans TDX Alibaba Cloud sekaligus melindungi data saat transit dan saat digunakan serta menjamin integritas aplikasi. Lihat BigDL-PPML.

Intel^® Trusted Domain Extensions (Intel^® TDX) menyediakan perlindungan data berbantuan perangkat keras yang independen dari status keamanan firmware dan host, memungkinkan confidential computing pada mesin fisik.
Instans g8i Alibaba Cloud adalah instans yang diaktifkan Intel^® TDX (selanjutnya disebut instans TDX) yang menyediakan confidential computing yang diberlakukan oleh perangkat keras. Instans TDX mengurangi risiko serangan malware serta menjamin privasi data dan integritas aplikasi.
BigDL PPML adalah solusi yang dibangun di atas Intel^® TDX untuk mengamankan aplikasi analitik data dan AI.

Arsitektur

BigDL PPML menjalankan aplikasi analitik data besar dan AI terdistribusi yang sudah ada, seperti Apache Spark, Apache Flink, TensorFlow, dan PyTorch, dalam lingkungan rahasia tanpa perubahan kode. Aplikasi berjalan pada kluster Kubernetes berbasis instans TDX, di mana Intel® TDX melindungi komputasi dan memori. BigDL PPML menyediakan mekanisme keamanan ujung ke ujung berikut:

Attestation kluster tepercaya dalam kluster Kubernetes berbasis instans TDX.
Key Management Service (KMS): mengelola kunci untuk mengenkripsi dan mendekripsi data terdistribusi.
Komputasi dan komunikasi terdistribusi yang aman.

Seperti ditunjukkan pada gambar sebelumnya, BigDL PPML mengamankan pipeline data besar dan AI ujung ke ujung dalam kluster Kubernetes yang dideploy pada instans yang diaktifkan Intel^® TDX. Semua data dienkripsi dan disimpan di data lake dan data warehouse.

Pekerja BigDL PPML memuat data masukan terenkripsi, memperoleh kunci data melalui remote attestation atau KMS, dan mendekripsi data masukan pada instans TDX.
Pekerja BigDL PPML melakukan pra-pemrosesan data secara terdistribusi, melatih model, dan melakukan inferensi dengan framework data besar dan AI.
Pekerja BigDL PPML mengenkripsi dan menulis hasil akhir, data keluaran, atau model ke penyimpanan terdistribusi.

Data yang dikirimkan antar node dienkripsi saat transit dengan protokol keamanan, seperti Advanced Encryption Standard (AES) dan Transport Layer Security, untuk menjamin keamanan dan privasi data ujung ke ujung.

Prosedur

Contoh ini menggunakan aplikasi Simple Query Apache Spark pada instans TDX. Untuk aplikasi data besar dan AI lainnya, lihat Tutorial & Contoh BigDL PPML.

Langkah 1: Deploy kluster Kubernetes dan lingkungan runtime

Contoh ini menggunakan kluster Kubernetes dengan satu node master dan dua node pekerja. Jumlah node harus sesuai dengan jumlah instans TDX yang Anda beli. Sesuaikan ukuran kluster berdasarkan kebutuhan Anda.

Buat instans g8i yang diaktifkan Intel^® TDX.

Lihat Buat instans dengan Custom Launch. Perhatikan parameter berikut:
- Tipe Instans: Pilih tipe instans dengan minimal 32 vCPU dan memori 64 GiB. Contoh ini menggunakan ecs.g8i.8xlarge.
- Image: Pilih Alibaba Cloud Linux 3.2104 LTS 64-bit.
- Alamat IP Publik: Pilih Assign Public IPv4 Address.
- Jumlah: Masukkan 3.
Hubungkan ke instans.

Lihat Pilih metode koneksi.
Deploy kluster Kubernetes dan konfigurasikan pengaturan keamanan.
1. Deploy kluster Kubernetes pada instans g8i.
  
  Lihat Creating a cluster with kubeadm.
2. Konfigurasikan pengaturan keamanan (role-based access control) pada node master:
```
kubectl create serviceaccount spark
kubectl create clusterrolebinding spark-role --clusterrole=edit --serviceaccount=default:spark --namespace=default
```

Buat PersistentVolume.

Buat file pv-volume.yaml sebagai pengguna root:
```
vim pv-volume.yaml
```
Tekan tombol I untuk memasuki mode Insert.

Tambahkan konten berikut ke pv-volume.yaml:

apiVersion: v1
kind: PersistentVolume
metadata:
  name: task-pv-volume
  labels:
    type: local
spec:
  storageClassName: manual
  capacity:
    storage: 10Gi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: "/mnt/data"

Tekan tombol Esc dan masukkan :wq untuk menyimpan perubahan dan keluar dari mode Insert.

Buat dan lihat PersistentVolume:

kubectl apply -f pv-volume.yaml
kubectl get pv task-pv-volume

Buat PersistentVolumeClaim.
1. Buat file pv-claim.yaml sebagai pengguna root:
```
vim pv-claim.yaml
```
2. Tekan tombol I untuk memasuki mode Insert.
3. Tambahkan konten berikut ke pv-claim.yaml:
```
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: task-pv-claim
spec:
  storageClassName: manual
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 3Gi
```
4. Tekan tombol Esc dan masukkan :wq untuk menyimpan perubahan dan keluar dari mode Insert.
5. Buat dan lihat PersistentVolumeClaim:
```
kubectl apply -f pv-claim.yaml
kubectl get pvc task-pv-claim
```

Langkah 2: Enkripsi data pelatihan

Dapatkan image BigDL PPML pada setiap node kluster Kubernetes.

Image ini menjalankan aplikasi Apache Spark standar dengan enkripsi dan dekripsi data.
```
docker pull intelanalytics/bigdl-ppml-trusted-bigdata-gramine-reference-16g:2.3.0-SNAPSHOT
```
Hasilkan file dataset pelatihan people.csv.
1. Unduh skrip pelatihan generate_people_csv.py pada node master:
```
wget https://github.com/intel-analytics/BigDL/raw/main/ppml/scripts/generate_people_csv.py
```
2. Hasilkan people.csv:
```
python generate_people_csv.py </save/path/of/people.csv> <num_lines>
```
  Catatan
  - </save/path/of/people.csv>: jalur output untuk people.csv. Contoh ini menggunakan /home/user.
  - <num_lines>: jumlah baris dalam people.csv. Contoh ini menggunakan 500.
3. Pindahkan people.csv ke direktori target:
```
sudo scp /home/user/people.csv /mnt/data/simplekms/
```
  Penting
  - Ganti /home/user dengan direktori aktual.
  - Contoh ini menggunakan /mnt/data/simplekms/ untuk menyimpan data terenkripsi dan didekripsi. Direktori /mnt/data/simplekms/ tidak dijelaskan secara terpisah di bagian selanjutnya.

Jalankan kontainer bigdl-ppml-client pada node master.

Kontainer ini mengenkripsi dan mendekripsi data pelatihan.

Catatan

Ganti /home/user/kuberconfig:/root/.kube/config berdasarkan pengguna yang menjalankan kontainer.

Untuk pengguna root, ganti dengan /root/kuberconfig:/root/.kube/config.
Untuk pengguna biasa (misalnya, test), ganti dengan /home/test/kuberconfig:/root/.kube/config.

export K8S_MASTER=k8s://$(kubectl cluster-info | grep 'https.*6443' -o -m 1)
echo The k8s master is $K8S_MASTER .
export SPARK_IMAGE=intelanalytics/bigdl-ppml-trusted-bigdata-gramine-reference-16g:2.3.0-SNAPSHOT

sudo docker run -itd --net=host \
-v /etc/kubernetes:/etc/kubernetes \
-v /home/user/kuberconfig:/root/.kube/config \
-v /mnt/data:/mnt/data \
-e RUNTIME_SPARK_MASTER=$K8S_MASTER \
-e RUNTIME_K8S_SPARK_IMAGE=$SPARK_IMAGE \
-e RUNTIME_PERSISTENT_VOLUME_CLAIM=task-pv-claim \
--name bigdl-ppml-client \
$SPARK_IMAGE bash

docker exec -it bigdl-ppml-client bash

Enkripsi people.csv pada node master kluster Kubernetes.

Hasilkan kunci utama (primarykey) dari ID aplikasi (APPID) dan kunci API (APIKEY).

Gunakan simple KMS untuk menghasilkan APPID dan APIKEY (1 hingga 12 karakter). Pada contoh ini, APPID adalah 98463816**** dan APIKEY adalah 15780936****. --primaryKeyPath menentukan direktori penyimpanan kunci utama.

java -cp '/ppml/spark-3.1.3/conf/:/ppml/spark-3.1.3/jars/*:/ppml/bigdl-2.3.0-SNAPSHOT/jars/*' \
com.intel.analytics.bigdl.ppml.examples.GeneratePrimaryKey \
 --primaryKeyPath /mnt/data/simplekms/primaryKey \
 --kmsType SimpleKeyManagementService \
 --simpleAPPID 98463816**** \
 --simpleAPIKEY 15780936****

Buat skrip enkripsi encrypt.py.

Beralih ke direktori /mnt/data/simplekms:
```
cd /mnt/data/simplekms
```
Buat dan buka file encrypt.py:
```
sudo vim encrypt.py
```
Tekan tombol I untuk memasuki mode Insert.

Tambahkan konten berikut ke file encrypt.py:

# encrypt.py
from bigdl.ppml.ppml_context import *
args = {"kms_type": "SimpleKeyManagementService",
 "app_id": "98463816****",
 "api_key": "15780936****",
 "primary_key_material": "/mnt/data/simplekms/primaryKey"
 }

sc = PPMLContext("PPMLTest", args)

csv_plain_path = "/mnt/data/simplekms/people.csv"

csv_plain_df = sc.read(CryptoMode.PLAIN_TEXT) \
 .option("header", "true") \
 .csv(csv_plain_path)
csv_plain_df.show()

output_path = "/mnt/data/simplekms/encrypted-input"

sc.write(csv_plain_df, CryptoMode.AES_CBC_PKCS5PADDING) \
 .mode('overwrite') \
 .option("header", True) \
 .csv(output_path)

Tekan tombol Esc dan masukkan :wq untuk menyimpan perubahan dan keluar dari mode Insert.

Enkripsi people.csv dalam kontainer bigdl-ppml-client dengan APPID, APIKEY, dan primarykey.

Data terenkripsi disimpan di /mnt/data/simplekms/encrypted-output.

java \
 -cp '/ppml/spark-3.1.3/conf/:/ppml/spark-3.1.3/jars/*:/ppml/bigdl-2.3.0-SNAPSHOT/jars/*' \
 -Xmx1g org.apache.spark.deploy.SparkSubmit \
 --master 'local[4]' \
 --conf spark.network.timeout=10000000 \
 --conf spark.executor.heartbeatInterval=10000000 \
 --conf spark.python.use.daemon=false \
 --conf spark.python.worker.reuse=false \
 --py-files /ppml/bigdl-2.3.0-SNAPSHOT/python/bigdl-ppml-spark_3.1.3-2.3.0-SNAPSHOT-python-api.zip,/ppml/bigdl-2.3.0-SNAPSHOT/python/bigdl-spark_3.1.3-2.3.0-SNAPSHOT-python-api.zip,/ppml/bigdl-2.3.0-SNAPSHOT/python/bigdl-dllib-spark_3.1.3-2.3.0-SNAPSHOT-python-api.zip \
 /mnt/data/simplekms/encrypt.py

Salin /mnt/data/simplekms dari node master ke setiap node pekerja.
```
cd /mnt/data
sudo scp -r user@192.168.XXX.XXX:/mnt/data/simplekms .
```
Catatan
Ganti user dengan username aktual dan 192.168.XXX.XXX dengan alamat IP aktual node master.

Langkah 3: Jalankan contoh analitik data besar berbasis BigDL PPML

Dalam kontainer bigdl-ppml-client, submit job Spark untuk menjalankan contoh Simple Query.

Catatan

Pada spark.driver.host=192.168.XXX.XXX, ganti 192.168.XXX.XXX dengan alamat IP aktual node master.

${SPARK_HOME}/bin/spark-submit \
    --master $RUNTIME_SPARK_MASTER \
    --deploy-mode client \
    --name spark-simplequery-tdx \
    --conf spark.driver.memory=4g \
    --conf spark.executor.cores=4 \
    --conf spark.executor.memory=4g \
    --conf spark.executor.instances=2 \
    --conf spark.driver.host=192.168.XXX.XXX \
    --conf spark.kubernetes.authenticate.driver.serviceAccountName=spark \
    --conf spark.cores.max=8 \
    --conf spark.kubernetes.container.image=$RUNTIME_K8S_SPARK_IMAGE \
    --class com.intel.analytics.bigdl.ppml.examples.SimpleQuerySparkExample \
    --conf spark.network.timeout=10000000 \
    --conf spark.executor.heartbeatInterval=10000000 \
    --conf spark.kubernetes.executor.deleteOnTermination=false \
    --conf spark.driver.extraClassPath=local://${BIGDL_HOME}/jars/* \
    --conf spark.executor.extraClassPath=local://${BIGDL_HOME}/jars/* \
    --conf spark.kubernetes.file.upload.path=/mnt/data \
    --conf spark.kubernetes.driver.volumes.persistentVolumeClaim.${RUNTIME_PERSISTENT_VOLUME_CLAIM}.options.claimName=${RUNTIME_PERSISTENT_VOLUME_CLAIM} \
    --conf spark.kubernetes.driver.volumes.persistentVolumeClaim.${RUNTIME_PERSISTENT_VOLUME_CLAIM}.mount.path=/mnt/data \
    --conf spark.kubernetes.executor.volumes.persistentVolumeClaim.${RUNTIME_PERSISTENT_VOLUME_CLAIM}.options.claimName=${RUNTIME_PERSISTENT_VOLUME_CLAIM} \
    --conf spark.kubernetes.executor.volumes.persistentVolumeClaim.${RUNTIME_PERSISTENT_VOLUME_CLAIM}.mount.path=/mnt/data \
    --jars local:///ppml/bigdl-2.3.0-SNAPSHOT/jars/bigdl-ppml-spark_3.1.3-2.3.0-SNAPSHOT.jar \
    local:///ppml/bigdl-2.3.0-SNAPSHOT/jars/bigdl-ppml-spark_3.1.3-2.3.0-SNAPSHOT.jar \
    --inputPartitionNum 8 \
    --outputPartitionNum 8 \
    --inputEncryptModeValue AES/CBC/PKCS5Padding \
    --outputEncryptModeValue AES/CBC/PKCS5Padding \
    --inputPath /mnt/data/simplekms/encrypted-input \
    --outputPath /mnt/data/simplekms/encrypted-output \
    --primaryKeyPath /mnt/data/simplekms/primaryKey \
    --kmsType SimpleKeyManagementService \
    --simpleAPPID 98463816**** \
    --simpleAPIKEY 15780936****

Lihat status job Spark pada node master.
1. Lihat nama dan status driver serta executor:
```
kubectl get pod
```
  Saat job selesai, STATUS berubah dari Running menjadi Completed.
2. Lihat log pod:
```
kubectl logs simplequery-xxx-exec-1
```
  Catatan
  Ganti simplequery-xxx-exec-1 dengan nilai Name dari langkah sebelumnya.
  
  Saat job selesai, Finished muncul dalam log pod.

Langkah 4: Dekripsi hasil

Unggah file .meta dan part-XXXX.csv.cbc dari direktori encrypted-output setiap node pekerja ke direktori encrypted-output node master.

Setelah diunggah, direktori encrypted-output node master berisi data seperti yang ditunjukkan di bawah ini.

Buat file decrypt.py di /mnt/data/simplekms pada node master.

Beralih ke direktori /mnt/data/simplekms:
```
cd /mnt/data/simplekms
```
Buat dan buka file decrypt.py:
```
sudo vim decrypt.py
```
Tekan tombol I untuk memasuki mode Insert.

Tambahkan konten berikut ke file decrypt.py:

from bigdl.ppml.ppml_context import *
args = {"kms_type": "SimpleKeyManagementService",
        "app_id": "98463816****",
        "api_key": "15780936****",
        "primary_key_material": "/mnt/data/simplekms/primaryKey"
        }
sc = PPMLContext("PPMLTest", args)
encrypted_csv_path = "/mnt/data/simplekms/encrypted-output"
csv_plain_df = sc.read(CryptoMode.AES_CBC_PKCS5PADDING) \
    .option("header", "true") \
    .csv(encrypted_csv_path)
csv_plain_df.show()
output_path = "/mnt/data/simplekms/decrypted-output"
sc.write(csv_plain_df, CryptoMode.PLAIN_TEXT) \
    .mode('overwrite') \
    .option("header", True)\
    .csv(output_path)

Tekan tombol Esc dan masukkan :wq untuk menyimpan perubahan dan keluar dari mode Insert.

Dekripsi data dalam direktori encrypted_csv_path pada node master.

APPID, APIKEY, dan primarykey mendekripsi data. File didekripsi part-XXXX.csv disimpan di /mnt/data/simplekms/decrypted-output.

java \
    -cp '/ppml/spark-3.1.3/conf/:/ppml/spark-3.1.3/jars/*:/ppml/bigdl-2.3.0-SNAPSHOT/jars/*' \
    -Xmx1g org.apache.spark.deploy.SparkSubmit \
    --master 'local[4]' \
    --conf spark.network.timeout=10000000 \
    --conf spark.executor.heartbeatInterval=10000000 \
    --conf spark.python.use.daemon=false \
    --conf spark.python.worker.reuse=false \
    --py-files /ppml/bigdl-2.3.0-SNAPSHOT/python/bigdl-ppml-spark_3.1.3-2.3.0-SNAPSHOT-python-api.zip,/ppml/bigdl-2.3.0-SNAPSHOT/python/bigdl-spark_3.1.3-2.3.0-SNAPSHOT-python-api.zip,/ppml/bigdl-2.3.0-SNAPSHOT/python/bigdl-dllib-spark_3.1.3-2.3.0-SNAPSHOT-python-api.zip \
    /mnt/data/simplekms/decrypt.py

Data yang didekripsi muncul seperti yang ditunjukkan di bawah ini.

Decrypted data