Bagikan Dataset Melintasi Namespace melalui Fluid - ACK

Ketika beberapa tim menjalankan beban kerja AI atau ML di namespace Kubernetes yang terpisah, masing-masing tim membuat cache-nya sendiri, sehingga menyia-nyiakan penyimpanan dan memperlambat akses data. Fluid memungkinkan Anda melakukan caching dataset sekali di namespace sumber dan membagikan cache tersebut ke beberapa namespace referensi—tanpa duplikasi cache maupun overhead waktu proses tambahan.

Pengaturan ini menggunakan dua peran namespace:

Namespace sumber (share): berisi Dataset dan runtime cache (JindoRuntime atau JuiceFSRuntime). Di sinilah cache data aktual berada.
Namespace referensi (ref): berisi Dataset referensi yang mengarah ke Dataset sumber melalui titik kait dataset://. Pod di namespace ini membaca dari cache bersama tanpa menjalankan runtime cache-nya sendiri.

Cara kerjanya

Fluid menggunakan ThinRuntime untuk menghubungkan Dataset di satu namespace ke Dataset di namespace lain. Saat pod di namespace referensi membaca data, permintaan dialihkan ke runtime cache di namespace sumber. Tidak ada runtime cache tambahan yang dibuat di namespace referensi.

Prasyarat

Sebelum memulai, pastikan Anda telah:

Memiliki kluster ACK Pro yang menjalankan Kubernetes 1.18 atau lebih baru, dengan kelompok node non-ContainerOS (komponen ack-fluid tidak mendukung ContainerOS). Untuk informasi selengkapnya, lihat Buat kluster ACK Pro.
Memasang suite AI cloud-native dengan komponen ack-fluid dideploy:
- Jika Anda belum menginstal suite AI cloud-native, aktifkan Fluid acceleration saat menginstalnya. Untuk informasi selengkapnya, lihat Deploy suite AI cloud-native.
- Jika suite AI cloud-native sudah terinstal, buka halaman Cloud-native AI Suite di Konsol ACK dan deploy komponen ack-fluid.
- Jika Fluid open-source sudah terinstal, uninstal terlebih dahulu sebelum mendeploy komponen ack-fluid.
Memiliki klien kubectl yang terhubung ke kluster ACK Pro Anda. Untuk informasi selengkapnya, lihat Hubungkan ke kluster menggunakan kubectl.

Langkah 1: Unggah dataset uji ke OSS

Unduh dataset uji (sekitar 2 GB).
Unggah dataset ke bucket Object Storage Service (OSS) Anda menggunakan ossutil. Untuk informasi selengkapnya, lihat Instal ossutil.

Langkah 2: Buat dataset dan runtime bersama

Buat namespace bernama share untuk menampung Dataset dan runtime bersama. Pilih jenis runtime yang sesuai dengan konfigurasi penyimpanan Anda.

JindoRuntime

Buat namespace share:
```
kubectl create ns share
```
Buat Secret untuk menyimpan pasangan AccessKey bucket OSS Anda:
```
kubectl apply -f - <<EOF
apiVersion: v1
kind: Secret
metadata:
  name: dataset-secret
  namespace: share
stringData:
  fs.oss.accessKeyId: <YourAccessKey ID>
  fs.oss.accessKeySecret: <YourAccessKey Secret>
EOF
```
Ganti <YourAccessKey ID> dan <YourAccessKey Secret> dengan ID AccessKey dan Rahasia AccessKey Anda. Untuk informasi selengkapnya, lihat Dapatkan pasangan AccessKey.

Buat file bernama shared-dataset.yaml dengan konten berikut:

# Dataset: menjelaskan data yang disimpan di OSS (sistem file dasar, UFS).
apiVersion: data.fluid.io/v1alpha1
kind: Dataset
metadata:
  name: shared-dataset
  namespace: share
spec:
  mounts:
  - mountPoint: oss://<oss_bucket>/<bucket_dir> # Jalur ke data di bucket OSS Anda.
    options:
      fs.oss.endpoint: <oss_endpoint> # Titik akhir bucket OSS Anda.
    name: hadoop
    path: "/"
    encryptOptions:
      - name: fs.oss.accessKeyId
        valueFrom:
          secretKeyRef:
            name: dataset-secret
            key: fs.oss.accessKeyId
      - name: fs.oss.accessKeySecret
        valueFrom:
          secretKeyRef:
            name: dataset-secret
            key: fs.oss.accessKeySecret
