Zugriffssteuerung einrichten

Mit der Zugriffssteuerung wird bestimmt, wer berechtigt ist, auf Dienste und Ressourcen in einem Google Cloud-Projekt zuzugreifen. In App Engine gibt es einige verschiedene Anwendungsfälle für die Einrichtung der Zugriffssteuerung:

Diese Seite bietet für jeden Anwendungsfall eine Übersicht über die Einrichtung der Zugriffssteuerung.

Hintergrundinformationen zur Zugriffssteuerung mit der Google Cloud Platform finden Sie in der Übersicht über Identity and Access Management (IAM).

Teammitgliedern Zugriff gewähren

Wenn Sie einem Entwickler Zugriff auf Ihr Cloud-Projekt gewähren möchten, erstellen Sie mindestens eines der beiden folgenden Konten:

  • Ein Nutzerkonto, das mit einem Google-Konto verknüpft ist und eine bestimmte Person in Ihrem Projekt repräsentiert.

    Mit einem Nutzerkonto können Sie sich über die folgenden Tools authentifizieren:

    • Google Cloud Console
    • Cloud SDK-Tools wie das gcloud-Befehlszeilentool
    • IDEs und Build-Tools, die Cloud SDK-Tools zum Testen und Bereitstellen von App Engine-Anwendungen verwenden
  • Ein Dienstkonto, das statt einer Person eine Anwendung oder einen Prozess darstellen soll. Verwenden Sie Dienstkonten in Ihren automatisierten Build-, Test- und Bereitstellungsprozessen, insbesondere wenn mehrere Entwickler diese Prozesse ausführen können.

    Sie können ein Dienstkonto für die Authentifizierung über die folgenden Tools verwenden:

    • Cloud SDK-Tools wie das gcloud-Befehlszeilentool
    • IDEs und Build-Tools, die Cloud SDK-Tools zum Testen und Bereitstellen von App Engine-Anwendungen verwenden

Nutzerkonto erstellen

  1. Öffnen Sie in der Cloud Console die Seite „IAM“.

    Zur Seite „IAM“

  2. Klicken Sie auf Projekt auswählen, wählen Sie ein Projekt aus und klicken Sie auf Öffnen.

  3. Klicken Sie auf Hinzufügen.

  4. Geben Sie eine E-Mail-Adresse ein.

  5. Wählen Sie Rollen aus, die Zugriff auf App Engine-Features gewähren.

    Wenn der Nutzer auch Zugriff auf andere Cloud-Dienste benötigt, wählen Sie Rollen aus, die Zugriff auf andere Cloud-Dienste gewähren.

  6. Klicken Sie auf Speichern.

Der Nutzer kann sich jetzt in der Google Cloud Console anmelden und Cloud SDK-Tools autorisieren.

Sie können auch Nutzerkonten über gcloud, die REST API oder Clientbibliotheken erstellen.

Dienstkonto erstellen

  1. Öffnen Sie in der Cloud Console die Seite Dienstkonten.

    Seite „Dienstkonten“ öffnen

  2. Wählen Sie Ihr Projekt aus und klicken Sie auf Öffnen.

  3. Klicken Sie auf Dienstkonto erstellen.

  4. Geben Sie einen Namen für das Dienstkonto ein. Dieser Name sollte für die Anzeige nutzerfreundlich sein.

  5. Klicken Sie auf Erstellen.

  6. Wählen Sie Rollen aus, die Zugriff auf App Engine-Features gewähren.

    Wenn das Dienstkonto auch Zugriff auf andere Cloud-Dienste benötigt, wählen Sie Rollen aus, die Zugriff auf andere Cloud-Dienste gewähren.

  7. Klicken Sie auf Weiter.

  8. Geben Sie optional Nutzerkonten an, die das Dienstkonto verwalten können. Sie können auch Nutzerkonten angeben, die über das Dienstkonto indirekt auf alle Ressourcen zugreifen können, auf die das Dienstkonto Zugriff hat.

  9. Klicken Sie auf Speichern.

    Eine Liste der vorhandenen Dienstkonten wird angezeigt.

  10. Wenn Sie Ihr Dienstkonto außerhalb von Google Cloud verwenden müssen, folgen Sie der Anleitung zum Erstellen eines Dienstkontoschlüssels.

