สร้างระบบถ่ายโอนระหว่าง Google Drive กับ OneDrive อย่างปลอดภัยด้วย Python

คำตอบสั้น ๆ

สำหรับการย้ายข้อมูลแบบมีการจัดการ FileArk จะทำให้เวิร์กโฟลว์นี้เป็นอัตโนมัติโดยไม่ใช้คอมพิวเตอร์ของคุณเป็นเส้นทางรับส่งข้อมูล ระบบผ่านการทดสอบกับภาระงานย้ายข้อมูลขนาดหลายเทราไบต์ และตรวจสอบการรับข้อมูลจากต้นทาง การยอมรับการอัปโหลดของผู้ให้บริการ และออบเจ็กต์ที่ปลายทางก่อนรายงานว่าสำเร็จ หากคุณต้องการควบคุมไปป์ไลน์ด้วยตนเอง โปรแกรม Python ที่ใช้สัญญาอนุญาต MIT ด้านล่างจะคัดลอกข้อมูลผ่านเครื่องของคุณอย่างรัดกุมและไม่ลบไฟล์ต้นทาง

เลือกรูปแบบการดำเนินงานก่อนเลือกโค้ด

บริการย้ายข้อมูลระหว่างคลาวด์โดยตรงเป็นตัวเลือกที่เหมาะสมเมื่อคลังข้อมูลมีขนาดใหญ่ การเชื่อมต่อต้องทำงานโดยไม่มีผู้ดูแล หรือไม่ควรให้ข้อมูลผ่านแล็ปท็อป FileArk ดำเนินการถ่ายโอนทางออนไลน์ เฝ้าติดตามการตอบกลับจากผู้ให้บริการ ลองใหม่เมื่อเกิดข้อผิดพลาดที่กู้คืนได้ และแสดงความคืบหน้าทั้งหมดในมุมมองเดียว กระบวนการตรวจสอบจะดำเนินการตรวจสอบอิสระสามรายการก่อนถือว่าไฟล์เสร็จสมบูรณ์

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

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

ไปป์ไลน์การถ่ายโอนและขอบเขตความล้มเหลว

1. จัดทำรายการโครงสร้างต้นทาง

   อะแดปเตอร์ต้นทางจะสำรวจโฟลเดอร์แบบเรียกซ้ำ ติดตามการแบ่งหน้าของผู้ให้บริการ บันทึก ID พาธ ประเภท และขนาดที่รายงาน พร้อมแปลงไฟล์รูปแบบเฉพาะของ Google ที่รองรับเป็นรูปแบบส่งออกที่นำไปใช้ต่อได้

2. ตรวจสอบความจุของปลายทางและเครื่องล่วงหน้า

   เอนจินจะเปรียบเทียบจำนวนไบต์ที่ค้างอยู่รวมกับพื้นที่สำรองที่กำหนดค่าได้กับโควตาปลายทาง และยังตรวจสอบระบบไฟล์สำหรับพักข้อมูลก่อนทุกแบตช์และก่อนดาวน์โหลดไฟล์แต่ละรายการ

3. พักไฟล์เป็นแบตช์ที่มีขอบเขตจำกัด

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

4. คำนวณแฮชและอัปโหลด

   หลังดาวน์โหลด สคริปต์จะคำนวณ SHA-256 ในเครื่อง ตรวจสอบขนาดต้นทางที่ทราบ สร้างโฟลเดอร์ปลายทาง และอัปโหลดเป็นส่วนย่อยที่รองรับการทำต่อและเข้ากันได้กับผู้ให้บริการ

5. ตรวจสอบและบันทึกจุดตรวจสอบ

   โหมดเริ่มต้นจะดาวน์โหลดออบเจ็กต์ใหม่จากปลายทางซ้ำและเปรียบเทียบ SHA-256 เฉพาะไฟล์ที่ตรงกันเท่านั้นที่จะถูกบันทึกลงในเช็กพอยต์ JSON และลบออกจากพื้นที่พักข้อมูลในเครื่อง

ดาวน์โหลดโปรแกรม Python ฉบับสมบูรณ์ที่ใช้สัญญาอนุญาต MIT

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

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

ดูขั้นตอนด้านความปลอดภัยก่อนอนุญาตให้เข้าถึงคลาวด์

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

chmod +x fileark-cloud-transfer.py
python3 fileark-cloud-transfer.py --demo
python3 fileark-cloud-transfer.py --help

สร้างไคลเอ็นต์ OAuth โดยไม่ฝังข้อมูลลับไว้ในโค้ด