---
# JindoRuntime: mengaktifkan caching data berbasis JindoFS di kluster.
apiVersion: data.fluid.io/v1alpha1
kind: JindoRuntime
metadata:
  name: shared-dataset
  namespace: share
spec:
  replicas: 1
  tieredstore:
    levels:
      - mediumtype: MEM
        path: /dev/shm
        quota: 4Gi
        high: "0.95"
        low: "0.7"

Untuk informasi selengkapnya tentang konfigurasi Dataset dan JindoRuntime, lihat Gunakan JindoFS untuk mempercepat akses ke OSS.

Terapkan konfigurasi:

kubectl apply -f shared-dataset.yaml

Output yang diharapkan:

dataset.data.fluid.io/shared-dataset created
jindoruntime.data.fluid.io/shared-dataset created

Tunggu beberapa menit, lalu verifikasi bahwa Dataset telah terikat dan JindoRuntime siap:

kubectl get dataset,jindoruntime -n share

Output yang diharapkan:

NAME                                   UFS TOTAL SIZE   CACHED   CACHE CAPACITY   CACHED PERCENTAGE   PHASE   AGE
dataset.data.fluid.io/shared-dataset   1.16GiB          0.00B    4.00GiB          0.0%                Bound   4m1s

NAME                                        MASTER PHASE   WORKER PHASE   FUSE PHASE   AGE
jindoruntime.data.fluid.io/shared-dataset   Ready          Ready          Ready        15m

Dataset dianggap terikat dan JindoRuntime siap jika semua fase menunjukkan Ready.

JuiceFSRuntime

Buat namespace share:
```
kubectl create ns share
```

Buat Secret untuk menyimpan kredensial bucket OSS dan volume JuiceFS Anda:

kubectl apply -f - <<EOF
apiVersion: v1
kind: Secret
metadata:
  name: dataset-secret
  namespace: share
type: Opaque
stringData:
  token: <JUICEFS_VOLUME_TOKEN>
  access-key: <OSS_ACCESS_KEY>
  secret-key: <OSS_SECRET_KEY>
EOF

Ganti <OSS_ACCESS_KEY> dan <OSS_SECRET_KEY> dengan ID AccessKey dan Rahasia AccessKey Anda. Untuk informasi selengkapnya, lihat Dapatkan pasangan AccessKey.

Buat file bernama shared-dataset.yaml dengan konten berikut:

# Dataset: menjelaskan data yang disimpan di OSS (sistem file dasar, UFS).
apiVersion: data.fluid.io/v1alpha1
kind: Dataset
metadata:
  name: shared-dataset
  namespace: share
spec:
  accessModes: ["ReadOnlyMany"]
  sharedEncryptOptions:
  - name: access-key
    valueFrom:
      secretKeyRef:
        name: dataset-secret
        key: access-key
  - name: secret-key
    valueFrom:
      secretKeyRef:
        name: dataset-secret
        key: secret-key
  - name: token
    valueFrom:
      secretKeyRef:
        name: dataset-secret
        key: token
  mounts:
  - name: <JUICEFS_VOLUME_NAME>
    mountPoint: juicefs:/// # Titik kait sistem file JuiceFS.
    options:
      bucket: https://<OSS_BUCKET_NAME>.oss-<REGION_ID>.aliyuncs.com # Contoh: https://mybucket.oss-cn-beijing-internal.aliyuncs.com
---
# JuiceFSRuntime: mengaktifkan caching data berbasis JuiceFS di kluster.
apiVersion: data.fluid.io/v1alpha1
kind: JuiceFSRuntime
metadata:
  name: shared-dataset
  namespace: share
spec:
  replicas: 1
  tieredstore:
    levels:
    - mediumtype: MEM
      path: /dev/shm
      quota: 1Gi
      high: "0.95"
      low: "0.7"

Terapkan konfigurasi:

kubectl apply -f shared-dataset.yaml

Output yang diharapkan:

dataset.data.fluid.io/shared-dataset created
juicefsruntime.data.fluid.io/shared-dataset created

Tunggu beberapa menit, lalu verifikasi bahwa Dataset telah terikat:

kubectl get dataset,juicefsruntime -n share

Output yang diharapkan:

