การตรวจสอบสิทธิ์และการจัดเตรียม

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

โปรแกรมแก้ไขโค้ดของ Earth Engine และ JavaScript

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

หากคุณใช้ JavaScript API (ภายนอกตัวแก้ไขโค้ด) ให้ใช้เครื่องมือช่วยในการตรวจสอบสิทธิ์อย่างใดอย่างหนึ่งใน ee.data (เช่น ee.data.authenticateViaPopup()) ตามด้วย ee.initialize() ดังที่แสดงในตัวอย่างนี้

Python และบรรทัดคำสั่ง

ก่อนใช้ไลบรารีของไคลเอ็นต์ Python ของ Earth Engine คุณต้องตรวจสอบสิทธิ์ (ยืนยันตัวตน) และใช้ข้อมูลเข้าสู่ระบบที่ได้เพื่อเริ่มต้นไคลเอ็นต์ Python ขั้นตอนการตรวจสอบสิทธิ์ใช้ Cloud Projects เพื่อตรวจสอบสิทธิ์ และใช้สำหรับการใช้งานแบบไม่ชำระเงิน (ฟรี ไม่ใช่เชิงพาณิชย์) รวมถึงการใช้งานแบบชำระเงิน หากต้องการ ตรวจสอบสิทธิ์และเริ่มต้น ให้เรียกใช้

    ee.Authenticate()
    ee.Initialize(project='my-project')

โดยขั้นแรก ระบบจะเลือกโหมดการตรวจสอบสิทธิ์ที่ดีที่สุดสำหรับสภาพแวดล้อมของคุณ และ แจ้งให้คุณยืนยันการเข้าถึงสคริปต์ หากมีข้อมูลเข้าสู่ระบบอยู่แล้ว ระบบจะนำข้อมูลเข้าสู่ระบบเหล่านั้นมาใช้ซ้ำโดยอัตโนมัติ - เรียกใช้ ee.Authenticate(force=True) เพื่อสร้างข้อมูลเข้าสู่ระบบใหม่

ขั้นตอนการเริ่มต้นจะยืนยันว่ามีข้อมูลเข้าสู่ระบบที่ถูกต้อง ซึ่งอาจสร้างจาก ee.Authenticate() หรือมีอยู่แล้วเป็นข้อมูลเข้าสู่ระบบเริ่มต้นของ Google จากนั้นจะ เริ่มต้นไลบรารีของไคลเอ็นต์ Python ด้วยเมธอดที่เซิร์ฟเวอร์แบ็กเอนด์ รองรับ คุณจะต้องระบุโปรเจ็กต์ที่คุณเป็นเจ้าของหรือมีสิทธิ์ในการใช้ ดูการตั้งค่าโปรเจ็กต์ที่อยู่ในระบบคลาวด์เพื่อลงทะเบียนโปรเจ็กต์และเปิดใช้ Earth Engine API โปรเจ็กต์นี้จะใช้เพื่อเรียกใช้การดำเนินการ Earth Engine ทั้งหมด

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

นอกจากนี้ คุณยังกำหนดค่าโปรเจ็กต์สำหรับการเรียกใช้ในอนาคตทั้งหมดได้โดยเรียกใช้ earthengine set_project {my-project} บรรทัดคำสั่งและ ee.Initialize() จะใช้ข้อมูลนี้ เมื่อใดก็ตามที่ไม่ได้ระบุโปรเจ็กต์โดยตรง หากใช้การตรวจสอบสิทธิ์ผ่าน gcloud (ดูด้านล่าง) ระบบจะใช้โปรเจ็กต์ที่ตั้งค่าโดย gcloud auth application-default set-quota-project {my-project} เป็นกรณีสุดท้าย

รายละเอียดการตรวจสอบสิทธิ์

