Menyediakan dan menggunakan SSD Lokal campuran untuk block storage mentah dan penyimpanan efemeral

Dokumen ini menunjukkan cara menyediakan dan mempartisi SSD Lokal di Google Kubernetes Engine (GKE) untuk mendukung workload yang memerlukan sistem file penyimpanan efemeral standar dan block storage mentah yang tidak diformat pada node yang sama.

Gunakan konfigurasi ini untuk aplikasi stateful dan database yang sangat dioptimalkan. Workload ini sering kali memerlukan akses disk langsung untuk meningkatkan performa, tetapi juga memerlukan penyimpanan file sementara standar untuk sidecar, log, atau cache container. Dengan menggunakan kapasitas SSD Lokal campuran, Anda dapat mengurangi overhead pengelolaan cluster dan memaksimalkan pemanfaatan hardware, karena Anda tidak perlu mendedikasikan node terpisah atau disk penuh secara eksklusif untuk infrastruktur blok mentah.

Saat Anda membuat cluster atau node pool dengan kapasitas SSD Lokal campuran, GKE mempartisi setiap SSD Lokal yang terpasang secara fisik sebagai berikut:

  • Penyimpanan efemeral: kapasitas efemeral yang diminta dibagi secara merata di seluruh SSD Lokal dan digabungkan untuk menyediakan penyimpanan file efemeral standar node. Jika kapasitas efemeral dipartisi di beberapa SSD Lokal, penyimpanan akan digabungkan ke dalam array RAID-0. Anda dapat mengakses penyimpanan sementara menggunakan volume emptyDir standar.
  • Penyimpanan blok mentah: sisa kapasitas fisik pada setiap disk disajikan ke node sebagai perangkat blok mentah yang berbeda dan tidak diformat.

Dokumen ini ditujukan untuk admin dan operator Platform serta DevOps yang ingin mengoptimalkan pemanfaatan hardware dan performa penyimpanan di GKE untuk workload khusus.

Pertimbangan

Selain batasan SSD Lokal Compute Engine, tinjau pertimbangan khusus GKE berikut sebelum mengonfigurasi mode SSD Lokal campuran:

  • Kompatibilitas Autopilot: Cluster GKE Autopilot tidak mendukung penyimpanan ephemeral dan blok mentah campuran. Untuk mempelajari cara menggunakan SSD Lokal untuk penyimpanan efemeral standar di Autopilot, lihat SSD Lokal di cluster Autopilot.
  • ComputeClass Kustom: ComputeClass kustom tidak mendukung konfigurasi SSD Lokal campuran.
  • Sistem operasi: mode SSD Lokal campuran hanya didukung pada image node Linux (Container-Optimized OS dan Ubuntu). Node pool Windows Server tidak didukung.
  • Peristiwa pemeliharaan: sebaiknya jangan gunakan SSD Lokal sebagai block storage raw untuk VM Z3 atau Z4D yang dioptimalkan untuk penyimpanan. Data pada VM ini mungkin tidak bertahan selama peristiwa pemeliharaan. Untuk mengetahui informasi selengkapnya, lihat Menyediakan dan menggunakan block storage mentah yang didukung SSD Lokal.
  • I/O Bersama: karena array RAID-0 efemeral dan partisi blok mentah yang ditargetkan mengandalkan SSD fisik dasar yang sama, operasi intensif pada satu partisi logis dapat memengaruhi throughput partisi lainnya. Untuk mengetahui informasi tentang batas throughput maksimum, lihat Performa SSD lokal.
  • Harga: saat menggunakan mode campuran untuk mempartisi kapasitas SSD Lokal, Anda membayar total kapasitas SSD Lokal fisik yang mendasarinya yang terpasang ke node, terlepas dari berapa banyak kapasitas yang dialokasikan untuk penyimpanan efemeral dibandingkan dengan block storage mentah. Untuk mengetahui informasi selengkapnya, lihat Harga SSD lokal.
  • Konfigurasi manual: untuk menggunakan block storage mentah yang didukung SSD Lokal, Anda harus mengonfigurasi perangkat secara manual karena GKE tidak memformat atau memasang partisi blok mentah. Anda juga bertanggung jawab untuk mengelola kapasitas node dan menangani potensi gangguan dari workload yang ditempatkan bersama. Penggunaan objek PersistentVolume lokal menyediakan penjadwalan Pod terintegrasi. Jika workload Anda tidak memerlukan data untuk bertahan di seluruh siklus proses Pod, atau jika workload tidak memiliki kebutuhan performa khusus, gunakan konfigurasi SSD Lokal yang sepenuhnya efemeral. Konfigurasi yang sepenuhnya efemeral cocok untuk sebagian besar kasus penggunaan.
  • Swap memori node: Anda dapat menggabungkan kapasitas SSD Lokal campuran dengan swap memori node menggunakan profil boot disk atau profil SSD Lokal efemeral. Profil SSD Lokal khusus tidak didukung dengan kapasitas SSD Lokal campuran. Untuk mengetahui informasi selengkapnya, lihat Swap memori node dengan kapasitas SSD Lokal campuran.

