क्विकस्टार्ट आज़माएं

क्विकस्टार्ट में, Google Workspace API को कॉल करने वाले ऐप्लिकेशन को सेट अप और चलाने का तरीका बताया गया है.

Google Workspace के क्विकस्टार्ट, पुष्टि करने और अनुमति देने की प्रोसेस की कुछ जानकारी को मैनेज करने के लिए, एपीआई क्लाइंट लाइब्रेरी का इस्तेमाल करते हैं. हमारा सुझाव है कि आप अपने ऐप्लिकेशन के लिए क्लाइंट लाइब्रेरी का इस्तेमाल करें. इस क्विकस्टार्ट में, पुष्टि करने के लिए आसान तरीके का इस्तेमाल किया गया है. यह तरीका, टेस्टिंग एनवायरमेंट के लिए सही है. हमारा सुझाव है कि प्रोडक्शन एनवायरमेंट के लिए, अपने ऐप्लिकेशन के लिए सही ऐक्सेस क्रेडेंशियल चुनने से पहले, पुष्टि और अनुमति के बारे में जानें.

Go कमांड-लाइन ऐप्लिकेशन बनाएं, जो Google Sheets API को अनुरोध करता हो.

मकसद

  • अपना एनवायरमेंट सेट अप करें.
  • सैंपल सेट अप करें.
  • सैंपल चलाएं.

ज़रूरी शर्तें

  • एक Google खाता.

अपना एनवायरमेंट सेट अप करने का तरीका

यह शुरुआती लेख पूरा करने के लिए, अपना एनवायरमेंट सेट अप करें.

एपीआई चालू करना

Google API का इस्तेमाल करने से पहले, आपको उन्हें Google Cloud प्रोजेक्ट में चालू करना होगा. किसी एक Google Cloud प्रोजेक्ट में, एक या उससे ज़्यादा एपीआई चालू किए जा सकते हैं.

अगर इस शुरुआती लेख को पूरा करने के लिए, किसी नए Google Cloud प्रोजेक्ट का इस्तेमाल किया जा रहा है, तो OAuth की सहमति वाली स्क्रीन को कॉन्फ़िगर करें और खुद को टेस्ट उपयोगकर्ता के तौर पर जोड़ें. अगर आपने अपने Cloud प्रोजेक्ट के लिए यह चरण पहले ही पूरा कर लिया है, तो अगले सेक्शन पर जाएं.

  1. Google Cloud Console में, मेन्यू > एपीआई और सेवाएं > OAuth की सहमति वाली स्क्रीन पर जाएं.

    OAuth की सहमति वाली स्क्रीन पर जाना

  2. उपयोगकर्ता टाइप के लिए, इंटरनल चुनें. इसके बाद, बनाएं पर क्लिक करें.
  3. ऐप्लिकेशन रजिस्ट्रेशन फ़ॉर्म को पूरा करें. इसके बाद, सेव करें और जारी रखें पर क्लिक करें.

  4. फ़िलहाल, स्कोप जोड़ने की प्रोसेस को छोड़ा जा सकता है. इसके बाद, सेव करें और जारी रखें पर क्लिक करें. आने वाले समय में, जब आप अपने Google Workspace संगठन के बाहर इस्तेमाल करने के लिए कोई ऐप्लिकेशन बनाएं, तो आपको उपयोगकर्ता टाइप को बाहरी में बदलना होगा. इसके बाद, अपने ऐप्लिकेशन के लिए अनुमति के दायरे जोड़ें.

  5. अपने ऐप्लिकेशन के रजिस्ट्रेशन की खास जानकारी देखें. बदलाव करने के लिए, बदलाव करें पर क्लिक करें. अगर ऐप्लिकेशन का रजिस्ट्रेशन ठीक है, तो डैशबोर्ड पर वापस जाएं पर क्लिक करें.

किसी डेस्कटॉप ऐप्लिकेशन के लिए क्रेडेंशियल को अनुमति देना

