Guía de inicio rápido de Go

Completa los pasos que se describen en el resto de esta página y, en unos cinco minutos, tendrás una aplicación simple de línea de comandos de Go que realiza solicitudes a la API de YouTube Data.

El código de muestra que se usa en esta guía recupera el recurso channel para el canal de YouTube de GoogleDevelopers y muestra información básica de ese recurso.

Requisitos previos

Para ejecutar esta guía de inicio rápido, necesitarás lo siguiente:

  • Go, se recomienda la versión más reciente
  • Git, se recomienda la versión más reciente
  • Acceso a Internet y un navegador web
  • Una Cuenta de Google

Paso 1: Activa la API de YouTube Data

  1. Usa este asistente para crear o seleccionar un proyecto en Google Developers Console y activar automáticamente la API. Haz clic en Continue y, luego, en Go to credentials.

  2. En la página Create credentials, haz clic en el botón Cancel.

  3. En la parte superior de la página, selecciona la pestaña pantalla de consentimiento de OAuth. Selecciona una dirección de correo electrónico, ingresa un nombre del producto si aún no está configurado y haz clic en el botón Save.

  4. Selecciona la pestaña Credentials, haz clic en el botón Create credentials y selecciona ID de cliente de OAuth.

  5. Selecciona el tipo de aplicación Other, ingresa el nombre "API de YouTube Data Quickstart" y haz clic en el botón Create.

  6. Haz clic en OK para descartar el diálogo resultante.

  7. Haz clic en el botón (Descargar JSON) a la derecha del ID de cliente.

  8. Mueve el archivo descargado a tu directorio de trabajo y cámbiale el nombre a client_secret.json.

Paso 2: Prepara el espacio de trabajo

  1. Establece la variable de entorno GOPATH en tu directorio de trabajo.
  2. Obtén la biblioteca cliente de Go de la API de YouTube Data y el paquete OAuth2 con los siguientes comandos:
go get -u google.golang.org/api/youtube/v3
go get -u golang.org/x/oauth2/...

Paso 3: Configura la muestra

Crea un archivo llamado quickstart.go en tu directorio de trabajo y copia el siguiente código:

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

Paso 4: Ejecuta la muestra

Compila y ejecuta la muestra con el siguiente comando desde tu directorio de trabajo:

go run quickstart.go

La primera vez que ejecutes la muestra, se te solicitará que autorices el acceso:

  1. Navega a la URL proporcionada en tu navegador web.

    Si aún no accediste a tu Cuenta de Google, se te solicitará que lo hagas. Si accediste a varias Cuentas de Google, se te pedirá que selecciones una cuenta para usarla en la autorización.

  2. Haz clic en el botón Accept.
  3. Copia el código que recibiste, pégalo en el símbolo del sistema y presiona Intro.

Notas

  • La información de autorización se almacena en el sistema de archivos, por lo que las ejecuciones posteriores no solicitarán autorización.
  • El flujo de autorización en este ejemplo está diseñado para una aplicación de línea de comandos. Para obtener información sobre cómo realizar la autorización en una aplicación web, consulta Usa OAuth 2.0 para aplicaciones de servidor web.

Lecturas adicionales