דף זה תורגם על ידי Cloud Translation API.

פיתוח אפליקציית אינטרנט עם גישה למכשירים

1. מבוא

תוכנית הגישה למכשירים מספקת את Smart Device Management API – API ל-REST שמאפשר למפתחים לשלוט במכשירי Google Nest מהאפליקציות שלהם. המשתמשים צריכים להביע הסכמה לגישה של צד שלישי למכשירי Nest שלהם.

יש שלושה שלבים עיקריים לשילוב מוצלח של 'גישה למכשירים':

יצירת פרויקט – יצירת פרויקט ב-Google Cloud Platform והרשמה כמפתח במסוף הגישה למכשירים.
קישור חשבונות – אפשר לספק למשתמשים הוראות לקישור חשבונות ולקבל קוד גישה. להחליף את הקוד באסימון גישה.
Device Control – שליחת בקשות של Smart Device Management API לשליטה במכשירים על ידי שליחת פקודות עם אסימון הגישה.

בשיעור הזה של Codelab נתעמק במידע על האופן שבו 'גישה למכשירים' פועלת, על ידי בניית אפליקציית אינטרנט לטיפול באימות וביצוע קריאות ל-Smart Device Management API. נבדוק גם פריסה של שרת proxy פשוט באמצעות Node.js ו-Express, כדי לנתב את בקשות הגישה למכשירים.

לפני שמתחילים, מומלץ לרענן את הידע שלכם על טכנולוגיות אינטרנט נפוצות שבהן נשתמש ב-Codelab הזה, כמו אימות באמצעות OAuth 2.0 או בניית אפליקציית אינטרנט באמצעות Node.js, למרות שהן לא דרישות מוקדמות.

הפרטים הדרושים

Node.js מגרסה 8 ואילך
חשבון Google שמקושר אליו Nest Thermostat

הנושאים שתלמד

הגדרה של פרויקט Firebase שמארח דפי אינטרנט סטטיים ופונקציות בענן
שליחת בקשות גישה למכשירים דרך אפליקציית אינטרנט מבוססת דפדפן
בניית שרת proxy באמצעות Node.js ו-Express לניתוב הבקשות שלך

2. יצירת פרויקט

כדי להגדיר שילוב של גישה למכשירים, מפתחים צריכים ליצור פרויקט ב-Google Cloud Platform (GCP). מזהה לקוח וסוד לקוח שנוצרו בתוך הפרויקט ב-GCP ישמשו כחלק מתהליך ה-OAuth בין האפליקציה של המפתח לבין Google Cloud. המפתחים צריכים גם להיכנס ל-Device Access Console כדי ליצור פרויקט לצורך גישה ל-Smart Device Management API.

Google Cloud Platform

נכנסים אל Google Cloud Platform. לוחצים על 'יצירת פרויקט חדש' ונותנים שם לפרויקט. יוצג גם מזהה פרויקט [GCP-Project-Id] ל-Google Cloud. צריך לתעד אותו, כי נשתמש בו במהלך ההגדרה של Firebase. (ב-Codelab הזה נתייחס למזהה הזה בתור [GCP-Project-Id].)

השלב הראשון הוא להפעיל בפרויקט שלנו את ספריית ה-API הנדרשת. עוברים אל APIs & Services > Library (ספרייה) ומחפשים את Smart Device Management API. כדי לאפשר לפרויקט לשלוח בקשות לקריאות ל-Device Access API, צריך להפעיל את ה-API הזה.

לפני שנעבור ליצירת פרטי כניסה ל-OAuth, עלינו להגדיר את מסך ההסכמה ל-OAuth עבור הפרויקט שלנו. עוברים אל APIs & Services (ממשקי API ושירותים > מסך הסכמה ל-OAuth). בשדה סוג משתמש, בוחרים באפשרות חיצוני. נותנים לאפליקציה שם וכתובת אימייל לתמיכה, וגם פרטים ליצירת קשר עם המפתח כדי להשלים את המסך הראשון. כשמופיעה בקשה למשתמשי בדיקה, יש להקפיד לספק את כתובת האימייל עם המכשירים המקושרים בשלב הזה.

