ดาวน์โหลด google api nodejs client - google api nodejs client ดาวน์โหลด

google api nodejs client

ซอร์สโค้ดอื่น ๆ

v0.1.0

ดาวน์โหลด

ไคลเอนต์ Google APIS Node.js

ไลบรารีไคลเอนต์ Node.js สำหรับการใช้ Google APIs สนับสนุนการอนุญาตและการรับรองความถูกต้องด้วย OAuth 2.0, API Keys และ Tokens JWT รวมอยู่ด้วย

Google APIS
เริ่มต้น

การติดตั้ง
การใช้ไลบรารีไคลเอนต์
ตัวอย่าง
การอ้างอิง API

การรับรองความถูกต้องและการอนุญาต

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

การใช้งาน

ระบุตัวตน
อัปโหลดสื่อ
ตัวเลือกขอ
ใช้พร็อกซี
API ที่รองรับ
ตัวพิมพ์ใหญ่
http/2

ใบอนุญาต
การบริจาค
คำถาม/ปัญหา?

Google APIS

รายการ API ที่รองรับทั้งหมดสามารถพบได้ใน Google APIS Explorer จุดสิ้นสุด API จะถูกสร้างขึ้นโดยอัตโนมัติดังนั้นหาก API ไม่ได้อยู่ในรายการปัจจุบันจะไม่ได้รับการสนับสนุนจากไลบรารีไคลเอนต์ API นี้

ทำงานกับ Google Cloud Platform API หรือไม่

เมื่อใช้ประโยชน์จาก Google Cloud Platform API เช่น Datastore, Cloud Storage หรือ Pub/Sub ขอแนะนำให้ใช้ประโยชน์จากไลบรารีไคลเอนต์ @Google Cloud ไลบรารีเหล่านี้เป็นไคลเอนต์ Node.js ที่สร้างขึ้นโดยมีวัตถุประสงค์ที่ออกแบบมาสำหรับบริการแพลตฟอร์ม Google Cloud เฉพาะ เราขอแนะนำให้ติดตั้งแพ็คเกจ API แต่ละตัวเช่น @google-cloud/storage ในการสำรวจรายการที่ครอบคลุมของแพลตฟอร์มแพลตฟอร์ม API-specific ของ Google Cloud โปรดดูที่ https://cloud.google.com/nodejs/docs/reference

สนับสนุนและบำรุงรักษา

ห้องสมุดลูกค้าเหล่านี้ได้รับการสนับสนุนอย่างเป็นทางการโดย Google อย่างไรก็ตามห้องสมุดเหล่านี้ถือว่าสมบูรณ์และอยู่ในโหมดการบำรุงรักษา ซึ่งหมายความว่าเราจะจัดการกับข้อบกพร่องที่สำคัญและปัญหาด้านความปลอดภัย แต่จะไม่เพิ่มคุณสมบัติใหม่ใด ๆ สำหรับ Google Cloud Platform APIs เราขอแนะนำให้ใช้ Google-Cloud-Node ซึ่งอยู่ระหว่างการพัฒนาที่ใช้งานอยู่

ห้องสมุดนี้รองรับ LTS การบำรุงรักษา LTS ที่ใช้งานอยู่และการเปิดตัว Node.JS ปัจจุบันปัจจุบัน ดูกำหนดการเปิดตัว node.js สำหรับข้อมูลเพิ่มเติม

เริ่มต้น

การติดตั้ง

ห้องสมุดนี้มีการกระจายใน npm ในการเพิ่มเป็นการพึ่งพาให้เรียกใช้คำสั่งต่อไปนี้:

 $ npm ติดตั้ง googleapis

หากคุณต้องการลดเวลาเริ่มต้นคุณสามารถติดตั้ง submodule เป็นการพึ่งพาของตัวเอง เราใช้ความพยายามในการเผยแพร่ submodules ที่ ไม่ได้ อยู่ในรายการนี้ ในการเพิ่มเป็นการพึ่งพาให้เรียกใช้คำสั่งตัวอย่างต่อไปนี้แทนที่ด้วย API ที่คุณต้องการ:

 $ npm ติดตั้ง @googleapis/docs

คุณสามารถเรียกใช้การค้นหานี้ใน npm เพื่อค้นหารายการของ submodules ที่มีอยู่

