מדריך למתחילים

משלימים את השלבים שמתוארים בהמשך הדף הזה, ותוך חמש דקות בערך תהיה לכם אפליקציית שורת פקודה פשוטה ב-Go ששולחת בקשות אל YouTube Data API.

קוד הדוגמה שמופיע במדריך הזה מאחזר את משאב channel של ערוץ YouTube‏ GoogleDevelopers ומדפיס מידע בסיסי מהמשאב הזה.

דרישות מוקדמות

כדי להפעיל את המדריך למתחילים הזה, אתם צריכים:

  • ‫Go, מומלץ להשתמש בגרסה העדכנית.
  • ‫Git, מומלץ להשתמש בגרסה העדכנית.
  • גישה לאינטרנט ודפדפן אינטרנט.
  • חשבון Google.

שלב 1: הפעלת YouTube Data API

  1. משתמשים באשף הזה כדי ליצור או לבחור פרויקט ב-Google Developers Console ולהפעיל את ה-API באופן אוטומטי. לוחצים על Continue ואז על Go to credentials.

  2. בדף Create credentials, לוחצים על Cancel.

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

  4. לוחצים על הכרטיסייה Credentials (פרטי כניסה), על הלחצן Create credentials (יצירת פרטי כניסה) ובוחרים באפשרות OAuth client ID (מזהה לקוח OAuth).

  5. בוחרים בסוג האפליקציה Other (אחר), מזינים את השם YouTube Data API Quickstart (התחלה מהירה של YouTube Data API) ולוחצים על הלחצן Create (יצירה).

  6. לוחצים על אישור כדי לסגור את תיבת הדו-שיח שמופיעה.

  7. לוחצים על הלחצן (הורדת JSON) שמשמאל למזהה הלקוח.

  8. מעבירים את הקובץ שהורדתם לספריית העבודה ומשנים את השם שלו ל-client_secret.json.

שלב 2: הכנת סביבת העבודה

  1. מגדירים את משתנה הסביבה GOPATH לספריית העבודה.
  2. כדי לקבל את ספריית הלקוח של YouTube Data API Go ואת חבילת OAuth2, משתמשים בפקודות הבאות:
go get -u google.golang.org/api/youtube/v3
go get -u golang.org/x/oauth2/...

שלב 3: מגדירים את הדוגמה

יוצרים קובץ בשם quickstart.go בספריית העבודה ומעתיקים אליו את הקוד הבא:

// Sample Go code for user authorization

package main

import (
  "encoding/json"
  "fmt"
  "log"
  "io/ioutil"
  "net/http"
  "net/url"
  "os"
  "os/user"
  "path/filepath"

  "golang.org/x/net/context"
  "golang.org/x/oauth2"
  "golang.org/x/oauth2/google"
  "google.golang.org/api/youtube/v3"
)

const missingClientSecretsMessage = `
Please configure OAuth 2.0
`

// getClient uses a Context and Config to retrieve a Token
// then generate a Client. It returns the generated Client.
func getClient(ctx context.Context, config *oauth2.Config) *http.Client {
  cacheFile, err := tokenCacheFile()
  if err != nil {
    log.Fatalf("Unable to get path to cached credential file. %v", err)
  }
  tok, err := tokenFromFile(cacheFile)
  if err != nil {
    tok = getTokenFromWeb(config)
    saveToken(cacheFile, tok)
  }
  return config.Client(ctx, tok)
}

// getTokenFromWeb uses Config to request a Token.
// It returns the retrieved Token.
func getTokenFromWeb(config *oauth2.Config) *oauth2.Token {
  authURL := config.AuthCodeURL("state-token", oauth2.AccessTypeOffline)
  fmt.Printf("Go to the following link in your browser then type the "+
    "authorization code: \n%v\n", authURL)

  var code string
  if _, err := fmt.Scan(&code); err != nil {
    log.Fatalf("Unable to read authorization code %v", err)
  }

  tok, err := config.Exchange(oauth2.NoContext, code)
  if err != nil {
    log.Fatalf("Unable to retrieve token from web %v", err)
  }
  return tok
}

// tokenCacheFile generates credential file path/filename.
// It returns the generated credential path/filename.
func tokenCacheFile() (string, error) {
  usr, err := user.Current()
  if err != nil {
    return "", err
  }
  tokenCacheDir := filepath.Join(usr.HomeDir, ".credentials")
  os.MkdirAll(tokenCacheDir, 0700)
  return filepath.Join(tokenCacheDir,
    url.QueryEscape("youtube-go-quickstart.json")), err
}

// tokenFromFile retrieves a Token from a given file path.
// It returns the retrieved Token and any read error encountered.
func tokenFromFile(file string) (*oauth2.Token, error) {
  f, err := os.Open(file)
  if err != nil {
    return nil, err
  }
  t := &oauth2.Token{}
  err = json.NewDecoder(f).Decode(t)
  defer f.Close()
  return t, err
}

// saveToken uses a file path to create a file and store the
// token in it.
func saveToken(file string, token *oauth2.Token) {
  fmt.Printf("Saving credential file to: %s\n", file)
  f, err := os.OpenFile(file, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0600)
  if err != nil {
    log.Fatalf("Unable to cache oauth token: %v", err)
  }
  defer f.Close()
  json.NewEncoder(f).Encode(token)
}

func handleError(err error, message string) {
  if message == "" {
    message = "Error making API call"
  }
  if err != nil {
    log.Fatalf(message + ": %v", err.Error())
  }
}

func channelsListByUsername(service *youtube.Service, part string, forUsername string) {
  call := service.Channels.List(part)
  call = call.ForUsername(forUsername)
  response, err := call.Do()
  handleError(err, "")
  fmt.Println(fmt.Sprintf("This channel's ID is %s. Its title is '%s', " +
              "and it has %d views.",
              response.Items[0].Id,
              response.Items[0].Snippet.Title,
              response.Items[0].Statistics.ViewCount))
}


func main() {
  ctx := context.Background()

  b, err := ioutil.ReadFile("client_secret.json")
  if err != nil {
    log.Fatalf("Unable to read client secret file: %v", err)
  }

  // If modifying these scopes, delete your previously saved credentials
  // at ~/.credentials/youtube-go-quickstart.json
  config, err := google.ConfigFromJSON(b, youtube.YoutubeReadonlyScope)
  if err != nil {
    log.Fatalf("Unable to parse client secret file to config: %v", err)
  }
  client := getClient(ctx, config)
  service, err := youtube.New(client)

  handleError(err, "Error creating YouTube client")

  channelsListByUsername(service, "snippet,contentDetails,statistics", "GoogleDevelopers")
}

שלב 4: מריצים את הדוגמה

מפתחים ומריצים את הדוגמה באמצעות הפקודה הבאה מספריית העבודה:

go run quickstart.go

בפעם הראשונה שתריצו את הקוד לדוגמה, תתבקשו לאשר את הגישה:

  1. עוברים לכתובת ה-URL שסופקה בדפדפן האינטרנט.

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

  2. לוחצים על הכפתור אישור.
  3. מעתיקים את הקוד שקיבלתם, מדביקים אותו בשורת הפקודה ומקישים על Enter.

הערות

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

קריאה נוספת