Cara menggunakan Fluid untuk mempercepat akses ke file OSS dari node edge - Container Service for Kubernetes

Fluid adalah mesin orkestrasi dan akselerasi dataset terdistribusi yang bersifat open source dan native Kubernetes. Fluid dirancang untuk aplikasi yang intensif data dalam skenario cloud-native, seperti aplikasi big data dan AI. Dalam skenario edge, mesin akselerasi dataset Fluid dapat secara signifikan meningkatkan kecepatan akses node edge ke file Object Storage Service (OSS). Topik ini menjelaskan cara menggunakan fitur akselerasi data Fluid di kluster ACK Edge.

Prasyarat

Kluster ACK Edge yang menjalankan Kubernetes 1.18 atau versi lebih baru telah dibuat. Untuk informasi selengkapnya, lihat Buat kluster ACK Edge.
Kelompok node edge telah dibuat dan node edge telah ditambahkan ke dalamnya. Untuk informasi selengkapnya, lihat Buat kelompok node edge dan Tambahkan node edge.
Suite AI cloud-native telah diinstal dan komponen ack-fluid telah dideploy.
Penting
Jika Fluid open source telah diinstal, uninstal terlebih dahulu sebelum mendeploy komponen ack-fluid.
- Jika suite AI cloud-native belum diinstal, pilih Fluid data acceleration selama instalasi. Untuk informasi selengkapnya, lihat Deploy konsol AI Suite.
- Jika suite AI cloud-native sudah diinstal, buka halaman Cloud-native AI Suite di ACK Console dan deploy ack-fluid.
Klien kubectl telah terhubung ke kluster Kubernetes. Untuk informasi selengkapnya, lihat Hubungkan ke kluster menggunakan kubectl.
OSS telah diaktifkan. Untuk informasi selengkapnya, lihat Aktifkan OSS.

Langkah 1: Siapkan data di bucket OSS

Jalankan perintah berikut untuk mengunduh data uji ke instans Elastic Compute Service (ECS) Anda.
```
wget https://archive.apache.org/dist/spark/spark-3.0.1/spark-3.0.1-bin-hadoop2.7.tgz
```
Unggah data uji yang telah diunduh ke bucket di Alibaba Cloud OSS.
Penting
Langkah-langkah berikut menjelaskan cara mengunggah data ke OSS dari instans ECS yang menjalankan Alibaba Cloud Linux 3.2104 LTS 64-bit. Untuk petunjuk pada sistem operasi lain, lihat referensi perintah ossutil dan ossutil.
1. Instal ossutil.
2. Buat bucket bernama examplebucket.
  - Jalankan perintah berikut untuk membuat examplebucket.
```
ossutil mb oss://examplebucket
```
  - Output berikut menunjukkan bahwa examplebucket telah dibuat.
```
0.668238(s) elapsed
```
3. Unggah data uji yang telah diunduh ke bucket examplebucket.
```
ossutil cp spark-3.0.1-bin-hadoop2.7.tgz oss://examplebucket
```

Langkah 2: Buat Dataset dan JindoRuntime

Sebelum membuat dataset, buat file bernama mySecret.yaml di direktori root instans ECS.
```
apiVersion: v1
kind: Secret
metadata:
  name: mysecret
stringData:
  fs.oss.accessKeyId: xxx
  fs.oss.accessKeySecret: xxx
```
Tentukan fs.oss.accessKeyId dan fs.oss.accessKeySecret sebagai ID AccessKey dan Rahasia AccessKey yang digunakan untuk mengakses OSS di Langkah 1.
Jalankan perintah berikut untuk membuat Secret: Kubernetes mengenkripsi Secret yang dibuat untuk mencegah informasi yang disimpan terekspos sebagai teks biasa.
```
kubectl create -f mySecret.yaml
```

Gunakan contoh YAML berikut untuk membuat file bernama resource.yaml yang terdiri dari dua bagian:

Buat Dataset yang mendeskripsikan dataset remote dan sistem file dasar (UFS).
Buat JindoRuntime untuk menjalankan kluster JindoFS yang menyediakan layanan cache.