จุดประสงค์ของขั้นตอนการตรวจสอบสิทธิ์ Earth Engine คือการรับ "โทเค็น" ความปลอดภัย จากบัญชีที่คุณลงชื่อเข้าใช้ ซึ่งสามารถจัดเก็บไว้เพื่อให้สคริปต์มีสิทธิ์ เข้าถึงข้อมูลของคุณ ระบบการตรวจสอบสิทธิ์ของ Google จะส่งโทเค็นดังกล่าวไปยังระบบที่สามารถรักษาความปลอดภัยได้เท่านั้น โปรดดูหมายเหตุทางเทคนิคด้านล่าง

เนื่องจากระบบที่เกี่ยวข้องมีความละเอียดอ่อน จึงมีวิธีดำเนินการที่แตกต่างกันไปตามสถานการณ์ของคุณ ตัวเลือกส่วนใหญ่จะควบคุมโดยพารามิเตอร์ auth_mode ไม่ว่าจะเป็น ee.Authenticate(auth_mode=...) หรือ earthengine authenticate --auth_mode=... ในบรรทัดคำสั่ง

โปรดทราบว่าหากมีข้อมูลเข้าสู่ระบบของ Google อยู่แล้วในสภาพแวดล้อม คุณอาจไม่จำเป็นต้องเรียกใช้ ee.Authenticate() เลย VM ของ Google Cloud, App Engine และสภาพแวดล้อมอื่นๆ มี "ข้อมูลเข้าสู่ระบบโดยรอบ" ที่ใช้ได้ และ gcloud auth application-default login จะสร้างข้อมูลเข้าสู่ระบบดังกล่าวด้วย

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

  • colab หากเรียกใช้ใน Google Colab Notebook
  • notebook หากเรียกใช้ใน Jupyter Notebook อื่นที่ไม่ใช่ Colab
  • localhost หากตรวจพบเว็บเบราว์เซอร์และไม่ได้ติดตั้งไบนารี gcloud
  • gcloud มิฉะนั้น สำหรับโหมดนี้ คุณจะต้องติดตั้ง gcloud

คู่มืออ้างอิงฉบับย่อและตาราง

คำแนะนำในการตัดสินใจนี้จะอธิบายตัวเลือกที่เป็นไปได้หากโหมดเริ่มต้นที่ee.Authenticate()เลือกใช้ไม่ได้ เช่น หากคุณใช้งานในสภาพแวดล้อม Notebook อื่นๆ คุณอาจต้องระบุ notebook อย่างชัดเจน

  • สภาพแวดล้อมในพื้นที่
    • "ในเครื่อง" หมายความว่าคุณ กำลังเรียกใช้โค้ดในเชลล์ Python หรือสมุดบันทึก Python ในเครื่องที่อยู่ ตรงหน้าคุณ หรือพูดให้เจาะจงกว่านั้นคือในเครื่องเดียวกันกับที่เว็บเบราว์เซอร์ ของคุณกำลังทำงานอยู่ ซึ่งรวมถึงสถานการณ์การใช้เดสก์ท็อประยะไกลที่ทั้ง Python และ เบราว์เซอร์อยู่ในเครื่องเดียวกัน (ระยะไกล)
    • การใช้ auth_mode=localhost เป็นวิธีที่ง่ายที่สุด และระบบจะเลือกวิธีนี้โดยค่าเริ่มต้นหากไม่ได้ติดตั้ง gcloud แต่สคริปต์จะทำงานในสภาพแวดล้อมในเครื่องเท่านั้น
    • นอกจากนี้ยังมีauth_mode=gcloudและauth_mode=notebookด้วย
  • สภาพแวดล้อมระยะไกล
    • "ระยะไกล" หมายความว่าเบราว์เซอร์ของคุณอยู่ในเครื่อง (ในเครื่อง) เครื่องหนึ่ง แต่โค้ดของคุณ ทำงานที่อื่น เช่น ในเวิร์กสเตชันระยะไกลหรือ Notebook บนเว็บ
    • หากอยู่ใน Colab ให้ใช้ auth_mode=colab หรือใช้ gcloud หากต้องการตั้งค่า scopes เพื่อเรียกใช้ API อื่นๆ
    • หากติดตั้ง gcloud ได้ทั้งในเครื่องระยะไกลและเครื่องของคุณ ให้ใช้ auth_mode=gcloud
    • หากใช้โปรเจ็กต์การตรวจสอบสิทธิ์ได้ (ดูด้านล่าง) ให้ใช้ auth_mode=notebook
    • หรือหากคุณใช้โปรเจ็กต์ ติดตั้ง gcloud ใช้ Colab หรือใช้ เบราว์เซอร์ในเครื่องเดียวกันไม่ได้ ให้ทำดังนี้
    • พูดคุยกับผู้ดูแลระบบ (อีกครั้ง) เกี่ยวกับการสร้างโปรเจ็กต์ ตัวอย่างเช่น
      • ขอให้ผู้ดูแลระบบกำหนดค่าโปรเจ็กต์ให้คุณ (ในฐานะเจ้าของหรือผู้แก้ไข หรือผู้แก้ไขการกำหนดค่า OAuth)
      • หรือขอให้ผู้ดูแลระบบมอบสิทธิ์ให้คุณสร้างโปรเจ็กต์

