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

Thomas Steiner

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

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

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

เหตุใดเว็บจึงต้องใช้ Storage API อื่น

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

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

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

Use Case ที่แนะนําสําหรับ 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): ขอความจุใหม่ (เป็นไบต์) เพื่อใช้งานโดยบริบทการดําเนินการปัจจุบัน แสดงผล Promise ที่แก้ไขแล้วพร้อมด้วยจำนวนความจุที่เหลืออยู่
  • storageFoundation.releaseCapacity(toBeReleasedCapacity): ปล่อยไบต์ตามจำนวนที่ระบุจากบริบทการเรียกใช้ปัจจุบัน และแสดงผลพรอมิสที่แก้ไขด้วยความสามารถที่เหลือ
  • storageFoundation.getRemainingCapacity(): แสดงผลพรอมต์ที่แก้ไขด้วยความสามารถที่พร้อมใช้งานสําหรับบริบทการดําเนินการปัจจุบัน

แฮนเดิลไฟล์

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

  • NativeIOFile.close(): ปิดไฟล์และแสดงผล Promise ที่แก้ไขเมื่อการดำเนินการเสร็จสมบูรณ์
  • 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 เรียบร้อยแล้ว ซึ่งอาจน้อยกว่าขนาดบัฟเฟอร์หากเกิดข้อผิดพลาด
เพื่อให้มั่นใจว่าข้อมูลจะไม่สูญหายเมื่อระบบขัดข้อง

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

ตัวอย่างต่อไปนี้จะช่วยให้คุณเข้าใจแนวคิดที่อธิบายไว้ข้างต้นได้ชัดเจนขึ้น โดยเราจะอธิบายขั้นตอนต่างๆ ในวงจรชีวิตของไฟล์ 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 พื้นที่เก็บข้อมูลสมัยใหม่อื่นๆ บนเว็บ ซึ่งหมายความว่าต้นทางจะเข้าถึงได้เฉพาะข้อมูลที่สร้างขึ้นเองเท่านั้น และจำกัดไว้เฉพาะบริบทที่ปลอดภัย

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

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

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

ขอขอบคุณ

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

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