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

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

  • 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 ใน Unspiske