Conclua as etapas descritas no restante desta página e, em cerca de cinco minutos, você terá um aplicativo de linha de comando Go simples que faz solicitações à API YouTube Data.
A amostra de código usada neste guia recupera o recursochannel
para o canal do Google Developers do YouTube e imprime algumas informações básicas desse recurso.
Pré-requisitos
Para executar este guia de início rápido, você precisará do seguinte:
- Go, a versão mais recente é recomendada.
- Git, a versão mais recente é recomendada.
- Acesso à Internet e a um navegador da Web.
- uma Conta do Google.
Etapa 1: ativar a API YouTube Data
-
Use este assistente para criar ou selecionar um projeto no Google Developers Console e ativar a API automaticamente. Clique em Continuar e em Acessar credenciais.
-
Na página Criar credenciais, clique no botão Cancelar.
-
Na parte superior da página, selecione a guia OAuth consent screen. Selecione um Endereço de e-mail, insira um Nome de produto, se ainda não estiver definido, e clique no botão Salvar.
-
Selecione a guia Credenciais, clique no botão Criar credenciais e selecione ID do cliente OAuth.
-
Selecione o tipo de aplicativo Outro, insira o nome "Guia de início rápido da API YouTube Data" e clique no botão Criar.
-
Clique em OK para dispensar a caixa de diálogo exibida.
-
Clique no botão
(Fazer o download do JSON) à direita do ID do cliente. -
Mova o arquivo salvo para o diretório de trabalho e renomeie-o como
client_secret.json
.
Etapa 2: preparar o espaço de trabalho
- Defina a variável de ambiente
GOPATH
como seu diretório de trabalho. - Encontre a biblioteca de cliente Go do YouTube API e o pacote do OAuth2 usando os seguintes comandos:
go get -u google.golang.org/api/youtube/v3
go get -u golang.org/x/oauth2/...
Etapa 3: configurar o exemplo
Crie um arquivo chamado quickstart.go
no diretório de trabalho e copie
o seguinte 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")
}
Etapa 4: executar a amostra
Crie e execute o exemplo usando o seguinte comando do seu diretório de trabalho:
go run quickstart.go
Na primeira vez que você executar o exemplo, ele vai solicitar a autorização de acesso:
Navegue até o URL fornecido no seu navegador da Web.
Se ainda não estiver conectado à sua Conta do Google, você será solicitado a fazer login. Se você tiver feito login em várias Contas do Google, precisará escolher uma para usar na autorização.
- Clique no botão Aceitar.
- Copie o código que você recebeu, cole-o no prompt de linha de comando e pressione Enter.
Observações
- As informações de autorização são armazenadas no sistema de arquivos para que as execuções subsequentes não solicitem autorização.
- O fluxo de autorização neste exemplo é projetado para um aplicativo de linha de comando. Para informações sobre como executar a autorização em um aplicativo da Web, consulte Como usar o OAuth 2.0 para aplicativos de servidor da Web.