Percepat akses OSS di ACK menggunakan Fluid dan JindoRuntime - Container Service for Kubernetes

JindoRuntime berbasis C++ dan mendukung manajemen set data, cache data, serta penyimpanan data di OSS. Fluid memungkinkan observabilitas, penskalaan otomatis, dan portabilitas set data dengan mengelola serta menjadwalkan JindoRuntime. Topik ini menjelaskan cara menggunakan Fluid untuk mempercepat akses data dalam skenario penggunaan daya komputasi ACS.

Ketika Pod membaca data OSS secara berulang, setiap pembacaan mengambil data melalui jaringan—bahkan jika file yang sama baru saja diakses beberapa saat sebelumnya. JindoFS menghilangkan perjalanan bolak-balik berulang tersebut dengan menyimpan data dalam cache memori lokal. Setelah file dicache, pembacaan berikutnya dilayani dengan kecepatan hampir setara akses lokal. Contoh dalam topik ini menunjukkan percepatan 9x pada file berukuran 210 MiB setelah pembacaan pertama yang telah dicache.

Prasyarat

Sebelum memulai, pastikan Anda telah:

Mengaktifkan akun OSS. Lihat Activate OSS.
ack-fluid versi 1.0.11-* atau yang lebih baru telah diinstal di kluster Anda. Lihat Gunakan Helm untuk mengelola aplikasi di ACS.
Mengaktifkan mode privileged untuk Pod ACS.
Catatan
Mode privileged diperlukan untuk menggunakan Fluid guna akselerasi data. Untuk mengaktifkannya, submit a ticket.

Langkah 1: Unggah data ke OSS

Unduh set data uji.

wget https://archive.apache.org/dist/spark/spark-3.0.1/spark-3.0.1-bin-hadoop2.7.tgz

Unggah set data ke bucket OSS.
1. Install ossutil.
2. Buat bucket bernama examplebucket.
  Catatan
  Jika perintah mengembalikan ErrorCode=BucketAlreadyExists, artinya bucket tersebut sudah ada. Nama bucket OSS harus unik secara global—ubah nama sesuai kebutuhan.
```
ossutil64 mb oss://examplebucket
```
  Output yang diharapkan:
```
0.668238(s) elapsed
```
3. Unggah set data ke bucket.
```
ossutil64 cp spark-3.0.1-bin-hadoop2.7.tgz oss://examplebucket
```
4. (Opsional) Konfigurasikan izin akses bucket dan data. Lihat Permission control.
Penting
Langkah-langkah berikut menggunakan instance ECS yang menjalankan Alibaba Cloud Linux 3.2104 LTS 64-bit. Untuk sistem operasi lain, lihat ossutil command reference dan ossutil 1.0.

Buat file bernama mySecret.yaml dengan konten berikut.

apiVersion: v1
kind: Secret
metadata:
  name: mysecret
stringData:
  fs.oss.accessKeyId: <your-access-key-id>          # Ganti dengan ID AccessKey Anda
  fs.oss.accessKeySecret: <your-access-key-secret>  # Ganti dengan Secret AccessKey Anda

Kubernetes secara otomatis mengenkripsi Secret untuk menghindari pengeksposan data sensitif dalam teks biasa.

Terapkan Secret tersebut.
```
kubectl create -f mySecret.yaml
```

Langkah 2: Buat Dataset dan JindoRuntime

Catatan

Sebelum melanjutkan, verifikasi bahwa dataset-controller dan jindoruntime-controller dari komponen ack-fluid sedang berjalan:

kubectl get pods --field-selector=status.phase=Running -n fluid-system

Dalam contoh ini, daya komputasi CPU lebih disukai. Untuk mempercepat pemuatan LLM, pastikan zona kluster Anda menyediakan resource GPU. Lihat Introduction to GPU compute classes.

Buat file bernama resource.yaml dengan konten berikut. File ini mendefinisikan Dataset yang mengarah ke data OSS Anda, dan JindoRuntime yang meluncurkan kluster JindoFS untuk mencachenya.

Parameter	Deskripsi
`mountPoint`	Path OSS yang akan dimount sebagai underlying file system (UFS). Gunakan format `oss://<bucket>` atau `oss://<bucket>/<path>` untuk subdirektori.
`fs.oss.endpoint`	Titik akhir bucket OSS — publik atau privat. Contoh: `oss-cn-beijing-internal.aliyuncs.com`. Lihat OSS regions and endpoints.
`replicas`	Jumlah node pekerja dalam kluster JindoFS.
`mediumtype`	Media penyimpanan cache. Nilai yang didukung: `MEM`, `HDD`, `SSD`.
`quota`	Ukuran cache maksimum per pekerja.
`high` / `low`	Ambang batas atas dan bawah untuk eviksi cache.

apiVersion: data.fluid.io/v1alpha1
kind: Dataset
metadata:
  name: hadoop