Sebelum memulai

Sebelum memulai, pastikan Anda telah melakukan tugas berikut:

  • Aktifkan Google Kubernetes Engine API.
    • Aktifkan Google Kubernetes Engine API
  • Untuk menggunakan Google Cloud CLI untuk tugas ini, instal lalu lakukan inisialisasi gcloud CLI. Jika sebelumnya Anda telah menginstal gcloud CLI, dapatkan versi terbaru dengan menjalankan perintah gcloud components update. Versi gcloud CLI yang lebih lama mungkin tidak mendukung menjalankan perintah dalam dokumen ini.

Untuk menggunakan fitur ini, node GKE harus menjalankan versi 1.37.0-gke.3570000 atau yang lebih baru.

Peran yang diperlukan

Untuk mendapatkan izin yang diperlukan untuk membuat cluster dan node pool dengan kapasitas SSD Lokal campuran, minta administrator untuk memberi Anda peran IAM Kubernetes Engine Admin (roles/container.admin) di project Anda. Untuk mengetahui informasi selengkapnya tentang cara memberikan peran, lihat Mengelola akses ke project, folder, dan organisasi.

Anda mungkin juga bisa mendapatkan izin yang diperlukan melalui peran khusus atau peran bawaan lainnya.

Membuat cluster atau node pool dengan penyimpanan SSD Lokal campuran

Anda dapat mengalokasikan kapasitas sementara dan memesan partisi blok mentah menggunakan properti capacity dari flag --ephemeral-storage-local-ssd.

Buat cluster atau node pool Anda dengan menentukan subkolom capacity dengan flag --ephemeral-storage-local-ssd.

Jika jenis mesin Anda mengizinkan jumlah SSD Lokal yang dapat dikonfigurasi, Anda juga harus menentukan subkolom count. Jika jenis mesin Anda memiliki jumlah SSD Lokal yang tetap, misalnya, jenis -lssd, Anda dapat menghilangkan subkolom count karena GKE otomatis menghitung jumlah disk berdasarkan bentuk VM.

Membuat cluster dengan penyimpanan SSD Lokal campuran

Untuk membuat cluster baru, gunakan perintah gcloud container clusters create. Setelan ini hanya berlaku untuk node pool default. Jika node pool berikutnya memerlukan penyimpanan SSD Lokal campuran, tentukan flag --ephemeral-storage-local-ssd saat Anda membuat node pool. Jumlah maksimum disk yang dapat Anda pasang bervariasi menurut jenis mesin dan region.

Jika versi untuk cluster Anda lebih lama dari 1.37.0-gke.3570000, tambahkan salah satu flag berikut ke perintah pembuatan cluster berikut:

  • Flag --cluster-version=<var>VERSION</var> dengan <var>VERSION</var> ditetapkan ke 1.37.0-gke.3570000 atau yang lebih baru, atau
  • Flag --release-channel=rapid.

Untuk jenis mesin dengan jumlah SSD Lokal yang dapat dikonfigurasi, jalankan perintah berikut:

