Bangun aplikasi analitik data besar Apache Spark terdistribusi dengan keamanan ujung ke ujung menggunakan BigDL PPML pada instans TDX - Elastic Compute Service

Topik ini menjelaskan cara menggunakan BigDL Privacy Preserving Machine Learning (BigDL PPML) untuk menjalankan aplikasi analitik data besar Apache Spark terdistribusi dengan keamanan ujung ke ujung pada instans g8i yang diaktifkan Intel^® TDX.

Informasi latar belakang

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

BigDL PPML dapat digunakan untuk menjalankan aplikasi data besar dan AI standar (seperti Apache Spark, Apache Flink, Tensorflow, dan PyTorch) pada instans TDX Alibaba Cloud sambil melindungi data yang sedang dikirim dan digunakan serta menjamin integritas aplikasi. Untuk informasi lebih lanjut, lihat BigDL-PPML.

Intel^® Trusted Domain Extensions (Intel^® TDX) menyediakan keamanan berbasis perangkat keras untuk melindungi data. Ini independen dari firmware dan status keamanan host dan dapat membangun lingkungan komputasi rahasia pada mesin fisik.
Instans g8i Alibaba Cloud adalah instans yang diaktifkan Intel^® TDX (selanjutnya disebut instans TDX) yang menyediakan kemampuan komputasi rahasia TDX dan menciptakan lingkungan yang lebih aman, tepercaya, dan rahasia dengan perlindungan berbasis perangkat keras. Instans TDX mengurangi risiko yang terkait dengan serangan malware dan mencapai tingkat privasi data dan integritas aplikasi yang tinggi.
BigDL PPML adalah solusi yang dikembangkan berdasarkan Intel^® TDX untuk mengamankan analisis data dan aplikasi AI.

Arsitektur

Dengan menggunakan BigDL PPML, Anda dapat menjalankan aplikasi analitik data besar dan AI terdistribusi yang ada, seperti Apache Spark, Apache Flink, Tensorflow, dan PyTorch, dalam lingkungan rahasia tanpa perubahan kode. Aplikasi analitik data besar dan AI berjalan pada kluster Kubernetes yang didasarkan pada instans TDX, di mana komputasi dan memori dilindungi oleh Intel® TDX. BigDL PPML memungkinkan mekanisme keamanan ujung ke ujung berikut untuk aplikasi terdistribusi di lapisan bawah:

Mekanisme keamanan ini menyediakan dan memvalidasi lingkungan kluster tepercaya di dalam kluster Kubernetes yang didasarkan pada instans TDX.
Layanan Manajemen Kunci (KMS): mengelola kunci serta menggunakan kunci untuk mengenkripsi dan mendekripsi data terdistribusi.
Komputasi dan komunikasi terdistribusi yang aman.

BigDL PPML mengamankan pipeline data besar dan AI secara ujung ke ujung dalam kluster Kubernetes yang diterapkan pada instans yang diaktifkan Intel^® TDX, seperti yang ditunjukkan pada gambar sebelumnya. Seluruh data dienkripsi dan disimpan di data lake serta data warehouse.

Pekerja BigDL PPML memuat data input terenkripsi, memperoleh kunci data dengan melakukan validasi jarak jauh atau menggunakan KMS, dan menggunakan kunci untuk mendekripsi data input pada instans TDX.
Pekerja BigDL PPML menggunakan framework komputasi data besar dan AI untuk memproses data secara terdistribusi, melatih model, dan melakukan inferensi menggunakan model.
Pekerja BigDL PPML mengenkripsi dan menulis hasil akhir, data output, atau model ke penyimpanan terdistribusi.

Data yang ditransmisikan antar node dienkripsi dalam transit berdasarkan protokol keamanan, seperti Advanced Encryption Standard (AES) dan Transport Layer Security, untuk memastikan keamanan dan privasi data ujung ke ujung.

Prosedur

Bagian ini menjelaskan cara menjalankan aplikasi analitik data besar terdistribusi dengan keamanan ujung-ke-ujung pada instans TDX. Contoh yang digunakan meliputi aplikasi analitik data besar Apache Spark dan Simple Query. Untuk informasi lebih lanjut tentang penggunaan aplikasi data besar dan AI, lihat Tutorial & Contoh BigDL PPML.

