Go-Kurzanleitung

Wenn Sie die Schritte auf dieser Seite ausführen, haben Sie in etwa fünf Minuten eine einfache Go-Befehlszeilenanwendung, die Anfragen an die YouTube Data API sendet.

Im Beispielcode in diesem Leitfaden wird die channel-Ressource für den YouTube-Kanal „GoogleDevelopers“ abgerufen und es werden einige grundlegende Informationen aus dieser Ressource ausgegeben.

Vorbereitung

Für diese Kurzanleitung benötigen Sie Folgendes:

  • Go, neueste Version empfohlen.
  • Git (neueste Version empfohlen)
  • Zugriff auf das Internet und einen Webbrowser
  • Ein Google-Konto.

Schritt 1: YouTube Data API aktivieren

  1. Verwenden Sie diesen Assistenten, um ein Projekt in der Google Developers Console zu erstellen oder auszuwählen und die API automatisch zu aktivieren. Klicken Sie auf Weiter und dann auf Zu den Anmeldedaten.

  2. Klicken Sie auf der Seite Anmeldedaten erstellen auf Abbrechen.

  3. Klicken Sie oben auf der Seite auf den Tab OAuth-Zustimmungsbildschirm. Wählen Sie eine E-Mail-Adresse aus, geben Sie einen Produktnamen ein, falls noch nicht festgelegt, und klicken Sie auf die Schaltfläche Speichern.

  4. Wählen Sie den Tab Anmeldedaten aus, klicken Sie auf die Schaltfläche Anmeldedaten erstellen und wählen Sie OAuth-Client-ID aus.

  5. Wählen Sie den Anwendungstyp Andere aus, geben Sie den Namen „YouTube Data API Quickstart“ ein und klicken Sie auf die Schaltfläche Erstellen.

  6. Klicken Sie auf OK, um das resultierende Dialogfeld zu schließen.

  7. Klicken Sie rechts neben der Client-ID auf die Schaltfläche (JSON herunterladen).

  8. Verschieben Sie die heruntergeladene Datei in Ihr Arbeitsverzeichnis und benennen Sie sie in client_secret.json um.

Schritt 2: Arbeitsbereich vorbereiten

  1. Legen Sie die Umgebungsvariable GOPATH auf Ihr Arbeitsverzeichnis fest.
  2. Rufen Sie die YouTube Data API Go-Clientbibliothek und das OAuth 2.0-Paket mit den folgenden Befehlen ab:
go get -u google.golang.org/api/youtube/v3
go get -u golang.org/x/oauth2/...

Schritt 3: Beispiel einrichten

Erstellen Sie in Ihrem Arbeitsverzeichnis eine Datei mit dem Namen quickstart.go und kopieren Sie den folgenden Code hinein:

// 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

Schritt 4: Beispiel ausführen

Erstellen und führen Sie das Beispiel mit dem folgenden Befehl aus Ihrem Arbeitsverzeichnis aus:

go run quickstart.go

Wenn Sie das Beispiel zum ersten Mal ausführen, werden Sie aufgefordert, den Zugriff zu autorisieren:

  1. Rufen Sie die angegebene URL in Ihrem Webbrowser auf.

    Wenn Sie noch nicht in Ihrem Google-Konto angemeldet sind, werden Sie aufgefordert, sich anzumelden. Wenn Sie in mehreren Google-Konten angemeldet sind, werden Sie aufgefordert, ein Konto für die Autorisierung auszuwählen.

  2. Klicken Sie auf die Schaltfläche Akzeptieren.
  3. Kopieren Sie den Code, fügen Sie ihn in die Eingabeaufforderung ein und drücken Sie die Eingabetaste.

Hinweise

  • Autorisierungsinformationen werden im Dateisystem gespeichert, sodass bei nachfolgenden Ausführungen keine Autorisierung erforderlich ist.
  • Der Autorisierungsablauf in diesem Beispiel ist für eine Befehlszeilenanwendung konzipiert. Informationen zur Autorisierung in einer Webanwendung finden Sie unter OAuth 2.0 für Webserveranwendungen verwenden.

Weitere Informationen