Panduan memulai Go

Panduan memulai menjelaskan cara menyiapkan dan menjalankan aplikasi yang memanggil Google Workspace API.

Panduan memulai Google Workspace menggunakan library klien API untuk menangani beberapa detail alur autentikasi dan otorisasi. Sebaiknya gunakan library klien untuk aplikasi Anda sendiri. Panduan memulai ini menggunakan pendekatan autentikasi sederhana yang sesuai untuk lingkungan pengujian. Untuk lingkungan produksi, sebaiknya pelajari autentikasi dan otorisasi sebelum memilih kredensial akses yang sesuai untuk aplikasi Anda.

Buat aplikasi command line Go yang membuat permintaan ke Admin SDK API.

Tujuan

• Siapkan lingkungan Anda.
• Siapkan contoh.
• Jalankan contoh.

Prasyarat

• Versi terbaru Go.
• Versi terbaru Git.
• Project Google Cloud.

• Domain Google Workspace dengan akses API diaktifkan.
• Akun Google di domain tersebut dengan hak istimewa administrator.

Menyiapkan lingkungan Anda

Untuk menyelesaikan panduan memulai ini, siapkan lingkungan Anda.

Mengaktifkan API

Sebelum menggunakan Google API, Anda harus mengaktifkannya di project Google Cloud. Anda dapat mengaktifkan satu atau beberapa API dalam satu project Google Cloud.

• Di konsol Google Cloud, aktifkan Admin SDK API.

  Mengaktifkan API

Mengonfigurasi layar izin OAuth

Jika Anda menggunakan project Google Cloud baru untuk menyelesaikan panduan memulai ini, konfigurasikan layar izin OAuth dan tambahkan diri Anda sebagai pengguna pengujian. Jika Anda sudah menyelesaikan langkah ini untuk project Cloud, lanjutkan ke bagian berikutnya.

1. Di konsol Google Cloud, buka Menu > APIs & Services > OAuth consent screen.

   Buka layar izin OAuth

2. Untuk Jenis pengguna, pilih Internal, lalu klik Buat.
3. Isi formulir pendaftaran aplikasi, lalu klik Simpan dan Lanjutkan.

4. Untuk saat ini, Anda dapat melewati penambahan cakupan dan mengklik Save and Continue. Di masa mendatang, saat membuat aplikasi untuk digunakan di luar organisasi Google Workspace, Anda harus mengubah Jenis pengguna menjadi Eksternal, lalu menambahkan cakupan otorisasi yang diperlukan aplikasi Anda.

5. Tinjau ringkasan pendaftaran aplikasi Anda. Untuk melakukan perubahan, klik Edit. Jika pendaftaran aplikasi terlihat OK, klik Kembali ke Dasbor.

Mengizinkan kredensial untuk aplikasi desktop

Untuk mengautentikasi pengguna akhir dan mengakses data pengguna di aplikasi, Anda perlu membuat satu atau beberapa Client ID OAuth 2.0. Client ID digunakan untuk mengidentifikasi satu aplikasi ke server OAuth Google. Jika aplikasi Anda berjalan di beberapa platform, Anda harus membuat client ID terpisah untuk setiap platform.

1. Di konsol Google Cloud, buka Menu > APIs & Services > Credentials.

   Buka Kredensial

2. Klik Create Credentials > OAuth client ID.
3. Klik Jenis aplikasi > Aplikasi desktop.
4. Di kolom Name, ketik nama untuk kredensial. Nama ini hanya ditampilkan di konsol Google Cloud.
5. Klik Buat. Layar yang menampilkan klien OAuth yang dibuat akan muncul, yang menampilkan Client ID dan Rahasia klien baru Anda.
6. Klik Oke. Kredensial yang baru dibuat akan muncul di bagian Client ID OAuth 2.0.
7. Simpan file JSON yang didownload sebagai credentials.json, dan pindahkan file ke direktori kerja Anda.

Menyiapkan ruang kerja

1. Buat direktori kerja:

   mkdir quickstart
   

2. Ubah ke direktori kerja:

   cd quickstart
   

3. Lakukan inisialisasi modul baru:

   go mod init quickstart
   

4. Dapatkan library klien Go Admin SDK API dan paket OAuth2.0:

   go get google.golang.org/api/admin/reports/v1
   go get golang.org/x/oauth2/google
   

