Bagikan dataset di seluruh namespace - Container Service for Kubernetes

Fluid mengisolasi sumber daya di Kubernetes berdasarkan namespace. Anda dapat menggunakan Fluid untuk mengatur akses ke dataset dari berbagai pekerjaan komputasi dan mengisolasi data yang dimiliki oleh tim yang berbeda. Selain itu, Fluid mendukung akses data dan berbagi cache di seluruh namespace. Dengan Fluid, Anda hanya perlu menyimpan data sekali ketika ingin berbagi data antara beberapa tim. Hal ini meningkatkan efisiensi pemanfaatan data dan fleksibilitas manajemen data serta memfasilitasi kolaborasi antar tim R&D. Topik ini menjelaskan cara berbagi dataset di seluruh namespace dengan menggunakan Fluid.

Cara kerjanya

Fluid mendukung ThinRuntime, yang memungkinkan Anda mengakses berbagai sistem penyimpanan secara low-code dan menggunakan kembali kemampuan utama Fluid seperti orkestrasi data dan akses data melalui platform runtime. Dengan ThinRuntime, Fluid memungkinkan Anda mengaitkan dataset dalam satu namespace dengan dataset di namespace lain. Dengan cara ini, Anda dapat berbagi runtime cache yang sama di antara aplikasi dalam namespace yang berbeda.

Prasyarat

Sebuah kluster ACK Pro dari Container Service for Kubernetes (ACK) dengan non-containerOS telah dibuat, dan versi Kubernetes kluster tersebut adalah 1.18 atau lebih baru. Untuk informasi lebih lanjut, lihat Create an ACK Pro cluster.
Penting
Komponen ack-fluid saat ini tidak didukung pada ContainerOS.
Suite AI cloud-native telah diinstal dan komponen ack-fluid telah diterapkan.
Penting
Jika Anda sudah menginstal Fluid open source, uninstall Fluid dan terapkan komponen ack-fluid.
- Jika Anda belum menginstal suite AI cloud-native, aktifkan Fluid acceleration saat Anda menginstal suite tersebut. Untuk informasi lebih lanjut, lihat Terapkan suite AI cloud-native.
- Jika Anda sudah menginstal suite AI cloud-native, buka halaman Cloud-native AI Suite di Konsol ACK dan terapkan komponen ack-fluid.
Klien kubectl terhubung ke kluster ACK Pro. Untuk informasi lebih lanjut, lihat Hubungkan ke kluster menggunakan kubectl.

Langkah 1: Unggah dataset uji ke bucket OSS

Buat dataset uji berukuran 2 GB. Dalam contoh ini, dataset uji digunakan.
Unggah dataset uji ke bucket OSS yang Anda buat.
Anda dapat menggunakan alat ossutil yang disediakan oleh OSS untuk mengunggah data. Untuk informasi lebih lanjut, lihat Instal ossutil.

Langkah 2: Buat dataset bersama dan objek Runtime

JindoRuntime

Buat namespace bernama share. Dalam contoh berikut, dataset bersama dan objek runtime dibuat di namespace ini.
```
kubectl create ns share
```
Jalankan perintah berikut untuk membuat Secret guna menyimpan pasangan AccessKey yang digunakan untuk mengakses bucket Object Storage Service (OSS):
```
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                                         
```
Dalam kode sebelumnya, parameter fs.oss.accessKeyId menentukan ID AccessKey dan parameter fs.oss.accessKeySecret menentukan rahasia AccessKey. Untuk informasi lebih lanjut tentang cara mendapatkan pasangan AccessKey, lihat Dapatkan pasangan AccessKey.

Buat file bernama shared-dataset.yaml dan salin konten berikut ke file tersebut. File ini digunakan untuk membuat dataset dan JindoRuntime. Untuk informasi lebih lanjut tentang cara mengonfigurasi dataset dan JindoRuntime, lihat Gunakan JindoFS untuk mempercepat akses ke OSS.

# Buat dataset yang menggambarkan dataset yang disimpan di bucket OSS dan 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> # Ganti nilai dengan jalur file yang ingin Anda bagikan di bucket OSS.
    options:
      fs.oss.endpoint: <oss_endpoint> # Ganti nilai dengan titik akhir bucket OSS yang Anda gunakan.
    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

---
# Buat JindoRuntime untuk mengaktifkan JindoFS untuk caching data 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"

Jalankan perintah berikut untuk membuat dataset dan JindoRuntime:
```
kubectl apply -f shared-dataset.yaml
```
Output yang diharapkan:
```
dataset.data.fluid.io/shared-dataset created
jindoruntime.data.fluid.io/shared-dataset created
```
Output menunjukkan bahwa dataset dan JindoRuntime telah dibuat.

Tunggu beberapa menit dan jalankan perintah berikut untuk menanyakan dataset dan JindoRuntime yang dibuat:

kubectl get dataset,jindoruntime -nshare

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

Output menunjukkan bahwa dataset terkait dengan JindoRuntime.

JuiceFSRuntime

Buat namespace bernama share. Dalam contoh berikut, dataset bersama dan objek runtime dibuat di namespace ini.
```
kubectl create ns share
```

Jalankan perintah berikut untuk membuat Secret guna menyimpan pasangan AccessKey yang digunakan untuk mengakses bucket OSS:

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