apiVersion: data.fluid.io/v1alpha1
kind: Dataset
metadata:
  name: hadoop
spec:
  nodeAffinity:
    required:
      nodeSelectorTerms:
        - matchExpressions:
          - key: alibabacloud.com/nodepool-id
            operator: In
            values:
              - npxxxxxxxxxxxxxx
  mounts:
    - mountPoint: oss://<oss_bucket>/<bucket_dir>
      options:
        fs.oss.endpoint: <oss_endpoint>
      name: hadoop
      path: "/"
      encryptOptions:
        - name: fs.oss.accessKeyId
          valueFrom:
            secretKeyRef:
              name: mysecret
              key: fs.oss.accessKeyId
        - name: fs.oss.accessKeySecret
          valueFrom:
            secretKeyRef:
              name: mysecret
              key: fs.oss.accessKeySecret
---
apiVersion: data.fluid.io/v1alpha1
kind: JindoRuntime
metadata:
  name: hadoop
spec:
  nodeSelector:
    alibabacloud.com/nodepool-id: npxxxxxxxxxxxxxx
  replicas: 2
  tieredstore:
    levels:
      - mediumtype: MEM
        path: /dev/shm
        volumeType: emptyDir
        quota: 2Gi
        high: "0.99"
        low: "0.95"

Catatan

Di kluster ACK Edge, Anda harus menggunakan nodeAffinity dan nodeSelector untuk mendeploy Dataset dan JindoRuntime ke kelompok node yang sama. Hal ini memastikan konektivitas jaringan antar node dalam kelompok node tersebut.
Manajemen node edge dan akses OSS keduanya memerlukan koneksi jaringan cloud-to-edge. Kami menyarankan agar Anda menyediakan lebar pita jaringan yang cukup untuk memastikan stabilitas saluran manajemen.

Tabel berikut menjelaskan parameter-parameter tersebut.

Parameter	Deskripsi
mountPoint	Jalur UFS yang akan dipasang, dalam format `oss://<oss_bucket>/<bucket_dir>`. Jalur ini harus mengarah ke direktori, bukan file tunggal. Titik akhir tidak diperlukan dalam jalur ini.
fs.oss.endpoint	Titik akhir publik atau pribadi bucket OSS. Untuk informasi selengkapnya, lihat Wilayah dan titik akhir.
replicas	Jumlah worker dalam kluster JindoFS.
mediumtype	Jenis cache. Parameter ini menentukan jenis cache yang digunakan saat membuat templat JindoRuntime. Nilai yang valid: HDD, SDD, dan MEM.
path	Jalur penyimpanan. Anda hanya dapat menentukan satu jalur. Jika Anda mengatur mediumtype ke MEM, Anda harus menentukan jalur lokal untuk menyimpan data, seperti log.
quota	Ukuran maksimum data yang dicache. Satuan: GB.
high	Batas atas kapasitas penyimpanan.
low	Batas bawah kapasitas penyimpanan.

Jalankan perintah berikut untuk membuat dataset dan JindoRuntime:
```
kubectl create -f resource.yaml
```

Jalankan perintah berikut untuk memeriksa apakah dataset telah dideploy:

kubectl get dataset hadoop

Output yang diharapkan:

NAME     UFS TOTAL SIZE   CACHED   CACHE CAPACITY   CACHED PERCENTAGE   PHASE   AGE
hadoop        210MiB       0.00B    4.00GiB              0.0%          Bound   1h

Jalankan perintah berikut untuk memeriksa apakah JindoRuntime telah dideploy:

kubectl get jindoruntime hadoop

Output yang diharapkan:

NAME     MASTER PHASE   WORKER PHASE   FUSE PHASE   AGE
hadoop   Ready          Ready          Ready        4m45s

Jalankan perintah berikut untuk memeriksa apakah persistent volume (PV) dan persistent volume claim (PVC) telah dibuat:

kubectl get pv,pvc

Output yang diharapkan:

NAME                      CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS   CLAIM            STORAGECLASS   REASON   AGE
persistentvolume/hadoop   100Gi      RWX            Retain           Bound    default/hadoop                           52m

