Configura la autenticación para aplicaciones de producción de servidor a servidor

En esta guía se explica cómo configurar la autenticación y autorización en las aplicaciones de producción de servidor a servidor. La autenticación hace referencia al proceso de determinar la identidad de un cliente. La autorización hace referencia al proceso de determinar los permisos que un cliente autenticado tiene para un recurso específico. Es decir, la autenticación identifica quién eres y la autorización determina lo que puedes hacer. Para obtener más información sobre los métodos de autenticación compatibles y cómo elegirlos, consulta la Descripción general de la autenticación.

Google usa credenciales para identificar las cuotas y la facturación de tus aplicaciones. Las credenciales también se usan para autorizar el acceso a las API, los recursos y las funciones de GCP.

Proporciona credenciales para tu aplicación

Encuentra credenciales automáticamente

Las bibliotecas cliente de GCP usan una estrategia llamada credenciales predeterminadas de la aplicación (ADC) para encontrar las credenciales. Si tu código usa una biblioteca cliente, la estrategia comprueba las credenciales en el siguiente orden:

  1. Primero, ADC comprueba si se configuró la variable GOOGLE_APPLICATION_CREDENTIALS del entorno. Si está configurada, ADC usa el archivo de cuenta de servicio al que apunta la variable. En la siguiente sección se describe cómo configurar la variable de entorno.

  2. Si no se configuró la variable de entorno, ADC usa la cuenta de servicio predeterminada que proporciona Compute Engine, Kubernetes Engine, Cloud Run, App Engine y Cloud Functions para las aplicaciones que se ejecutan en esos servicios.

  3. Se mostrará un error si ADC no puede usar ninguna de las credenciales ya mencionadas.

Esta estrategia se describe en el siguiente ejemplo de código, pero no se especifican las credenciales de la aplicación de forma explícita. Sin embargo, ADC puede encontrar las credenciales implícitamente solo si configuraste la variable de entorno GOOGLE_APPLICATION_CREDENTIALS o si la aplicación se ejecuta en Compute Engine, Kubernetes Engine, App Engine o Cloud Functions.

Instala la biblioteca cliente de Cloud Storage para ejecutar el siguiente ejemplo.

C#

public object AuthImplicit(string projectId)
{
    // If you don't specify credentials when constructing the client, the
    // client library will look for credentials in the environment.
    var credential = GoogleCredential.GetApplicationDefault();
    var storage = StorageClient.Create(credential);
    // Make an authenticated API request.
    var buckets = storage.ListBuckets(projectId);
    foreach (var bucket in buckets)
    {
        Console.WriteLine(bucket.Name);
    }
    return null;
}

Go


// implicit uses Application Default Credentials to authenticate.
func implicit() {
	ctx := context.Background()

	// For API packages whose import path is starting with "cloud.google.com/go",
	// such as cloud.google.com/go/storage in this case, if there are no credentials
	// provided, the client library will look for credentials in the environment.
	storageClient, err := storage.NewClient(ctx)
	if err != nil {
		log.Fatal(err)
	}

	it := storageClient.Buckets(ctx, "project-id")
	for {
		bucketAttrs, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			log.Fatal(err)
		}
		fmt.Println(bucketAttrs.Name)
	}

	// For packages whose import path is starting with "google.golang.org/api",
	// such as google.golang.org/api/cloudkms/v1, use NewService to create the client.
	kmsService, err := cloudkms.NewService(ctx)
	if err != nil {
		log.Fatal(err)
	}

	_ = kmsService
}

Java

static void authImplicit() {
  // If you don't specify credentials when constructing the client, the client library will
  // look for credentials via the environment variable GOOGLE_APPLICATION_CREDENTIALS.
  Storage storage = StorageOptions.getDefaultInstance().getService();

  System.out.println("Buckets:");
  Page<Bucket> buckets = storage.list();
  for (Bucket bucket : buckets.iterateAll()) {
    System.out.println(bucket.toString());
  }
}

Node.js

// Imports the Google Cloud client library.
const {Storage} = require('@google-cloud/storage');

// Instantiates a client. If you don't specify credentials when constructing
// the client, the client library will look for credentials in the
// environment.
const storage = new Storage();

try {
  // Makes an authenticated API request.
  const results = await storage.getBuckets();

  const [buckets] = results;

  console.log('Buckets:');
  buckets.forEach(bucket => {
    console.log(bucket.name);
  });
} catch (err) {
  console.error('ERROR:', err);
}

PHP

// Imports the Cloud Storage client library.
use Google\Cloud\Storage\StorageClient;