אחרי שמגדירים את מסך ההסכמה של OAuth, עוברים אל APIs & Services > Credentials. לוחצים על +Create Credentials (יצירת פרטי כניסה) ובוחרים באפשרות OAuth client ID (מזהה לקוח OAuth). בשדה 'סוג האפליקציה', בוחרים באפשרות אפליקציית אינטרנט.

נותנים שם ללקוח ולוחצים על יצירה. בהמשך נוסיף מקור JavaScript מורשה ו-URI מורשה להפניה אוטומטית. השלמת התהליך הזה תציג את [Client-Id] ואת [Client-Secret] שמשויכים ללקוח OAuth 2.0 הזה.

מסוף הגישה למכשירים

עוברים אל מסוף הגישה למכשירים. אם לא השתמשת בעבר ב-Device Access Console, הסכם התנאים וההגבלות יתווסף ל-Google Play ותחויב בדמי רישום בסך 5$.

יוצרים פרויקט חדש ונותנים לו שם לפרויקט. בחלון הבא, מציינים את [Client-Id] שקיבלתם מ-GCP בשלב הקודם.

הפעלת האירועים והשלמת השלבים ליצירת פרויקט יעבירו אתכם לדף הבית של הפרויקט. הפרויקט [Project-Id] יופיע מתחת לשם שנתתם לפרויקט.

לתשומת ליבך, מזהה הפרויקט [Project-Id] ישמש אותנו לשליחת בקשות ל-Smart Device Management API.

3. הגדרת Firebase

פלטפורמת Firebase מספקת למפתחים דרך מהירה וקלה לפרוס אפליקציות אינטרנט. אנחנו מתכוונים לפתח אפליקציית אינטרנט בצד הלקוח לשילוב של 'גישה למכשירים' באמצעות Firebase.

יצירת פרויקט Firebase

נכנסים אל מסוף Firebase. לוחצים על Add Project (הוספת פרויקט) ובוחרים את הפרויקט שיצרתם בשלב Project Creation. הפעולה הזו תיצור פרויקט Firebase שיקושר לפרויקט GCP- [GCP-Project-Id].

אחרי שתיצרו את פרויקט Firebase בהצלחה, אמור להופיע המסך הבא:

התקנת הכלים של Firebase

פלטפורמת Firebase מספקת קבוצת כלי CLI ליצירה ולפריסה של האפליקציה. כדי להתקין את הכלים האלה, צריך לפתוח חלון טרמינל חדש ולהריץ את הפקודה הבאה. הפעולה הזו תתקין את הכלים של Firebase באופן גלובלי.

$ npm i -g firebase-tools

כדי לוודא שהכלים של Firebase מותקנים כמו שצריך, צריך לבדוק את פרטי הגרסה.

$ firebase --version

אתם יכולים להתחבר לכלים של ה-CLI של Firebase באמצעות חשבון Google באמצעות פקודת ההתחברות.

$ firebase login

אתחול פרויקט אירוח

לאחר שהצלחת להתחבר, השלב הבא הוא להפעיל פרויקט אירוח עבור אפליקציית האינטרנט. מהמסוף, נכנסים לתיקייה שבה רוצים ליצור את הפרויקט ומריצים את הפקודה הבאה:

$ firebase init hosting

כדי להתחיל לעבוד עם פרויקט אירוח, יוצגו לכם מ-Firebase כמה שאלות לגבי תחילת העבודה:

יש לבחור אפשרות – שימוש בפרויקט קיים
בוחרים פרויקט ברירת מחדל ב-Firebase לספרייה הזו — בוחרים***[GCP-Project-Id]***
במה ברצונך להשתמש כספרייה הציבורית שלך? – ציבורי
להגדיר כאפליקציה בדף יחיד? – כן
להגדיר יצירה ופריסות אוטומטיות באמצעות GitHub? – לא

