Guida rapida di Go

Completa i passaggi descritti nel resto di questa pagina e in circa cinque minuti avrai una semplice applicazione a riga di comando Go che invia richieste all'API YouTube Data.

Il codice campione utilizzato in questa guida recupera la risorsa channel per il canale YouTube GoogleDevelopers e stampa alcune informazioni di base della risorsa.

Prerequisiti

Per eseguire questa guida rapida, devi disporre di:

  • Go, utilizza la versione più recente.
  • Git, versione consigliata più recente.
  • Accesso a Internet e a un browser web.
  • Un Account Google.

Passaggio 1: attiva l'API YouTube Data

  1. Utilizza questa procedura guidata per creare o selezionare un progetto in Google Developers Console e attivare automaticamente l'API. Fai clic su Continua e poi su Vai alle credenziali.

  2. Nella pagina Crea credenziali, fai clic sul pulsante Annulla.

  3. Nella parte superiore della pagina, seleziona la scheda Schermata consenso OAuth. Seleziona un Indirizzo email, inserisci un Nome prodotto se non è già impostato e fai clic sul pulsante Salva.

  4. Seleziona la scheda Credenziali, fai clic sul pulsante Crea credenziali e seleziona ID client OAuth.

  5. Seleziona il tipo di applicazione Altro, inserisci il nome "Guida rapida all'API di dati di YouTube" e fai clic sul pulsante Crea.

  6. Fai clic su OK per ignorare la finestra di dialogo visualizzata.

  7. Fai clic sul pulsante (Scarica JSON) a destra dell'ID client.

  8. Sposta il file scaricato nella directory di lavoro e rinominalo client_secret.json.

Passaggio 2: prepara l'area di lavoro

  1. Imposta la variabile di ambiente GOPATH sulla tua directory di lavoro.
  2. Ottieni la libreria client Go di API YouTube Data e il pacchetto OAuth2 utilizzando i seguenti comandi:
go get -u google.golang.org/api/youtube/v3
go get -u golang.org/x/oauth2/...

Passaggio 3: configura l'esempio

Crea un file denominato quickstart.go nella directory di lavoro e copialo nel seguente codice:

// 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")
}
quickstart.go

Passaggio 4: esegui l'esempio

Crea ed esegui l'esempio utilizzando il comando seguente dalla directory di lavoro:

go run quickstart.go

La prima volta che esegui l'esempio, ti verrà richiesto di autorizzare l'accesso:

  1. Nel browser web, vai all'URL fornito.

    Se non hai ancora eseguito l'accesso al tuo Account Google, ti verrà chiesto di accedere. Se hai eseguito l'accesso a più Account Google, ti verrà chiesto di selezionare un account da utilizzare per l'autorizzazione.

  2. Fai clic sul pulsante Accetta.
  3. Copia il codice che ti viene fornito, incollalo nel prompt della riga di comando e premi Invio.

Note

  • Le informazioni di autorizzazione vengono archiviate nel file system, quindi le esecuzioni successive non richiederanno l'autorizzazione.
  • Il flusso di autorizzazione in questo esempio è progettato per un'applicazione a riga di comando. Per informazioni su come eseguire l'autorizzazione in un'applicazione web, consulta la pagina relativa all'utilizzo di OAuth 2.0 per le applicazioni server web.

Per approfondire