function auth_cloud_implicit($projectId)
{
    $config = [
        'projectId' => $projectId,
    ];

    # If you don't specify credentials when constructing the client, the
    # client library will look for credentials in the environment.
    $storage = new StorageClient($config);

    # Make an authenticated API request (listing storage buckets)
    foreach ($storage->buckets() as $bucket) {
        printf('Bucket: %s' . PHP_EOL, $bucket->name());
    }
}

Python

def implicit():
    from google.cloud import storage

    # If you don't specify credentials when constructing the client, the
    # client library will look for credentials in the environment.
    storage_client = storage.Client()

    # Make an authenticated API request
    buckets = list(storage_client.list_buckets())
    print(buckets)

Ruby

# project_id = "Your Google Cloud project ID"

require "google/cloud/storage"

# If you don't specify credentials when constructing the client, the client
# library will look for credentials in the environment.
storage = Google::Cloud::Storage.new project: project_id

# Make an authenticated API request
storage.buckets.each do |bucket|
  puts bucket.name
end

Esta estrategia es útil cuando se ejecutan pruebas y experimentos, pero puede dificultar saber qué credenciales está usando tu aplicación. Recomendamos especificar de forma explícita qué credenciales debe usar la aplicación, como se describe en la siguiente sección.

Obtén y proporciona las credenciales de la cuenta de servicio de forma manual

Si desarrollas código de manera local, implementas tu aplicación de manera local o en otra nube pública, puedes crear y obtener las credenciales de la cuenta de servicio de forma manual.

Crea una cuenta de servicio

Mediante los siguientes pasos se describe cómo crear una cuenta de servicio. Sin embargo, en lugar de configurar permisos en el nivel del propietario, debes restringir el acceso a los permisos, tal como se describe en la sección sobre restricción del acceso que se muestra a continuación.

Proporciona las credenciales de la cuenta de servicio

Tienes dos opciones para proporcionar las credenciales a tu aplicación después de crear una cuenta de servicio. Puedes configurar la variable de entorno GOOGLE_APPLICATION_CREDENTIALS explícitamente o pasar la ruta a la clave de la cuenta de servicio en código.

Configura la variable del entorno

Proporciona credenciales de autenticación a tu código de la aplicación configurando la variable de entorno GOOGLE_APPLICATION_CREDENTIALS. Reemplaza [PATH] con la ruta de acceso al archivo JSON que contiene la clave de tu cuenta de servicio y [FILE_NAME] con el nombre del archivo. Esta variable solo se aplica a la sesión actual de shell. Por lo tanto, si abres una sesión nueva, deberás volver a configurar la variable.

Linux o macOS

export GOOGLE_APPLICATION_CREDENTIALS="[PATH]"

Por ejemplo:

export GOOGLE_APPLICATION_CREDENTIALS="/home/user/Downloads/[FILE_NAME].json"

Windows

Con PowerShell:

$env:GOOGLE_APPLICATION_CREDENTIALS="[PATH]"

Por ejemplo:

$env:GOOGLE_APPLICATION_CREDENTIALS="C:\Users\username\Downloads\[FILE_NAME].json"

Con el símbolo del sistema:

set GOOGLE_APPLICATION_CREDENTIALS=[PATH]

Cuando completes los pasos anteriores, ADC podrá determinar las credenciales de forma implícita, tal como se describió en la sección anterior sobre cómo proporcionar credenciales a la aplicación. Recomendamos usar este método, porque requiere menos código. Además, cuando usas la variable de entorno, tu código es más portátil, ya que puedes ejecutar el mismo código en múltiples entornos con diferentes cuentas de servicio.

Pasa la ruta hacia la clave de la cuenta de servicio en el código

También puedes usar el código para apuntar de forma explícita hacia el archivo de la cuenta de servicio, como se muestra en el siguiente ejemplo de código.

Instala la biblioteca cliente de Cloud Storage para ejecutar el siguiente ejemplo.

C#

// Some APIs, like Storage, accept a credential in their Create()
// method.
public object AuthExplicit(string projectId, string jsonPath)
{
    // Explicitly use service account credentials by specifying
    // the private key file.
    var credential = GoogleCredential.FromFile(jsonPath);
    var storage = StorageClient.Create(credential);
    // Make an authenticated API request.
    var buckets = storage.ListBuckets(projectId);
    foreach (var bucket in buckets)
    {
        Console.WriteLine(bucket.Name);
    }
    return null;
}
// Other APIs, like Language, accept a channel in their Create()
// method.
public object AuthExplicit(string projectId, string jsonPath)
{
    var credential = GoogleCredential.FromFile(jsonPath)
        .CreateScoped(LanguageServiceClient.DefaultScopes);
    var channel = new Grpc.Core.Channel(
        LanguageServiceClient.DefaultEndpoint.ToString(),
        credential.ToChannelCredentials());
    var client = LanguageServiceClient.Create(channel);
    AnalyzeSentiment(client);
    return 0;
}

