พื้นที่เก็บข้อมูลประสิทธิภาพสูงสำหรับแอปของคุณ: Storage Foundation API

โธมัส สไตเนอร์

แพลตฟอร์มเว็บนำเสนอเครื่องมือที่จำเป็นแก่นักพัฒนาซอฟต์แวร์มากขึ้นเรื่อยๆ ในการสร้างแอปพลิเคชันประสิทธิภาพสูงที่ปรับแต่งมาอย่างดีสำหรับเว็บ สิ่งที่เห็นได้ชัดที่สุดคือ WebAssembly (Wasm) ได้เปิดประตูสู่เว็บแอปพลิเคชันที่รวดเร็วและมีประสิทธิภาพ ในขณะที่เทคโนโลยีอย่าง Emscripten ช่วยให้นักพัฒนาซอฟต์แวร์นำโค้ดที่ลองใช้และทดสอบในเว็บมาใช้ซ้ำได้ นักพัฒนาซอฟต์แวร์ต้องมีประสิทธิภาพและความยืดหยุ่นพอๆ กันในด้านพื้นที่เก็บข้อมูล เพื่อให้สามารถใช้ประโยชน์จากศักยภาพนี้ได้อย่างเต็มที่

ซึ่ง Storage Foundation API จะช่วยตอบโจทย์นี้ Storage Foundation API เป็น API พื้นที่เก็บข้อมูลแบบใหม่ที่รวดเร็วและไม่มีข้อสรุปที่ปลดล็อก Use Case ใหม่ๆ และเป็นที่ต้องการมากที่สุดสําหรับเว็บ เช่น การใช้ฐานข้อมูลที่มีประสิทธิภาพและการจัดการไฟล์ชั่วคราวขนาดใหญ่อย่างสวยงาม อินเทอร์เฟซใหม่นี้ช่วยให้นักพัฒนาซอฟต์แวร์ "เพิ่มพื้นที่เก็บข้อมูลของตัวเอง" ไปยังเว็บได้ ซึ่งจะช่วยลดช่องว่างของฟีเจอร์ระหว่างเว็บกับโค้ดเฉพาะแพลตฟอร์ม

Storage Foundation API ออกแบบมาให้มีลักษณะคล้ายกับระบบไฟล์พื้นฐานมากๆ เพื่อให้นักพัฒนาซอฟต์แวร์มีความยืดหยุ่นมากขึ้น ด้วยพื้นฐานทั่วไป เรียบง่าย และมีประสิทธิภาพ ซึ่งใช้สร้างคอมโพเนนต์ระดับสูงขึ้นได้ แอปพลิเคชันสามารถใช้ประโยชน์จากเครื่องมือที่ดีที่สุดที่เหมาะกับความต้องการของตน เพื่อหาจุดสมดุลที่เหมาะสมระหว่างความสามารถในการใช้งาน ประสิทธิภาพ และความน่าเชื่อถือ

เหตุใดเว็บจึงต้องมี API พื้นที่เก็บข้อมูลอีกตัว