NAME                                   UFS TOTAL SIZE   CACHED   CACHE CAPACITY   CACHED PERCENTAGE   PHASE   AGE
dataset.data.fluid.io/shared-dataset   2.32GiB          0.00B    4.00GiB          0.0%                Bound   3d16h

NAME                                          WORKER PHASE   FUSE PHASE   AGE
juicefsruntime.data.fluid.io/shared-dataset                               3m50s

Langkah 3: Buat dataset referensi dan pod

Buat namespace ref:
```
kubectl create ns ref
```
Buat file bernama ref-dataset.yaml dengan konten berikut:
- dataset:// — awalan protokol, menunjukkan bahwa Dataset ini mereferensikan Dataset lain.
- share — namespace tempat Dataset sumber berada.
- shared-dataset — nama Dataset sumber.
Penting
Nilai mountPoint harus menggunakan awalan protokol dataset://. Format lain akan menyebabkan pembuatan dataset gagal, dan bidang dalam bagian spec tidak berpengaruh.
```
apiVersion: data.fluid.io/v1alpha1
kind: Dataset
metadata:
  name: ref-dataset
  namespace: ref
spec:
  mounts:
  - mountPoint: dataset://share/shared-dataset
```
Nilai mountPoint mengikuti format dataset://<namespace>/<dataset-name>:
Terapkan Dataset referensi:
```
kubectl apply -f ref-dataset.yaml
```

Buat file bernama app.yaml dengan konten berikut. File ini membuat pod di namespace ref yang memasang Dataset referensi di /data.

apiVersion: v1
kind: Pod
metadata:
  name: nginx
  namespace: ref
spec:
  containers:
  - name: nginx
    image: anolis-registry.cn-zhangjiakou.cr.aliyuncs.com/openanolis/nginx:1.14.1-8.6
    command:
    - "bash"
    - "-c"
    - "sleep inf"
    volumeMounts:
    - mountPath: /data
      name: ref-data
  volumes:
  - name: ref-data
    persistentVolumeClaim:
      claimName: ref-dataset

Deploy pod:
```
kubectl apply -f app.yaml
```
Verifikasi bahwa pod sedang berjalan:
```
kubectl get pods -n ref -o wide
```
Pod siap digunakan jika status-nya menunjukkan Running.

Langkah 4: Uji berbagi dan caching data

Periksa pod di kedua namespace:

kubectl get pods -n share
kubectl get pods -n ref

Output yang diharapkan:

# Pod di namespace share
NAME                                READY   STATUS    RESTARTS   AGE
shared-dataset-jindofs-fuse-ftkb5   1/1     Running   0          44s
shared-dataset-jindofs-master-0     1/1     Running   0          9m13s
shared-dataset-jindofs-worker-0     1/1     Running   0          9m13s

# Pod di namespace ref
NAME    READY   STATUS    RESTARTS   AGE
nginx   1/1     Running   0          118s

Tiga pod terkait cache berjalan di namespace share. Namespace ref hanya memiliki pod nginx—tidak ada pod runtime cache yang dibuat di sana.

Masuk ke pod nginx:
```
kubectl exec nginx -n ref -it -- sh
```
Uji berbagi data dengan mengkueri file di direktori /data:
```
du -sh /data/wwm_uncased_L-24_H-1024_A-16.zip
```
Output yang diharapkan:
```
1.3G    /data/wwm_uncased_L-24_H-1024_A-16.zip
```
Pod nginx di namespace ref dapat mengakses file yang disimpan di namespace share.

Uji caching data dengan membaca file dua kali:

Nilai latensi berikut hanya sebagai referensi. Hasil aktual bervariasi tergantung lingkungan Anda.

# Pembacaan pertama — data diambil dari OSS dan ditulis ke cache
time cat /data/wwm_uncased_L-24_H-1024_A-16.zip > /dev/null
real    0m1.166s
user    0m0.007s
sys     0m1.154s

# Pembacaan kedua — data disajikan dari cache
time cat /data/wwm_uncased_L-24_H-1024_A-16.zip > /dev/null
real    0m0.289s
user    0m0.011s
sys     0m0.274s

Pembacaan kedua selesai dalam 0,289 detik dibandingkan 1,166 detik pada pembacaan pertama, yang mengonfirmasi bahwa file telah dicache setelah akses pertama.