ตารางนี้แสดงการผสมผสานฟีเจอร์ที่แต่ละโหมดรองรับ

สำหรับตำแหน่งในพื้นที่หรือตำแหน่งระยะไกล ต้องมีโปรเจ็กต์ ขอบเขตที่ตั้งค่าได้ ต้องใช้ CLI ในเครื่อง เจ้าของโปรเจ็กต์
localhost local Y ได้ ไม่ N
colab รีโมต Y ไม่ ไม่ N
gcloud ทั้งคู่ Y ได้ ไม่ N
notebook ทั้งคู่ Y ได้ ไม่ Y

ข้อมูลเข้าสู่ระบบสำหรับบัญชีบริการและ Compute Engine

ee.Initialize() จะใช้ข้อมูลเข้าสู่ระบบของ Earth Engine (ซึ่ง ee.Authenticate() จัดเก็บไว้ใน ~/.config/earthengine/credentials) หรือดึงข้อมูลเข้าสู่ระบบจาก google.auth.default() แต่หากจำเป็น คุณสามารถส่งอาร์กิวเมนต์ credentials= เพื่อใช้ข้อมูลเข้าสู่ระบบจากที่อื่น โดยข้ามค่าเริ่มต้นเหล่านี้ได้

หากคุณกำลังตรวจสอบสิทธิ์โค้ด Python ที่จะทำงานโดยไม่มีการดูแล คุณอาจต้อง ตรวจสอบสิทธิ์ด้วยบัญชีบริการแทนบัญชีผู้ใช้ ดูเอกสาร เหล่านี้เกี่ยวกับการใช้บัญชีบริการกับ Earth Engine วิธีอื่นๆ ได้แก่ authenticate_service_account ในโมดูลการตรวจสอบสิทธิ์ของ Colab และวิธีที่ อธิบายไว้ในคำแนะนำของ Cloud เกี่ยวกับการตรวจสอบสิทธิ์ในฐานะบัญชีบริการ

หากโค้ดทำงานใน VM ของ Compute Engine ระบบจะสร้างบัญชีบริการเริ่มต้นสำหรับสภาพแวดล้อม ซึ่ง ee.Initialize() จะใช้โดยค่าเริ่มต้น คุณอาจต้องลงทะเบียนบัญชีบริการเพื่อใช้ Earth Engine หากโปรเจ็กต์ Cloud ที่ใช้เริ่มต้น VM ไม่ได้ลงทะเบียนเพื่อใช้ กับ Earth Engine (เชิงพาณิชย์หรือไม่ใช่เชิงพาณิชย์)

รายละเอียดเกี่ยวกับโหมด

auth_mode=colab ee.Authenticate() จะสร้างหรือขอรับข้อมูลเข้าสู่ระบบเริ่มต้นที่ Colab รองรับโดยการเรียกใช้ colab.auth.authenticate_user() หากจำเป็น ข้อมูลเข้าสู่ระบบจะใช้ขอบเขต cloud-platform เสมอ และยังใช้เพื่อเรียก Cloud API อื่นๆ ได้ด้วย

