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 en Go que realiza solicitudes a la API de YouTube Data.

El código de ejemplo que se usa en esta guía recupera el recurso channel del 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 Continuar y, luego, en Ir a Credenciales.

  2. En la página Crear credenciales, haz clic en el botón Cancelar.

  3. En la parte superior de la página, seleccione la pestaña OAuth consent screen. Selecciona una dirección de correo electrónico, ingresa un nombre del producto si aún no se configuró y haz clic en el botón Guardar.

  4. Selecciona la pestaña Credenciales, haz clic en el botón Crear credenciales y selecciona ID de cliente de OAuth.

  5. Selecciona el tipo de aplicación Otro, ingresa el nombre "Guía de inicio rápido de la API de YouTube Data" y haz clic en el botón Crear.

  6. Haz clic en Aceptar 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")
}

quickstart.go

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 para la autorización.

  2. Haz clic en el botón Aceptar.
  3. Copia el código que se te proporciona, 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 de este ejemplo está diseñado para una aplicación de línea de comandos. Si deseas obtener información para realizar la autorización en una aplicación web, consulta Cómo usar OAuth 2.0 para aplicaciones de servidor web.

Lecturas adicionales