สำหรับ Google Drive ให้สร้างไคลเอ็นต์ OAuth ประเภทเดสก์ท็อปในโปรเจกต์ Google Cloud เปิดใช้ Drive API กำหนดค่าหน้าจอขอความยินยอม และดาวน์โหลด JSON ของไคลเอ็นต์ ส่งพาธด้วย --google-client-secret หรือตั้งค่า GOOGLE_OAUTH_CLIENT_SECRET_FILE สคริปต์ขอสิทธิ์เข้าถึง Drive เนื่องจากต้องแสดงรายการ ดาวน์โหลด สร้างโฟลเดอร์ อัปโหลด และตรวจสอบไฟล์

สำหรับ OneDrive ให้ลงทะเบียนแอปพลิเคชันไคลเอนต์สาธารณะใน Microsoft Entra ID เปิดใช้ขั้นตอนรหัสอุปกรณ์ เพิ่มสิทธิ์แบบมอบหมาย Files.ReadWrite และส่ง application client ID เลือก common สำหรับบัญชีผู้ใช้ทั่วไปและบัญชีองค์กร เลือก organizations สำหรับบัญชีที่ทำงาน หรือใช้ tenant ID ที่ระบุเมื่อเป็นข้อกำหนดของนโยบาย

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

python3 -m venv .venv
. .venv/bin/activate
python -m pip install --upgrade pip
python -m pip install -r requirements-fileark-cloud-transfer.txt

ถ่ายโอนจาก Google Drive ไปยัง OneDrive หรือย้อนกลับ

ค่าทั้งหมดที่ระบุตัวตนเป็นของผู้ดำเนินการ โปรแกรมไม่มี client ID, secret, tenant, token, บัญชีระยะไกล หรือข้อมูลประจำตัวของปลายทางให้มาด้วย คำสั่งแรกจะลงชื่อเข้าใช้ Google ในเบราว์เซอร์และ Microsoft ด้วยรหัสอุปกรณ์ จากนั้นคัดลอกข้อมูลไปยังโฟลเดอร์ใหม่ใน OneDrive

สลับต้นทางกับปลายทางเพื่อถ่ายโอนจาก OneDrive ไปยัง Google Drive ใช้ไฟล์สถานะและรากปลายทางคนละชุดสำหรับการย้ายข้อมูลแต่ละครั้งที่แยกจากกัน จุดตรวจสอบจะผูกผู้ให้บริการต้นทาง ผู้ให้บริการปลายทาง และรากไว้ด้วยกัน และจะไม่ยอมทำต่อหากการกำหนดค่าไม่ตรงกัน

export MICROSOFT_CLIENT_ID="your-public-client-id"
python fileark-cloud-transfer.py \
  --source google \
  --destination onedrive \
  --google-client-secret ./client_secret.json \
  --microsoft-tenant common \
  --destination-root "FileArk Manual Transfer 2026-07-25" \
  --batch-gib 8 \
  --batch-files 200 \
  --local-reserve-gib 15 \
  --destination-reserve-gib 10 \
  --verification redownload

python fileark-cloud-transfer.py \
  --source onedrive \
  --destination google \
  --microsoft-client-id "$MICROSOFT_CLIENT_ID" \
  --google-client-secret ./client_secret.json \
  --destination-root "OneDrive archive 2026-07-25" \
  --state-file ./onedrive-to-google-state.json \
  --verification redownload

เหตุใดจึงตรวจสอบความจุมากกว่าหนึ่งครั้ง

ผลการตรวจสอบล่วงหน้าเพียงครั้งเดียวอาจล้าสมัยระหว่างการถ่ายโอนที่ใช้เวลานาน อาจมีผู้อัปโหลดไฟล์อื่นไปยังปลายทาง เอกสาร Google ที่ส่งออกอาจมีขนาดใหญ่กว่าที่ข้อมูลเมตาของต้นทางระบุ และแอปพลิเคชันอื่นอาจใช้พื้นที่ดิสก์ในเครื่อง ดังนั้นเอนจินจึงตรวจสอบความจุรวมของปลายทางก่อนเริ่มงาน ตรวจสอบความจุของปลายทางในทุกแบตช์ ตรวจสอบความจุของปลายทางอีกครั้งหลังการดาวน์โหลดลงเครื่องแต่ละครั้ง และตรวจสอบดิสก์ในเครื่องก่อนการคัดลอกแต่ละขั้นตอนหรือการคัดลอกเพื่อยืนยันข้อมูล

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

