Visão geral da autenticação

Nesta página, você terá uma visão geral da autenticação na plataforma do Google Cloud para desenvolvedores de aplicativos (anteriormente conhecida como Google Cloud Platform ou GCP). Aqui estão descritos os principais, as credenciais de aplicativo e várias maneiras de autenticar chamadas para as APIs do Google Cloud.

Introdução

O controle de acesso para as APIs da plataforma engloba autenticação, autorização e auditoria. A autenticação determina quem você é, a autorização determina o que é possível fazer e os registros de auditoria gravam o que você fez.

O foco nesta página é a autenticação. Para autorização, consulte Cloud Identity and Access Management (Cloud IAM). Para auditoria, consulte Registros de auditoria do Cloud.

Principais

Um principal é uma entidade, também conhecida como identidade, que pode receber acesso a um recurso. As APIs do Google Cloud são compatíveis com dois tipos de principais: contas de usuário e contas de serviço.

As contas de usuário são gerenciadas como Contas do Google e representam um desenvolvedor, administrador ou qualquer outra pessoa que interaja com o Google Cloud. Elas são destinadas a cenários em que seu aplicativo precisa acessar recursos em nome de um usuário humano.

As contas de serviço são gerenciadas pelo Cloud IAM e representam usuários não humanos. Elas são destinadas a cenários em que seu aplicativo precisa acessar recursos ou executar ações por conta própria, como executar aplicativos do App Engine ou interagir com instâncias do Compute Engine.

Consulte Visão geral do Cloud IAM para mais informações sobre cada tipo de conta.

Apps

As APIs do Google Cloud aceitam somente solicitações de aplicativos registrados, ou seja, aplicativos exclusivamente identificáveis que apresentem uma credencial no momento da solicitação. Solicitações de aplicativos anônimos são rejeitadas.

As credenciais de aplicativo fornecem as informações necessárias sobre como o autor da chamada fez uma solicitação para uma API do Google Cloud. Os tipos de credenciais válidos incluem chaves de API, credenciais de cliente do OAuth 2.0 ou chaves de contas de serviço. As contas de serviço são exclusivas, porque podem ser usadas como uma credencial do aplicativo ou uma identidade principal. Consulte Como entender as contas de serviço para mais informações.

A apresentação de credenciais de aplicativos em solicitações para as APIs do Google Cloud só identifica o autor da chamada como um aplicativo registrado. Se a autenticação for necessária, será preciso que o cliente identifique o principal que está executando o aplicativo, como uma conta de usuário ou conta de serviço. Esse processo está descrito na seção abaixo.

Estratégias de autenticação

As APIs do Google Cloud usam o protocolo OAuth 2.0 (em inglês) para autenticar contas de usuário e de serviço. O processo de autenticação do OAuth 2.0 determina o principal e o aplicativo.

A maioria das APIs do Google Cloud também oferece suporte ao acesso anônimo a dados públicos usando chaves de API. No entanto, as chaves de API só identificam o aplicativo, não o principal. Ao usar chaves de API, o principal precisa ser autenticado por outros meios.

As APIs do Google Cloud são compatíveis com vários fluxos de autenticação para diferentes ambientes de execução. Para a melhor experiência de desenvolvedor, recomendamos usar bibliotecas de cliente do Google Cloud com as APIs da plataforma. Eles usam bibliotecas de autenticação fornecidas pelo Google compatíveis com uma variedade de fluxos de autenticação e ambientes de execução.

Para criar um aplicativo usando as APIs do Google Cloud, siga estas etapas gerais:

  • Escolha e use as bibliotecas de cliente do Cloud fornecidas.
  • Determine o fluxo de autenticação correto para seu aplicativo.
  • Encontre ou crie as credenciais necessárias para seu aplicativo.
  • Transmita as credenciais do aplicativo às bibliotecas de cliente no momento da inicialização do aplicativo, de preferência por meio do Application Default Credentials (ADC).

Você deve escolher as credenciais do aplicativo com base no que o aplicativo precisa e onde ele é executado. Na tabela a seguir, há algumas recomendações gerais para requisitos comuns:

Requisito Recomendação Comentário
Acesso a dados públicos anonimamente Chave de API Uma chave de API só identifica o aplicativo e não requer autenticação do usuário. Ela é suficiente para acessar dados públicos.
Acesso a dados privados em nome de um usuário final Cliente OAuth 2.0 Um cliente OAuth 2.0 identifica o aplicativo e permite que os usuários finais autentiquem seu aplicativo com o Google. Ele permite que seu aplicativo acesse as APIs do Google Cloud em nome do usuário final.
Acesso a dados privados em nome de uma conta de serviço dentro de ambientes do GCP Conta de serviço fornecida pelo ambiente Se seu aplicativo for executado em um ambiente do GCP, como o Compute Engine, o App Engine, o GKE, o Cloud Run ou o Cloud Functions, ele terá de usar a conta de serviço fornecida pelo ambiente.

As bibliotecas de cliente do Cloud encontrarão e usarão as credenciais da conta de serviço automaticamente.
Como acessar dados privados em nome de uma conta de serviço fora dos ambientes do Google Cloud Chave da conta de serviço Você precisa criar uma conta de serviço e fazer o download da chave privada dela como um arquivo JSON. É necessário passar o arquivo para as bibliotecas de cliente do Cloud, para que possam gerar as credenciais da conta de serviço no ambiente de execução.

As bibliotecas de cliente do Cloud encontrarão e usarão as credenciais da conta de serviço automaticamente usando a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS.

Exemplos

Os exemplos de código a seguir mostram como usar diferentes estratégias de autenticação usando a versão da linguagem Go da biblioteca de cliente do Pub/Sub. A experiência do desenvolvedor em outras linguagens é praticamente a mesma.

Chaves da conta de serviço

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
}
Para mais informações, consulte como autenticar aplicativos de servidor.

Contas de serviço do ambiente

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
}
Para mais informações, consulte como autenticar aplicativos de servidor.

Clientes 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
}
Para saber mais, consulte como realizar a autenticação como usuário final.

Chaves de 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
}
Para saber mais, consulte como usar chaves de API.