auth_mode=gcloud ซึ่งจะมอบสิทธิ์การตรวจสอบสิทธิ์ให้กับเครื่องมือ gcloud และเหมือนกับการเรียกใช้ gcloud auth application-default login ที่มีขอบเขต Earth Engine เริ่มต้น (earthengine, cloud-platform และ drive) หรือขอบเขตในอาร์กิวเมนต์ scopes โหมด gcloud จะทำงานได้ทั้งในกรณีที่อยู่ใกล้และอยู่ไกล

วิธีการทีละขั้นตอนสำหรับโหมด gcloud (กรณีในเครื่องและระยะไกล)

  1. ตรวจสอบว่าได้ติดตั้ง gcloud ในเครื่องแล้ว
    • เรียกใช้ gcloud help ในเทอร์มินัล หากไม่ได้ติดตั้ง gcloud ให้ทำตามวิธีการเหล่านี้เพื่อติดตั้ง gcloud
  2. เทอร์มินัลเครื่องของคุณเอง
    • เรียกใช้ earthengine authenticate ในเทอร์มินัล
    • เอาต์พุตจากคำสั่งจะระบุว่าระบบกำลังใช้ gcloud เพื่อ ดึงข้อมูลเข้าสู่ระบบ
    • หน้าต่างเบราว์เซอร์จะเปิดขึ้นและนำไปยังหน้าการเลือกบัญชี หากเบราว์เซอร์ไม่เปิดขึ้นโดยอัตโนมัติ ให้คลิก URL
  3. เบราว์เซอร์: การเลือกบัญชี
    • เลือกบัญชีที่ต้องการใช้สำหรับการตรวจสอบสิทธิ์
  4. เบราว์เซอร์: หน้าจอขอความยินยอม
    • ระบุว่าคุณยินดีให้สิทธิ์ขอบเขตที่ขอหรือไม่ แล้วคลิก "อนุญาต"
  5. เบราว์เซอร์: หน้าจอยืนยัน
    • เบราว์เซอร์จะแสดงหน้าเว็บที่ยืนยันว่าคุณได้รับการตรวจสอบสิทธิ์แล้ว และคำสั่ง earthengine authenticate ในหน้าต่างเทอร์มินัลจะรายงานว่า "บันทึกโทเค็นการให้สิทธิ์เรียบร้อยแล้ว"
    • ในกรณีที่ต้องดำเนินการจากระยะไกล หน้าเว็บจะให้รหัสแก่คุณเพื่อวางกลับลงในสภาพแวดล้อม Python
  6. ดำเนินการเริ่มต้น

auth_mode=localhost นี่คือโฟลว์ที่คล้ายกับ gcloud สำหรับกรณีที่ไม่ได้ติดตั้ง gcloud โดยจะทำตามขั้นตอนเดียวกับ gcloud แต่ใช้ได้เฉพาะในกรณีที่ เป็นเครื่องในพื้นที่เท่านั้น คุณระบุหมายเลขพอร์ตอินเทอร์เน็ตที่ไม่บังคับได้ เช่น localhost:8086 หรือใช้ localhost:0 เพื่อเลือกพอร์ตโดยอัตโนมัติ พอร์ตเริ่มต้น คือ 8085

auth_mode=notebook โหมดนี้เป็นโหมดอเนกประสงค์ที่ออกแบบมาให้ทำงานใน สถานการณ์ระยะไกลที่ไม่มีบรรทัดคำสั่งในเครื่อง ระบบจะนำคุณไปยังหน้า Notebook Authenticator ซึ่งคุณจะต้องเลือกหรือสร้าง "โปรเจ็กต์การตรวจสอบสิทธิ์" - ดูรายละเอียดและคู่มือการแก้ปัญหาด้านล่าง โปรเจ็กต์ที่ส่งไปยัง ee.Initialize() ไม่จำเป็นต้องตรงกับโปรเจ็กต์นี้ คุณสามารถใช้โปรเจ็กต์เดียวกันสำหรับการตรวจสอบสิทธิ์ขณะทำงานในโปรเจ็กต์ต่างๆ ใน Notebook ที่แตกต่างกันได้ ขอแนะนำให้ส่งโปรเจ็กต์อย่างชัดเจนไปยัง ee.Initialize() แต่ระบบจะใช้โปรเจ็กต์การตรวจสอบสิทธิ์โดยค่าเริ่มต้น