spec:
  placement: Shared          # Diperlukan untuk node virtual ACS
  mounts:
      # Untuk mount subdirektori, gunakan oss://<oss_bucket>/<oss_path>
    - mountPoint: oss://<oss_bucket>       # Ganti dengan nama bucket OSS Anda, misalnya oss://examplebucket
      options:
        fs.oss.endpoint: <oss_endpoint>    # Ganti dengan titik akhir OSS Anda, misalnya oss-cn-beijing-internal.aliyuncs.com
      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                # Harus sesuai dengan nama Dataset
spec:
  networkmode: ContainerNetwork
  replicas: 4                 # Jumlah node pekerja JindoFS; sesuaikan sesuai kebutuhan
  master:
    podMetadata:
      labels:
        alibabacloud.com/compute-class: performance
        alibabacloud.com/compute-qos: default
  worker:
    podMetadata:
      labels:
        alibabacloud.com/compute-class: performance
        alibabacloud.com/compute-qos: default
    resources:
      requests:
        cpu: 24
        memory: 48Gi
      limits:
        cpu: 24
        memory: 48Gi
  tieredstore:
    levels:
      - mediumtype: MEM       # Media cache: MEM, HDD, atau SSD
        path: /dev/shm        # Path penyimpanan untuk media cache
        volumeType: emptyDir
        quota: 48Gi           # Ukuran cache maksimum per pekerja; sesuaikan sesuai kebutuhan
        high: "0.99"          # Eviksi dimulai ketika penggunaan mencapai ambang batas ini
        low: "0.95"           # Eviksi berhenti ketika penggunaan turun ke ambang batas ini

Parameter utama:

Terapkan konfigurasi tersebut.
```
kubectl create -f resource.yaml
```

Verifikasi bahwa Dataset dan JindoRuntime siap digunakan. Periksa Dataset:

kubectl get dataset hadoop

Output yang diharapkan:

NAME     UFS TOTAL SIZE   CACHED   CACHE CAPACITY   CACHED PERCENTAGE   PHASE   AGE
hadoop   209.74MiB        0.00B    4.00GiB          0.0%                Bound   56s

Periksa JindoRuntime:

kubectl get jindoruntime hadoop

Output yang diharapkan:

NAME     MASTER PHASE   WORKER PHASE   FUSE PHASE   AGE
hadoop   Ready          Ready          Ready        2m11s

Konfirmasi bahwa persistent volume (PV) dan persistent volume claim (PVC) telah dibuat. PV menggunakan nama Dataset.

kubectl get pv,pvc

Output yang diharapkan:

NAME                              CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS   CLAIM            STORAGECLASS   VOLUMEATTRIBUTESCLASS   REASON   AGE
persistentvolume/default-hadoop   100Pi      ROX            Retain           Bound    default/hadoop   fluid          <unset>                          2m5s

NAME                           STATUS   VOLUME           CAPACITY   ACCESS MODES   STORAGECLASS   VOLUMEATTRIBUTESCLASS   AGE
persistentvolumeclaim/hadoop   Bound    default-hadoop   100Pi      ROX            fluid          <unset>                 2m5s

Langkah 3: Buat resource DataLoad

Memuat awal (preload) set data ke cache JindoFS sebelum beban kerja Anda berjalan memastikan akses pertama sudah cepat dan logika pemrosesan data valid.

Jika data di bucket OSS Anda statis, buat file bernama dataload.yaml dengan konten berikut.
```
apiVersion: data.fluid.io/v1alpha1
kind: DataLoad
metadata:
  name: hadoop
spec:
  dataset:
    name: hadoop
    namespace: default
  loadMetadata: true
```
Jika data berubah secara berkala, atur preload berulang sebagai gantinya. Lihat Scenario 2: Data in the backend storage is read-only but periodically changes.
Terapkan resource DataLoad untuk memulai preload.
```
kubectl create -f dataload.yaml
```

Monitor progres preload.

kubectl get dataload

Output yang diharapkan saat selesai:

NAME     DATASET   PHASE      AGE   DURATION
hadoop   hadoop    Complete   92m   51s

Langkah 4: Verifikasi akselerasi data

Deploy Pod uji yang memount Dataset dan ukur waktu penyalinan file sebelum dan sesudah cache JindoFS berlaku.

Buat file bernama app.yaml.

apiVersion: v1
kind: Pod
metadata:
  name: demo-app
  labels:
    # Wajib: menginstruksikan webhook Fluid untuk menyuntikkan kontainer sidecar JindoFS ke Pod ACS
    alibabacloud.com/fluid-sidecar-target: acs
spec:
  containers:
    - name: demo
      image: mirrors-ssl.aliyuncs.com/nginx:latest
      volumeMounts:
        - mountPath: /data
          name: hadoop
      resources:
        requests:
          cpu: 14
          memory: 56Gi
  volumes:
    - name: hadoop
      persistentVolumeClaim:
        claimName: hadoop    # Sesuai dengan nama Dataset Fluid
  nodeSelector:
    type: virtual-kubelet
  tolerations:
    - key: virtual-kubelet.io/provider
      operator: Equal
      value: alibabacloud
      effect: NoSchedule

