Présentation de l'authentification

Cette page présente l'authentification dans Google Cloud Platform (GCP) à l'intention des développeurs d'applications. Elle décrit les comptes principaux et les identifiants d'application, ainsi que différentes méthodes d'authentification des appels d'API GCP.

Présentation

Le contrôle d'accès concernant les API GCP 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 journaux d'audit enregistrent ce que vous avez fait.

Cette page traite de l'authentification. Pour une description de l'autorisation, consultez la documentation de Cloud Identity and Access Management (Cloud 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 GCP acceptent deux types de comptes principaux : les comptes utilisateur et les comptes de service.

Les comptes utilisateur sont gérés comme des comptes Google et peuvent représenter un développeur, un administrateur ou toute autre personne interagissant avec GCP. Ils sont destinés aux scénarios dans lesquels une application doit accéder à des ressources pour le compte d'un utilisateur.

Les comptes de service sont gérés par Cloud 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.

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

Applications

Les API GCP acceptent uniquement les requêtes émanant des applications enregistrées, c'est-à-dire des applications identifiables de façon unique qui présentent un identifiant au moment de la requête. Les requêtes provenant d'applications anonymes sont refusées.

L'identifiant d'une application fournit les informations requises sur l'appelant qui envoie une requête à une API GCP. 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 de l'identifiant de l'application dans les requêtes envoyées aux API GCP permet uniquement d'identifier l'appelant en tant qu'application enregistrée. Si une authentification est requise, le client doit également identifier le compte principal exécutant l'application, par exemple un compte utilisateur ou un compte de service. Ce processus est décrit dans la section ci-dessous.

Stratégies d'authentification

Les API GCP ont recours au protocole OAuth 2.0 pour authentifier les comptes utilisateur aussi bien que 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 GCP acceptent également l'accès anonyme aux données publiques à l'aide de 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 GCP acceptent différents 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 GCP. 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 GCP, procédez comme suit :

  • Sélectionnez et utilisez les bibliothèques clientes 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. Il permet ainsi à votre application d'accéder aux API GCP au nom de l'utilisateur final.
Accès à des données privées pour le compte d'un compte de service dans les environnements GCP Compte de service fourni par l'environnement Si votre application s'exécute dans un environnement GCP tel que Compute Engine, App Engine, GKE, Cloud Run ou Cloud Functions, elle doit utiliser le compte de service fourni par cet environnement.
Les bibliothèques clientes Cloud récupèrent 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 GCP 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 ce fichier aux bibliothèques clientes Cloud, afin qu'elles puissent générer les identifiants du compte de service lors de l'exécution.

Les bibliothèques clientes Cloud récupèrent 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 mettre en œuvre différentes stratégies d'authentification à l'aide d'une bibliothèque cliente Cloud dans l'environnement Go. 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 documentation sur l'authentification d'applications serveur.

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 documentation sur l'authentification d'applications serveur.

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 plus d'informations, consultez la page S'authentifier 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.