gcloud container clusters create CLUSTER_NAME \
    --machine-type=MACHINE_TYPE \
    --ephemeral-storage-local-ssd count=NUMBER_OF_DISKS,capacity=CAPACITY

Untuk jenis mesin dengan jumlah SSD Lokal tetap, jalankan perintah berikut:

gcloud container clusters create CLUSTER_NAME \
    --machine-type=MACHINE_TYPE \
    --ephemeral-storage-local-ssd capacity=CAPACITY

Ganti kode berikut:

  • CLUSTER_NAME: nama cluster yang ingin Anda buat.
  • MACHINE_TYPE: jenis mesin yang akan digunakan. Untuk mengetahui daftar jenis mesin yang didukung, lihat Dukungan seri mesin. Anda tidak dapat menggunakan SSD Lokal dengan jenis mesin e2-medium default, karena jenis mesin dengan inti bersama tidak mendukungnya.
  • NUMBER_OF_DISKS: untuk jenis mesin dengan jumlah SSD Lokal yang dapat dikonfigurasi, jumlah disk SSD Lokal yang akan disediakan di setiap node.

  • CAPACITY: total kapasitas SSD Lokal yang akan diformat untuk penyimpanan efemeral. Nilai ini harus lebih besar dari 0 dan benar-benar kurang dari total kapasitas SSD Lokal fisik (jumlah disk × ukuran per disk), misalnya, 200GB. Perhatikan hal berikut:

    • Nilai tidak dapat diubah setelah cluster dibuat.
    • GKE mencadangkan sebagian kapasitas ini untuk penggunaan sistem, sehingga penyimpanan efemeral yang dapat dialokasikan kurang dari CAPACITY. Untuk mengetahui informasi selengkapnya, lihat Reservasi penyimpanan sementara lokal.

Membuat node pool dengan penyimpanan SSD Lokal campuran

Untuk menambahkan node pool ke cluster yang ada, gunakan perintah gcloud container node-pools create.

Jika versi node pool Anda lebih lama dari 1.37.0-gke.3570000, Anda harus melakukan hal berikut:

  • Tambahkan flag --node-version=<var>VERSION</var> ke perintah pembuatan node pool berikut, dengan <var>VERSION</var> ditetapkan ke 1.37.0-gke.3570000 atau yang lebih baru.
  • Pastikan bidang kontrol cluster menggunakan versi 1.37.0-gke.3570000 atau yang lebih baru.

Untuk jenis mesin dengan jumlah SSD Lokal yang dapat dikonfigurasi, jalankan perintah berikut:

gcloud container node-pools create POOL_NAME \
    --cluster=CLUSTER_NAME \
    --machine-type=MACHINE_TYPE \
    --ephemeral-storage-local-ssd count=NUMBER_OF_DISKS,capacity=CAPACITY

Untuk jenis mesin dengan jumlah SSD Lokal tetap, jalankan perintah berikut:

gcloud container node-pools create POOL_NAME \
    --cluster=CLUSTER_NAME \
    --machine-type=MACHINE_TYPE \
    --ephemeral-storage-local-ssd capacity=CAPACITY

Ganti kode berikut:

  • POOL_NAME: nama node pool baru yang ingin Anda buat.
  • CLUSTER_NAME: nama cluster.
  • MACHINE_TYPE: jenis mesin yang akan digunakan. Untuk mengetahui daftar jenis mesin yang didukung, lihat Dukungan seri mesin. Anda tidak dapat menggunakan SSD Lokal dengan jenis mesin e2-medium default, karena jenis mesin dengan inti bersama tidak mendukungnya.
  • NUMBER_OF_DISKS: untuk jenis mesin dengan jumlah SSD Lokal yang dapat dikonfigurasi, jumlah disk SSD Lokal yang akan disediakan di setiap node.

  • CAPACITY: total kapasitas SSD Lokal yang akan diformat untuk penyimpanan efemeral. Nilai ini harus lebih besar dari 0 dan benar-benar kurang dari total kapasitas SSD Lokal fisik (jumlah disk × ukuran per disk), misalnya, 200GB. Perhatikan hal berikut:

    • Nilai ini tidak dapat diubah setelah node pool dibuat.
    • GKE mencadangkan sebagian kapasitas ini untuk penggunaan sistem, sehingga penyimpanan efemeral yang dapat dialokasikan kurang dari CAPACITY. Untuk mengetahui informasi selengkapnya, lihat Reservasi penyimpanan sementara lokal.