Tipp

  • Wenn Sie das Dienstkonto in Ihren automatisierten Build- und Bereitstellungsprozessen verwenden, autorisieren Sie das Cloud SDK mit einem Dienstkonto.
  • Wenn Sie das Dienstkonto mit einer IDE verwenden, folgen Sie der Anleitung der IDE.
  • Wenn Sie beim Zugriff auf andere Google Cloud-Dienste oder beim Ausführen von Aufgaben eine eindeutige Identität für eine Version Ihrer App Engine-Anwendung verwenden müssen, können Sie in App Engine ein nutzerverwaltetes Dienstkonto angeben.

Anwendung Zugriff auf Cloud-Dienste gewähren

Jeder Aufruf eines Cloud-Dienstes muss authentifiziert und autorisiert werden, einschließlich der Aufrufe anderer Cloud-Dienste wie Cloud Storage mit einer App Engine-Anwendung.

Standardmäßig sind Aufrufe der Dienste mit Ihrer App Engine-Anwendung autorisiert, die sich im selben Projekt befinden. So funktioniert der Standardablauf:

  1. Um Aufrufe eines Cloud-Dienstes zu initiieren, erstellt Ihre Anwendung ein Clientobjekt, das die Anmeldedaten und andere Daten enthält, die sie benötigt, um mit dem Dienst zu interagieren. Wenn Sie keine Anmeldedaten im Konstruktor des Clients angeben, sucht der Client in der Anwendungsumgebung nach Anmeldedaten.

    Beispiel für das Erstellen eines Clients für Cloud Storage:

    Go

    
    // implicit uses Application Default Credentials to authenticate.
    func implicit() {
    	ctx := context.Background()
    
    	// For API packages whose import path is starting with "cloud.google.com/go",
    	// such as cloud.google.com/go/storage in this case, if there are no credentials
    	// provided, the client library will look for credentials in the environment.
    	storageClient, err := storage.NewClient(ctx)
    	if err != nil {
    		log.Fatal(err)
    	}
    	defer storageClient.Close()
    
    	it := storageClient.Buckets(ctx, "project-id")
    	for {
    		bucketAttrs, err := it.Next()
    		if err == iterator.Done {
    			break
    		}
    		if err != nil {
    			log.Fatal(err)
    		}
    		fmt.Println(bucketAttrs.Name)
    	}
    
    	// For packages whose import path is starting with "google.golang.org/api",
    	// such as google.golang.org/api/cloudkms/v1, use NewService to create the client.
    	kmsService, err := cloudkms.NewService(ctx)
    	if err != nil {
    		log.Fatal(err)
    	}
    
    	_ = kmsService
    }
    

    Java

    static void authImplicit() {
      // If you don't specify credentials when constructing the client, the client library will
      // look for credentials via the environment variable GOOGLE_APPLICATION_CREDENTIALS.
      Storage storage = StorageOptions.getDefaultInstance().getService();
    
      System.out.println("Buckets:");
      Page<Bucket> buckets = storage.list();
      for (Bucket bucket : buckets.iterateAll()) {
        System.out.println(bucket.toString());
      }
    }

    Node.js

    // Imports the Google Cloud client library.
    const {Storage} = require('@google-cloud/storage');
    
    // Instantiates a client. If you don't specify credentials when constructing
    // the client, the client library will look for credentials in the
    // environment.
    const storage = new Storage();
    // Makes an authenticated API request.
    async function listBuckets() {
      try {
        const results = await storage.getBuckets();
    
        const [buckets] = results;
    
        console.log('Buckets:');
        buckets.forEach(bucket => {
          console.log(bucket.name);
        });
      } catch (err) {
        console.error('ERROR:', err);
      }
    }
    listBuckets();

    PHP

    // Imports the Cloud Storage client library.
    use Google\Cloud\Storage\StorageClient;
    
    /**
     * Authenticate to a cloud client library using a service account implicitly.
     *
     * @param string $projectId The Google project ID.
     */
    function auth_cloud_implicit($projectId)
    {
        $config = [
            'projectId' => $projectId,
        ];
    
        # If you don't specify credentials when constructing the client, the
        # client library will look for credentials in the environment.
        $storage = new StorageClient($config);
    
        # Make an authenticated API request (listing storage buckets)
        foreach ($storage->buckets() as $bucket) {
            printf('Bucket: %s' . PHP_EOL, $bucket->name());
        }
    }

    Python

    def implicit():
        from google.cloud import storage
    
        # If you don't specify credentials when constructing the client, the
        # client library will look for credentials in the environment.
        storage_client = storage.Client()
    
        # Make an authenticated API request
        buckets = list(storage_client.list_buckets())
        print(buckets)

    Ruby

    # project_id = "Your Google Cloud project ID"
    
    require "google/cloud/storage"
    
    # If you don't specify credentials when constructing the client, the client
    # library will look for credentials in the environment.
    storage = Google::Cloud::Storage.new project: project_id
    
    # Make an authenticated API request
    storage.buckets.each do |bucket|
      puts bucket.name
    end
  2. Standardmäßig enthält die Anwendungsumgebung Anmeldedaten aus dem App Engine-Standarddienstkonto.

    Dieses Dienstkonto wird von Google angelegt, wenn Sie eine App Engine-Anwendung erstellen. Es erhält die vollständigen Berechtigungen zum Verwalten und Verwenden aller Cloud-Dienste in einem GCP-Projekt.