แพลตฟอร์มเว็บมีตัวเลือกพื้นที่เก็บข้อมูลมากมายสำหรับนักพัฒนาซอฟต์แวร์ แต่ละแบบสร้างขึ้นโดยคำนึงถึง Use Case เฉพาะตัว

  • ตัวเลือกบางรายการไม่ได้ซ้อนทับกับข้อเสนอนี้อย่างชัดเจน เนื่องจากอนุญาตให้มีการจัดเก็บข้อมูลจำนวนเล็กน้อยเท่านั้น เช่น คุกกี้ หรือ Web Storage API ที่ประกอบด้วยกลไก sessionStorage และ localStorage
  • เราเลิกใช้งานตัวเลือกอื่นๆ ไปแล้วด้วยเหตุผลต่างๆ เช่น File and Directory Entries API หรือ WebSQL
  • File System Access API มีแพลตฟอร์ม API ที่คล้ายกัน แต่ใช้เพื่อโต้ตอบกับระบบไฟล์ของไคลเอ็นต์และให้การเข้าถึงข้อมูลที่อาจอยู่นอกต้นทางหรือแม้แต่การเป็นเจ้าของของเบราว์เซอร์ การมุ่งเน้นที่แตกต่างนี้มาพร้อมกับการพิจารณาด้านความปลอดภัยที่เข้มงวดขึ้นและค่าใช้จ่ายด้านประสิทธิภาพที่สูงขึ้น
  • คุณสามารถใช้ IndexedDB API เป็นแบ็กเอนด์สำหรับกรณีการใช้งานของ Storage Foundation API บางรายการได้ ตัวอย่างเช่น Emscripten รวม IDBFS ซึ่งเป็นระบบไฟล์ถาวรที่อิงตาม IndexedDB แต่เนื่องจากโดยพื้นฐานแล้ว IndexedDB เป็นที่เก็บคีย์-ค่า จึงมีข้อจำกัดด้านประสิทธิภาพที่สําคัญ นอกจากนี้ การเข้าถึงส่วนย่อยของไฟล์โดยตรงยังยากและช้ากว่าเมื่อใช้ IndexedDB
  • สุดท้ายนี้ อินเทอร์เฟซ CacheStorage ได้รับการรองรับอย่างกว้างขวางและได้รับการปรับแต่งให้จัดเก็บข้อมูลขนาดใหญ่ เช่น ทรัพยากรของเว็บแอปพลิเคชัน แต่ค่าต่างๆ จะเปลี่ยนแปลงไม่ได้

Storage Foundation API คือความพยายามในการปิดช่องว่างทั้งหมดของตัวเลือกพื้นที่เก็บข้อมูลก่อนหน้านี้ ด้วยการให้พื้นที่เก็บข้อมูลที่มีประสิทธิภาพของไฟล์ขนาดใหญ่ที่เปลี่ยนแปลงได้ซึ่งกำหนดภายในต้นทางของแอปพลิเคชัน

กรณีการใช้งานที่แนะนำสำหรับ Storage Foundation API

ตัวอย่างเว็บไซต์ที่อาจใช้ API นี้ ได้แก่

  • แอปเพื่อการทำงานหรือการสร้างสรรค์ที่ทำงานกับข้อมูลวิดีโอ เสียง หรือรูปภาพจำนวนมาก แอปดังกล่าวสามารถส่งกลุ่มลงดิสก์แทนที่จะเก็บไว้ในหน่วยความจำ
  • แอปที่ใช้ระบบไฟล์ถาวรซึ่งเข้าถึงได้จาก Wasm และต้องการประสิทธิภาพมากกว่าที่ IDBFS รับประกันได้

Storage Foundation API คืออะไร

API มี 2 ส่วนหลักๆ ได้แก่

  • การเรียกระบบไฟล์ ซึ่งมีฟังก์ชันพื้นฐานในการโต้ตอบกับไฟล์และเส้นทางของไฟล์
  • แฮนเดิลไฟล์ ซึ่งให้สิทธิ์อ่านและเขียนไฟล์ที่มีอยู่

การเรียกระบบไฟล์

Storage Foundation API มีออบเจ็กต์ใหม่ชื่อ storageFoundation ซึ่งอยู่บนออบเจ็กต์ window และมีฟังก์ชันมากมาย ดังนี้

  • storageFoundation.open(name): เปิดไฟล์ที่มีชื่อนั้นๆ หากมีอยู่ หรือสร้างไฟล์ใหม่ แสดงผลคำมั่นสัญญาที่มีไฟล์ที่เปิดอยู่
  • storageFoundation.delete(name): นำไฟล์ที่มีชื่อที่ระบุออก จะแสดงคำมั่นสัญญาที่ได้รับการแก้ไขเมื่อไฟล์ถูกลบ
  • storageFoundation.rename(oldName, newName): เปลี่ยนชื่อไฟล์จากชื่อเก่าเป็นชื่อใหม่โดยอัตโนมัติ แสดงคำมั่นสัญญาที่แก้ไขปัญหาเมื่อมีการเปลี่ยนชื่อไฟล์
  • storageFoundation.getAll(): แสดงผลสัญญาที่แปลค่าด้วยอาร์เรย์ของชื่อไฟล์ที่มีอยู่ทั้งหมด
  • storageFoundation.requestCapacity(requestedCapacity): ขอความจุใหม่ (เป็นไบต์) สำหรับการใช้งานตามบริบทของการดำเนินการปัจจุบัน จะแสดงผลสัญญาที่แก้ไขปัญหาด้วยความจุที่เหลืออยู่
  • storageFoundation.releaseCapacity(toBeReleasedCapacity): ปล่อยจำนวนไบต์ที่ระบุจากบริบทการดำเนินการปัจจุบัน และแสดงผลคำมั่นสัญญาที่แปลงด้วยความจุที่เหลืออยู่
  • storageFoundation.getRemainingCapacity(): แสดงผลสัญญาที่แปลงค่าด้วยความจุที่มีสำหรับบริบทการดำเนินการปัจจุบัน