Memverifikasi label node

Setelah penyediaan, untuk memverifikasi bahwa node memiliki label yang benar untuk penyimpanan ephemeral dan block storage mentah, jalankan perintah berikut:

kubectl describe node NODE_NAME

Output harus berisi kedua label node berikut:

  • cloud.google.com/gke-ephemeral-storage-local-ssd: "true"
  • cloud.google.com/gke-local-nvme-ssd-partition: "true"

Mengakses kapasitas sementara

Akses penyimpanan efemeral yang dicadangkan melalui volume emptyDir persis seperti yang Anda lakukan untuk volume efemeral GKE lainnya.

Mengakses kapasitas blok mentah

Untuk mengakses kapasitas block storage raw, Anda harus membuat objek StorageClass, menyediakan objek PersistentVolume lokal, dan mengklaimnya menggunakan objek PersistentVolumeClaim.

Membuat StorageClass

Karena Anda menyediakan objek PersistentVolume tanpa penyedia statis komunitas, sebaiknya buat objek StorageClass dengan kolom volumeBindingMode: WaitForFirstConsumer. Tindakan ini menunda binding hingga penjadwalan Pod, sehingga memastikan Kubernetes memilih SSD Lokal dari node yang sesuai yang dapat menjalankan Pod.

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: "local-storage"
provisioner: "kubernetes.io/no-provisioner"
volumeBindingMode: "WaitForFirstConsumer"

Membuat PersistentVolume

Objek PersistentVolume Lokal memiliki batasan penting terkait upgrade node, penskalaan, dan autoscaler cluster. Sebelum membuat volume, tinjau Batasan PersistentVolume lokal untuk memahami pengaruh peristiwa siklus proses terhadap data Anda.

Untuk membuat objek PersistentVolume, selesaikan langkah-langkah berikut untuk menemukan jalur link simbolis ke partisi SSD Lokal, menentukan kapasitas tersisa yang tepat, dan mengonfigurasi manifes.

Menemukan kapasitas partisi

Jalankan perintah berikut pada node target untuk menemukan kapasitas blok mentah yang tersisa untuk partisi.

kubectl debug node/NODE_NAME -it --image=ubuntu -- \
    sh -c 'ls -l /host/dev/disk/by-id/ | grep partition; lsblk -o NAME,SIZE,TYPE'

Ganti NODE_NAME dengan nama node tempat SSD Lokal terpasang.

Output menunjukkan pemetaan antara nama perangkat dan symlink partisi sehingga Anda dapat memverifikasi partisi mana yang sesuai dengan perangkat mana. Perintah ini juga mencantumkan perangkat blok yang terpasang ke node beserta ukurannya.

Misalnya, jika Anda memasang dua SSD Lokal ke node dan mengalokasikan 200 GB ke penyimpanan efemeral (capacity=200GB), output-nya akan mirip dengan berikut ini:

google-local-ssd-partition0 -> /dev/nvme0n1p2
google-local-ssd-partition1 -> /dev/nvme0n2p2
NAME          SIZE TYPE
...
nvme0n1       375G disk
|-nvme0n1p1   100G part
| `-md0     199.9G raid0
`-nvme0n1p2   275G part
nvme0n2       375G disk
|-nvme0n2p1   100G part
| `-md0     199.9G raid0
`-nvme0n2p2   275G part

Perhatikan pemetaan antara symlink google-local-ssd-partition dan nama perangkat yang mendasarinya, serta ukuran partisi tersebut. Anda menggunakan ukuran sebagai PARTITION_SIZE dan jalur symlink sebagai LOCAL_SSD_SYMLINK_PATH dalam manifes PersistentVolume.

Misalnya, dalam output sebelumnya, symlink /dev/disk/by-id/google-local-ssd-partition0 mengarah ke partisi nvme0n1p2, yang memiliki ukuran 275G.