Sie können diesen Standardablauf mit einer der folgenden Methoden überschreiben:

  • Legen Sie die Umgebungsvariable GOOGLE_APPLICATION_CREDENTIALS fest. Wenn diese Variable festgelegt ist, verwenden Cloud-Dienste die von der Variablen angegebenen Anmeldedaten anstelle der Daten aus dem Standarddienstkonto.

  • Geben Sie Anmeldedaten an, wenn Sie das Objekt Client für einen Cloud-Dienst instanziieren. Wenn Ihre Anwendung beispielsweise einen Cloud-Dienst in einem anderen Projekt aufruft, müssen Sie möglicherweise Anmeldedaten manuell übergeben.

Wenn Sie die Umgebungsvariable GOOGLE_APPLICATION_CREDENTIALS festlegen oder in Ihrem Code Anmeldedaten übergeben, empfehlen wir, die Anmeldedaten auf eine der folgenden Arten zu speichern:

  • Speichern Sie Ihre Anmeldedaten an einem sicheren Ort wie Datastore und rufen Sie sie zur Laufzeit ab.
  • Behalten Sie die Anmeldedaten im Code bei, aber verschlüsseln Sie sie mit einem Schlüsselspeicher wie Cloud KMS.

Informationen zu den Vorteilen der einzelnen Methoden finden Sie unter Secret-Verwaltungslösung auswählen.

Nutzern Zugriff auf Cloud-Ressourcen gewähren

Wenn Sie möchten, dass Ihre Anwendung Nutzerdaten von einem anderen Google-Dienst liest, müssen Sie OAuth 2.0 für Webserveranwendungen einrichten. Wenn Sie beispielsweise die Daten eines Nutzers aus Google Drive abrufen und in Ihre Anwendung übernehmen möchten, verwenden Sie OAuth 2.0 für Webserveranwendungen, um bestimmte Daten freizugeben, während andere Daten wie Nutzernamen und Passwörter privat bleiben.

Domainweite Übertragung von Befugnissen in Google Workspace

Wenn Sie eine Google Workspace-Domain (ehemals G Suite) haben, kann ein Administrator der Domain eine Anwendung dazu autorisieren, im Namen von Nutzern in der Google Workspace-Domain auf Nutzerdaten zuzugreifen. Beispielsweise nutzt eine Anwendung, die die Google Calendar API zum Hinzufügen von Ereignissen zu den Kalendern aller Nutzer in einer Google Workspace-Domain verwendet, ein Dienstkonto, um im Namen der Nutzer auf die Google Calendar API zuzugreifen.

Das Autorisieren eines Dienstkontos für den Zugriff auf Daten im Namen von Nutzern in einer Domain wird manchmal als „Übertragen domainweiter Befugnisse“ an ein Dienstkonto bezeichnet. Dieser Schritt setzt weiterhin OAuth 2.0 voraus und erfordert, dass ein Google Workspace-Domainadministrator die domainweiten Befugnisse für das Dienstkonto autorisiert.

Dienstkonto angeben

Mit App Engine können Sie zwei Arten von Dienstkonten verwenden:

  • Das App Engine-Standarddienstkonto wird standardmäßig automatisch mit der Rolle „Bearbeiter“ erstellt und ist die Standardidentität für alle Versionen Ihrer App Engine-Anwendung, wenn kein nutzerverwaltetes Dienstkonto angegeben ist. Wir empfehlen, die Standardberechtigungen für Ihr Standarddienstkonto in die Rollen zu ändern, die den Zugriffsanforderungen Ihrer App Engine-Anwendung besser entsprechen.
  • Das nutzerverwaltete Dienstkonto (Vorschau) ist ein Dienstkonto, das Sie in Identity and Access Management (IAM) erstellen. Sie können ein nutzerverwaltetes Dienstkonto für eine Version angeben. Es wird verwendet, wenn Sie auf andere App Engine-Dienste zugreifen und Aufgaben für diese Version ausführen.