Panduan Memulai Go

Selesaikan langkah-langkah yang dijelaskan di bagian selanjutnya halaman ini, dan dalam waktu sekitar lima menit, Anda akan memiliki aplikasi command line Go sederhana yang membuat permintaan ke YouTube Data API.

Kode contoh yang digunakan dalam panduan ini mengambil resource channel untuk channel YouTube GoogleDevelopers dan mencetak beberapa informasi dasar dari resource tersebut.

Prasyarat

Untuk menjalankan panduan memulai ini, Anda memerlukan:

  • Go, versi terbaru direkomendasikan.
  • Git, direkomendasikan versi terbaru.
  • Akses ke internet dan browser web.
  • Akun Google.

Langkah 1: Aktifkan YouTube Data API

  1. Gunakan wizard ini untuk membuat atau memilih project di Google Developers Console, dan otomatis mengaktifkan API. Klik Continue, lalu Go to credentials.

  2. Di halaman Create credentials, klik tombol Cancel.

  3. Di bagian atas halaman, pilih tab Layar persetujuan OAuth. Pilih Alamat email, masukkan Nama produk jika belum ditetapkan, dan klik tombol Simpan.

  4. Pilih tab Credentials, klik tombol Create credentials, lalu pilih OAuth client ID.

  5. Pilih jenis aplikasi Lainnya, masukkan nama "Panduan Memulai YouTube Data API", dan klik tombol Buat.

  6. Klik OK untuk menutup dialog yang dihasilkan.

  7. Klik tombol (Download JSON) di sebelah kanan client ID.

  8. Pindahkan file yang didownload ke direktori kerja Anda dan ganti namanya client_secret.json.

Langkah 2: Siapkan ruang kerja

  1. Tetapkan variabel lingkungan GOPATH ke direktori kerja Anda.
  2. Dapatkan library klien YouTube Data API Go dan paket OAuth2 menggunakan perintah berikut:
go get -u google.golang.org/api/youtube/v3
go get -u golang.org/x/oauth2/...

Langkah 3: Siapkan contoh aplikasi

Buat file bernama quickstart.go di direktori kerja Anda dan salin dalam kode berikut:

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

Langkah 4: Jalankan contoh aplikasi

Buat dan jalankan contoh menggunakan perintah berikut dari direktori kerja Anda:

go run quickstart.go

Saat pertama kali menjalankan contoh, Anda akan diminta untuk mengizinkan akses:

  1. Jelajahi URL yang diberikan di browser web Anda.

    Jika belum login ke Akun Google, Anda akan diminta untuk login. Jika login ke beberapa akun Google, Anda akan diminta untuk memilih satu akun yang akan digunakan untuk otorisasi.

  2. Klik tombol Accept.
  3. Salin kode yang diberikan, tempel ke command line, dan tekan Enter.

Catatan

  • Informasi otorisasi disimpan di sistem file, sehingga eksekusi berikutnya tidak akan meminta otorisasi.
  • Alur otorisasi dalam contoh ini dirancang untuk aplikasi command line. Untuk informasi tentang cara menjalankan otorisasi di aplikasi web, lihat Menggunakan OAuth 2.0 untuk Aplikasi Server Web.

Bacaan lebih lanjut