Als Dienstkonto authentifizieren

In diesem Thema wird erklärt, wie Sie eine Anwendung als Dienstkonto authentifizieren können. Allgemeine Informationen zur Authentifizierung bei Google Cloud APIs, einschließlich gängiger Authentifizierungsszenarien und -strategien, finden Sie in der Übersicht zu Authentifizierung. Weitere Informationen zu Dienstkonten finden Sie in der Dokumentation zu Identitäts- und Zugriffsverwaltung unter Dienstkonten.

Anmeldedaten automatisch finden

Wenn Ihre Anwendung in einer Google Cloud-Umgebung ausgeführt wird und Sie an diese Umgebung ein Dienstkonto angehängt haben, kann Ihre Anwendung Anmeldedaten für das Dienstkonto abrufen. Die Anwendung kann diese Anmeldedaten dann zum Aufrufen von Google Cloud APIs verwenden.

Sie können Dienstkonten mit Ressourcen für viele verschiedene Google Cloud-Dienste verbinden, z. B. Compute Engine, Google Kubernetes Engine, App Engine, Cloud Run und Cloud Functions. Wir empfehlen diese Strategie, da sie praktischer und sicherer ist, als die Anmeldedaten manuell zu übergeben.

Darüber hinaus empfehlen wir die Verwendung von Google Cloud-Clientbibliotheken für Ihre Anwendung. Google Cloud-Clientbibliotheken verwenden eine Bibliothek namens "Standardanmeldedaten für Anwendungen" (Application Default Credentials, ADC), um die Anmeldedaten Ihres Dienstkontos automatisch zu finden. ADC sucht in der folgenden Reihenfolge nach Anmeldedaten für Dienstkonten:

  1. Wenn die Umgebungsvariable GOOGLE_APPLICATION_CREDENTIALS festgelegt ist, verwendet ADC den Dienstkontoschlüssel oder die Konfigurationsdatei, auf die die Variable verweist.

  2. Wenn die Umgebungsvariable GOOGLE_APPLICATION_CREDENTIALS nicht festgelegt ist, verwendet ADC das Dienstkonto, das an die Ressource angehängt ist, die Ihren Code ausführt.

    Dieses Dienstkonto kann ein Standarddienstkonto sein, das von Compute Engine, Google Kubernetes Engine, App Engine, Cloud Run oder Cloud Functions bereitgestellt wird. Es kann auch ein nutzerverwaltetes Dienstkonto sein, das Sie erstellt haben.

  3. Wenn ADC keine der oben genannten Anmeldedaten verwenden kann, tritt ein Fehler auf.

Das folgende Codebeispiel zeigt, wie Sie die ADC-Bibliothek in Ihrem Anwendungscode verwenden können. Sie müssen die Cloud Storage-Clientbibliothek installieren, um dieses Beispiel auszuführen.

C#

public object AuthImplicit(string projectId)
{
    // If you don't specify credentials when constructing the client, the
    // client library will look for credentials in the environment.
    var credential = GoogleCredential.GetApplicationDefault();
    var storage = StorageClient.Create(credential);
    // Make an authenticated API request.
    var buckets = storage.ListBuckets(projectId);
    foreach (var bucket in buckets)
    {
        Console.WriteLine(bucket.Name);
    }
    return null;
}

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

Anmeldedaten manuell übergeben

Wenn Ihre Anwendung in einer Umgebung ausgeführt wird, in der kein Dienstkonto angehängt ist, z. B. lokal oder bei einem anderen Cloud-Anbieter, sollten Sie die Workload Identity-Föderation verwenden.

Wenn Sie die Workload Identity-Föderation nicht verwenden können, müssen Sie ein Dienstkonto und einen oder mehrere Dienstkontoschlüssel erstellen. Dies sind die dem Dienstkonto zugeordneten Anmeldedaten. Die Dienstkontoschlüssel können dann manuell an Ihre Anwendung übergeben werden.

Best Practices für die Verwaltung von Dienstkontoschlüsseln

Dienstkonto erstellen

In den folgenden Schritten wird beschrieben, wie Sie ein Dienstkonto erstellen, wenn Sie noch keines haben:

Console