אחרי אתחול הפרויקט, אפשר לפרוס אותו ב-Firebase באמצעות הפקודה הבאה:

$ firebase deploy

מערכת Firebase תסרוק את הפרויקט ותפרוס את הקבצים הנחוצים לאירוח בענן.

כשתפתחו את כתובת ה-URL לאירוח בדפדפן, תראו את הדף שיצרתם:

עכשיו, אחרי שהבנתם את העקרונות הבסיסיים של פריסת דף אינטרנט באמצעות Firebase, הגיע הזמן להתחיל לפרוס את הדוגמה של Codelab!

4. דוגמה ל-Codelab

אפשר לשכפל את מאגר Codelab שמתארח ב-GitHub באמצעות הפקודה הבאה:

$ git clone https://github.com/google/device-access-codelab-web-app.git

במאגר הזה אנחנו מספקים דוגמאות בשתי תיקיות נפרדות. התיקייה codelab-start כוללת את הקבצים הנחוצים כדי לעזור לך להתחיל מהנקודה הנוכחית ב-Codelab הזה. התיקייה codelab-done מכילה גרסה מלאה של ה-Codelab הזה, עם הלקוח שכולל את כל הפעולות של הלקוח ושרת ה-net.js.

נשתמש בקבצים מהתיקייה codelab-start במהלך ה-Codelab הזה, אבל אם בכל שלב תרגיש תקוע, אפשר להיעזר גם בגרסה של Codelab.

קבצים לדוגמה של Codelab

מבנה הקובץ של תיקיית codelab-start הוא:

public
├───index.html
├───scripts.js
├───style.css
firebase.json

התיקייה הציבורית מכילה דפים סטטיים של האפליקציה שלנו. firebase.json אחראי לניתוב בקשות אינטרנט לאפליקציה שלנו. בגרסה codelab-done, רואים גם את הספרייה functions שכוללת לוגיקה של שרת proxy (אקספרס) לפריסה בפונקציות של Google Cloud.

פריסה של Codelab לדוגמה

מעתיקים את הקבצים מהתיקייה codelab-start לספרייה של הפרויקט.

$ firebase deploy

כשמסתיימת הפריסה של Firebase, אתם אמורים לראות את האפליקציה Codelab:

כדי להתחיל את תהליך האימות יש צורך בפרטי כניסה של שותף, שבהם נעסוק בקטע הבא.

5. טיפול ב-OAuth

OAuth הוא תקן האינטרנט להאצלת גישה, המשמש בדרך כלל למשתמשים כדי להעניק לאפליקציות צד שלישי גישה לפרטי החשבון שלהם בלי לשתף סיסמאות. אנחנו משתמשים ב-OAuth 2.0 כדי לאפשר למפתחים לגשת למכשירים של משתמשים באמצעות 'גישה למכשירים'.

ציון URI של כתובת אתר להפניה מחדש

השלב הראשון בתהליך OAuth כולל העברה של קבוצת פרמטרים לנקודת הקצה של OAuth 2.0 של Google. לאחר קבלת הסכמת המשתמש, שרתי OAuth של Google ישלחו בקשה עם קוד הרשאה ל-URI להפניה אוטומטית.

מעדכנים את הקבוע SERVER_URI (שורה 19) בכתובת URL מארחת משלכם ב-scripts.js:

const SERVER_URI = "https://[GCP-Project-Id].web.app";

פריסה מחדש של האפליקציה עם השינוי הזה תעדכן את ה-URI של ההפניה האוטומטית שנעשה בו שימוש בפרויקט שלך.

$ firebase deploy

הפעל URI להפניה מחדש

לאחר שתעדכנו את ה-URI של ההפניה האוטומטית בקובץ הסקריפטים, עליכם להוסיף אותו גם לרשימה של מזהי ה-URI המותרים להפניה אוטומטית עבור מזהה הלקוח שיצרתם לפרויקט. נכנסים לדף פרטי הכניסה ב-Google Cloud Platform כדי לראות את כל פרטי הכניסה שנוצרו לפרויקט שלכם:

