Descripción general de la autenticación

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

Introducción

El control de acceso para las API de GCP 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 GCP admiten dos tipos de principales: las cuentas de usuario y las 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 GCP. 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 Descripción general de Cloud IAM para obtener más información sobre cada tipo de cuenta.

Aplicaciones

Las API de GCP 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 requerida sobre el emisor que realiza una solicitud a una API de GCP. 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.

La presentación de credenciales de aplicaciones en las solicitudes a las API de GCP solo 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 una cuenta de servicio. Este proceso se describe en la siguiente sección.

Estrategias de autenticación

Las API de GCP usan el protocolo OAuth 2.0 para autenticar las cuentas de usuario y las cuentas 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 GCP también admiten el acceso anónimo a los datos públicos mediante claves de API. Sin embargo, las claves de API solo identifican a la aplicación, pero no al principal. Cuando se usan claves de API, el principal se debe autenticar por otros medios.

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

Para compilar una aplicación mediante las API de GCP, 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 GCP 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 proporcionada por el entorno.
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 GCP 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, de forma 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 mediante la biblioteca cliente de Cloud en Go. La experiencia del desarrollador en 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
}
Para obtener más información, consulta la página sobre cómo usar claves de API.