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

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 מקושר

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

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

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

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

Google Cloud Platform

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

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

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

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

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

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

עוברים אל מסוף הגישה למכשירים. אם לא השתמשתם בעבר במסוף לגישה למכשירים, תתבקשו לאשר את התנאים וההגבלות ולשלם דמי רישום בסך 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 Tools

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

$ npm i -g firebase-tools

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

$ firebase --version

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

$ firebase login

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

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

$ firebase init hosting

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

צריך לבחור אפשרות – שימוש בפרויקט קיים
בחירת פרויקט ברירת מחדל ב-Firebase לספרייה הזו – בחירה ***[GCP-Project-Id]***
מה רוצים להגדיר כספרייה ציבורית? ‫— גלויים לכולם
האם להגדיר כאפליקציה של דף יחיד? ‫— כן
איך מגדירים גרסאות build ופריסות אוטומטיות באמצעות 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 הזה, עם הלקוח ושרת node.js שפועלים באופן מלא.

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

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

מבנה הקבצים בתיקייה codelab-start הוא כזה:

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

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

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

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

$ firebase deploy

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

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

5. טיפול ב-OAuth

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

ציון URI של הפניה אוטומטית

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

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

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

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

$ firebase deploy

הפעלת ה-URI של ההפניה

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

מתחת לרשימה OAuth 2.0 Client Ids, בוחרים את מזהה הלקוח שיצרתם בשלב Project Creation. מוסיפים את כתובת ה-URI להפניה אוטומטית של האפליקציה לרשימה Authorized Redirect URIs בפרויקט.

כדאי לנסות להיכנס לחשבון!

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

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

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

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

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

6. שליטה במכשיר

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

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

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

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

ניצור ממשק משתמש לדוגמה עם אמצעי בקרה (List Devices, ‏ Set Mode, ‏ Set Temp) כדי לשלוט ב-Nest Thermostat:

אמצעי הבקרה האלה בממשק המשתמש יפעילו פונקציות תואמות (listDevices(), ‏ postThermostatMode(), ‏ postTemperatureSetpoint()) מ-scripts.js. הם נשארים ריקים כדי שתוכלו להטמיע אותם! המטרה היא לבחור את השיטה או הנתיב הנכונים ולהעביר את מטען הנתונים לפונקציה 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 לאחד מארבעת המצבים האפשריים: {Off, Heat, Cool, HeatCool}. לאחר מכן צריך לספק את המצב שנבחר כחלק מהמטען הייעודי (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 שיכול להפנות מחדש את הבקשות שלכם מהדפדפן.

לשרת הפרוקסי הזה נשתמש ב-Firebase Cloud Functions, ב-Node.js וב-Express.

איך מאתחלים את Cloud Functions

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

$ firebase init functions

מערכת Firebase תשאל אתכם סדרה של שאלות כדי לאתחל את Cloud Functions:

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

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

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

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

לאחר מכן, הפעלת npm install מהספרייה functions אמורה להתקין את התלויות של הפרויקט:

$ npm install

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

$ npm install express xmlhttprequest --save

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

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

איך יוצרים שרת Express

שרת Express פועל לפי מסגרת פשוטה כדי להגיב לבקשות נכנסות מסוג GET ו-POST. יצרנו servlet שמקשיב לבקשות 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 ב-Cloud Functions.

מתן הרשאות ל-Cloud Functions

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

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

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

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

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

השלבים הבאים

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

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