Menyiapkan contoh

1. Di direktori kerja, buat file bernama quickstart.go.

2. Di file tersebut, tempelkan kode berikut:

   admin_sdk/reports/quickstart.go

   Lihat di GitHub
   package main
   
   import (
   	"context"
   	"encoding/json"
   	"fmt"
   	"log"
   	"net/http"
   	"os"
   	"time"
   
   	"golang.org/x/oauth2"
   	"golang.org/x/oauth2/google"
   	admin "google.golang.org/api/admin/reports/v1"
   	"google.golang.org/api/option"
   )
   
   // Retrieve a token, saves the token, then returns the generated client.
   func getClient(config *oauth2.Config) *http.Client {
   	// The file token.json stores the user's access and refresh tokens, and is
   	// created automatically when the authorization flow completes for the first
   	// time.
   	tokFile := "token.json"
   	tok, err := tokenFromFile(tokFile)
   	if err != nil {
   		tok = getTokenFromWeb(config)
   		saveToken(tokFile, tok)
   	}
   	return config.Client(context.Background(), tok)
   }
   
   // Request a token from the web, then 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 authCode string
   	if _, err := fmt.Scan(&authCode); err != nil {
   		log.Fatalf("Unable to read authorization code: %v", err)
   	}
   
   	tok, err := config.Exchange(context.TODO(), authCode)
   	if err != nil {
   		log.Fatalf("Unable to retrieve token from web: %v", err)
   	}
   	return tok
   }
   
   // Retrieves a token from a local file.
   func tokenFromFile(file string) (*oauth2.Token, error) {
   	f, err := os.Open(file)
   	if err != nil {
   		return nil, err
   	}
   	defer f.Close()
   	tok := &oauth2.Token{}
   	err = json.NewDecoder(f).Decode(tok)
   	return tok, err
   }
   
   // Saves a token to a file path.
   func saveToken(path string, token *oauth2.Token) {
   	fmt.Printf("Saving credential file to: %s\n", path)
   	f, err := os.OpenFile(path, 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 main() {
   	ctx := context.Background()
   	b, err := os.ReadFile("credentials.json")
   	if err != nil {
   		log.Fatalf("Unable to read client secret file: %v", err)
   	}
   
   	// If modifying these scopes, delete your previously saved token.json.
   	config, err := google.ConfigFromJSON(b, admin.AdminReportsAuditReadonlyScope)
   	if err != nil {
   		log.Fatalf("Unable to parse client secret file to config: %v", err)
   	}
   	client := getClient(config)
   
   	srv, err := admin.NewService(ctx, option.WithHTTPClient(client))
   	if err != nil {
   		log.Fatalf("Unable to retrieve reports Client %v", err)
   	}
   
   	r, err := srv.Activities.List("all", "login").MaxResults(10).Do()
   	if err != nil {
   		log.Fatalf("Unable to retrieve logins to domain. %v", err)
   	}
   
   	if len(r.Items) == 0 {
   		fmt.Println("No logins found.")
   	} else {
   		fmt.Println("Logins:")
   		for _, a := range r.Items {
   			t, err := time.Parse(time.RFC3339Nano, a.Id.Time)
   			if err != nil {
   				fmt.Println("Unable to parse login time.")
   				// Set time to zero.
   				t = time.Time{}
   			}
   			fmt.Printf("%s: %s %s\n", t.Format(time.RFC822), a.Actor.Email,
   				a.Events[0].Name)
   		}
   	}
   }

Menjalankan contoh

1. Di direktori kerja, build dan jalankan contoh:

   go run quickstart.go
   

2. Saat pertama kali dijalankan, contoh aplikasi meminta Anda untuk mengotorisasi akses:
   1. Jika Anda belum login ke Akun Google, login saat diminta. Jika Anda login ke beberapa akun, pilih satu akun yang akan digunakan untuk otorisasi.
   2. Klik Setuju.

   Aplikasi Go Anda berjalan dan memanggil Admin SDK API.

   Informasi otorisasi disimpan dalam sistem file, sehingga saat menjalankan kode contoh lagi, Anda tidak akan diminta untuk memberikan otorisasi.

Langkah berikutnya

• Memecahkan masalah autentikasi dan otorisasi
• Dokumentasi referensi Reports API Admin SDK
• Bagian google-api-go-client di GitHub