Présentation de l'authentification

Cette page présente l'authentification sur la plate-forme de Google Cloud pour les développeurs d'applications. Elle décrit les comptes principaux, les identifiants d'application et les différentes méthodes d'authentification des appels vers les API Google Cloud.

Présentation

Le contrôle d'accès pour les API Google Cloud comprend l'authentification, l'autorisation et l'audit. L'authentification établit qui vous êtes, l'autorisation détermine ce que vous pouvez faire et les audits enregistrent ce que vous avez fait.

Cette page traite de l'authentification. Pour en savoir plus sur l'autorisation, consultez la page Gestion de l'authentification et des accès (IAM). Pour une description de l'audit, consultez la page Journaux d'audit Cloud.

Comptes principaux

Un compte principal est une entité, également appelée identité, qui peut se voir accorder l'accès à une ressource. Les API Google Cloud sont compatibles avec deux types d'entités principales : les comptes utilisateur et les comptes de service.

  • Les comptes utilisateur sont gérés comme des comptes Google et représentent un développeur, un administrateur ou toute autre personne interagissant avec Google Cloud. Ils sont destinés aux scénarios dans lesquels une application doit accéder à des ressources pour le compte d'un utilisateur. Pour en savoir plus, consultez la page Authentification en tant qu'utilisateur final.

  • Les comptes de service sont gérés par IAM et représentent des utilisateurs non humains. Ils sont destinés aux scénarios dans lesquels une application doit accéder à des ressources ou effectuer des actions pour son propre compte, comme exécuter des applications App Engine ou interagir avec des instances Compute Engine. Consultez la section Authentification en tant que compte de service pour plus d'informations.

Pour en savoir plus sur chaque type de compte, consultez la présentation d'IAM.

Applications

Les API Google Cloud n'acceptent que les requêtes provenant d'applications enregistrées, qui sont des applications identifiables de manière unique et qui présentent des informations d'identification au moment de la requête. Les requêtes provenant d'applications anonymes sont refusées.

Les identifiants d'application fournissent les informations requises sur l'appelant qui envoie une requête à une API Google Cloud. Les types d'identifiants valides sont les clés API, les identifiants client OAuth 2.0 et les clés de compte de service. Les comptes de service sont uniques dans la mesure où ils peuvent servir à la fois d'identifiant d'application ou d'identité principale. Pour en savoir plus, consultez la page Comprendre les comptes de service.

La présentation des identifiants d'application dans les requêtes envoyées aux API Google Cloud identifie uniquement l'appelant en tant qu'application enregistrée. Si une authentification est requise, le client doit également identifier l'entité principale exécutant l'application, telle qu'un compte utilisateur ou un compte de service. Ce processus est décrit dans la section ci-dessous.

Stratégies d'authentification

Les API Google Cloud utilisent le protocole OAuth 2.0 pour authentifier à la fois les comptes utilisateur et les comptes de service. Le processus d'authentification OAuth 2.0 détermine à la fois le compte principal et l'application.

La plupart des API Google Cloud sont également compatibles avec l'accès anonyme aux données publiques à l'aide des clés API. Toutefois, les clés API identifient uniquement l'application, et non le compte principal. Lorsque vous utilisez des clés API, le compte principal doit être authentifié par d'autres moyens.

Les API Google Cloud sont compatibles avec plusieurs flux d'authentification selon l'environnement d'exécution. Afin d'optimiser l'expérience développeur, nous vous recommandons d'utiliser les bibliothèques clientes Google Cloud avec les API Google Cloud. Celles-ci exploitent des bibliothèques d'authentification fournies par Google qui prennent en charge divers flux d'authentification et environnements d'exécution.

Pour créer une application à l'aide des API Google Cloud, procédez comme suit :

  • Sélectionnez et utilisez les bibliothèques clientes Google Cloud fournies.
  • Déterminez le flux d'authentification approprié pour votre application.
  • Recherchez ou créez les identifiants d'application requis pour votre application.
  • Transmettez les identifiants d'application aux bibliothèques clientes lors du démarrage de l'application, de préférence via les identifiants par défaut de l'application (ADC).

Vous devez choisir les identifiants d'application en fonction des besoins de votre application et de son contexte d'exécution. Le tableau suivant fournit des recommandations générales correspondant aux exigences les plus courantes :

Exigence Recommandation Commentaire
Accès anonyme aux données publiques Clé API Une clé API identifie uniquement l'application et ne nécessite pas d'authentification de l'utilisateur. Cette méthode est donc suffisante pour l'accès aux données publiques.
Accès à des données privées pour le compte d'un utilisateur final Client OAuth 2.0 Un client OAuth 2.0 identifie l'application et permet aux utilisateurs finaux d'authentifier votre application auprès de Google. Cela permet à votre application d'accéder aux API Google Cloud pour le compte de l'utilisateur final.
Accès à des données privées au nom d'un compte de service dans les environnements Google Cloud Compte de service fourni par l'environnement Si votre application s'exécute dans un environnement Google Cloud, tel que Compute Engine, App Engine, GKE, Cloud Run ou Cloud Functions, elle doit utiliser le compte de service fourni par l'environnement.

Les bibliothèques clientes Google Cloud trouvent et utilisent automatiquement les identifiants du compte de service.
Accès à des données privées pour le compte d'un compte de service en dehors des environnements Google Cloud Clé de compte de service Vous devez créer un compte de service et télécharger sa clé privée sous la forme d'un fichier JSON. Vous devez transmettre le fichier aux bibliothèques clientes Google Cloud afin qu'elles puissent générer les identifiants du compte de service lors de l'exécution.

Les bibliothèques clientes Google Cloud trouvent et utilisent automatiquement les identifiants du compte de service à l'aide de la variable d'environnement GOOGLE_APPLICATION_CREDENTIALS.

Exemples

Les exemples de code suivants montrent comment utiliser différentes stratégies d'authentification à l'aide de la version en langage Go de la bibliothèque cliente Pub/Sub. L'expérience développeur est pratiquement identique dans les autres langages.

Clés de compte de service

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
}
Pour en savoir plus, consultez la section Authentification en tant que compte de service.

Comptes de service de l'environnement

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
}
Pour en savoir plus, consultez la section Authentification en tant que compte de service.

Clients OAuth 2.0

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
}
Pour en savoir plus, consultez la section Authentification en tant qu'utilisateur final.

Clés API

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
}
Pour plus d'informations, consultez la section Utiliser des clés API.

Étapes suivantes