วิธีการทีละขั้นตอนสำหรับโหมด Notebook

  1. เบราว์เซอร์: Notebook
    1. ในโค้ดเซลล์ของ Notebook ให้เรียกใช้โค้ดต่อไปนี้เพื่อเริ่ม ขั้นตอนการตรวจสอบสิทธิ์โดยใช้โหมด "notebook" 
      import ee
ee.Authenticate()
       คลิกลิงก์ในเอาต์พุตของเซลล์เพื่อเปิดหน้า Notebook Authenticator ในแท็บใหม่
  2. เบราว์เซอร์: Notebook Authenticator
    1. ตรวจสอบว่าบัญชีผู้ใช้ที่ถูกต้องแสดงอยู่
    2. เลือกโปรเจ็กต์ Google Cloud ที่จะใช้สำหรับการตรวจสอบสิทธิ์ หาก ต้องการสร้างโปรเจ็กต์ใหม่ เราขอแนะนำให้ใช้วิธีการตั้งชื่อ "ee-xyz" โดยที่ xyz คือชื่อผู้ใช้ Earth Engine ปกติของคุณ (หากเลือกหรือสร้างโปรเจ็กต์ Cloud ไม่ได้ โปรดดูส่วนการแก้ปัญหาด้านล่าง)
    3. คลิกสร้างโทเค็น
  3. เบราว์เซอร์: การเลือกบัญชี
    • ระบบจะแสดงหน้าการเลือกบัญชี คลิกบัญชีผู้ใช้ ที่คุณต้องการให้สิทธิ์เข้าถึงจาก Notebook
  4. เบราว์เซอร์: หน้าคำเตือน
    • หน้าคำเตือนจะปรากฏขึ้นเพื่อระบุว่า Google ไม่ได้สร้างแอป (เช่น โค้ดใน Notebook) คลิก "ดำเนินการต่อ" เพื่อรับทราบ
  5. เบราว์เซอร์: หน้าจอขอความยินยอม
    • ระบุว่าคุณยินดีให้ขอบเขตที่ขอหรือไม่ แล้วคลิกต่อไป
  6. เบราว์เซอร์: หน้าจอรหัสการให้สิทธิ์
    • คัดลอกรหัสยืนยันการให้สิทธิ์
  7. เบราว์เซอร์: Notebook
    • สลับกลับไปที่แท็บ Notebook แล้ววางรหัสยืนยันลงใน เอาต์พุตของเซลล์ Notebook
    • เอาต์พุตของเซลล์ควรระบุ "บันทึกโทเค็นการให้สิทธิ์เรียบร้อยแล้ว"
  8. ดำเนินการเริ่มต้น

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

โปรเจ็กต์การตรวจสอบสิทธิ์

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

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

รายละเอียดเกี่ยวกับขอบเขต

การตั้งค่าการตรวจสอบสิทธิ์เริ่มต้นของ Earth Engine มีขอบเขตที่ใช้ได้ทั้งหมด ดังนั้น คุณจึงข้ามส่วนนี้ได้หากค่าเริ่มต้นตรงกับข้อกำหนดของคุณ

ขอบเขตของ Earth Engine: ขอบเขต OAuth 2.0 จะกำหนดและจำกัดชุดทรัพยากรและการดำเนินการที่แอปพลิเคชันได้รับอนุญาตให้เข้าถึงในนามของผู้ใช้ เมื่อใช้ OAuth เพื่อตรวจสอบสิทธิ์กับ Earth Engine คุณต้องขอขอบเขตต่อไปนี้อย่างน้อย 1 รายการ

  • https://www.googleapis.com/auth/earthengine: สิทธิ์อ่านและเขียนสำหรับ ชิ้นงานและทรัพยากรของ Earth Engine ต้องใช้ในการสร้าง แก้ไข หรือ ลบชิ้นงาน จัดการสิทธิ์ของชิ้นงาน และเรียกใช้งานการส่งออก
  • https://www.googleapis.com/auth/earthengine.readonly: สิทธิ์เข้าถึงแบบอ่านอย่างเดียวสำหรับ ชิ้นงาน Earth Engine

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