Erstellen Sie ein Dienstkonto:

  1. Wechseln Sie in der Cloud Console zur Seite Dienstkonto erstellen.

    Zur Seite „Dienstkonto erstellen“
  2. Wählen Sie Ihr Projekt aus.

  3. Geben Sie im Feld Dienstkontoname einen Namen ein. Die Cloud Console füllt das Feld Dienstkonto-ID anhand dieses Namens aus.

    Geben Sie im Feld Dienstkontobeschreibung eine Beschreibung ein. Beispiel: Service account for quickstart.

  4. Klicken Sie auf Erstellen und fortfahren.

  5. Um Zugriff auf Ihr Projekt zu gewähren, weisen Sie Ihrem Dienstkonto die folgenden Rollen zu: Projekt > Inhaber .

    Wählen Sie in der Liste Rolle auswählen eine Rolle aus.

    Klicken Sie auf Weitere Rolle hinzufügen, um weitere Rollen hinzuzufügen.

  6. Klicken Sie auf Weiter.

  7. Klicken Sie auf Fertig, um das Erstellen des Dienstkontos abzuschließen.

    Schließen Sie das Browserfenster nicht. Sie verwenden es in der nächsten Aufgabe.

Erstellen Sie einen Dienstkontoschlüssel:

  1. Klicken Sie in der Cloud Console auf die E-Mail-Adresse des von Ihnen erstellten Dienstkontos.
  2. Klicken Sie auf Schlüssel.
  3. Klicken Sie auf Schlüssel hinzufügen und dann auf Neuen Schlüssel erstellen.
  4. Klicken Sie auf Erstellen. Daraufhin wird eine JSON-Schlüsseldatei auf Ihren Computer heruntergeladen.
  5. Klicken Sie auf Schließen.

gcloud

Richten Sie die Authentifizierung ein:

  1. Erstellen Sie das Dienstkonto. Ersetzen Sie NAME durch einen Namen für das Dienstkonto: 

    gcloud iam service-accounts create NAME

  2. Weisen Sie dem Dienstkonto Rollen zu. Führen Sie den Befehl roles/owner für jede der folgenden IAM-Rollen einmal aus: 

    gcloud projects add-iam-policy-binding PROJECT_ID --member="serviceAccount:NAME@PROJECT_ID.iam.gserviceaccount.com" --role=ROLE

    Dabei gilt:

    • NAME: der Name des Dienstkontos
    • PROJECT_ID: die Projekt-ID, unter der Sie das Dienstkonto erstellt haben
    • ROLE: die zu gewährende Rolle

  3. Erstellen Sie die Schlüsseldatei: 

    gcloud iam service-accounts keys create FILE_NAME.json --iam-account=NAME@PROJECT_ID.iam.gserviceaccount.com

    Dabei gilt:

    • FILE_NAME: ein Name für die Schlüsseldatei
    • NAME: der Name des Dienstkontos
    • PROJECT_ID: die Projekt-ID, unter der Sie das Dienstkonto erstellt haben

Anmeldedaten mit einer Umgebungsvariable übergeben

Geben Sie die Anmeldedaten zur Authentifizierung für Ihren Anwendungscode durch Festlegung der Umgebungsvariable GOOGLE_APPLICATION_CREDENTIALS an. Diese Variable gilt nur für Ihre aktuelle Shellsitzung. Wenn Sie möchten, dass die Variable für zukünftige Shell-Sitzungen gilt, legen Sie die Variable in Ihrer Shell-Startdatei fest, z. B. in der Datei ~/.bashrc oder ~/.profile.

Linux oder macOS

export GOOGLE_APPLICATION_CREDENTIALS="KEY_PATH"

Geben Sie für KEY_PATH den Dateipfad der JSON-Datei an, die Ihren Dienstkontoschlüssel enthält.

Beispiel:

export GOOGLE_APPLICATION_CREDENTIALS="/home/user/Downloads/service-account-file.json"

Windows

Für PowerShell:

$env:GOOGLE_APPLICATION_CREDENTIALS="KEY_PATH"

Geben Sie für KEY_PATH den Dateipfad der JSON-Datei an, die Ihren Dienstkontoschlüssel enthält.

Beispiel:

$env:GOOGLE_APPLICATION_CREDENTIALS="C:\Users\username\Downloads\service-account-file.json"

Für Eingabeaufforderung:

set GOOGLE_APPLICATION_CREDENTIALS=KEY_PATH

Geben Sie für KEY_PATH den Dateipfad der JSON-Datei an, die Ihren Dienstkontoschlüssel enthält.

Nachdem Sie die oben genannten Schritte ausgeführt haben, kann ADC Ihre Anmeldedaten automatisch finden. Dies wurde im Abschnitt oben beschrieben. Wir empfehlen die Verwendung von Standardanmeldedaten für Anwendungen, da es weniger Codeeingaben erfordert und der Code in verschiedene Umgebungen portierbar ist.