Go


// explicit reads credentials from the specified path.
func explicit(jsonPath, projectID string) {
	ctx := context.Background()
	client, err := storage.NewClient(ctx, option.WithCredentialsFile(jsonPath))
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Buckets:")
	it := client.Buckets(ctx, projectID)
	for {
		battrs, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			log.Fatal(err)
		}
		fmt.Println(battrs.Name)
	}
}

Java

static void authExplicit(String jsonPath) throws IOException {
  // You can specify a credential file by providing a path to GoogleCredentials.
  // Otherwise credentials are read from the GOOGLE_APPLICATION_CREDENTIALS environment variable.
  GoogleCredentials credentials = GoogleCredentials.fromStream(new FileInputStream(jsonPath))
        .createScoped(Lists.newArrayList("https://www.googleapis.com/auth/cloud-platform"));
  Storage storage = StorageOptions.newBuilder().setCredentials(credentials).build().getService();

  System.out.println("Buckets:");
  Page<Bucket> buckets = storage.list();
  for (Bucket bucket : buckets.iterateAll()) {
    System.out.println(bucket.toString());
  }
}

Node.js

// Imports the Google Cloud client library.
const {Storage} = require('@google-cloud/storage');

// Instantiates a client. Explicitly use service account credentials by
// specifying the private key file. All clients in google-cloud-node have this
// helper, see https://github.com/GoogleCloudPlatform/google-cloud-node/blob/master/docs/authentication.md
// const projectId = 'project-id'
// const keyFilename = '/path/to/keyfile.json'
const storage = new Storage({projectId, keyFilename});

// Makes an authenticated API request.
try {
  const [buckets] = await storage.getBuckets();

  console.log('Buckets:');
  buckets.forEach(bucket => {
    console.log(bucket.name);
  });
} catch (err) {
  console.error('ERROR:', err);
}

PHP

namespace Google\Cloud\Samples\Auth;

// Imports the Cloud Storage client library.
use Google\Cloud\Storage\StorageClient;

function auth_cloud_explicit($projectId, $serviceAccountPath)
{
    # Explicitly use service account credentials by specifying the private key
    # file.
    $config = [
        'keyFilePath' => $serviceAccountPath,
        'projectId' => $projectId,
    ];
    $storage = new StorageClient($config);

    # Make an authenticated API request (listing storage buckets)
    foreach ($storage->buckets() as $bucket) {
        printf('Bucket: %s' . PHP_EOL, $bucket->name());
    }
}

Python

def explicit():
    from google.cloud import storage

    # Explicitly use service account credentials by specifying the private key
    # file.
    storage_client = storage.Client.from_service_account_json(
        'service_account.json')

    # Make an authenticated API request
    buckets = list(storage_client.list_buckets())
    print(buckets)

Ruby

# project_id = "Your Google Cloud project ID"
# key_file   = "path/to/service-account.json"
require "google/cloud/storage"

# Explicitly use service account credentials by specifying the private key
# file.
storage = Google::Cloud::Storage.new project: project_id, keyfile: key_file

# Make an authenticated API request
storage.buckets.each do |bucket|
  puts bucket.name
end

Obtén credenciales en Compute Engine, Kubernetes Engine, el entorno flexible de App Engine y Cloud Functions

Si tu aplicación se ejecuta en Compute Engine, Kubernetes Engine, el entorno flexible de App Engine o Cloud Functions, no es necesario que crees tu propia cuenta de servicio. Compute Engine incluye una cuenta de servicio predeterminada que se crea automáticamente y puedes asignar una cuenta de servicio diferente para cada instancia, si es necesario. Cuando creas una instancia nueva, esta se habilita automáticamente para que se ejecute como la cuenta de servicio predeterminada y tiene un conjunto predeterminado de permisos de autorización. Para obtener más información, consulta Cuenta de servicio predeterminada de Compute Engine.

Después de configurar una cuenta de servicio, ADC ubica las credenciales de forma implícita sin necesidad de cambiar el código, tal como se describió en la sección anterior. Si quieres especificar que se usen credenciales de Compute Engine, puedes hacerlo de forma explícita tal como se muestra en el siguiente ejemplo de código.

Instala la biblioteca cliente de Cloud Storage para ejecutar el siguiente ejemplo.

C#