ขอบเขตของ Google Cloud และไดรฟ์: หากการค้นหาหรือสคริปต์ Earth Engine อ้างอิงข้อมูลหรือชิ้นงานภายนอก ข้อมูลเข้าสู่ระบบของคุณต้องมีขอบเขตที่เหมาะสมสำหรับบริการเหล่านั้นด้วย

  • Cloud Storage (GCS) (เมื่ออ่านหรือเขียนไปยัง Bucket ของ Cloud Storage เช่น การโหลด GeoTIFF ที่เพิ่มประสิทธิภาพสำหรับ Cloud หรือการส่งออกเอาต์พุตของงาน)
    • https://www.googleapis.com/auth/devstorage.full_control
    • https://www.googleapis.com/auth/devstorage.read_write
    • https://www.googleapis.com/auth/devstorage.read_only
  • BigQuery (BQ) (เมื่ออ่านตารางหรือเขียนการส่งออกไปยัง BigQuery)
    • https://www.googleapis.com/auth/bigquery
  • Google ไดรฟ์ (เมื่อเข้าถึงหรือส่งออกข้อมูลไปยัง Google ไดรฟ์)
    • https://www.googleapis.com/auth/drive
    • https://www.googleapis.com/auth/drive.readonly

นอกจากนี้ Google Cloud ยังมีขอบเขตกว้างที่ครอบคลุมบริการ Google Cloud ทั้งหมดด้วย

  • Cloud Platform (สิทธิ์เข้าถึงบริการของ Google Cloud อย่างกว้างขวาง ซึ่งครอบคลุม Earth Engine, Cloud Storage และ BigQuery โปรดทราบว่า Google ไดรฟ์เป็น บริการ Workspace แยกต่างหากและไม่ครอบคลุมขอบเขตเหล่านี้)
    • https://www.googleapis.com/auth/cloud-platform
    • https://www.googleapis.com/auth/cloud-platform.read-only

ขอบเขตเริ่มต้น: ขอบเขตเริ่มต้นที่กำหนดค่าโดยทั้ง Earth Engine Code Editor และไลบรารีไคลเอ็นต์ (เช่น ee.Authenticate()) จะรวมขอบเขตทั้งหมดต่อไปนี้ earthengine, cloud-platform และ drive (ดูรายละเอียดก่อนหน้านี้) ดังนั้น การปรับแต่งขอบเขต (เช่น การใช้พารามิเตอร์ scopes ใน ee.Authenticate(scopes=[...])) จะจำเป็นก็ต่อเมื่อคุณมีข้อจำกัดด้านความปลอดภัยหรือนโยบายขององค์กรที่กำหนดให้จำกัดสิทธิ์ เท่านั้น

การแก้ปัญหา

ฉันควรทำอย่างไรหากสร้างโปรเจ็กต์ Cloud ไม่ได้

บางองค์กรควบคุมผู้ที่มีสิทธิ์สร้างโปรเจ็กต์ Cloud หากได้รับข้อผิดพลาดในหน้า Notebook Authenticator เมื่อพยายามสร้างโปรเจ็กต์ คุณลองทำสิ่งต่อไปนี้ได้

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

ข้อผิดพลาด: "ไม่เคยใช้ Earth Engine API ในโปรเจ็กต์ XXX มาก่อนหรือถูกปิดใช้"

ก่อนอื่น ตรวจสอบว่าคุณได้กำหนดค่าโปรเจ็กต์ใน ee.Initialize() หรือใน บรรทัดคำสั่งแล้ว (โปรเจ็กต์เริ่มต้นที่ Cloud และ Colab จัดเตรียมให้จะไม่ได้เปิดใช้ Earth Engine) ประการที่สอง ตรวจสอบว่าโปรเจ็กต์ เปิดใช้ Earth Engine API แล้ว

