Authentifizierung

Diese Seite bietet eine Übersicht über die Authentifizierung auf der Google Cloud-Plattform für Anwendungsentwickler (früher bekannt als die Google Cloud Platform oder GCP). Darin werden Hauptkonten, Anmeldedaten für Anwendungen und verschiedene Möglichkeiten zur Authentifizierung von Aufrufen bei Google Cloud APIs beschrieben.

Einführung

Die Zugriffssteuerung für die Google Cloud APIs umfasst Authentifizierung, Autorisierung und Auditing. Die Authentifizierung bestimmt, wer Sie sind, die Autorisierung bestimmt, was Sie tun können, und die Audit-Logs zeichnen auf, was Sie getan haben.

Auf dieser Seite geht es um Authentifizierung. Informationen zur Autorisierung finden Sie unter Identity and Access Management (IAM). Informationen zum Auditing finden Sie unter Cloud-Audit-Logs.

Hauptkonten

Ein Hauptkonto ist eine Entität, die auch als Identität bezeichnet wird und der Zugriff auf eine Ressource gewährt werden kann. Google Cloud APIs unterstützen zwei Arten von Hauptkonten: Nutzerkonten und Dienstkonten:

  • Nutzerkonten werden als Google-Konten verwaltet und stellen einen Entwickler, Administrator oder eine andere Person dar, die mit Google Cloud interagiert. Sie sind für Szenarien gedacht, in denen Ihre Anwendung im Namen eines menschlichen Nutzers auf Ressourcen zugreifen muss. Weitere Informationen finden Sie unter Als Endnutzer authentifizieren.

  • Dienstkonten werden von IAM verwaltet und stellen nicht menschliche Nutzer dar. Sie sind für Szenarien gedacht, in denen Ihre Anwendung auf Ressourcen zugreifen oder selbst Aktionen wie das Ausführen von App Engine-Anwendungen oder das Interagieren mit Compute Engine-Instanzen durchführen muss. Weitere Informationen finden Sie unter Als Dienstkonto authentifizieren.

Weitere Informationen zu jedem Kontotyp finden Sie in der IAM-Übersicht.

Anwendungen

Google Cloud APIs akzeptieren nur Anfragen von registrierten Anwendungen, bei denen es sich um eindeutig identifizierbare Anwendungen handelt, die zum Zeitpunkt der Anfrage über Anmeldedaten verfügen. Anfragen von anonymen Anwendungen werden abgelehnt.

Anmeldedaten für Anwendungen enthalten die erforderlichen Informationen über den Aufrufer, der eine Anfrage an eine Google Cloud API sendet. Gültige Anmeldedaten sind API-Schlüssel, OAuth 2.0-Clientanmeldedaten oder Dienstkontoschlüssel. Dienstkonten sind eindeutig, da sie sowohl als Anwendungsanmeldedaten als auch als Hauptidentität verwendet werden können. Weitere Details finden Sie in den Informationen zu Dienstkonten.

Wenn Anmeldedaten für Anwendungen in Anfragen an Google Cloud APIs verwendet werden, wird der Aufrufer nur als registrierte Anwendung identifiziert. Wenn eine Authentifizierung erforderlich ist, muss der Client auch das Hauptkonto identifizieren, das die Anwendung ausführt, wie z. B. ein Nutzerkonto oder ein Dienstkonto. Dieser Vorgang wird im folgenden Abschnitt beschrieben.

Authentifizierungsstrategien

Google Cloud APIs verwenden das OAuth 2.0-Protokoll zur Authentifizierung sowohl von Nutzerkonten als auch von Dienstkonten. Der OAuth 2.0-Authentifizierungsprozess bestimmt sowohl das Hauptkonto als auch die Anwendung.

Die meisten Google Cloud APIs unterstützen auch den anonymen Zugriff auf öffentliche Daten mithilfe von API-Schlüsseln. API-Schlüssel identifizieren jedoch nur die Anwendung, nicht das Hauptkonto. Bei der Verwendung von API-Schlüsseln muss das Hauptkonto auf andere Weise authentifiziert werden.

Google Cloud APIs unterstützen mehrere Authentifizierungsabläufe für verschiedene Laufzeitumgebungen. Für eine optimale Entwicklung empfehlen wir die Verwendung von Google Cloud-Clientbibliotheken mit Google Cloud APIs. Sie verwenden von Google bereitgestellte Authentifizierungsbibliotheken, die eine Vielzahl von Authentifizierungsabläufen und Laufzeitumgebungen unterstützen.

Führen Sie die folgenden allgemeinen Schritte aus, um eine Anwendung zu erstellen, die Google Cloud APIs verwendet:

  • Wählen Sie die bereitgestellten Google Cloud-Clientbibliotheken aus und verwenden Sie sie.
  • Bestimmen Sie den korrekten Authentifizierungsablauf für Ihre Anwendung.
  • Suchen oder erstellen Sie die für Ihre Anwendung erforderlichen Anmeldedaten.
  • Übergeben Sie zum Startzeitpunkt der Anwendung die Anwendungsanmeldedaten an die Clientbibliotheken, idealerweise über Standardanmeldedaten für Anwendungen (Application Default Credentials, ADC).

Sie sollten die Anwendungsanmeldedaten basierend auf den Anforderungen Ihrer Anwendung und der Ausführungsumgebung auswählen. Die folgende Tabelle enthält einige Empfehlungen für allgemeine Anforderungen:

