Diese Seite wurde von der Cloud Translation API übersetzt.

Go – Kurzanleitung

In den Kurzanleitungen wird erklärt, wie Sie eine App einrichten und ausführen, die eine Google Workspace API

In Google Workspace-Kurzanleitungen werden die API-Clientbibliotheken Details zum Authentifizierungs- und Autorisierungsvorgang. Wir empfehlen, Clientbibliotheken für Ihre eigenen Apps verwenden. In dieser Kurzanleitung wird ein vereinfachten Authentifizierungsansatz, der für Tests geeignet ist, zu verbessern. Für eine Produktionsumgebung empfehlen wir, sich über Authentifizierung und Autorisierung vorher Anmeldedaten auswählen die für Ihre App geeignet sind.

Erstellen Sie eine Go-Befehlszeilenanwendung, die Anfragen an den Google Docs-API

Zielsetzungen

die Umgebung einrichten
Richten Sie das Beispiel ein.
Führen Sie das Beispiel aus.

Vorbereitung

Die aktuelle Version von Go
Die aktuelle Version von Git
Ein Google Cloud-Projekt

Ein Google-Konto.

Umgebung einrichten

Richten Sie Ihre Umgebung ein, um diese Kurzanleitung abzuschließen.

API aktivieren

Bevor Sie Google APIs verwenden können, müssen Sie sie in einem Google Cloud-Projekt aktivieren. Sie können eine oder mehrere APIs in einem einzelnen Google Cloud-Projekt aktivieren.

Aktivieren Sie in der Google Cloud Console die Google Docs API.

API aktivieren

OAuth-Zustimmungsbildschirm konfigurieren

Wenn Sie für diese Kurzanleitung ein neues Google Cloud-Projekt verwenden, OAuth-Zustimmungsbildschirm öffnen und sich selbst als Testnutzer hinzufügen. Wenn Sie bereits Sie diesen Schritt für Ihr Cloud-Projekt abgeschlossen haben, fahren Sie mit dem nächsten Abschnitt fort.

Öffnen Sie in der Google Cloud Console das Menü . > APIs und Dienste > OAuth-Zustimmungsbildschirm.
Zum OAuth-Zustimmungsbildschirm
Wählen Sie für Nutzertyp die Option Intern aus und klicken Sie dann auf Erstellen.
Füllen Sie das Formular zur App-Registrierung aus und klicken Sie dann auf Speichern und fortfahren.
Vorerst können Sie das Hinzufügen von Bereichen überspringen und auf Speichern und fortfahren klicken. Wenn Sie in Zukunft eine App erstellen, die außerhalb Ihres Google Workspace-Organisation verwenden, müssen Sie den Nutzertyp in Extern ändern. fügen Sie die Autorisierungsbereiche hinzu, die Ihre Anwendung benötigt.
Überprüfen Sie Ihre App-Registrierungsübersicht. Wenn Sie Änderungen vornehmen möchten, klicken Sie auf Bearbeiten. Wenn die App mit der Registrierung in Ordnung ist, klicken Sie auf Zurück zum Dashboard.

Anmeldedaten für eine Desktopanwendung autorisieren

Um Endnutzer zu authentifizieren und auf Nutzerdaten in Ihrer Anwendung zuzugreifen, müssen Sie eine oder mehrere OAuth 2.0-Client-IDs erstellen. Eine Client-ID wird zur Identifizierung einer einzelnen Anwendung bei Googles OAuth-Servern verwendet. Wenn Ihre App auf mehreren Plattformen läuft, müssen Sie für jede Plattform eine separate Client-ID erstellen.

Öffnen Sie in der Google Cloud Console das Dreistrich-Menü > APIs und Dienste > Anmeldedaten.
Zu den Anmeldedaten
Klicken Sie auf Anmeldedaten erstellen > OAuth-Client-ID.
Klicken Sie auf Anwendungstyp > Desktop-App.
Geben Sie in das Feld Name einen Namen für die Anmeldedaten ein. Dieser Name wird nur in der Google Cloud Console angezeigt.
Klicken Sie auf Erstellen. Der Bildschirm "OAuth-Client erstellt" wird mit Ihrer neuen Client-ID und Ihrem neuen Clientschlüssel angezeigt.
Klicken Sie auf OK. Die neu erstellten Anmeldedaten werden unter OAuth 2.0-Client-IDs angezeigt.
Speichern Sie die heruntergeladene JSON-Datei als credentials.json und verschieben Sie den in Ihr Arbeitsverzeichnis.

Arbeitsbereich vorbereiten

Erstellen Sie ein Arbeitsverzeichnis:
```
mkdir quickstart
```
Wechseln Sie in das Arbeitsverzeichnis:
```
cd quickstart
```
Initialisieren Sie das neue Modul:
```
go mod init quickstart
```
Rufen Sie die Go-Clientbibliothek der Google Docs API und das OAuth2.0-Paket ab:
```
go get google.golang.org/api/docs/v1
go get golang.org/x/oauth2/google
```

Beispielanwendung einrichten

Erstellen Sie in Ihrem Arbeitsverzeichnis eine Datei mit dem Namen quickstart.go.

Fügen Sie den folgenden Code in die Datei ein:

docs/quickstart/quickstart.go

Auf GitHub ansehen

package main

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

	"golang.org/x/oauth2"
	"golang.org/x/oauth2/google"
	"google.golang.org/api/docs/v1"
	"google.golang.org/api/option"
)

// Retrieves a token, saves the token, then returns the generated client.
func getClient(config *oauth2.Config) *http.Client {
	tokFile := "token.json"
	tok, err := tokenFromFile(tokFile)
	if err != nil {
		tok = getTokenFromWeb(config)
		saveToken(tokFile, tok)
	}
	return config.Client(context.Background(), tok)
}

// Requests 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(oauth2.NoContext, 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)
	defer f.Close()
	if err != nil {
		return nil, err
	}
	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)
	defer f.Close()
	if err != nil {
		log.Fatalf("Unable to cache OAuth token: %v", err)
	}
	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/documents.readonly")
	if err != nil {
		log.Fatalf("Unable to parse client secret file to config: %v", err)
	}
	client := getClient(config)

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

	// Prints the title of the requested doc:
	// https://docs.google.com/document/d/195j9eDD3ccgjQRttHhJPymLJUCOUjs-jmwTrekvdjFE/edit
	docId := "195j9eDD3ccgjQRttHhJPymLJUCOUjs-jmwTrekvdjFE"
	doc, err := srv.Documents.Get(docId).Do()
	if err != nil {
		log.Fatalf("Unable to retrieve data from document: %v", err)
	}
	fmt.Printf("The title of the doc is: %s\n", doc.Title)
}

Beispiel ausführen

Erstellen Sie das Beispiel in Ihrem Arbeitsverzeichnis und führen Sie es aus:
```
go run quickstart.go
```

Wenn Sie das Beispiel zum ersten Mal ausführen, werden Sie aufgefordert, den Zugriff zu autorisieren: <ph type="x-smartling-placeholder">
1. Wenn Sie noch nicht in Ihrem Google-Konto angemeldet sind, melden Sie sich an, wenn Sie dazu aufgefordert werden. Wenn Sie in mehreren Konten angemeldet sind, wählen Sie ein Konto für die Autorisierung aus.
2. Klicken Sie auf Akzeptieren.
Ihre Go-Anwendung wird ausgeführt und ruft die Google Docs API auf.

Autorisierungsinformationen werden im Dateisystem gespeichert. Wenn Sie das Beispiel das nächste Mal ausführen, Code eingeben, werden Sie nicht zur Autorisierung aufgefordert.