// Some APIs, like Storage, accept a credential in their Create()
// method.
public object AuthExplicitComputeEngine(string projectId)
{
    // Explicitly request service account credentials from the compute
    // engine instance.
    GoogleCredential credential =
        GoogleCredential.FromComputeCredential();
    var storage = StorageClient.Create(credential);
    // Make an authenticated API request.
    var buckets = storage.ListBuckets(projectId);
    foreach (var bucket in buckets)
    {
        Console.WriteLine(bucket.Name);
    }
    return null;
}
// Other APIs, like Language, accept a channel in their Create()
// method.
public object AuthExplicitComputeEngine(string projectId)
{
    var credential = GoogleCredential.FromComputeCredential();
    var channel = new Grpc.Core.Channel(
        LanguageServiceClient.DefaultEndpoint.ToString(),
        credential.ToChannelCredentials());
    var client = LanguageServiceClient.Create(channel);
    AnalyzeSentiment(client);
    return 0;
}

Go


// explicitDefault finds the default credentials.
//
// It is very uncommon to need to explicitly get the default credentials in Go.
// Most of the time, client libraries can use Application Default Credentials
// without having to pass the credentials in directly. See implicit above.
func explicitDefault(projectID string) {
	ctx := context.Background()

	creds, err := google.FindDefaultCredentials(ctx, storage.ScopeReadOnly)
	if err != nil {
		log.Fatal(err)
	}
	client, err := storage.NewClient(ctx, option.WithCredentials(creds))
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Buckets:")
	it := client.Buckets(ctx, projectID)
	for {
		battrs, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			log.Fatal(err)
		}
		fmt.Println(battrs.Name)
	}
}

Java

static void authCompute() {
  // Explicitly request service account credentials from the compute engine instance.
  GoogleCredentials credentials = ComputeEngineCredentials.create();
  Storage storage = StorageOptions.newBuilder().setCredentials(credentials).build().getService();

  System.out.println("Buckets:");
  Page<Bucket> buckets = storage.list();
  for (Bucket bucket : buckets.iterateAll()) {
    System.out.println(bucket.toString());
  }
}

Node.js

'use strict';

const {auth, Compute} = require('google-auth-library');

/**
 * This example directly instantiates a Compute client to acquire credentials.
 * Generally, you wouldn't directly create this class, rather call the
 * `auth.getClient()` method to automatically obtain credentials.
 */
async function main() {
  const client = new Compute({
    // Specifying the serviceAccountEmail is optional. It will use the default
    // service account if one is not defined.
    serviceAccountEmail: 'some-service-account@example.com',
  });
  const projectId = await auth.getProjectId();
  const url = `https://dns.googleapis.com/dns/v1/projects/${projectId}`;
  const res = await client.request({url});
  console.log(res.data);
}

main().catch(console.error);

PHP

namespace Google\Cloud\Samples\Auth;

// Imports GCECredentials and the Cloud Storage client library.
use Google\Auth\Credentials\GCECredentials;
use Google\Cloud\Storage\StorageClient;

function auth_cloud_explicit_compute_engine($projectId)
{
    $gceCredentials = new GCECredentials();
    $config = [
        'projectId' => $projectId,
        'credentialsFetcher' => $gceCredentials,
    ];
    $storage = new StorageClient($config);

    # Make an authenticated API request (listing storage buckets)
    foreach ($storage->buckets() as $bucket) {
        printf('Bucket: %s' . PHP_EOL, $bucket->name());
    }
}

Python

def explicit_compute_engine(project):
    from google.auth import compute_engine
    from google.cloud import storage

    # Explicitly use Compute Engine credentials. These credentials are
    # available on Compute Engine, App Engine Flexible, and Container Engine.
    credentials = compute_engine.Credentials()

    # Create the client using the credentials and specifying a project ID.
    storage_client = storage.Client(credentials=credentials, project=project)

    # Make an authenticated API request
    buckets = list(storage_client.list_buckets())
    print(buckets)

Ruby

require "googleauth"
require "google/cloud/env"
require "google/cloud/storage"

# Explicitly use Compute Engine credentials and a project ID to create a new
# Cloud Storage client. These credentials are available on Compute Engine,
# App Engine Flexible, and Container Engine.
storage = Google::Cloud::Storage.new project: Google::Cloud.env.project_id,
                                     keyfile: Google::Auth::GCECredentials.new

# Make an authenticated API request
storage.buckets.each do |bucket|
  puts bucket.name
end

Obtén credenciales en el entorno estándar de App Engine

Puedes usar la API de App Identity de App Engine para obtener credenciales si tu aplicación se ejecuta en el entorno estándar de App Engine.