Dalam kode sebelumnya, parameter access-key menentukan ID AccessKey dan parameter secret-key menentukan rahasia AccessKey. Untuk informasi lebih lanjut tentang cara mendapatkan pasangan AccessKey, lihat Dapatkan pasangan AccessKey.

Buat file bernama shared-dataset.yaml dan salin konten berikut ke file tersebut. File ini digunakan untuk membuat dataset dan JuiceFSRuntime.

# Buat dataset yang menggambarkan dataset yang disimpan di bucket OSS dan 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 pemasangan sistem file adalah juicefs:///.
    options:
      bucket: https://<OSS_BUCKET_NAME>.oss-<REGION_ID>.aliyuncs.com # Ganti nilai dengan titik akhir bucket OSS yang Anda gunakan. Contoh: https://mybucket.oss-cn-beijing-internal.aliyuncs.com.
---
# Buat JuiceFSRuntime untuk mengaktifkan JuiceFS untuk caching data 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"

Jalankan perintah berikut untuk membuat dataset dan JuiceFSRuntime:
```
kubectl apply -f shared-dataset.yaml
```
Output yang diharapkan:
```
dataset.data.fluid.io/shared-dataset created
juicefsruntime.data.fluid.io/shared-dataset created
```
Output menunjukkan bahwa dataset dan JuiceFSRuntime telah dibuat.

Tunggu beberapa menit dan jalankan perintah berikut untuk menanyakan dataset dan JuiceFSRuntime yang dibuat:

kubectl get dataset,juicefsruntime -nshare

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 bernama ref. Dalam contoh berikut, dataset ref-dataset dibuat di namespace ini.
```
kubectl create ns ref
```
Buat file bernama ref-dataset.yaml dan salin konten berikut ke file tersebut. File ini digunakan untuk membuat dataset bernama ref-dataset di namespace ref. Dataset ini dapat digunakan untuk mengakses (merujuk) dataset di namespace lain, yaitu namespace share dalam contoh ini.
Penting
Dalam Fluid, dataset harus dipasang ke jalur unik. Selain itu, nilai parameter mountPoint dataset harus dalam format dataset://. Jika Anda menentukan nilai mountPoint dalam format lain, dataset tidak dapat dibuat dan bidang dalam bagian spec tidak akan berlaku.
```
apiVersion: data.fluid.io/v1alpha1
kind: Dataset
metadata:
  name: ref-dataset
  namespace: ref
spec:
  mounts:
  - mountPoint: dataset://share/shared-dataset
```
Daftar berikut menjelaskan nilai parameter mountPoint:
- dataset://: awalan protokol, yang menunjukkan bahwa dataset dirujuk.
- share: namespace tempat dataset yang dirujuk berada, yaitu share dalam contoh ini.
- shared-dataset: nama dataset yang dirujuk.
Jalankan perintah berikut untuk menerapkan sumber daya yang didefinisikan dalam file ref-dataset.yaml di kluster:
```
kubectl apply -f ref-dataset.yaml        
```

Buat file bernama app.yaml dan salin konten berikut ke file tersebut. File ini digunakan untuk membuat pod di namespace ref dan pod tersebut menggunakan dataset ref-dataset.

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

Jalankan perintah berikut untuk menerapkan sumber daya yang didefinisikan dalam file app.yaml di kluster:
```
kubectl apply -f app.yaml
```
Jalankan perintah berikut untuk menanyakan pod di namespace ref:
```
kubectl get pods -n ref -o wide
```
Jika pod dalam output berada dalam status Running, pod tersebut telah dibuat.

Langkah 3: Uji berbagi data dan caching

Jalankan perintah berikut untuk menanyakan pod di namespace share dan ref:

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

Output yang diharapkan:

# Daftar berikut menunjukkan 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
# Daftar berikut menunjukkan pod di namespace ref.
NAME    READY   STATUS    RESTARTS   AGE
nginx   1/1     Running   0          118s

Output menunjukkan bahwa tiga pod terkait dataset berjalan di namespace share. Hanya satu pod bernama nginx yang berjalan di namespace ref. Tidak ada pod terkait dataset yang berjalan di namespace ref.

Uji berbagi data dan caching.
1. Jalankan perintah berikut untuk masuk ke pod nginx:
```
kubectl exec nginx -n ref -it -- sh
```
2. Uji berbagi data.
  Jalankan perintah berikut untuk menanyakan file di direktori /data: Dataset ref-dataset berada di jalur /data di namespace ref.
```
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
```
  Output menunjukkan bahwa pod nginx di namespace ref dapat mengakses file config.json yang dimiliki oleh namespace share.
3. Uji caching data.
  Catatan
  Hasil pengujian berikut hanya untuk referensi. Latensi baca aktual bervariasi berdasarkan kondisi aktual.
```
# Latensi baca saat file dibaca pertama kali.
sh-4.4# time cat /data/wwm_uncased_L-24_H-1024_A-16.zip > /dev/null
real	0m1.166s
user	0m0.007s
sys	0m1.154s

# Baca file lagi untuk menguji apakah latensi baca berkurang setelah file dicache.
sh-4.4# time cat /data/wwm_uncased_L-24_H-1024_A-16.zip > /dev/null
real	0m0.289s
user	0m0.011s
sys	0m0.274s
```
  Output menunjukkan bahwa 1.166 detik diperlukan untuk membaca file pertama kali dan waktu yang diperlukan untuk membaca file kedua kali berkurang menjadi 0.289 detik. Ini menunjukkan bahwa file telah dicache.