def ensure_destination_capacity(quota, required, reserve):
    if quota.remaining is None:
        LOG.warning("Destination did not report a finite quota")
        return
    needed = required + reserve
    if quota.remaining < needed:
        raise RuntimeError(
            f"Destination is too small: {human_bytes(quota.remaining)} free, "
            f"{human_bytes(needed)} required including reserve."
        )

จำกัดขนาดพื้นที่พักข้อมูลตามจำนวนไบต์และจำนวนไฟล์

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

ขนาดชิ้นส่วนเริ่มต้นคือ 10 MiB ซึ่งเป็นพหุคูณร่วมของหน่วยย่อย 256 KiB สำหรับการอัปโหลดแบบดำเนินการต่อได้ของ Google Drive และข้อกำหนดชิ้นส่วนต่อเนื่องขนาด 320 KiB ของ Microsoft Graph ตัวตรวจสอบคำสั่งในบรรทัดคำสั่งจะปฏิเสธขนาดชิ้นส่วนที่ไม่รองรับก่อนการยืนยันตัวตน

def batches(files, max_bytes, max_files):
    batch, batch_size = [], 0
    for item in files:
        planned_size = max(item.size, 1)
        if batch and (
            len(batch) >= max_files
            or batch_size + planned_size > max_bytes
        ):
            yield batch
            batch, batch_size = [], 0
        batch.append(item)
        batch_size += planned_size
    if batch:
        yield batch

จัดการเอกสารเนทีฟของ Google ด้วยการแปลงรูปแบบ

โปรเจกต์ Google Docs, Sheets, Slides, Drawings และ Apps Script ไม่ใช่สตรีมไบต์ทั่วไปที่ดาวน์โหลดได้ อะแดปเตอร์ Google จะส่งออกเป็น DOCX, XLSX, PPTX, PNG และ JSON ตามลำดับ พร้อมเพิ่มนามสกุลไฟล์ที่นำไปใช้ต่อได้ ระบบจะสำรวจโฟลเดอร์ แต่จะไม่อัปโหลดเป็นออบเจ็กต์ว่างหากไม่มีไฟล์อยู่ภายใน

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

ทางลัด ไดรฟ์ที่แชร์ ไฟล์ที่แชร์กับคุณแต่ไม่ได้อยู่ใน My Drive แพ็กเกจ OneNote ข้อมูลเมตาด้านการเก็บรักษาขององค์กร ประวัติเวอร์ชัน และ ACL การแชร์ ไม่อยู่ในขอบเขตของรุ่นนี้ ข้อจำกัดเหล่านี้คือเหตุผลที่ไม่ควรเรียกการคัดลอกไฟล์ว่าเป็นการย้ายข้อมูลผู้เช่าอย่างสมบูรณ์

ใช้การตรวจสอบด้วยการดาวน์โหลดซ้ำจากปลายทางทั้งหมดเพื่อยืนยันว่าไบต์ตรงกันทุกประการ

การอัปโหลดไปยังผู้ให้บริการสำเร็จเป็นเงื่อนไขที่จำเป็น แต่ยังไม่เพียงพอ หลังการอัปโหลด สคริปต์จะเปรียบเทียบขนาดในข้อมูลเมตาของปลายทางกับไฟล์ในพื้นที่พักข้อมูลก่อน จากนั้นในโหมดดาวน์โหลดซ้ำเริ่มต้น สคริปต์จะดาวน์โหลดออบเจ็กต์จากปลายทางเป็นไฟล์ชั่วคราวในตำแหน่งข้างเคียง คำนวณ SHA-256 และเปรียบเทียบไดเจสต์นั้นกับไดเจสต์ของต้นทางในพื้นที่พักข้อมูล

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

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

destination.redownload(uploaded, verification_copy)
verification_hash = sha256_file(verification_copy)
if verification_hash != local_hash:
    raise RuntimeError(
        f"SHA-256 mismatch after destination re-download: {relative!r}."
    )

state["completed"][relative] = {
    "source_id": item.id,
    "destination_id": uploaded.id,
    "bytes": actual_size,
    "sha256": local_hash,
    "destination_sha256": verification_hash,
}

ทำต่อโดยไม่ถือว่าความไม่แน่นอนคือความสำเร็จ

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

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

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

ดำเนินการทดสอบการยอมรับจริง