Después de configurar una cuenta de servicio, ADC ubica las credenciales de forma implícita sin necesidad de cambiar el código, tal como se describió en la sección anterior. Si quieres especificar que se usen credenciales de App Engine, puedes hacerlo de forma explícita tal como se muestra en el siguiente ejemplo de código.

Instala la biblioteca cliente de Cloud Storage para ejecutar el siguiente ejemplo.

PHP

namespace Google\Cloud\Samples\Auth;

// Imports AppIdentityCredentials and the Cloud Storage client library.
use Google\Auth\Credentials\AppIdentityCredentials;
use Google\Cloud\Storage\StorageClient;

function auth_cloud_explicit_app_engine($projectId)
{
    # Learn more about scopes at https://cloud.google.com/storage/docs/authentication#oauth-scopes
    $scope = 'https://www.googleapis.com/auth/devstorage.read_only';
    $gaeCredentials = new AppIdentityCredentials($scope);
    $config = [
        'projectId' => $projectId,
        'credentialsFetcher' => $gaeCredentials,
    ];
    $storage = new StorageClient($config);

    # Make an authenticated API request (listing storage buckets)
    foreach ($storage->buckets() as $bucket) {
        printf('Bucket: %s' . PHP_EOL, $bucket->name());
    }
}

Go


// explicitDefault finds the default credentials.
//
// It is very uncommon to need to explicitly get the default credentials in Go.
// Most of the time, client libraries can use Application Default Credentials
// without having to pass the credentials in directly. See implicit above.
func explicitDefault(projectID string) {
	ctx := context.Background()

	creds, err := google.FindDefaultCredentials(ctx, storage.ScopeReadOnly)
	if err != nil {
		log.Fatal(err)
	}
	client, err := storage.NewClient(ctx, option.WithCredentials(creds))
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Buckets:")
	it := client.Buckets(ctx, projectID)
	for {
		battrs, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			log.Fatal(err)
		}
		fmt.Println(battrs.Name)
	}
}

Java

static void authAppEngineStandard() throws IOException {
  // Explicitly request service account credentials from the app engine standard instance.
  GoogleCredentials credentials = AppEngineCredentials.getApplicationDefault();
  Storage storage = StorageOptions.newBuilder().setCredentials(credentials).build().getService();

  System.out.println("Buckets:");
  Page<Bucket> buckets = storage.list();
  for (Bucket bucket : buckets.iterateAll()) {
    System.out.println(bucket.toString());
  }
}

Python

def explicit_app_engine(project):
    from google.auth import app_engine
    import googleapiclient.discovery

    # Explicitly use App Engine credentials. These credentials are
    # only available when running on App Engine Standard.
    credentials = app_engine.Credentials()

    # Explicitly pass the credentials to the client library.
    storage_client = googleapiclient.discovery.build(
        'storage', 'v1', credentials=credentials)

    # Make an authenticated API request
    buckets = storage_client.buckets().list(project=project).execute()
    print(buckets)

Restricción de acceso

Solo debes conceder a tu aplicación los permisos de autorización que necesita para interactuar con las API, las funciones o los recursos aplicables de GCP. GCP usa Cloud Identity and Access Management (Cloud IAM) para controlar los accesos. Para limitar los accesos cuando creas una cuenta de servicio, puedes usar las funciones de Cloud IAM. Cuando creas una cuenta de servicio, la explicación que aparece en comenzar con la autenticación indica que debes elegir la función Owner. El valor se puede cambiar en cualquier momento. Para obtener más información, consulta asignar funciones en las cuentas de servicio.

Recomendaciones para administrar las credenciales

Las credenciales permiten acceder a datos sensibles. Con las siguientes prácticas podrás proteger el acceso a estos recursos.

  • No incorpores secretos relacionados con la autenticación en el código fuente, como claves de API, tokens de OAuth y credenciales de cuentas de servicio. Puedes usar una variable de entorno que apunte hacia las credenciales externas al código fuente de la aplicación, como Cloud Key Management Service.

  • Usa credenciales distintas para contextos diferentes, como en entornos de pruebas y de producción.

  • Solo transfiere las credenciales mediante HTTPS para evitar que las puedan intervenir terceros. Nunca las transfieras en texto claro o como parte de una URL.

  • Nunca incorpores credenciales de larga duración en la aplicación del cliente. Por ejemplo, no incorpores credenciales de cuenta de servicio en una aplicación para dispositivos móviles. Las aplicaciones del cliente se pueden examinar y un tercero puede encontrar y usar fácilmente las credenciales.

  • Revoca los token que ya no necesites.

Soluciona errores de la API

Revisa la sección sobre errores de las API de Cloud para obtener más información sobre cómo solucionar problemas con las solicitudes a la API.

Próximos pasos