ข้อผิดพลาด: "โปรเจ็กต์มีการกำหนดค่าไคลเอ็นต์ OAuth2 ที่เข้ากันไม่ได้"

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

ข้อผิดพลาด: "gcloud ล้มเหลว โปรดตรวจสอบข้อผิดพลาดด้านบนและติดตั้ง gcloud หากจำเป็น"

ข้อผิดพลาดนี้อาจเกิดขึ้นหากไม่ได้ติดตั้ง gcloud หรือไม่ได้อยู่ใน PATH นอกจากนี้ ปัญหานี้อาจเกิดขึ้นหากคุณเรียกใช้ ee.Authenticate(auth_mode='gcloud') จากภายในโค้ดเซลล์ของ Notebook ให้ใช้ ee.Authenticate() แทน ซึ่งจะใช้การตรวจสอบสิทธิ์โหมด Notebook เป็นค่าเริ่มต้น หากสร้างโปรเจ็กต์ไม่ได้ โปรดดูวิธีแก้ปัญหาด้านบน

จะเกิดอะไรขึ้นหากฉันไม่มีสิทธิ์เข้าถึงเครื่องในพื้นที่เพื่อติดตั้ง gcloud

หากคุณทำงานในสภาพแวดล้อมบนเว็บเท่านั้นโดยไม่มีสิทธิ์เข้าถึงเทอร์มินัลในเครื่อง และยังคงต้องใช้เทอร์มินัลระยะไกล คุณจะยังคงเริ่มต้นเครื่องมือ บรรทัดคำสั่งได้โดยการเรียกใช้โหมด Notebook ด้วยการเรียกใช้คำสั่ง earthengine authenticate --auth_mode=notebook

ข้อผิดพลาด 400: redirect_uri_mismatch

คุณอาจได้รับข้อผิดพลาดนี้หากตรวจสอบสิทธิ์ในเครื่องระยะไกลโดยไม่มีสิทธิ์เข้าถึง เว็บเบราว์เซอร์ ลองเพิ่ม --quiet หากเรียกใช้ earthengine authenticate จากบรรทัดคำสั่ง หรือ ee.Authenticate(quiet=True) หากใช้ไคลเอ็นต์ Python ซึ่งจะกำหนดให้คุณต้องตรวจสอบสิทธิ์ด้วย gcloud จากเครื่องที่มีสิทธิ์เข้าถึงเว็บเบราว์เซอร์

ข้อผิดพลาด: "แอปพลิเคชันของคุณกำลังตรวจสอบสิทธิ์โดยใช้ข้อมูลรับรองเริ่มต้นของแอปพลิเคชันในเครื่อง API earthengine.googleapis.com ต้องใช้โปรเจ็กต์โควต้า ซึ่งไม่ได้ตั้งค่าไว้โดยค่าเริ่มต้น"

ข้อผิดพลาดนี้อาจเกิดขึ้นเมื่อ Earth Engine กำหนดรหัสโปรเจ็กต์ไม่ได้ หากตัวเลือกการแก้ปัญหาของ Google Cloud ไม่ได้ผล ให้ลองเรียกใช้ earthengine set_project YOUR_PROJECT_ID หรือ gcloud auth application-default set-quota-project YOUR_PROJECT_ID

ข้อผิดพลาด: "ไม่มีขอบเขตที่จำเป็นสำหรับ [Cloud Storage / BigQuery]"

ข้อผิดพลาดนี้เกิดขึ้นเมื่อคำขอของ Earth Engine เข้าถึงทรัพยากร Cloud Storage หรือ BigQuery แต่ข้อมูลเข้าสู่ระบบที่ใช้ในการเริ่มต้น Earth Engine ไม่มีขอบเขตที่จำเป็นสำหรับบริการนั้น (หรือขอบเขต cloud-platform ซึ่งครอบคลุมบริการทั้งหมดของ Google Cloud) โดยปกติแล้ว เหตุการณ์นี้จะเกิดขึ้นหากคุณ ปรับแต่งพารามิเตอร์ scopes ระหว่างการตรวจสอบสิทธิ์ (เช่น ระบุขอบเขต Earth Engine เท่านั้นให้กับ ee.Authenticate(scopes=[...])) หรือหากมีการสร้างข้อมูลเข้าสู่ระบบที่มีอยู่โดยไม่มีขอบเขตเหล่านั้น