การใช้ไลบรารีไคลเอนต์

นี่เป็นตัวอย่างที่ง่ายมาก สิ่งนี้สร้างไคลเอนต์บล็อกเกอร์และดึงรายละเอียดของบล็อกที่ได้รับรหัสบล็อก:

 const {google} = ต้องการ ('googleapis'); // แต่ละ API อาจรองรับหลายเวอร์ชัน ด้วยตัวอย่างนี้เราได้รับ // v3 ของบล็อกเกอร์ API และใช้คีย์ API เพื่อตรวจสอบความถูกต้องของบล็อกเกอร์ = google.blogger ({
  เวอร์ชัน: 'v3',
  auth: 'คีย์ API ของคุณ'}); const params = {
  blogid: '3213900'}; // รับ blog detailsblogger.blogs.get (params, (err, res) => {
  ถ้า (err) {console.error (err); โยน err;
  -
  console.log (`url บล็อกคือ $ {res.data.url}`);});

แทนที่จะใช้การโทรกลับคุณสามารถใช้สัญญาได้!

 blogger.blogs.get (params)
  .then (res => {console.log (`url บล็อกคือ $ {res.data.url}`);
  -
  .catch (error => {console.error (ข้อผิดพลาด);
  -

หรือ async/รอ:

 ฟังก์ชั่น async runsample () {
  const res = รอ Blogger.blogs.get (params);
  console.log (`url บล็อกคือ $ {res.data.url}`);} runsample (). catch (console.error);

หรือคุณสามารถโทรไปยัง API ได้โดยตรงโดยการติดตั้ง submodule:

 const docs = ต้องการ ('@googleapis/docs') const auth = docs.auth.googleauth ({
  keyfilename: 'path_to_service_account_key.json', // scopes สามารถระบุได้ว่าเป็นอาร์เรย์หรือเป็นสตริงเดียวที่คั่นด้วยอวกาศ
  scopes: ['https://www.googleapis.com/auth/documents'.khin )); }); const createresponse = รอไคลเอนต์ documents.create ({requestbody: {title: 'เอกสารใหม่ของคุณ!',},}); console.log (createResponse.data);

ตัวอย่าง

มีตัวอย่างมากมาย? หากคุณกำลังพยายามหาวิธีใช้ API ... ดูที่นั่นก่อน! หากมีตัวอย่างที่คุณต้องหายไปอย่าลังเลที่จะยื่นปัญหา

การอ้างอิง API

ไลบรารีนี้มีเอกสารอ้างอิง API เต็มรูปแบบ เอกสารนี้มีการสร้างอัตโนมัติและตำแหน่งอาจเปลี่ยนแปลง

การรับรองความถูกต้องและการอนุญาต

มีหลายวิธีในการรับรองความถูกต้องของ Google API บริการบางอย่างสนับสนุนวิธีการตรวจสอบทั้งหมดในขณะที่วิธีอื่น ๆ อาจรองรับเพียงหนึ่งหรือสอง

OAUTH2 - สิ่งนี้ช่วยให้คุณสามารถโทร API ในนามของผู้ใช้ที่กำหนด ในรุ่นนี้ผู้ใช้เยี่ยมชมแอปพลิเคชันของคุณลงชื่อเข้าใช้ด้วยบัญชี Google ของพวกเขาและให้การอนุญาตแอปพลิเคชันของคุณกับชุดของขอบเขต เรียนรู้เพิ่มเติม
คีย์ API - ด้วยคีย์ API คุณสามารถเข้าถึงบริการของคุณจากไคลเอนต์หรือเซิร์ฟเวอร์ โดยทั่วไปจะมีความปลอดภัยน้อยกว่านี้มีให้บริการเฉพาะบริการย่อยขนาดเล็กที่มีขอบเขต จำกัด เรียนรู้เพิ่มเติม
ข้อมูลรับรองเริ่มต้นของแอปพลิเคชัน - ให้การเข้าถึง Google API โดยอัตโนมัติโดยใช้ Google Cloud SDK สำหรับการพัฒนาในท้องถิ่นหรือ GCE Metadata Server สำหรับแอปพลิเคชันที่ปรับใช้กับแพลตฟอร์ม Google Cloud เรียนรู้เพิ่มเติม
ข้อมูลรับรองบัญชีบริการ - ในรูปแบบนี้แอปพลิเคชันของคุณจะพูดถึง Google API โดยตรงโดยใช้บัญชีบริการ มันมีประโยชน์เมื่อคุณมีแอปพลิเคชันแบ็กเอนด์ที่จะพูดคุยโดยตรงกับ Google API จากแบ็กเอนด์ เรียนรู้เพิ่มเติม

หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับไคลเอนต์การรับรองความถูกต้องดูที่ Google Auth Library

ไคลเอนต์ OAuth2

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

ในตัวอย่างต่อไปนี้คุณอาจต้องใช้ CLIENT_ID , CLIENT_SECRET และ REDIRECT_URL คุณสามารถค้นหาข้อมูลชิ้นส่วนเหล่านี้ได้โดยไปที่คอนโซลนักพัฒนาซอฟต์แวร์คลิกโครงการของคุณ -> APIS & Auth -> ข้อมูลรับรอง

นำทางไปยังคลาวด์คอนโซลและสร้างรหัสไคลเอนต์ OAuth2 ใหม่
เลือก Web Application สำหรับประเภทแอปพลิเคชัน
เพิ่ม URI ที่ได้รับอนุญาตด้วยค่า http://localhost:3000/oauth2callback (หรือค่าที่เกี่ยวข้องสำหรับสถานการณ์ของคุณ)
คลิก Create และ Ok บนหน้าจอต่อไปนี้
คลิกไอคอน Download ถัดจากรหัสไคลเอนต์ OAuth2 ที่สร้างขึ้นใหม่ของคุณ

ตรวจสอบให้แน่ใจว่าได้จัดเก็บไฟล์นี้ในที่ปลอดภัยและ อย่าตรวจสอบไฟล์นี้ลงในการควบคุมต้นทาง!

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับ OAUTH2 และวิธีการทำงานดูที่นี่

แอปพลิเคชั่นตัวอย่างที่สมบูรณ์ที่อนุญาตและตรวจสอบสิทธิ์กับไคลเอนต์ OAuth2 มีอยู่ที่ samples/oauth2.js

สร้าง URL การตรวจสอบสิทธิ์

ในการขอสิทธิ์จากผู้ใช้เพื่อดึงโทเค็นการเข้าถึงคุณเปลี่ยนเส้นทางไปยังหน้ายินยอม เพื่อสร้าง URL หน้ายินยอม:

 const {google} = ต้องการ ('googleapis'); const oauth2client = ใหม่ google.auth.oauth2 (
  your_client_id
  your_client_secret
  your_redirect_url); // สร้าง URL ที่ขออนุญาตสำหรับบล็อกเกอร์และ Google ปฏิทิน scopesconst scopes = [
  'https://www.googleapis.com/auth/blogger'
  'https://www.googleapis.com/auth/calendar'like;
  // 'ออนไลน์' (ค่าเริ่มต้น) หรือ 'ออฟไลน์' (รับ refresh_token)
  access_type: 'ออฟไลน์',

  // ถ้าคุณต้องการเพียงหนึ่งขอบเขตคุณสามารถผ่านมันเป็นสตริงได้
  ขอบเขต: ขอบเขต});

หมายเหตุสำคัญ - refresh_token จะถูกส่งคืนในการอนุญาตครั้งแรกเท่านั้น รายละเอียดเพิ่มเติมที่นี่

ดึงรหัสการอนุญาต

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

    GET /oauthcallback?code={authorizationCode}

ดึงโทเค็นการเข้าถึง

ด้วยรหัสที่ส่งคืนคุณสามารถขอโทเค็นการเข้าถึงได้ตามที่แสดงด้านล่าง:

 // สิ่งนี้จะให้วัตถุด้วย access_token และ refresh_token.// บันทึกสิ่งเหล่านี้ที่ปลอดภัยเหล่านี้เพื่อให้สามารถใช้ในเวลาต่อมา const {tokens} = รอ oauth2client.getToken (รหัส) oauth2client.setCredentials (tokens);

ด้วยข้อมูลประจำตัวที่ตั้งไว้ในไคลเอนต์ OAuth2 ของคุณ - คุณพร้อมที่จะไป!

การจัดการโทเค็นรีเฟรช

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

 oauth2client.on ('โทเค็น', (โทเค็น) => {
  if (tokens.refresh_token) {// เก็บ refresh_token ในฐานข้อมูลของฉัน! console.log (tokens.refresh_token);
  -
  console.log (tokens.access_token);});

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

ในการตั้ง refresh_token ในภายหลังคุณสามารถใช้วิธี setCredentials :

 oauth2client.setCredentials ({
  refresh_token: `stored_refresh_token`});

เมื่อลูกค้ามีโทเค็นรีเฟรชโทเค็นการเข้าถึงจะได้รับและรีเฟรชโดยอัตโนมัติในการโทรไปยัง API ครั้งต่อไป

การรีเฟรชโทเค็นอาจหยุดทำงานหลังจากที่ได้รับเพราะ::

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

ในฐานะนักพัฒนาคุณควรเขียนรหัสของคุณเพื่อจัดการกับกรณีที่โทเค็นรีเฟรชไม่ทำงานอีกต่อไป

ใช้ปุ่ม API

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

 const {google} = ต้องการ ('googleapis'); const blogger = google.blogger_v3 ({
  เวอร์ชัน: 'v3',
  รับรองความถูกต้อง: 'your_api_key' // ระบุคีย์ API ของคุณที่นี่}); const params = {
  blogid: '3213900'}; ฟังก์ชั่น async หลัก (params) {
  const res = รอ Blogger.blogs.get ({blogid: params.blogid});
  console.log (`$ {res.data.name} มี $ {res.data.posts.totalitems} โพสต์! URL บล็อกคือ $ {res.data.url}`)}; main () ข้อผิดพลาด);

หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับคีย์ API โปรดดูเอกสาร

แอปพลิเคชันข้อมูลประจำตัวเริ่มต้น

แทนที่จะสร้างไคลเอนต์ OAuth2 ไคลเอนต์ JWT หรือการคำนวณไคลเอนต์ด้วยตนเองไลบรารี Auth สามารถสร้างประเภทข้อมูลรับรองที่ถูกต้องสำหรับคุณขึ้นอยู่กับสภาพแวดล้อมที่รหัสของคุณทำงานอยู่ภายใต้

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

หากต้องการใช้ข้อมูลรับรองเริ่มต้นของแอปพลิเคชันในเครื่องด้วย Google Cloud SDK ให้เรียกใช้:

 $ GCloud Auth Application-Default Login

เมื่อทำงานใน GCP บริการจะให้บริการโดยอัตโนมัติผ่านเซิร์ฟเวอร์ Metadata GCE

 const {google} = ต้องการ ('googleapis'); const compute = google.compute ('v1'); ฟังก์ชั่น async main () {
  const auth = ใหม่ google.auth.googleauth ({// scopes สามารถระบุได้ว่าเป็นอาร์เรย์หรือเป็นสตริงเดี่ยวที่ตัดตอน
  -
  const authclient = รอ auth.getClient ();

  // รับรหัสโครงการปัจจุบัน
  Const Project = Await Auth.getProjectId ();

  // ดึงรายการโซน GCE ภายในโครงการ
  const res = รอ compute.zones.list ({Project, Auth: Authlient});
  console.log (res.data);} main (). catch (console.error);

ข้อมูลรับรองบัญชีบริการ

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

ไปที่หน้าสร้างคีย์บัญชีบริการบริการ
เลือก New Service Account ในแบบเลื่อนลง
คลิกปุ่ม Create

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

การใช้ `GOOGLE_APPLICATION_CREDENTIALS` env var

คุณสามารถเริ่มกระบวนการด้วยตัวแปรสภาพแวดล้อมที่ชื่อว่า GOOGLE_APPLICATION_CREDENTIALS ค่าของ env var นี้ควรเป็นเส้นทางเต็มไปยังไฟล์ข้อมูลรับรองบัญชีบริการ:

 $ google_application_credentials =./ของคุณ secret-key.json node server.js

ใช้คุณสมบัติ `keyFile`

หรือคุณสามารถระบุพา ธ ไปยังไฟล์ข้อมูลรับรองบัญชีบริการผ่านคุณสมบัติ keyFile ในตัวสร้าง GoogleAuth :

 const {google} = ต้องการ ('googleapis'); const auth = ใหม่ google.auth.googleauth ({
  KeyFile: '/path/to/your-secret-key.json'
  Scopes: ['https://www.googleapis.com/auth/cloud-platform'],});

การตั้งค่าการรับรองความถูกต้องระดับทั่วโลกหรือระดับบริการ

คุณสามารถตั้ง auth เป็นตัวเลือกระดับโลกหรือระดับบริการดังนั้นคุณไม่จำเป็นต้องระบุทุกคำขอ ตัวอย่างเช่นคุณสามารถตั้ง auth เป็นตัวเลือกส่วนกลาง:

 const {google} = ต้องการ ('googleapis'); const oauth2client = ใหม่ google.auth.oauth2 (
  your_client_id
  your_client_secret
  your_redirect_url); // set auth เป็น global default google.options ({{{
  auth: oauth2client});

แทนที่จะตั้งค่าตัวเลือกทั่วโลกคุณสามารถตั้งค่าไคลเอนต์การตรวจสอบความถูกต้องได้ในระดับบริการ:

 const {google} = ต้องการ ('googleapis'); const oauth2client = ใหม่ google.auth.oauth2 (
  your_client_id
  your_client_secret
  your_redirect_url); const drive = google.drive ({
  เวอร์ชัน: 'v2',
  auth: oauth2client});

ดูส่วนตัวเลือกสำหรับข้อมูลเพิ่มเติม

การใช้งาน

ระบุตัวตน

มีการระบุเนื้อหาของคำขอในวัตถุพารามิเตอร์ requestBody ของคำขอ ร่างกายถูกระบุเป็นวัตถุ JavaScript ที่มีคู่คีย์/ค่า ตัวอย่างเช่นตัวอย่างนี้สร้างผู้เฝ้าดูที่โพสต์การแจ้งเตือนไปยังหัวข้อ Google Cloud Pub/Sub เมื่อส่งอีเมลไปยังบัญชี Gmail:

 const res = รอ gmail.users.watch ({
  userid: 'ฉัน',
  requestbody: {// แทนที่ด้วย `projects/$ {project_id}/หัวข้อ/$ {topic_name}` topicName: `Projects/el-gato/topics/gmail`
  }}); console.log (res.data);

อัปโหลดสื่อ

ไคลเอนต์นี้รองรับการอัปโหลดสื่อหลายส่วน พารามิเตอร์ทรัพยากรถูกระบุในวัตถุพารามิเตอร์ requestBody และสื่อนั้นถูกระบุในพารามิเตอร์ media.body ที่มีประเภท MIME ที่ระบุใน media.mimeType

ตัวอย่างนี้อัปโหลดไฟล์ข้อความธรรมดาไปยัง Google Drive พร้อมชื่อ "ทดสอบ" และเนื้อหา "Hello World"

 const drive = google.drive ({
  เวอร์ชัน: 'v3',
  auth: oauth2client}); const res = รอ drive.files.create ({{{
  requestbody: {name: 'test', mimetype: 'text/plain'
  -
  สื่อ: {mimetype: 'text/plain', body: 'Hello World'
  -

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

 const fs = ต้องการ ('fs'); const drive = google.drive ({
  เวอร์ชัน: 'v3',
  auth: oauth2client}); ฟังก์ชั่น async main () {
  const res = รอ drive.files.create ({requestbody: {ชื่อ: 'testimage.png', mimetype: 'image/png'}, สื่อ: {mimetype: 'image/png', body: fs.createReadStream ('น่ากลัว .png ')}
  -
  console.log (res.data);} main (). catch (console.error);

สำหรับตัวอย่างเพิ่มเติมของคำขอการสร้างและการปรับเปลี่ยนที่มีเอกสารแนบสื่อลองดูตัวอย่าง samples/drive/upload.js

ตัวเลือกขอ

สำหรับการควบคุมที่ปรับแต่งได้ดีขึ้นเกี่ยวกับวิธีการโทร API ของคุณเราให้ความสามารถในการระบุตัวเลือกเพิ่มเติมที่สามารถนำไปใช้โดยตรงกับวัตถุ 'Gaxios' ที่ใช้ในไลบรารีนี้เพื่อทำการโทรเครือข่ายไปยัง API

คุณอาจระบุตัวเลือกเพิ่มเติมไม่ว่าจะในวัตถุ google Global หรือบนพื้นฐานของบริการไคลเอนต์ ตัวเลือกที่คุณระบุจะถูกแนบไปกับวัตถุ gaxios ดังนั้นสิ่งที่ gaxios รองรับไลบรารีนี้รองรับ นอกจากนี้คุณยังสามารถระบุพารามิเตอร์การร้องขอทั่วโลกหรือต่อบริการที่จะแนบกับการโทร API ทั้งหมดที่คุณทำ

รายการตัวเลือกที่รองรับทั้งหมดสามารถดูได้ที่นี่

ตัวเลือกทั่วโลก

คุณสามารถเลือกตัวเลือกเริ่มต้นที่จะส่งด้วยแต่ละคำขอ ตัวเลือกเหล่านี้จะถูกใช้สำหรับทุกบริการที่สร้างอินสแตนซ์โดย Google ไคลเอนต์ ในตัวอย่างนี้คุณสมบัติ timeout ของ GaxiosOptions จะถูกตั้งค่าสำหรับทุกคำขอ:

 const {google} = ต้องการ ('googleapis'); google.options ({
  // คำขอทั้งหมดที่ทำกับวัตถุนี้จะใช้การตั้งค่าเหล่านี้เว้นแต่จะถูกแทนที่
  หมดเวลา: 1,000
  รับรองความถูกต้อง: auth});

นอกจากนี้คุณยังสามารถแก้ไขพารามิเตอร์ที่ส่งด้วยแต่ละคำขอ:

 const {google} = ต้องการ ('googleapis'); google.options ({
  // คำขอทั้งหมดจากบริการทั้งหมดจะมีพารามิเตอร์แบบสอบถามข้างต้น
  // เว้นแต่จะถูกแทนที่ทั้งในไคลเอนต์บริการหรือในการโทร API แต่ละรายการ
  params: {quotauser: '[email protected]'
  -

ตัวเลือกบริการลูกค้า

คุณยังสามารถระบุตัวเลือกเมื่อสร้างไคลเอนต์บริการ

 const Blogger = google.blogger ({
  เวอร์ชัน: 'v3',
  // คำขอทั้งหมดที่ทำกับวัตถุนี้จะใช้การรับรองความถูกต้องที่ระบุ
  Auth: 'API Key';});

ด้วยการทำเช่นนี้การโทร API ทุกครั้งที่ทำกับไคลเอนต์บริการนี้จะใช้ 'API KEY' เพื่อตรวจสอบสิทธิ์

หมายเหตุ: ไคลเอนต์ที่สร้างขึ้นนั้น ไม่เปลี่ยนรูป ดังนั้นคุณต้องสร้างไคลเอนต์ใหม่หากคุณต้องการระบุตัวเลือกที่แตกต่างกัน

คล้ายกับตัวอย่างด้านบนคุณยังสามารถแก้ไขพารามิเตอร์ที่ใช้สำหรับการโทรทุกครั้งของบริการที่กำหนด:

 const Blogger = google.blogger ({
  เวอร์ชัน: 'v3',
  // คำขอทั้งหมดที่ทำกับไคลเอนบริการนี้จะมีไฟล์
  // พารามิเตอร์การสืบค้น Blogid เว้นแต่จะถูกแทนที่ในการโทร API แต่ละรายการ
  params: {blogid: '3213900'
  }}); // การโทรด้วยไคลเอนต์ไดรฟ์นี้จะไม่มีพารามิเตอร์การสืบค้นบล็อก Drive = google.drive ('v3'); ...

ตัวเลือกระดับคำขอ

คุณสามารถระบุวัตถุ auth ที่จะใช้ต่อคำขอ แต่ละคำขอยังสืบทอดตัวเลือกที่ระบุในระดับบริการและระดับโลก

ตัวอย่างเช่น:

 const {google} = ต้องการ ('googleapis'); const bigQuery = google.bigQuery ('v2'); ฟังก์ชั่น async main () {

  // วิธีนี้ค้นหา gcloud_project และ google_application_credentials
  // ตัวแปรสภาพแวดล้อม
  const auth = ใหม่ google.auth.googleauth ({scopes: ['https://www.googleapis.com/auth/cloud-platform'
  -
  const authclient = รอ auth.getClient ();

  const projectId = รอ auth.getProjectId ();

  const request = {projectId, dataSetId: '<your_dataset_id>', // นี่คือตัวเลือก "คำขอระดับ": AuthClient
  -

  const res = รอ bigQuery.datasets.delete (คำขอ);
  console.log (res.data);} main (). catch (console.error);

นอกจากนี้คุณยังสามารถแทนที่ตัวเลือก Gaxios ต่อคำขอเช่น url method และ responseType

ตัวอย่างเช่น:

 const res = รอ Drive.files.export ({
  FileId: 'ASXKJOD9S79', // Google DOC
  mimetype: 'application/pdf'}, {
  // ตรวจสอบให้แน่ใจว่าเราได้รับข้อมูลไบนารี
  Responsetype: 'สตรีม'});

ใช้พร็อกซี

คุณสามารถใช้ตัวแปรสภาพแวดล้อมต่อไปนี้กับคำขอ HTTP และ HTTPS PROXY:

HTTP_PROXY / http_proxy
HTTPS_PROXY / https_proxy

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

รับ APIs ที่ได้รับการสนับสนุน

คุณสามารถรับรายการ API ที่รองรับได้โดยทางโปรแกรมและเวอร์ชันที่มีทั้งหมด:

 const {google} = ต้องการ ('googleapis'); const apis = google.getsupportedapis ();

สิ่งนี้จะส่งคืนวัตถุด้วยชื่อ API เป็นชื่อคุณสมบัติวัตถุและอาร์เรย์ของสตริงเวอร์ชันเป็นค่าวัตถุ

ตัวพิมพ์ใหญ่

ไลบรารีนี้เขียนด้วย TypeScript และจัดเตรียมประเภทออกจากกล่อง คลาสและอินเทอร์เฟซทั้งหมดที่สร้างขึ้นสำหรับแต่ละ API จะถูกส่งออกภายใต้ Namespace ${apiName}_${version} namespace ตัวอย่างเช่นประเภทไดรฟ์ V3 API มีให้บริการทั้งหมดจากเนมสเปซ drive_v3 :

 นำเข้า {
  Google, // วัตถุระดับบนสุดที่ใช้ในการเข้าถึงบริการ
  drive_v3, // สำหรับไคลเอนต์บริการทุกรายมีเนมสเปซที่ส่งออก
  รับรองความถูกต้อง // เนมสเปซสำหรับประเภทที่เกี่ยวข้องกับการรับรองความถูกต้อง
  Common, // ประเภททั่วไปที่ใช้ตลอดห้องสมุด} จาก 'googleapis'; // หมายเหตุ: การใช้ประเภทที่ชัดเจนเช่น `auth.googleauth` อยู่ที่นี่เท่านั้นสำหรับวัตถุประสงค์ // การสาธิต  โดยทั่วไปด้วย typeScript ประเภทเหล่านี้จะ // emferred.const auth: auth.googleuth = ใหม่ google.auth.googleuth (); const drive: drive_v3.drive = google.drive ({{{
  เวอร์ชัน: 'v3',
  auth,}); // มีประเภทที่สร้างขึ้นสำหรับทุกชุดของชุดคำขอพารามิเตอร์ ListParams: drive_v3.params $ ทรัพยากร $ files $ list = {}; const res = รอ drive.files.list (listparams); // มีการสร้าง ประเภทสำหรับฟิลด์การตอบสนองเช่นเดียวกับ listresults: drive_v3.schema $ filelist = res.data;

http/2

ไลบรารีนี้มีการสนับสนุน HTTP/2 ในการเปิดใช้งานให้ใช้ตัวเลือก http2 ทุกที่ที่ยอมรับพารามิเตอร์คำขอ:

 const {google} = ต้องการ ('googleapis'); google.options ({
  http2: true,});

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

บันทึกย่อและการเปลี่ยนแปลงที่แตกหัก

คุณสามารถค้นหารายละเอียดของการเปลี่ยนแปลงการทำลายและคุณสมบัติใหม่ในบันทึกย่อของเรา หากคุณใช้ไลบรารีนี้ก่อน 25.x ให้ดูบันทึกย่อของเราเพื่อเรียนรู้เกี่ยวกับการย้ายรหัสของคุณจาก 24.xx ถึง 25.xx มันค่อนข้างง่าย :)