NAME                           STATUS   VOLUME   CAPACITY   ACCESS MODES   STORAGECLASS   AGE
persistentvolumeclaim/hadoop   Bound    hadoop   100Gi      RWX                           52m

Output di atas menunjukkan bahwa dataset dan JindoRuntime telah dibuat.

Langkah 3: Buat kontainer aplikasi untuk menguji efek akselerasi

Anda dapat mendeploy aplikasi dalam kontainer untuk menguji akselerasi data JindoFS. Anda juga dapat mengirimkan pekerjaan pembelajaran mesin untuk menggunakan fitur-fitur terkait. Pada topik ini, sebuah aplikasi dideploy dalam kontainer untuk menguji akses ke data yang sama. Pengujian ini menunjukkan efek akselerasi JindoRuntime dengan membandingkan waktu akses.

Buat file bernama app.yaml dengan konten berikut.

apiVersion: v1
kind: Pod
metadata:
  name: demo-app
spec:
  nodeSelector:
    alibabacloud.com/nodepool-id: npxxxxxxxxxxxxx
  containers:
    - name: demo
      image: anolis-registry.cn-zhangjiakou.cr.aliyuncs.com/openanolis/nginx:1.14.1-8.6
      volumeMounts:
        - mountPath: /data
          name: hadoop
  volumes:
    - name: hadoop
      persistentVolumeClaim:
        claimName: hadoop

Catatan

Di kluster ACK Edge, Anda harus menggunakan nodeSelector untuk mendeploy pod pengujian ke kelompok node yang telah Anda tentukan di Langkah 2.

Jalankan perintah berikut untuk mendeploy aplikasi:
```
kubectl create -f app.yaml
```

Jalankan perintah berikut untuk menanyakan ukuran file tertentu:

kubectl exec -it demo-app -- bash
du -sh /data/spark-3.0.1-bin-hadoop2.7.tgz

Output yang diharapkan:

210M    /data/spark-3.0.1-bin-hadoop2.7.tgz

Jalankan perintah berikut untuk menanyakan waktu yang dibutuhkan untuk menyalin file:
```
time cp /data/spark-3.0.1-bin-hadoop2.7.tgz /dev/null
```
Output yang diharapkan:
```
real    0m18.386s
user    0m0.002s
sys    0m0.105s
```
Output tersebut menunjukkan bahwa penyalinan file membutuhkan waktu 18 detik.

Jalankan perintah berikut untuk memeriksa data yang dicache oleh dataset:

kubectl get dataset hadoop

Output yang diharapkan:

NAME     UFS TOTAL SIZE   CACHED   CACHE CAPACITY   CACHED PERCENTAGE   PHASE   AGE
hadoop   210.00MiB       210.00MiB    4.00GiB        100.0%           Bound   1h

Output tersebut menunjukkan bahwa data sebesar 210 MiB telah dicache ke penyimpanan lokal.

Jalankan perintah berikut untuk menghapus aplikasi saat ini, lalu buat kembali aplikasi yang sama:
Catatan
Langkah ini dilakukan untuk menghindari faktor lain, seperti page cache, yang dapat memengaruhi hasil.
```
kubectl delete -f app.yaml && kubectl create -f app.yaml
```
Jalankan perintah berikut untuk menanyakan waktu yang dibutuhkan untuk menyalin file:
```
kubectl exec -it demo-app -- bash
time cp /data/spark-3.0.1-bin-hadoop2.7.tgz /dev/null
```
Output yang diharapkan:
```
real    0m0.048s
user    0m0.001s
sys     0m0.046s
```
Output tersebut menunjukkan bahwa penyalinan file hanya membutuhkan waktu 48 milidetik, berkurang lebih dari 300 kali lipat.
Catatan
Hal ini terjadi karena file telah dicache oleh JindoFS.

(Opsional) Bersihkan lingkungan

Jika Anda tidak lagi menggunakan akselerasi data, Anda dapat menjalankan perintah berikut untuk membersihkan lingkungan.

Jalankan perintah berikut untuk menghapus aplikasi:

kubectl delete pod demo-app

Jalankan perintah berikut untuk menghapus dataset dan JindoRuntime:

kubectl delete dataset hadoop