คุณแก้ปัญหานี้ได้ 2 วิธีดังนี้

  • ตรวจสอบสิทธิ์อีกครั้งด้วยขอบเขตเริ่มต้น: ข้อมูลเข้าสู่ระบบเริ่มต้นสำหรับ Earth Engine มีขอบเขต cloud-platform ซึ่งครอบคลุมทั้ง Cloud Storage และ BigQuery ตรวจสอบสิทธิ์อีกครั้งโดยใช้การตั้งค่าเริ่มต้น
    • ใน Python ให้ทำดังนี้ ee.Authenticate(force=True)
    • ในบรรทัดคำสั่ง ให้ทำดังนี้ earthengine authenticate --force
  • รวมขอบเขตที่จำเป็น: หากสภาพแวดล้อมของคุณต้องปรับแต่ง ขอบเขต ให้ตรวจสอบว่ารายการ scopes มี https://www.googleapis.com/auth/cloud-platform หรือขอบเขตบริการที่เฉพาะเจาะจง (เช่น https://www.googleapis.com/auth/devstorage.full_control หรือ https://www.googleapis.com/auth/devstorage.read_only สำหรับ Cloud Storage หรือ https://www.googleapis.com/auth/bigquery สำหรับ BigQuery)

ดูรายละเอียดเพิ่มเติมเกี่ยวกับขอบเขตที่ใช้ได้ได้ที่ รายละเอียดเกี่ยวกับขอบเขต

หมายเหตุทางเทคนิค

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

  • ก่อนหน้านี้มีpasteโหมดที่ให้โทเค็นแก่คุณเพื่อวางได้ทุกที่ แต่ เราพิจารณาแล้วว่าโหมดนี้มีความเสี่ยงมากเกินไปและไม่พร้อมให้บริการอีกต่อไป
  • colab: auth.authenticate_user() จะแจ้งให้คุณแชร์ข้อมูลเข้าสู่ระบบกับ ไคลเอ็นต์การให้สิทธิ์ "Colab" ซึ่งเป็นสภาพแวดล้อมของ Notebook เอง จากนั้นจะพร้อมให้บริการผ่าน google.auth.default() และใช้โดย ee.Initialize()
  • localhost: ระบบจะส่งข้อมูลเข้าสู่ระบบจากเบราว์เซอร์ไปยังพอร์ตในเครื่อง ของคุณ ในกรณีนี้ ความปลอดภัยแบบต้นทางถึงปลายทางจะขึ้นอยู่กับข้อเท็จจริงที่ว่าเครื่องในพื้นที่ของคุณไม่ถูกบุกรุก ไคลเอ็นต์การให้สิทธิ์ที่คุณจะเห็นคือ "โปรแกรมตรวจสอบสิทธิ์ของ Earth Engine"
  • gcloud: ใช้โฟลว์ --launch-browser ที่อธิบายไว้ในข้อมูลอ้างอิง gcloud และ --no-launch-browser หากอยู่ในเครื่องระยะไกล ไคลเอ็นต์การตรวจสอบสิทธิ์ที่ใช้คือ "Google Auth Library"
  • notebook: เราจะสร้างไคลเอ็นต์การให้สิทธิ์ใหม่สำหรับงานของคุณโดยเฉพาะ คุณจะเห็นอีเมลในหน้าความยินยอม ไคลเอ็นต์นี้ตั้งค่าในโหมด "development" ซึ่งเป็นกรณีพิเศษที่อนุญาตให้ใช้โทเค็นโหมดวางแบบเก่า เราจำเป็นต้องใช้โปรเจ็กต์ของคุณเองสำหรับขั้นตอนนี้ เนื่องจากไคลเอ็นต์ดังกล่าวไม่สามารถแชร์กับผู้ใช้จำนวนมากได้