ברשימה של מזהי לקוחות ב-OAuth 2.0, בוחרים את מספר הלקוח שיצרתם בשלב יצירת פרויקט. מוסיפים את ה-URI להפניה אוטומטית של האפליקציה לרשימה מזהי URI של הפניות אוטומטיות בפרויקט.

כדאי לנסות להיכנס!

עוברים אל כתובת ה-URL לאירוח שהגדרתם באמצעות Firebase, מזינים את פרטי הכניסה של השותף ולוחצים על הלחצן כניסה. מזהה לקוח וסוד לקוח הם פרטי הכניסה שקיבלתם מ-Google Cloud Platform. מזהה הפרויקט הוא מ-Device Access Console.

הלחצן כניסה יעביר את המשתמשים שלך דרך תהליך OAuth בארגון, ממסך ההתחברות לחשבון Google שלהם. לאחר ההתחברות, המשתמשים יתבקשו להעניק הרשאות לפרויקט שלך כדי לגשת למכשירי Nest שלהם.

מכיוון שזו אפליקציה לדוגמה, Google תציג אזהרה לפני שליחת הפניה לכתובת אחרת.

צריך ללחוץ על 'מתקדם' ולבחור באפשרות 'מעבר אל web.app (לא בטוח)' כדי להשלים את ההפניה לאפליקציה.

הפעולה הזו תספק קוד OAuth כחלק מבקשת ה-GET הנכנסת, והאפליקציה תחליף אסימון גישה ואסימון רענון.

6. בקרת מכשיר

באפליקציה לדוגמה של 'גישה למכשירים' נעשה שימוש בקריאות ל-API ל-REST של ניהול מכשירים חכמים כדי לשלוט במכשירי Google Nest. הקריאות האלה כוללות העברה של אסימון הגישה בכותרת של בקשת GET או POST, לצד מטען ייעודי (payload) שנדרש לפקודות מסוימות.

כתבנו פונקציה כללית לבקשת גישה כדי לטפל בקריאות האלה. עם זאת, צריך לספק לפונקציה הזו את נקודת הקצה הנכונה, וכן את אובייקט המטען הייעודי (payload) במקרה הצורך.

function deviceAccessRequest(method, call, localpath, payload = null) {...}

