Krótkie wprowadzenie

Utwórz aplikację wiersza poleceń w Go, która wysyła żądania do interfejsu Directory API.

Krótkie wprowadzenia wyjaśniają, jak skonfigurować i uruchomić aplikację, która wywołuje interfejs Google Workspace API. W tym krótkim wprowadzeniu używamy uproszczonego podejścia do uwierzytelniania, które jest odpowiednie dla środowiska testowego. W przypadku środowiska produkcyjnego zalecamy zapoznanie się z uwierzytelnianiem i autoryzacją przed wybraniem danych logowania odpowiednich dla Twojej aplikacji.

W tym krótkim wprowadzeniu używamy zalecanych przez Google Workspace bibliotek klienta interfejsu API, aby obsługiwać niektóre szczegóły przepływu uwierzytelniania i autoryzacji.

Cele

  • skonfigurować środowisko,
  • skonfigurować próbkę,
  • uruchomić próbkę.

Wymagania wstępne

Konfigurowanie środowiska

Aby ukończyć to krótkie wprowadzenie, skonfiguruj środowisko.

Włączanie interfejsu API

Zanim zaczniesz korzystać z interfejsów API Google, musisz je włączyć w projekcie w chmurze Google. W jednym projekcie Google Cloud możesz włączyć co najmniej 1 interfejs API.

  • W konsoli Google Cloud włącz interfejs Directory API.

    Włącz API

Jeśli do wykonania zadań z tego krótkiego wprowadzenia używasz nowego projektu w chmurze Google Cloud, skonfiguruj ekran zgody OAuth. Jeśli ten krok został już wykonany w przypadku projektu w chmurze, przejdź do następnej sekcji.

  1. W Konsoli interfejsów API Google otwórz Menu > Platforma uwierzytelniania Google > Elementy marki.

    Przejdź na stronę Elementy marki

  2. Jeśli platforma uwierzytelniania Google została już skonfigurowana, możesz skonfigurować te ustawienia ekranu zgody OAuth w sekcjach Elementy marki, Odbiorcy i Dostęp do danych. Jeśli zobaczysz komunikat Platforma uwierzytelniania Google nie została jeszcze skonfigurowana, kliknij Rozpocznij:
    1. W sekcji Informacje o aplikacji w polu Nazwa aplikacji wpisz nazwę aplikacji.
    2. W polu Adres e-mail dla użytkowników potrzebujących pomocy wybierz adres e-mail, na który użytkownicy mogą się z Tobą skontaktować, jeśli mają pytania dotyczące zgody.
    3. Kliknij Dalej.
    4. W sekcji Odbiorcy wybierz Wewnętrzni.
    5. Kliknij Dalej.
    6. W sekcji Informacje kontaktowe wpisz Adres e-mail, na który chcesz otrzymywać powiadomienia o zmianach w projekcie.
    7. Kliknij Dalej.
    8. W sekcji Zakończ zapoznaj się z Zasadami dotyczącymi danych użytkownika w usługach interfejsu API Google. Jeśli się z nimi zgadzasz, zaznacz pole Akceptuję zasady dotyczące danych użytkownika w usługach interfejsu API Google.
    9. Kliknij Dalej.
    10. Kliknij Utwórz.
  3. Na razie możesz pominąć dodawanie zakresów. W przyszłości, gdy będziesz tworzyć aplikację do użytku poza organizacją Google Workspace, musisz zmienić Typ użytkownika na Zewnętrzny. Następnie dodaj zakresy autoryzacji wymagane przez aplikację. Więcej informacji znajdziesz w pełnym przewodniku Konfigurowanie ekranu zgody OAuth.

Autoryzowanie danych logowania aplikacji na komputer

Aby uwierzytelniać użytkowników i uzyskiwać dostęp do danych użytkowników w aplikacji, musisz utworzyć co najmniej 1 identyfikator klienta OAuth 2.0. Identyfikator klienta służy do identyfikowania pojedynczej aplikacji na serwerach OAuth Google. Jeśli Twoja aplikacja działa na kilku platformach, musisz utworzyć osobny identyfikator klienta dla każdej platformy.
  1. W konsoli Google Cloud otwórz Menu > Platforma uwierzytelniania Google > Klienci.

    Otwórz stronę Klienci

  2. Kliknij Utwórz klienta.
  3. Kliknij Typ aplikacji > Aplikacja komputerowa.
  4. W polu Nazwa wpisz nazwę danych logowania. Ta nazwa jest widoczna tylko w konsoli Google Cloud.
  5. Opcjonalnie: jeśli Twoja aplikacja jest agentem AI, który wykonuje działania w imieniu użytkowników, wybierz Używaj tego klienta w przypadku agenta opartego na AI. Jeśli Twoja aplikacja obsługuje zarówno przepływy pracy agenta AI, jak i standardowe funkcje użytkownika, utwórz osobnych klientów OAuth dla każdego z tych przepływów i każdej z tych funkcji. Po utworzeniu klienta nie możesz zmienić tego ustawienia.
  6. Kliknij Utwórz.

    Nowo utworzone dane logowania pojawią się w sekcji „Identyfikatory klientów OAuth 2.0”.

  7. Zapisz pobrany plik JSON jako credentials.json i przenieś plik do katalogu roboczego.

Przygotowywanie obszaru roboczego

  1. Utwórz katalog roboczy:

    mkdir quickstart

  2. Przejdź do katalogu roboczego:

    cd quickstart

  3. Zainicjuj nowy moduł:

    go mod init quickstart

  4. Pobierz bibliotekę klienta interfejsu Directory API w Go i pakiet OAuth2.0:

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

Konfigurowanie próbki

  1. W katalogu roboczym utwórz plik o nazwie quickstart.go.

  2. Wklej do pliku ten kod:

    admin_sdk/directory/quickstart.go
    package main

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

	"golang.org/x/oauth2"
	"golang.org/x/oauth2/google"
	admin "google.golang.org/api/admin/directory/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.AdminDirectoryUserReadonlyScope)
	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 directory Client %v", err)
	}

	r, err := srv.Users.List().Customer("my_customer").MaxResults(10).
		OrderBy("email").Do()
	if err != nil {
		log.Fatalf("Unable to retrieve users in domain: %v", err)
	}

	if len(r.Users) == 0 {
		fmt.Print("No users found.\n")
	} else {
		fmt.Print("Users:\n")
		for _, u := range r.Users {
			fmt.Printf("%s (%s)\n", u.PrimaryEmail, u.Name.FullName)
		}
	}
}

Uruchamianie próbki

  1. W katalogu roboczym skompiluj i uruchom próbkę:

    go run quickstart.go
  1. Gdy uruchomisz próbkę po raz pierwszy, pojawi się prośba o autoryzację dostępu:
    1. Jeśli nie jesteś jeszcze zalogowany(-a) na konto Google, zaloguj się, gdy pojawi się prośba. Jeśli korzystasz z kilku kont, wybierz jedno, którego chcesz użyć do autoryzacji.
    2. Kliknij Akceptuję.

    Twoja aplikacja w Go uruchomi się i wywoła interfejs Directory API.

    Informacje o autoryzacji są przechowywane w systemie plików, więc gdy następnym razem uruchomisz przykładowy kod, nie pojawi się prośba o autoryzację.

Dalsze kroki