Anforderung Empfehlung Kommentar
Auf öffentliche Daten ohne Anmeldedaten zugreifen API-Schlüssel Ein API-Schlüssel identifiziert nur die Anwendung und erfordert keine Nutzerauthentifizierung. Dies ist für den Zugriff auf öffentliche Daten ausreichend.
Auf private Daten im Namen eines Endnutzers zugreifen OAuth 2.0-Client Ein OAuth 2.0-Client identifiziert die Anwendung und ermöglicht es Endnutzern, Ihre Anwendung bei Google zu authentifizieren. Dadurch kann Ihre Anwendung im Namen des Endnutzers auf Google Cloud APIs zugreifen.
Innerhalb von Google Cloud-Umgebungen im Namen eines Dienstkontos auf private Daten zugreifen Von der Umgebung bereitgestelltes Dienstkonto Wenn Ihre Anwendung in einer Google Cloud-Umgebung wie Compute Engine, App Engine, GKE, Cloud Run oder Cloud Functions ausgeführt wird, sollte sie das von der Umgebung bereitgestellte Dienstkonto verwenden.

Google Cloud-Clientbibliotheken suchen und verwenden automatisch die Anmeldedaten für das Dienstkonto.
Außerhalb von Google Cloud-Umgebungen im Namen eines Dienstkontos auf private Daten zugreifen Dienstkontoschlüssel Sie müssen ein Dienstkonto erstellen und den privaten Schlüssel als JSON-Datei herunterladen. Sie müssen die Datei an Google Cloud-Clientbibliotheken übergeben, damit sie die Anmeldedaten für das Dienstkonto zur Laufzeit generieren können.

Google Cloud-Clientbibliotheken suchen und verwenden die Anmeldedaten für das Dienstkonto automatisch mithilfe der Umgebungsvariablen GOOGLE_APPLICATION_CREDENTIALS.

Beispiele

Die folgenden Codebeispiele zeigen, wie verschiedene Authentifizierungsstrategien mithilfe der Go-Sprachversion der Pub/Sub-Clientbibliothek verwendet werden. Die Entwicklung für andere Sprachen ist nahezu identisch.

Dienstkontoschlüssel

import (
	"context"
	"fmt"

	"cloud.google.com/go/pubsub"
)

// serviceAccount shows how to use a service account to authenticate.
func serviceAccount() error {
	// Download service account key per https://cloud.google.com/docs/authentication/production.
	// Set environment variable GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account-key.json
	// This environment variable will be automatically picked up by the client.
	client, err := pubsub.NewClient(context.Background(), "your-project-id")
	if err != nil {
		return fmt.Errorf("pubsub.NewClient: %v", err)
	}
	// Use the authenticated client.
	_ = client

	return nil
}
Weitere Informationen finden Sie unter Authentifizierung als Dienstkonto.

Umgebungsdienstkonten

import (
	"context"
	"fmt"

	"cloud.google.com/go/pubsub"
)

// envServiceAccount shows how to use an environment-provided service account to authenticate.
func envServiceAccount() error {
	// If your application runs in a GCP environment, such as Compute Engine,
	// you don't need to provide any application credentials. The client
	// library will find the credentials by itself.
	client, err := pubsub.NewClient(context.Background(), "your-project-id")
	if err != nil {
		return fmt.Errorf("pubsub.NewClient: %v", err)
	}
	// Use the authenticated client.
	_ = client

	return nil
}
Weitere Informationen finden Sie unter Authentifizierung als Dienstkonto.

OAuth 2.0-Clients

import (
	"context"
	"fmt"
	"os"

	"cloud.google.com/go/pubsub"
	"golang.org/x/oauth2"
	"golang.org/x/oauth2/google"
	"google.golang.org/api/option"
)

// oauthClient shows how to use an OAuth client ID to authenticate as an end-user.
func oauthClient() error {
	ctx := context.Background()

	// Please make sure the redirect URL is the same as the one you specified when you
	// created the client ID.
	redirectURL := os.Getenv("OAUTH2_CALLBACK")
	if redirectURL == "" {
		redirectURL = "your redirect url"
	}
	config := &oauth2.Config{
		ClientID:     "your-client-id",
		ClientSecret: "your-client-secret",
		RedirectURL:  redirectURL,
		Scopes:       []string{"email", "profile"},
		Endpoint:     google.Endpoint,
	}

	// Dummy authorization flow to read auth code from stdin.
	authURL := config.AuthCodeURL("your state")
	fmt.Printf("Follow the link in your browser to obtain auth code: %s", authURL)

	// Read the authentication code from the command line
	var code string
	fmt.Scanln(&code)

	// Exchange auth code for OAuth token.
	token, err := config.Exchange(ctx, code)
	if err != nil {
		return fmt.Errorf("config.Exchange: %v", err)
	}
	client, err := pubsub.NewClient(ctx, "your-project-id", option.WithTokenSource(config.TokenSource(ctx, token)))

	// Use the authenticated client.
	_ = client

	return nil
}
Weitere Informationen finden Sie unter Als Endnutzer authentifizieren.

API-Schlüssel

import (
	"context"
	"fmt"

	"cloud.google.com/go/pubsub"
	"google.golang.org/api/option"
)

// apiKey shows how to use an API key to authenticate.
func apiKey() error {
	client, err := pubsub.NewClient(context.Background(), "your-project-id", option.WithAPIKey("api-key-string"))
	if err != nil {
		return fmt.Errorf("pubsub.NewClient: %v", err)
	}
	// Use the authenticated client.
	_ = client

	return nil
}
Weitere Informationen finden Sie unter API-Schlüssel verwenden.

Weitere Informationen