• เริ่มจากโฟลเดอร์ขนาดเล็กที่มีไฟล์ว่าง ไฟล์ขนาดใหญ่ พาธหลายระดับ ชื่อแบบ Unicode และเอกสารเนทีฟของ Google
• เรียกใช้ --dry-run ก่อน แล้วเปรียบเทียบจำนวนไบต์รวมในรายการไฟล์กับอินเทอร์เฟซของผู้ให้บริการ
• ตรวจติดตามพื้นที่ว่างในเครื่องและโควตาปลายทางแยกจากกันระหว่างแบตช์ใช้งานจริงชุดแรก
• เปิดใช้การตรวจสอบด้วยการดาวน์โหลดซ้ำไว้ และจัดเก็บเช็กพอยต์ถาวรร่วมกับบันทึกการย้ายข้อมูลของคุณ
• เปิดตรวจสอบไฟล์ตัวอย่างที่ปลายทาง ทั้ง PDF, ไฟล์ Office, รูปภาพ, วิดีโอ, ไฟล์บีบอัด และเอกสารเนทีฟที่แปลงรูปแบบแล้ว
• เปรียบเทียบจำนวนโฟลเดอร์และไฟล์กับค่าที่คาดไว้ ตรวจสอบทุกรายการที่ถูกข้ามหรือล้มเหลว และทดสอบการเข้าถึงจากผู้ใช้รายที่สอง
• คงต้นทางไว้โดยไม่เปลี่ยนแปลงตลอดช่วงเวลาที่กำหนดให้ระบบเดิมและใหม่ทำงานซ้อนกัน สคริปต์นี้จะไม่ลบต้นทาง

คำถามที่พบบ่อย

สคริปต์ Python ลบไฟล์ต้นทางในกรณีใด ๆ หรือไม่

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

ถ่ายโอนได้ทั้งสองทิศทางหรือไม่

ได้ ตั้ง Google Drive หรือ OneDrive เป็นแหล่งต้นทาง และตั้งอีกผู้ให้บริการเป็นปลายทาง ใช้จุดตรวจสอบและรากปลายทางที่ไม่ซ้ำกันสำหรับการย้ายข้อมูลแต่ละครั้ง

สคริปต์รักษาสิทธิ์การแชร์และประวัติไฟล์ไว้หรือไม่

ไม่ รุ่นนี้คัดลอกเนื้อหาไฟล์ปัจจุบันและพาธของโฟลเดอร์ ส่วน ACL การแชร์ ลิงก์สาธารณะ เวอร์ชัน ความคิดเห็น ป้ายกำกับ นโยบายการเก็บรักษา และข้อมูลเมตาเฉพาะขององค์กร ต้องย้ายและตรวจสอบแยกต่างหาก

เหตุใดจึงต้องดาวน์โหลดไฟล์ที่เพิ่งอัปโหลดซ้ำ

การที่ระบบยอมรับการอัปโหลดและขนาดในข้อมูลเมตาไม่ได้พิสูจน์ว่าจะอ่านไบต์ที่ถูกต้องตรงกันทุกประการกลับจากปลายทางได้ โหมดดาวน์โหลดซ้ำจะคำนวณ SHA-256 จากเนื้อหาที่ปลายทาง และบันทึกจุดตรวจสอบเฉพาะเมื่อข้อมูลตรงกันทุกประการ

นี่เป็นเครื่องมืออย่างเป็นทางการของ Google หรือ Microsoft หรือไม่

ไม่ นี่คือการใช้งานอ้างอิงอิสระของ FileArk ที่เผยแพร่ภายใต้สัญญาอนุญาต MIT โปรดตรวจสอบ ทดสอบด้วยข้อมูลที่ไม่สำคัญ และปฏิบัติตามนโยบายของผู้ให้บริการและองค์กรของคุณ

แหล่งข้อมูลอย่างเป็นทางการที่ใช้จัดทำคู่มือนี้

• ศูนย์การเรียนรู้ Google Workspace: เปลี่ยนจาก OneDrive มาใช้ Google Drive
• ความช่วยเหลือของ Google Drive: พื้นที่เก็บข้อมูลและการทำงานของไฟล์
• ฝ่ายสนับสนุนของ Microsoft: อัปโหลดและบันทึกไฟล์ไปยัง OneDrive
• Google Drive API: ดาวน์โหลดและส่งออกไฟล์
• Google Drive API: การอัปโหลดแบบทำต่อได้
• Google Drive API: ฟิลด์โควตาพื้นที่เก็บข้อมูล
• Microsoft Graph: แสดงรายการรายการย่อยในไดรฟ์
• Microsoft Graph: สร้างเซสชันการอัปโหลดแบบดำเนินการต่อได้
• Microsoft Graph: ทรัพยากรโควตาของ OneDrive