Perintah kubectl debug membiarkan Pod sementara berjalan di namespace default. Agar Pod ini tidak menggunakan resource, hapus Pod dengan menjalankan perintah berikut:

kubectl delete pod DEBUG_POD_NAME

Ganti DEBUG_POD_NAME dengan nama Pod yang dibuat oleh perintah kubectl debug, yang dicetak saat Anda menjalankan perintah.

Mengonfigurasi manifes PersistentVolume

Konfigurasikan manifes volume dengan ukuran partisi yang Anda temukan. Kolom nodeAffinity wajib diisi untuk volume lokal. Hal ini membantu memastikan bahwa Kubernetes menjadwalkan Pod yang mengklaim volume ini ke node tertentu tempat SSD Lokal terpasang secara fisik. Contoh berikut menunjukkan manifes untuk partisi SSD Lokal blok mentah:

apiVersion: v1
kind: PersistentVolume
metadata:
  name: "example-local-pv"
spec:
  capacity:
    storage: PARTITION_SIZE
  accessModes:
  - "ReadWriteOnce"
  volumeMode: "Block"
  persistentVolumeReclaimPolicy: "Retain"
  storageClassName: "local-storage"
  local:
    path: "LOCAL_SSD_SYMLINK_PATH"
  nodeAffinity:
    required:
      nodeSelectorTerms:
      - matchExpressions:
        - key: "kubernetes.io/hostname"
          operator: "In"
          values:
          - "NODE_NAME"

Ganti kode berikut:

  • PARTITION_SIZE: kapasitas blok mentah aktual yang tersisa yang Anda temukan di langkah pertama. Gunakan akhiran Gi (misalnya, 275Gi) agar nilainya sama persis dengan kapasitas partisi.
  • NODE_NAME: nama node tempat SSD Lokal terpasang.
  • LOCAL_SSD_SYMLINK_PATH: jalur link simbolis ke partisi SSD Lokal yang tidak diformat yang Anda temukan di langkah pertama. Untuk setiap SSD Lokal yang terpasang ke node pool, OS host membuat link simbolis untuk mengakses kapasitas blok mentah yang tersisa. Jalur mengikuti pola yang diindeks nol. Misalnya, jika Anda memasang tiga SSD Lokal, jalur blok mentah untuk partisi adalah sebagai berikut:
    • /dev/disk/by-id/google-local-ssd-partition0
    • /dev/disk/by-id/google-local-ssd-partition1
    • /dev/disk/by-id/google-local-ssd-partition2

Membuat PersistentVolumeClaim

Buat objek PersistentVolumeClaim untuk mengklaim volume. Spesifikasi yang sesuai terlihat seperti berikut:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: "example-local-pvc"
spec:
  accessModes:
  - "ReadWriteOnce"
  volumeMode: "Block"
  storageClassName: "local-storage"
  resources:
    requests:
      storage: PARTITION_SIZE

Menggunakan volume di Pod

Anda dapat menggunakan objek PersistentVolume di Pod dengan mereferensikan objek PersistentVolumeClaim dalam spesifikasi volumeDevices. Berikut adalah contoh manifes Pod yang menggunakan klaim example-local-pvc:

apiVersion: v1
kind: Pod
metadata:
  name: "example-pod"
spec:
  containers:
  - name: "app"
    image: "ubuntu:22.04"
    command: ["/bin/sh", "-c"]
    args: ["tail -f /dev/null"]
    volumeDevices:
    - name: "raw"
      devicePath: "/dev/xvda"
  volumes:
  - name: "raw"
    persistentVolumeClaim:
      claimName: "example-local-pvc"

Karena Anda menggunakan penyedia kubernetes.io/no-provisioner, GKE tidak akan otomatis membersihkan volume lokal. Jika Anda menghapus objek PersistentVolume, Anda harus menghapus data dari disk yang mendasarinya secara manual sebelum disk dapat digunakan kembali dengan aman.

Pemecahan masalah

Untuk mengetahui petunjuk pemecahan masalah, lihat Memecahkan masalah penyimpanan di GKE.

Langkah berikutnya