Langkah 1: Terapkan kluster Kubernetes dan lingkungan runtime

Dalam topik ini, kluster Kubernetes yang terdiri dari node master dan dua node pekerja digunakan. Jumlah node dalam kluster harus sama dengan jumlah instans TDX yang Anda beli. Anda dapat membuat kluster Kubernetes yang terdiri dari sejumlah node tertentu berdasarkan kebutuhan bisnis Anda.

Buat instans g8i yang diaktifkan Intel^® TDX.
Untuk informasi lebih lanjut, lihat Buat instans pada tab Peluncuran Kustom. Perhatikan parameter berikut:
- Jenis Instans: Pilih jenis instans yang mendukung contoh Simple Query. Jenis instans harus memiliki setidaknya 32 vCPU dan 64 GiB memori untuk mendukung contoh Simple Query. Dalam topik ini, jenis instans ecs.g8i.8xlarge digunakan.
- Gambar: Pilih Alibaba Cloud Linux 3.2104 LTS 64-bit.
- Alamat IP Publik: Pilih Tetapkan Alamat IPv4 Publik.
- Jumlah: Masukkan 3.
Hubungkan ke instans.
Untuk informasi lebih lanjut, lihat Metode untuk menghubungkan ke instans ECS.
Terapkan kluster Kubernetes dan konfigurasikan pengaturan keamanan.
1. Terapkan kluster Kubernetes pada instans g8i.
  Untuk informasi lebih lanjut, lihat Membuat kluster dengan kubeadm.