method — סוג בקשת ה- HTTP (GET או POST))
call — מחרוזת שמייצגת את הקריאה ל-API, שמשמשת לניתוב תגובות (listDevices, thermostatMode, temperatureSetpoint)
localpath – נקודת הקצה שאליה נשלחת הבקשה, ומכילה מזהה פרויקט ומזהה מכשיר (שמצורפת אחרי https://smartdevicemanagement.googleapis.com/v1)
מטען ייעודי (payload) (*) — נתונים נוספים הנדרשים לקריאה ל-API (לדוגמה, ערך מספרי שמייצג טמפרטורה של נקודה קבועה)

אנחנו ניצור פקדים לדוגמה בממשק המשתמש (רשימת מכשירים, מצב הגדרה, הטמפרטורה שהוגדרה) לשליטה ב-Nest Thermostat:

הפקדים האלה בממשק המשתמש יקראו לפונקציות המתאימות (listDevices(), postThermostatMode(), postTemperatureSetpoint()) החל מ-scripts.js. הם נותרו ריקים כדי שתוכל ליישם! המטרה היא לבחור את השיטה או הנתיב הנכונים ולהעביר את המטען הייעודי (payload) לפונקציה deviceAccessRequest(...).

הצגת רשימה של מכשירים

השיחה הפשוטה ביותר עם גישה למכשיר היא listDevices. הוא משתמש בבקשת GET ולא דורש מטען ייעודי (payload). צריך לבנות את נקודת הקצה באמצעות projectId. השלם את הפונקציה listDevices() באופן הבא:

function listDevices() {
  var endpoint = "/enterprises/" + projectId + "/devices";
  deviceAccessRequest('GET', 'listDevices', endpoint);
}

שומרים את השינויים ופורסים שוב את פרויקט Firebase באמצעות הפקודה הבאה:

$ firebase deploy

לאחר פריסת הגרסה החדשה של האפליקציה, יש לנסות לטעון מחדש את הדף וללחוץ על רשימת מכשירים. הפעולה הזו אמורה לאכלס את הרשימה בקטע 'בקרת מכשיר', שבה אמור להופיע מזהה התרמוסטט:

בחירת מכשירים מהרשימה תעדכן את השדה deviceId בקובץ scripts.js. בשני הפקדים הבאים נצטרך לציין את deviceId של המכשיר הספציפי שבו אנחנו רוצים לשלוט.

בקרת תרמוסטט

יש שתי תכונות לשליטה בסיסית ב-Nest Thermostat ב-Smart Device Management API. ThermostatMode ו-TemperatureSetpoint. ThermostatMode מגדיר את המצב של Nest Thermostat לאחד מארבעת המצבים האפשריים הבאים: {כיבוי, חימום, קירור, חימום, קירור}. לאחר מכן נצטרך לספק את המצב שנבחר כחלק ממטען הייעודי (payload).

צריך להחליף את הפונקציה postThermostatMode() שבscripts.js באופן הבא:

function postThermostatMode() {
  var endpoint = "/enterprises/" + projectId + "/devices/" + deviceId + ":executeCommand";
  var tempMode = id("tempMode").value;
  var payload = {
    "command": "sdm.devices.commands.ThermostatMode.SetMode",
    "params": {
      "mode": tempMode
    }
  };
  deviceAccessRequest('POST', 'thermostatMode', endpoint, payload);
}

הפונקציה הבאה, postTemperatureSetpoint(), מטפלת בהגדרת הטמפרטורה (בצלזיוס) של Nest Thermostat. יש שני פרמטרים שאפשר להגדיר במטען הייעודי (payload), heatCelsius ו-coolCelsius, בהתאם למצב התרמוסטט שנבחר.

function postTemperatureSetpoint() {
  var endpoint = "/enterprises/" + projectId + "/devices/" + deviceId + ":executeCommand";
  var heatCelsius = parseFloat(id("heatCelsius").value);
  var coolCelsius = parseFloat(id("coolCelsius").value);

  var payload = {
    "command": "",
    "params": {}
  };
  
  if ("HEAT" === id("tempMode").value) {
    payload.command = "sdm.devices.commands.ThermostatTemperatureSetpoint.SetHeat";
    payload.params["heatCelsius"] = heatCelsius;
  }
  else if ("COOL" === id("tempMode").value) {
    payload.command = "sdm.devices.commands.ThermostatTemperatureSetpoint.SetCool";
    payload.params["coolCelsius"] = coolCelsius;
  }
  else if ("HEATCOOL" === id("tempMode").value) {
    payload.command = "sdm.devices.commands.ThermostatTemperatureSetpoint.SetRange";
    payload.params["heatCelsius"] = heatCelsius;
    payload.params["coolCelsius"] = coolCelsius;
  } else {
    console.log("Off and Eco mode don't allow this function");
    return;
  }
  deviceAccessRequest('POST', 'temperatureSetpoint', endpoint, payload);
}

7. שרת Node.js (אופציונלי)

כל הכבוד! פיתחתם אפליקציית אינטרנט בצד הלקוח שיכולה לשלוח בקשות של Smart Device Management API מדפדפן. אם אתם רוצים לבצע בנייה בצד של השרת, אנחנו רוצים לזרז את התהליך עם שרת proxy שיכול להפנות את הבקשות שלכם מהדפדפן.

בשביל שרת ה-proxy הזה נשתמש בפונקציות בענן של Firebase, ב-Node.js וב-Express.

הפעלה של Cloud Functions

פותחים חלון טרמינל חדש, מנווטים לספריית הפרויקט ומריצים את הפקודה הבאה:

$ firebase init functions

תוצג לכם ב-Firebase רשימת שאלות כדי להפעיל פונקציות ב-Cloud:

באיזו שפה היית רוצה לכתוב את ה-Cloud Functions? — JavaScript
רוצה להשתמש ב-ESLint כדי לאתר באגים אפשריים ולאכוף סגנון? — לא
רוצה להתקין עכשיו יחסי תלות עם npm? – כן

הפעולה הזו תפעיל את התיקייה functions בפרויקט שלך ותתקין את יחסי התלות הנדרשים. תראו שתיקיית הפרויקט מכילה ספריית פונקציות, עם קובץ index.js שמגדיר את הפונקציות ב-Cloud, package.json כדי לקבוע את ההגדרות וספריית node_modules שתכיל את יחסי התלות.

כדי לבנות את הפונקציונליות בצד השרת, נשתמש בשתי ספריות npm: express ו-xmlhttprequest. צריך להוסיף את הרשומות הבאות לרשימת יחסי התלות בקובץ package.json:

"xmlhttprequest": "^1.8.0",
"express": "^4.17.0"

לאחר מכן, הרצת התקנה של npm מספריית הפונקציות אמורה להתקין יחסי תלות בפרויקט:

$ npm install

אם יש בעיה בהורדת חבילות ב-npm, אפשר לנסות לשמור את הקובץ xmlhttprequest ולהביע אקספרס באופן מפורש באמצעות הפקודה הבאה:

$ npm install express xmlhttprequest --save

שדרוג לתוכנית Blaze

כדי להשתמש בפקודה firebase deploy, יהיה עליך לשדרג לתוכנית Blaze. לשם כך, עליך להוסיף אמצעי תשלום לחשבון. עוברים אל סקירת הפרויקט > שימוש וחיוב ומקפידים לבחור את תוכנית Blaze לפרויקט שלכם.

Build Express Server

שרת Express פועל לפי מסגרת פשוטה שמגיבה לבקשות נכנסות של GET ו-POST. יצרנו שרת proxy שמאזין לבקשות של POST, מעביר אותן לכתובת היעד שצוינה במטען הייעודי (payload) ומגיב בתגובה שמתקבלת מההעברה.

משנים את הקובץ index.js בספריית הפונקציות כך:

const XMLHttpRequest = require("xmlhttprequest").XMLHttpRequest;
const functions = require('firebase-functions');
const express = require('express');
const http = require('http');

const app = express();
app.use(express.json());


//***** Device Access - Proxy Server *****//

// Serving Get Requests (Not used) 
app.get('*', (request, response) => {
  response.status(200).send("Hello World!");
});
// Serving Post Requests
app.post('*', (request, response) => {
  
  setTimeout(() => {
    // Read the destination address from payload:
    var destination = request.body.address;
    
    // Create a new proxy post request:
    var xhr = new XMLHttpRequest();
    xhr.open('POST', destination);
    
    // Add original headers to proxy request:
    for (var key in request.headers) {
            var value = request.headers[key];
      xhr.setRequestHeader(key, value);
    }
    
    // Add command/parameters to proxy request:
    var newBody = {};
    newBody.command = request.body.command;
    newBody.params = request.body.params;
    
    // Respond to original request with the response coming
    // back from proxy request (to Device Access Endpoint)
    xhr.onload = function () {
      response.status(200).send(xhr.responseText);
    };
    
    // Send the proxy request!
    xhr.send(JSON.stringify(newBody));
  }, 1000);
});

// Export our app to firebase functions:
exports.app = functions.https.onRequest(app);

כדי לנתב בקשות לשרת שלנו, אנחנו צריכים לשנות את השכתובים מ-firebase.json באופן הבא:

{
  "hosting": {
    "public": "public",
    "ignore": [
      "firebase.json",
      "**/.*",
      "**/node_modules/**"
    ],
    "rewrites": [{
        "source": "/proxy**",
        "function": "app"
      },{
        "source": "**",
        "destination": "/index.html"
      }
    ]
  }
}

הפעולה הזו תנתב כתובות URL שמתחילות ב-/proxy לשרת ה-Express שלנו, ושאר הכתובות ימשיכו לעבור אל index.html.

קריאות ל-API מסוג Proxy

עכשיו, לאחר שהשרת שלנו מוכן, נגדיר URI של שרת proxy ב-scripts.js כך שהדפדפן שלנו ישלח בקשות לכתובת זו:

const PROXY_URI = SERVER_URI + "/proxy";

אחר כך צריך להוסיף את הפונקציה proxyRequest היא scripts.js, שהחתימה שלה זהה לחתימה של הפונקציה deviceAccessRequest(...), לקריאות עקיפות מסוג 'גישה למכשיר'.

function proxyRequest(method, call, localpath, payload = null) {
    var xhr = new XMLHttpRequest();
    
    // We are doing our post request to our proxy server:
    xhr.open(method, PROXY_URI);
    xhr.setRequestHeader('Authorization', 'Bearer ' + accessToken);
    xhr.setRequestHeader('Content-Type', 'application/json;charset=UTF-8');
    xhr.onload = function () {
      // Response is passed to deviceAccessResponse function:
      deviceAccessResponse(call, xhr.response);
    };
    
    // We are passing the device access endpoint in address field of the payload:
    payload.address = "https://smartdevicemanagement.googleapis.com/v1" + localpath;
    if ('POST' === method && payload)
        xhr.send(JSON.stringify(payload));
    else
        xhr.send();
}

בשלב האחרון, צריך להחליף את הקריאות deviceAccessRequest(...) בפונקציה proxyRequest(...), בפונקציות postThermostatMode() ו-postTemperatureSetpoint() בתוך scripts.js.

מריצים את הפקודה firebase deploy כדי לעדכן את האפליקציה.

$ firebase deploy

עכשיו יש לך שרת proxy פעיל של Node.js ומשתמש ב-Express on Cloud Functions.

מתן הרשאות לפונקציות ב-Cloud Functions

השלב האחרון הוא לבדוק את הרשאות הגישה לפונקציות ב-Cloud ולוודא שהאפליקציה בצד הלקוח תוכל להפעיל אותן.

מ-Google Cloud Platform, נכנסים לכרטיסייה Cloud Functions מהתפריט ובוחרים את הפונקציה ב-Cloud Functions:

לוחצים על Permissions ואז על Add Member (הוספת חבר). כותבים allUsers לשדה החבר החדש ובוחרים את התפקיד Cloud Functions > Cloud Functions Invoker. לחיצה על 'שמירה' תציג הודעת אזהרה:

בחירה באפשרות 'אישור גישה ציבורית' תאפשר לאפליקציה שלכם בצד הלקוח להשתמש בפונקציה שלכם בענן.

מזל טוב – השלמת את כל השלבים. עכשיו אפשר להיכנס לאפליקציית האינטרנט ולתת לבקרי המכשיר שמנותבים דרך שרת ה-proxy!

השלבים הבאים

מחפשים דרכים להרחיב את המומחיות שלכם בנושא גישה למכשירים? במסמכי התיעוד בנושא תכונות אפשר לקרוא מידע נוסף על שליטה במכשירי Nest אחרים ועל תהליך האישור כדי ללמוד מהם השלבים להשקת המוצר בעולם.

אתם יכולים לשפר את הכישורים שלכם בעזרת האפליקציה לדוגמה של אפליקציית האינטרנט Device Access, שבה תבנות את הניסיון שלך ב-Codelab ותפרוס אפליקציית אינטרנט תקינה כדי לשלוט במצלמות, בפעמוני דלת ובתרמוסטטים של Nest.