แฮนเดิลไฟล์

การทำงานกับไฟล์จะดำเนินการผ่านฟังก์ชันต่อไปนี้:

  • NativeIOFile.close(): ปิดไฟล์และส่งคืนคำมั่นสัญญาที่จะแก้ไขเมื่อการดำเนินการเสร็จสมบูรณ์
  • NativeIOFile.flush(): ซิงค์ข้อมูล (ซึ่งก็คือจะล้าง) สถานะในหน่วยความจำของไฟล์กับอุปกรณ์จัดเก็บข้อมูล และส่งกลับสัญญาที่จะแก้ไขเมื่อดำเนินการเสร็จสิ้น
  • NativeIOFile.getLength(): แสดงผลสัญญาที่แปลงความยาวของไฟล์เป็นไบต์
  • NativeIOFile.setLength(length): กำหนดความยาวของไฟล์เป็นไบต์ และแสดงคำมั่นสัญญาที่จะแก้ไขเมื่อการดำเนินการเสร็จสมบูรณ์ หากความยาวใหม่น้อยกว่าความยาวปัจจุบัน ระบบจะนำไบต์ออกโดยเริ่มจากส่วนท้ายของไฟล์ มิฉะนั้นไฟล์จะขยายด้วยไบต์ที่มีค่าเป็น 0

  • NativeIOFile.read(buffer, offset): อ่านเนื้อหาของไฟล์ตามออฟเซ็ตที่ระบุผ่านบัฟเฟอร์ที่เป็นผลมาจากการโอนบัฟเฟอร์ที่กำหนดให้ ซึ่งจากนั้นจะถอดออกหลังจากนั้น แสดงผล NativeIOReadResult พร้อมบัฟเฟอร์ที่โอนและจำนวนไบต์ที่อ่านสำเร็จ

    NativeIOReadResult เป็นออบเจ็กต์ที่ประกอบด้วย 2 รายการ ได้แก่

    • buffer: ArrayBufferView ซึ่งเป็นผลมาจากการโอนบัฟเฟอร์ที่ส่งไปยัง read() ซึ่งมีประเภทและความยาว เหมือนกับบัฟเฟอร์ต้นฉบับ
    • readBytes: จำนวนไบต์ที่อ่านแล้วลงใน buffer ซึ่งอาจน้อยกว่าขนาดบัฟเฟอร์ หากเกิดข้อผิดพลาดหรือช่วงการอ่านขยายไปจนเลยจุดสิ้นสุดของไฟล์ หากช่วงการอ่านอยู่นอกเหนือจุดสิ้นสุดของไฟล์ ระบบจะตั้งค่าเป็น 0

  • NativeIOFile.write(buffer, offset): เขียนเนื้อหาของบัฟเฟอร์ที่กำหนดลงในไฟล์ตามออฟเซ็ตที่ระบุ บัฟเฟอร์จะถูกถ่ายโอนก่อนที่จะมีการเขียนข้อมูลใดๆ ดังนั้นจึงถูกปล่อยทิ้งไว้ แสดงผล NativeIOWriteResult พร้อมบัฟเฟอร์ที่โอนและจำนวนไบต์ที่เขียนเสร็จแล้ว ระบบจะขยายไฟล์หากช่วงการเขียนเกินความยาว

    NativeIOWriteResult เป็นออบเจ็กต์ที่ประกอบด้วย 2 รายการ ได้แก่

    • buffer: ArrayBufferView ซึ่งเป็นผลมาจากการโอนบัฟเฟอร์ที่ส่งไปยัง write() เป็นประเภทและความยาวเดียวกันกับบัฟเฟอร์ต้นทาง
    • writtenBytes: จำนวนไบต์ที่เขียนลงใน buffer ได้สำเร็จ ซึ่งอาจน้อยกว่าขนาดบัฟเฟอร์หากเกิดข้อผิดพลาด