2. Jalankan perintah berikut untuk mengonfigurasi pengaturan keamanan (pengaturan kontrol akses berbasis peran) pada node master kluster Kubernetes:
```
kubectl create serviceaccount spark
kubectl create clusterrolebinding spark-role --clusterrole=edit --serviceaccount=default:spark --namespace=default
```
Buat PersistentVolume.
1. Jalankan perintah berikut sebagai pengguna root untuk membuat file pv-volume.yaml:
```
vim pv-volume.yaml
```
2. Tekan tombol I untuk masuk ke mode Insert.
3. 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"
```
4. Tekan tombol Esc dan masukkan :wq untuk menyimpan perubahan dan keluar dari mode Insert.
5. Jalankan perintah berikut untuk membuat PersistentVolume dan melihat PersistentVolume:
```
kubectl apply -f pv-volume.yaml
kubectl get pv task-pv-volume
```
Buat PersistentVolumeClaim.
1. Jalankan perintah berikut sebagai pengguna root untuk membuat file pv-claim.yaml:
```
vim pv-claim.yaml
```
2. Tekan tombol I untuk masuk ke 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. Jalankan perintah berikut untuk membuat PersistentVolumeClaim dan melihat PersistentVolumeClaim:
```
kubectl apply -f pv-claim.yaml
kubectl get pvc task-pv-claim
```

Langkah 2: Enkripsi data pelatihan

Jalankan perintah berikut pada setiap node kluster Kubernetes untuk mendapatkan gambar BigDL PPML.
Gambar ini digunakan untuk menjalankan aplikasi Apache Spark standar serta menyediakan fitur 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. Jalankan perintah berikut pada node master kluster Kubernetes untuk mengunduh skrip pelatihan generate_people_csv.py:
```
wget https://github.com/intel-analytics/BigDL/raw/main/ppml/scripts/generate_people_csv.py
```
2. Jalankan perintah berikut untuk menghasilkan file dataset pelatihan people.csv:
```
python generate_people_csv.py </save/path/of/people.csv> <num_lines>
```
  Catatan
  - Atur </save/path/of/people.csv> ke jalur tempat Anda ingin menghasilkan file people.csv. Dalam contoh ini, jalur /home/user digunakan.
  - Atur <num_lines> ke jumlah baris dalam people.csv. Dalam contoh ini, jumlah baris adalah 500.
3. Jalankan perintah berikut untuk memindahkan people.csv ke direktori tertentu:
```
sudo scp /home/user/people.csv /mnt/data/simplekms/
```
  Penting
  - Ganti /home/user dengan direktori aktual.
  - Dalam contoh ini, direktori /mnt/data/simplekms/ digunakan. Direktori /mnt/data/simplekms/ menyimpan data terenkripsi dan terdekripsi dan tidak dibahas secara terpisah dalam bagian selanjutnya dari topik ini.
Jalankan perintah berikut pada node master kluster Kubernetes untuk menjalankan container bigdl-ppml-client.
Container ini digunakan untuk mengenkripsi dan mendekripsi data pelatihan.
Catatan
Ganti /home/user/kuberconfig:/root/.kube/config berdasarkan pengguna yang menjalankan container bigdl-ppml-client.
- Jika pengguna root menjalankan container, ganti /home/user/kuberconfig:/root/.kube/config dengan/root/kuberconfig:/root/.kube/config.
- Jika pengguna biasa seperti pengguna test menjalankan container, ganti /home/user/kuberconfig:/root/.kube/config 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.

Jalankan perintah berikut untuk menghasilkan kunci utama (primarykey) berdasarkan ID aplikasi (APPID) dan kunci API (APIKEY).
Anda dapat menggunakan simple KMS untuk menghasilkan ID aplikasi dan kunci API yang panjangnya 1 hingga 12 karakter. Dalam contoh ini, nilai APPID adalah 98463816****, dan nilai APIKEY adalah 15780936****. --primaryKeyPath menentukan direktori tempat Anda ingin menyimpan 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.

Jalankan perintah berikut untuk beralih ke direktori /mnt/data/simplekms:
```
cd /mnt/data/simplekms
```
Jalankan perintah berikut untuk membuat dan membuka file encrypt.py:
```
sudo vim encrypt.py
```
Tekan tombol I untuk masuk ke 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.

Jalankan perintah berikut dalam container bigdl-ppml-client untuk mengenkripsi people.csv menggunakan APPID, APIKEY, dan primarykey.

Data terenkripsi disimpan dalam direktori /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

Jalankan perintah berikut pada setiap node pekerja kluster Kubernetes untuk menyalin /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 nama pengguna aktual node master dan 192.168.XXX.XXX dengan alamat IP aktual node master.

Langkah 3: Jalankan contoh analitik data besar berbasis BigDL PPML

Di dalam container bigdl-ppml-client, kirim pekerjaan Apache Spark ke kluster Kubernetes guna menjalankan contoh Simple Query.

Catatan

Dalam 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****

Periksa status pekerjaan Apache Spark pada node master.
1. Jalankan perintah berikut untuk melihat nama dan status driver dan executor:
```
kubectl get pod
```
  Saat pekerjaan Apache Spark selesai, nilai STATUS berubah dari Running menjadi Completed.
2. Jalankan perintah berikut untuk melihat log pod:
```
kubectl logs simplequery-xxx-exec-1
```
  Catatan
  Ganti simplequery-xxx-exec-1 dengan nilai Name yang sesuai dari langkah sebelumnya.
  Setelah pekerjaan Apache Spark selesai, status Finished akan ditampilkan di log pod.

Langkah 4: Dekripsi hasil

Unggah file .meta dan part-XXXX.csv.cbc yang disimpan dalam direktori encrypted-output setiap node pekerja ke direktori encrypted-output node master.
Setelah file diunggah, direktori encrypted-output node master berisi data seperti yang ditunjukkan pada gambar berikut.

Dalam direktori /mnt/data/simplekms node master, buat file decrypt.py.

Jalankan perintah berikut untuk beralih ke direktori /mnt/data/simplekms:
```
cd /mnt/data/simplekms
```
Jalankan perintah berikut untuk membuat dan membuka file decrypt.py:
```
sudo vim decrypt.py
```
Tekan tombol I untuk masuk ke 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.

Jalankan perintah berikut pada node master kluster Kubernetes untuk mendekripsi data yang disimpan dalam direktori encrypted_csv_path.

APPID, APIKEY, dan primarykey digunakan untuk mendekripsi data. File data terdekripsi part-XXXX.csv disimpan di direktori /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 terdekripsi ditampilkan di Windows, seperti yang ditunjukkan pada gambar berikut.

Decrypted data