Go-Kurzanleitung

Führe die im Folgenden beschriebenen Schritte aus. In etwa fünf Minuten erhältst du eine einfache Go-Befehlszeile, die Anfragen an die YouTube Data API sendet.

Der in diesem Leitfaden verwendete Beispielcode ruft die Ressource channel für den YouTube-Kanal von GoogleDevelopers ab und gibt einige grundlegende Informationen aus dieser Ressource aus.

Voraussetzungen

Für diese Kurzanleitung benötigen Sie Folgendes:

  • Los: Die neueste Version wird empfohlen.
  • Git ist die neueste Version.
  • 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 die Schaltfläche 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 geschehen, 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 Sonstiges aus, geben Sie den Namen „YouTube Data API-Kurzanleitung“ ein und klicken Sie auf die Schaltfläche Erstellen.

  6. Klicken Sie auf OK, um das 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 Go-Clientbibliothek und das OAuth2-Paket für die YouTube Data API 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:

// 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 Sie das Beispiel 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 in Ihrem Webbrowser die angegebene URL auf.

    Wenn Sie noch nicht in Ihrem Google-Konto angemeldet sind, werden Sie dazu aufgefordert. 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 Befehlszeile ein und drücken Sie die Eingabetaste.

Hinweise

  • Die Autorisierungsinformationen werden im Dateisystem gespeichert, sodass nachfolgende Ausführungen keine Autorisierung erfordern.
  • Der Autorisierungsablauf in diesem Beispiel ist für eine Befehlszeilenanwendung vorgesehen. Informationen zum Ausführen der Autorisierung in einer Webanwendung finden Sie unter OAuth 2.0 für Webserveranwendungen verwenden.

Weitere Informationen