Anmeldedaten mithilfe von Code übergeben

Alternativ können Sie im Code explizit auf Ihre Dienstkontodatei verweisen. Dies wird im folgenden Beispiel gezeigt. Für das folgende Beispiel müssen Sie die Cloud Storage-Clientbibliothek installieren.

C#

        // Some APIs, like Storage, accept a credential in their Create()
        // method.
        public object AuthExplicit(string projectId, string jsonPath)
        {
            // Explicitly use service account credentials by specifying
            // the private key file.
            var credential = GoogleCredential.FromFile(jsonPath);
            var storage = StorageClient.Create(credential);
            // Make an authenticated API request.
            var buckets = storage.ListBuckets(projectId);
            foreach (var bucket in buckets)
            {
                Console.WriteLine(bucket.Name);
            }
            return null;
        }
        // Other APIs, like Language, accept a channel in their Create()
        // method.
        public object AuthExplicit(string projectId, string jsonPath)
        {
            LanguageServiceClientBuilder builder = new LanguageServiceClientBuilder
            {
                CredentialsPath = jsonPath
            };

            LanguageServiceClient client = builder.Build();
            AnalyzeSentiment(client);
            return 0;
        }

Go


// explicit reads credentials from the specified path.
func explicit(jsonPath, projectID string) {
	ctx := context.Background()
	client, err := storage.NewClient(ctx, option.WithCredentialsFile(jsonPath))
	if err != nil {
		log.Fatal(err)
	}
	defer client.Close()
	fmt.Println("Buckets:")
	it := client.Buckets(ctx, projectID)
	for {
		battrs, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			log.Fatal(err)
		}
		fmt.Println(battrs.Name)
	}
}

Java

static void authExplicit(String jsonPath) throws IOException {
  // You can specify a credential file by providing a path to GoogleCredentials.
  // Otherwise credentials are read from the GOOGLE_APPLICATION_CREDENTIALS environment variable.
  GoogleCredentials credentials = GoogleCredentials.fromStream(new FileInputStream(jsonPath))
        .createScoped(Lists.newArrayList("https://www.googleapis.com/auth/cloud-platform"));
  Storage storage = StorageOptions.newBuilder().setCredentials(credentials).build().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. Explicitly use service account credentials by
// specifying the private key file. All clients in google-cloud-node have this
// helper, see https://github.com/GoogleCloudPlatform/google-cloud-node/blob/master/docs/authentication.md
// const projectId = 'project-id'
// const keyFilename = '/path/to/keyfile.json'
const storage = new Storage({projectId, keyFilename});

// Makes an authenticated API request.
async function listBuckets() {
  try {
    const [buckets] = await storage.getBuckets();

    console.log('Buckets:');
    buckets.forEach(bucket => {
      console.log(bucket.name);
    });
  } catch (err) {
    console.error('ERROR:', err);
  }
}
listBuckets();

PHP

namespace Google\Cloud\Samples\Auth;

// Imports the Cloud Storage client library.
use Google\Cloud\Storage\StorageClient;

/**
 * Authenticate to a cloud client library using a service account explicitly.
 *
 * @param string $projectId           The Google project ID.
 * @param string $serviceAccountPath  Path to service account credentials JSON.
 */
function auth_cloud_explicit($projectId, $serviceAccountPath)
{
    # Explicitly use service account credentials by specifying the private key
    # file.
    $config = [
        'keyFilePath' => $serviceAccountPath,
        'projectId' => $projectId,
    ];
    $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 explicit():
    from google.cloud import storage

    # Explicitly use service account credentials by specifying the private key
    # file.
    storage_client = storage.Client.from_service_account_json(
        'service_account.json')

    # Make an authenticated API request
    buckets = list(storage_client.list_buckets())
    print(buckets)

Ruby

# project_id = "Your Google Cloud project ID"
# key_file   = "path/to/service-account.json"
require "google/cloud/storage"

# Explicitly use service account credentials by specifying the private key
# file.
storage = Google::Cloud::Storage.new project: project_id, keyfile: key_file

# Make an authenticated API request
storage.buckets.each do |bucket|
  puts bucket.name
end

API-Fehler beheben

Weitere Informationen über die Fehlerbehandlung bei fehlgeschlagenen Anfragen in Fehlerbehebung für Cloud-APIs.

Nächste Schritte

Jetzt testen

Wenn Sie mit Google Cloud noch nicht vertraut sind, erstellen Sie einfach ein Konto, um die Leistungsfähigkeit unserer Produkte in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.

Jetzt kostenlos starten