Deploy Pod tersebut.
```
kubectl create -f app.yaml
```

Ukur waktu penyalinan file tanpa cache JindoFS. Periksa ukuran file:

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

Output yang diharapkan:

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

Ukur waktu penyalinan:

kubectl exec -it demo-app -c demo -- bash
time cp /data/spark-3.0.1-bin-hadoop2.7.tgz /dev/null

Output yang diharapkan:

real    0m1.883s
user    0m0.001s
sys     0m0.041s

Konfirmasi bahwa data telah sepenuhnya dicache.

kubectl get dataset hadoop

Output yang diharapkan:

NAME     UFS TOTAL SIZE   CACHED      CACHE CAPACITY   CACHED PERCENTAGE   PHASE   AGE
hadoop   209.74MiB        209.74MiB   4.00GiB          100.0%              Bound   64m

Hapus dan buat ulang Pod, lalu jalankan kembali uji penyalinan terhadap cache JindoFS.
Catatan
Membuat ulang Pod membersihkan cache halaman OS, sehingga pengukuran kedua hanya mencerminkan kecepatan cache JindoFS—bukan sisa data di memori dari eksekusi pertama.
Hapus Pod yang ada:
```
kubectl delete pod demo-app
```
Buat ulang:
```
kubectl create -f app.yaml
```
Jalankan uji penyalinan lagi:
```
kubectl exec -it demo-app -c demo -- bash
time cp /data/spark-3.0.1-bin-hadoop2.7.tgz /dev/null
```
Output yang diharapkan:
```
real    0m0.203s
user    0m0.000s
sys     0m0.047s
```
Penyalinan kini memakan waktu 0,203 detik—sekitar 9x lebih cepat dibandingkan 1,883 detik tanpa cache. Percepatan ini berasal dari JindoFS yang melayani file dari cache memori di /dev/shm alih-alih mengambilnya dari OSS melalui jaringan. Setelah data dicache secara lokal, pembacaan berikutnya tidak lagi melewati jaringan.
Penting
Waktu penyalinan yang ditunjukkan di sini hanya sebagai referensi dan dapat bervariasi tergantung konfigurasi kluster dan kondisi jaringan Anda.

Gunakan daya komputasi ACS di kluster ACK Pro

Langkah-langkah di atas berlaku untuk kluster ACS. Untuk menggunakan daya komputasi ACS di kluster ACK yang dikelola, lihat Use the computing power of ACS in ACK Pro clusters.

Untuk kluster ACK yang dikelola, lakukan penyesuaian berikut:

Instal komponen ack-fluid di kluster ACK yang dikelola. Lihat Use Helm to simplify application deployment.

Buat Dataset dan JindoRuntime menggunakan konfigurasi berikut. Perbedaan utama dari konfigurasi ACS adalah tidak adanya placement: Shared dan networkmode, serta tidak ada label compute-class—node ACK standar tidak memerlukan pengaturan ini.

Kluster ACS menggunakan node virtual yang tidak mendukung penskalaan node standar. Untuk mengaktifkan akses dataset bersama dan komunikasi antar-Pod, atur placement: Shared dan networkmode: ContainerNetwork dalam konfigurasi ACS. Field ini tidak diperlukan untuk kluster ACK yang dikelola.
Pekerja Fluid pada ACS memerlukan bandwidth tinggi. Atur compute-class: performance dan konfigurasikan resources CPU dan memori yang cukup dalam konfigurasi ACS untuk memastikan bandwidth memadai. Kluster ACK yang dikelola mengalokasikan resource secara berbeda dan tidak memerlukan label ini.

apiVersion: data.fluid.io/v1alpha1
kind: Dataset
metadata:
  name: hadoop
spec:
  mounts:
      # Untuk mount subdirektori, gunakan oss://<oss_bucket>/<oss_path>
    - mountPoint: oss://<oss_bucket>       # Ganti dengan nama bucket OSS Anda
      options:
        fs.oss.endpoint: <oss_endpoint>    # Ganti dengan titik akhir OSS Anda
      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:
  replicas: 4                 # Sesuaikan sesuai kebutuhan
  tieredstore:
    levels:
      - mediumtype: MEM
        path: /dev/shm
        volumeType: emptyDir
        quota: 48Gi
        high: "0.99"
        low: "0.95"

Perbedaan dari konfigurasi ACS:

Container Compute Service:Gunakan Fluid untuk mempercepat akses data

Prasyarat

Langkah 1: Unggah data ke OSS

Langkah 2: Buat Dataset dan JindoRuntime

Langkah 3: Buat resource DataLoad

Langkah 4: Verifikasi akselerasi data

Gunakan daya komputasi ACS di kluster ACK Pro

Langkah selanjutnya