असली उपयोगकर्ताओं की पुष्टि करने और अपने ऐप्लिकेशन में उपयोगकर्ता का डेटा ऐक्सेस करने के लिए, आपको एक या उससे ज़्यादा OAuth 2.0 क्लाइंट आईडी बनाने होंगे. क्लाइंट आईडी का इस्तेमाल, Google के OAuth सर्वर पर किसी एक ऐप्लिकेशन की पहचान करने के लिए किया जाता है. अगर आपका ऐप्लिकेशन कई प्लैटफ़ॉर्म पर काम करता है, तो आपको हर प्लैटफ़ॉर्म के लिए अलग-अलग क्लाइंट आईडी बनाना होगा.
  1. Google Cloud console में, मेन्यू > एपीआई और सेवाएं > क्रेडेंशियल पर जाएं.

    क्रेडेंशियल पर जाएं

  2. क्रेडेंशियल बनाएं > OAuth क्लाइंट आईडी पर क्लिक करें.
  3. ऐप्लिकेशन का टाइप > डेस्कटॉप ऐप्लिकेशन पर क्लिक करें.
  4. नाम फ़ील्ड में, क्रेडेंशियल के लिए कोई नाम टाइप करें. यह नाम सिर्फ़ Google Cloud Console में दिखता है.
  5. बनाएं पर क्लिक करें. OAuth क्लाइंट बनने के बाद, आपको एक स्क्रीन दिखेगी. इसमें आपका नया क्लाइंट आईडी और क्लाइंट पासवर्ड दिखेगा.
  6. ठीक है पर क्लिक करें. नया क्रेडेंशियल, OAuth 2.0 क्लाइंट आईडी में दिखता है.
  7. डाउनलोड की गई JSON फ़ाइल को credentials.json के तौर पर सेव करें और फ़ाइल को अपनी वर्किंग डायरेक्ट्री में ले जाएं.

फ़ाइल फ़ोल्डर तैयार करना

  1. वर्किंग डायरेक्ट्री बनाएं:

    mkdir quickstart

  2. वर्किंग डायरेक्ट्री में बदलने के लिए:

    cd quickstart

  3. नए मॉड्यूल को शुरू करने के लिए:

    go mod init quickstart

  4. Google Sheets API की Go क्लाइंट लाइब्रेरी और OAuth2.0 पैकेज पाएं:

    go get google.golang.org/api/sheets/v4
go get golang.org/x/oauth2/google

सैंपल सेट अप करना

  1. अपनी वर्किंग डायरेक्ट्री में, quickstart.go नाम की फ़ाइल बनाएं.

  2. फ़ाइल में यह कोड चिपकाएं:

    sheets/quickstart/quickstart.go
    package main

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"

	"golang.org/x/oauth2"
	"golang.org/x/oauth2/google"
	"google.golang.org/api/option"
	"google.golang.org/api/sheets/v4"
)

// 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, "https://www.googleapis.com/auth/spreadsheets.readonly")
	if err != nil {
		log.Fatalf("Unable to parse client secret file to config: %v", err)
	}
	client := getClient(config)

	srv, err := sheets.NewService(ctx, option.WithHTTPClient(client))
	if err != nil {
		log.Fatalf("Unable to retrieve Sheets client: %v", err)
	}

	// Prints the names and majors of students in a sample spreadsheet:
	// https://docs.google.com/spreadsheets/d/1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms/edit
	spreadsheetId := "1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms"
	readRange := "Class Data!A2:E"
	resp, err := srv.Spreadsheets.Values.Get(spreadsheetId, readRange).Do()
	if err != nil {
		log.Fatalf("Unable to retrieve data from sheet: %v", err)
	}

	if len(resp.Values) == 0 {
		fmt.Println("No data found.")
	} else {
		fmt.Println("Name, Major:")
		for _, row := range resp.Values {
			// Print columns A and E, which correspond to indices 0 and 4.
			fmt.Printf("%s, %s\n", row[0], row[4])
		}
	}
}

सैंपल चलाना

  1. अपनी वर्किंग डायरेक्ट्री में, सैंपल बनाएं और चलाएं:

    go run quickstart.go
  1. सैंपल को पहली बार चलाने पर, आपको ऐक्सेस की अनुमति देने के लिए कहा जाएगा:
    1. अगर आपने Google खाते में पहले से साइन इन नहीं किया है, तो कहा जाने पर साइन इन करें. अगर आपने एक से ज़्यादा खातों में साइन इन किया है, तो अनुमति देने के लिए कोई एक खाता चुनें.
    2. स्वीकार करें पर क्लिक करें.

    आपका Go ऐप्लिकेशन Google Sheets API को कॉल करता है और चलाता है.

    अनुमति की जानकारी फ़ाइल सिस्टम में सेव होती है. इसलिए, अगली बार सैंपल कोड चलाने पर, आपसे अनुमति नहीं मांगी जाती.

अगले चरण