Descripción general de la autenticación

En esta página, se proporciona una descripción general de la autenticación en la plataforma de Google Cloud para desarrolladores de aplicaciones (antes conocida como Google Cloud Platform o GCP). Se describen los principales, las credenciales de aplicaciones y diversas formas de autenticar las llamadas a las API de Google Cloud.

Introducción

En el control de acceso para las API de la plataforma, se abarca la autenticación, la autorización y la auditoría. La autenticación determina quién eres, la autorización determina lo que puedes hacer y los registros de auditoría registran lo que hiciste.

En esta página, se explica en detalle la autenticación. Para obtener una autorización, consulta Cloud Identity and Access Management (Cloud IAM). Para realizar una auditoría, consulta Cloud Audit Logs.

Principales

Un principal es una entidad, también conocida como una identidad, a la que se le puede otorgar acceso a un recurso. Las API de Google Cloud admiten dos tipos de principales: cuentas de usuario y cuentas de servicio.

Las cuentas de usuario se administran como Cuentas de Google y representan a un desarrollador, un administrador o cualquier otra persona que interactúe con Google Cloud. Se crearon para situaciones en las que la aplicación necesita acceder a los recursos en nombre de un usuario humano.

Cloud IAM administra las cuentas de servicio, que representan a usuarios que no son humanos. Se crearon para situaciones en las que la aplicación necesita acceder a recursos o realizar acciones por su cuenta, como ejecutar apps de App Engine o interactuar con instancias de Compute Engine.

Consulta la descripción general de Cloud IAM para obtener más información sobre cada tipo de cuenta.

Aplicaciones

Las API de Google Cloud solo aceptan solicitudes de aplicaciones registradas, que son aplicaciones de identificación única que presentan una credencial en el momento de la solicitud. Las solicitudes de aplicaciones anónimas se rechazan.

Las credenciales de aplicaciones proporcionan la información necesaria sobre el emisor que realiza una solicitud a una API de Google  Cloud. Los tipos de credenciales válidos incluyen las claves de API, las credenciales de cliente de OAuth 2.0 o las claves de cuentas de servicio. Las cuentas de servicio son únicas, ya que se pueden usar como una identidad principal o como credenciales de aplicaciones. Consulta cómo funcionan las cuentas de servicio para obtener más información.

Cuando se presentan credenciales de aplicaciones en las solicitudes a las API de Google Cloud, solo se identifica al emisor como una aplicación registrada. Si se requiere autenticación, el cliente también deberá identificar al principal que ejecuta la aplicación, como una cuenta de usuario o de servicio. Este proceso se describe en la siguiente sección.

Estrategias de autenticación

Las API de Google Cloud usan el protocolo OAuth 2.0 para autenticar cuentas de usuario y de servicio. El proceso de autenticación de OAuth 2.0 determina el principal y la aplicación.

La mayoría de las API de Google Cloud también admiten el acceso anónimo a datos públicos mediante claves de API. Sin embargo, las claves de API solo identifican a la aplicación y no al principal. Cuando se usan claves de API, el principal se debe autenticar por otros medios.

Las API de Google Cloud admiten varios flujos de autenticación para distintos entornos de ejecución. Para obtener la mejor experiencia como desarrollador, recomendamos usar las bibliotecas cliente de Google Cloud con las API de Google Cloud. Estas usan bibliotecas de autenticación proporcionadas por Google que admiten una variedad de flujos de autenticación y entornos de ejecución.

Si deseas compilar una aplicación con las API de Google Cloud, sigue estos pasos generales:

  • Elige y usa las bibliotecas cliente de Cloud proporcionadas
  • Determina el flujo de autenticación adecuado para la aplicación
  • Encuentra o crea las credenciales necesarias para la aplicación
  • Pasa las credenciales de la aplicación a las bibliotecas cliente en el momento de inicio de la aplicación, de ser posible, a través de las Credenciales predeterminadas de la aplicación (ADC)

Debes elegir las credenciales de la aplicación en función de las necesidades de la aplicación y del lugar en el que se ejecuta. En la siguiente tabla, se proporcionan algunas recomendaciones generales para los requisitos comunes:

Requisito Recomendación Comentario
Acceder a los datos públicos de forma anónima Clave de API Una clave de API solo identifica la aplicación y no requiere la autenticación del usuario. Es suficiente para acceder a los datos públicos.
Acceder a los datos privados en nombre de un usuario final Cliente de OAuth 2.0 Un cliente de OAuth 2.0 identifica la aplicación y permite que los usuarios finales autentiquen la aplicación con Google. Permite que la aplicación acceda a las API de Google Cloud en nombre del usuario final.
Acceder a los datos privados en nombre de una cuenta de servicio dentro de los entornos de GCP Cuenta de servicio proporcionada por el entorno Si la aplicación se ejecuta dentro de un entorno de GCP, como Compute Engine, App Engine, GKE, Cloud Run o Cloud Functions, la aplicación debe usar la cuenta de servicio que el entorno proporciona.

Las bibliotecas cliente de Cloud buscarán y usarán las credenciales de la cuenta de servicio de forma automática.
Acceder a los datos privados en nombre de una cuenta de servicio fuera de los entornos de Google Cloud Clave de cuenta de servicio Debes crear una cuenta de servicio y descargar su clave privada como un archivo JSON. Debes pasar el archivo a las bibliotecas cliente de Cloud a fin de que puedan generar las credenciales de la cuenta de servicio en el entorno de ejecución.

Las bibliotecas cliente de Cloud buscarán y usarán las credenciales de la cuenta de servicio de forma automática mediante la variable de entorno GOOGLE_APPLICATION_CREDENTIALS.

Ejemplos

En los siguientes ejemplos de código, se muestra cómo usar distintas estrategias de autenticación con la versión de lenguaje Go de la biblioteca cliente de Pub/Sub. La experiencia del desarrollador con otros lenguajes es casi la misma.

Claves de cuenta de servicio

auth/overview/service_account.go
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 obtener más información, consulta cómo autenticar las aplicaciones del servidor.

Cuentas de servicio del entorno

auth/overview/env_service_account.go
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 obtener más información, consulta cómo autenticar las aplicaciones del servidor.

Clientes de OAuth 2.0

auth/overview/oauth_client.go
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 obtener más información, consulta cómo autenticarte como usuario final.

Claves de API

auth/overview/api_key.go
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
}
Consulta Usar claves de API para obtener más información.