ตัวอย่างที่สมบูรณ์

เพื่อให้แนวคิดที่พูดถึงข้างต้นชัดเจนยิ่งขึ้น ต่อไปนี้เป็นตัวอย่างทั้งหมด 2 รายการที่จะแนะนำคุณผ่านขั้นตอนต่างๆ ในวงจรของไฟล์ Storage Foundation

การเปิด, การเขียน, การอ่าน, การปิด

// Open a file (creating it if needed).
const file = await storageFoundation.open('test_file');
try {
  // Request 100 bytes of capacity for this context.
  await storageFoundation.requestCapacity(100);

  const writeBuffer = new Uint8Array([64, 65, 66]);
  // Write the buffer at offset 0. After this operation, `result.buffer`
  // contains the transferred buffer and `result.writtenBytes` is 3,
  // the number of bytes written. `writeBuffer` is left detached.
  let result = await file.write(writeBuffer, 0);

  const readBuffer = new Uint8Array(3);
  // Read at offset 1. `result.buffer` contains the transferred buffer,
  // `result.readBytes` is 2, the number of bytes read. `readBuffer` is left
  // detached.
  result = await file.read(readBuffer, 1);
  // `Uint8Array(3) [65, 66, 0]`
  console.log(result.buffer);
} finally {
  file.close();
}

การเปิด การทำรายการ การลบ

// Open three different files (creating them if needed).
await storageFoundation.open('sunrise');
await storageFoundation.open('noon');
await storageFoundation.open('sunset');
// List all existing files.
// `["sunset", "sunrise", "noon"]`
await storageFoundation.getAll();
// Delete one of the three files.
await storageFoundation.delete('noon');
// List all remaining existing files.
// `["sunrise", "noon"]`
await storageFoundation.getAll();

การสาธิต

คุณสามารถเล่นเดโม Storage Foundation API ได้ในการฝังด้านล่าง สร้าง เปลี่ยนชื่อ เขียนลงไป และอ่านจากไฟล์ รวมถึงดูขีดจำกัดที่พร้อมใช้งานที่คุณขอการอัปเดตเมื่อทำการเปลี่ยนแปลง คุณดูซอร์สโค้ดของการสาธิตได้ใน Glitch

ความปลอดภัยและสิทธิ์

ทีม Chromium ได้ออกแบบและนำ Storage Foundation API มาใช้โดยใช้หลักการสำคัญที่ระบุไว้ในการควบคุมการเข้าถึงฟีเจอร์แพลตฟอร์มเว็บที่มีประสิทธิภาพ ซึ่งรวมถึงการควบคุมของผู้ใช้ ความโปร่งใส และการยศาสตร์

การเข้าถึง Storage Foundation API จะใช้รูปแบบเดียวกับ API พื้นที่เก็บข้อมูลสมัยใหม่อื่นๆ บนเว็บ กล่าวคือ ต้นทางอาจเข้าถึงได้เฉพาะข้อมูลที่สร้างด้วยตนเองเท่านั้น และยังจำกัดอยู่เพียง บริบทที่ปลอดภัยเท่านั้น

การควบคุมของผู้ใช้

ระบบจะใช้โควต้าพื้นที่เก็บข้อมูลเพื่อกระจายสิทธิ์เข้าถึงพื้นที่ในดิสก์และเพื่อป้องกันการละเมิด คุณต้องขอหน่วยความจำที่ต้องการใช้งานก่อน ผู้ใช้จะล้างพื้นที่เก็บข้อมูลที่ใช้ Storage Foundation API ผ่านเบราว์เซอร์ได้เช่นเดียวกับ API พื้นที่เก็บข้อมูลอื่นๆ

ลิงก์ที่มีประโยชน์

กิตติกรรมประกาศ

Storage Foundation API ระบุและใช้งานโดย Emanuel Krivoy และ Richard Stotz บทความนี้ได้รับการตรวจสอบโดย Pete LePage และ Joe Medley

รูปภาพหลักจาก Markus Spiske ใน Unsplash