Crear y borrar claves de cuentas de servicio

En esta página, se explica cómo crear y eliminar claves de cuentas de servicio mediante la consola de Google Cloud, Google Cloud CLI, la API de Identity and Access Management o una de las bibliotecas cliente de Google Cloud.

Antes de comenzar

Enable the IAM API.
Enable the API
Configura la autenticación.

Select the tab for how you plan to use the samples on this page:
Console

When you use the Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.
gcloud

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
C#

Para usar las muestras de .NET de esta página en un entorno de desarrollo local, instala e inicializa gcloud CLI y, luego, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.
1. Install the Google Cloud CLI.
2. To initialize the gcloud CLI, run the following command:
  
  gcloud init
3. If you're using a local shell, then create local authentication credentials for your user account:
  
  gcloud auth application-default login
  
  You don't need to do this if you're using Cloud Shell.
Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local en la documentación de autenticación de Google Cloud.
C++

Para usar las muestras de C++ de esta página en un entorno de desarrollo local, instala e inicializa gcloud CLI y, luego, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.
1. Install the Google Cloud CLI.
2. To initialize the gcloud CLI, run the following command:
  
  gcloud init
3. If you're using a local shell, then create local authentication credentials for your user account:
  
  gcloud auth application-default login
  
  You don't need to do this if you're using Cloud Shell.
Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local en la documentación de autenticación de Google Cloud.
Go

Para usar las muestras de Go de esta página en un entorno de desarrollo local, instala e inicializa gcloud CLI y, luego, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.
1. Install the Google Cloud CLI.
2. To initialize the gcloud CLI, run the following command:
  
  gcloud init
3. If you're using a local shell, then create local authentication credentials for your user account:
  
  gcloud auth application-default login
  
  You don't need to do this if you're using Cloud Shell.
Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local en la documentación de autenticación de Google Cloud.
Java

Para usar las muestras de Java de esta página en un entorno de desarrollo local, instala e inicializa gcloud CLI y, luego, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.
1. Install the Google Cloud CLI.
2. To initialize the gcloud CLI, run the following command:
  
  gcloud init
3. If you're using a local shell, then create local authentication credentials for your user account:
  
  gcloud auth application-default login
  
  You don't need to do this if you're using Cloud Shell.
Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local en la documentación de autenticación de Google Cloud.
Python

Para usar las muestras de Python de esta página en un entorno de desarrollo local, instala e inicializa gcloud CLI y, luego, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.
1. Install the Google Cloud CLI.
2. To initialize the gcloud CLI, run the following command:
  
  gcloud init
3. If you're using a local shell, then create local authentication credentials for your user account:
  
  gcloud auth application-default login
  
  You don't need to do this if you're using Cloud Shell.
Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local en la documentación de autenticación de Google Cloud.
REST

Para usar las muestras de la API de REST en esta página en un entorno de desarrollo local, debes usar las credenciales que proporcionas a la CLI de gcloud.
Si deseas obtener más información, consulta Autentica para usar REST en la documentación de autenticación de Google Cloud.
Comprende las credenciales de las cuentas de servicio.

Roles obligatorios

Para obtener los permisos que necesitas a fin de crear y eliminar las claves de cuentas de servicio, pídele a tu administrador que te otorgue el rol de IAM de administrador de claves de cuentas de servicio (roles/iam.serviceAccountKeyAdmin) en el proyecto o en la cuenta de servicio cuyas claves deseas administrar. Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

También puedes obtener los permisos necesarios mediante roles personalizados o cualquier otro rol predefinido.

Para obtener más información, consulta Roles de cuentas de servicio.

Según la configuración de la política de tu organización, es posible que también debas permitir que se creen claves de cuenta de servicio en tu proyecto antes de crear una clave.

Para obtener los permisos que necesitas para permitir que se creen claves de cuentas de servicio en un proyecto, pídele a tu administrador que te otorgue los siguientes roles de IAM en tu organización:

Administrador de políticas de la organización (roles/orgpolicy.policyAdmin)
Visualizador de la organización (roles/resourcemanager.organizationViewer)
Administrador de etiquetas (roles/resourcemanager.tagAdmin)

Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

Estos roles predefinidos contienen los permisos necesarios para permitir que se creen claves de cuentas de servicio en un proyecto. Para ver los permisos exactos que son necesarios, expande la sección Permisos requeridos:

Permisos necesarios

Los siguientes permisos son necesarios para permitir que se creen claves de cuenta de servicio en un proyecto:

orgpolicy.constraints.list
orgpolicy.customConstraints.create
orgpolicy.customConstraints.delete
orgpolicy.customConstraints.get
orgpolicy.customConstraints.list
orgpolicy.customConstraints.update
orgpolicy.policies.create
orgpolicy.policies.delete
orgpolicy.policies.list
orgpolicy.policies.update
orgpolicy.policy.get
orgpolicy.policy.set
resourcemanager.organizations.get
resourcemanager.projects.listTagBindings
resourcemanager.projects.listEffectiveTags
resourcemanager.tagKeys.get
resourcemanager.tagKeys.list
resourcemanager.tagValues.list
resourcemanager.tagValues.get

También puedes obtener estos permisos con roles personalizados o con otros roles predefinidos.

Permite la creación de claves de cuentas de servicio

Antes de crear una clave de cuenta de servicio, asegúrate de que la restricción de la política de la organización iam.disableServiceAccountKeyCreation no se aplique a tu proyecto. Si se aplica esta restricción a tu proyecto, no podrás crear claves de cuenta de servicio en él.

Recomendamos aplicar esta restricción para la mayoría de los proyectos y solo eximir a los proyectos que realmente requieran claves de cuenta de servicio. Para obtener más información sobre los métodos de autenticación alternativos, consulta Elige el método de autenticación adecuado para tu caso de uso.

Para eximir un proyecto de la restricción de la política de la organización iam.disableServiceAccountKeyCreation, pídele a un administrador de políticas de la organización que haga lo siguiente:

A nivel de la organización, crea una clave y un valor de etiqueta que usarás para definir si un proyecto o carpeta debe estar exento de la política de la organización. Recomendamos crear una etiqueta con la clave disableServiceAccountKeyCreation y los valores enforced y not_enforced.

Para aprender a crear claves y valores de etiqueta, consulta Crea y define una etiqueta nueva.
Adjunta la etiqueta disableServiceAccountKeyCreation a la organización y configúrala con el valor enforced. Todos los proyectos o carpetas de la organización heredan este valor de etiqueta, a menos que se reemplace por un valor de etiqueta diferente.

Para obtener información sobre cómo adjuntar etiquetas a los recursos, consulta Adjunta etiquetas a los recursos.
Para cada proyecto o carpeta que desees eximir de la política de la organización, adjunta la etiqueta disableServiceAccountKeyCreation y establece su valor en not_enforced. Configurar un valor de etiqueta para un proyecto o carpeta de esta manera anula el valor de la etiqueta heredado de la organización.
Crea o actualiza la política de la organización que impide la creación de claves de cuentas de servicio para que no aplique la restricción para los recursos exentos. Esta política debe tener las siguientes reglas:
- Configura la restricción iam.disableServiceAccountKeyCreation para que no se aplique en ningún recurso con la etiqueta disableServiceAccountKeyCreation: not_enforced. La condición en esta regla debería verse de la siguiente manera:
```
resource.matchTag(\"ORGANIZATION_ID/disableServiceAccountKeyCreation\", \"not_enforced\")
```
- Configura la restricción iam.disableServiceAccountKeyCreation para que se aplique en todos los demás recursos.
Para aprender a crear políticas de la organización con condiciones de etiquetas, consulta Configura una política de la organización con etiquetas.

Crea una clave de cuenta de servicio

Para usar una cuenta de servicio fuera de Google Cloud, como en otras plataformas o localmente, primero debes establecer la identidad de la cuenta de servicio. Los pares de claves públicas/privadas proporcionan una forma segura de lograr este objetivo. Cuando creas una clave de cuenta de servicio, la parte pública se almacena en Google Cloud, mientras que la parte privada solo está disponible para ti. Para obtener más información sobre los pares de claves públicas/privadas, consulta Claves de cuenta de servicio.

Puedes crear una clave de cuenta de servicio con la consola de Google Cloud, la CLI de gcloud, el método serviceAccounts.keys.create() o una de las bibliotecas cliente. Una cuenta de servicio puede tener hasta 10 claves.

De forma predeterminada, las claves de las cuentas de servicio nunca se vencen. Puedes usar una restricción de políticas de la organización para especificar el período durante el cual una clave de cuenta de servicio es válida. Si deseas obtener más detalles, consulta Tiempos de vencimiento para las claves administradas por el usuario.

En los siguientes ejemplos, SA_NAME es el nombre de tu cuenta de servicio y PROJECT_ID es el ID de tu proyecto de Google Cloud. Puedes recuperar la string SA_NAME@PROJECT_ID.iam.gserviceaccount.com desde la página Cuentas de servicio en la consola de Google Cloud.

Console

En la consola de Google Cloud, ve a la página Cuentas de servicio.
Ir a Cuentas de servicio

Los pasos restantes aparecen en la consola de Google Cloud.
Selecciona un proyecto
Haz clic en la dirección de correo electrónico de la cuenta de servicio para la que quieres crear una clave.
Haz clic en la pestaña Claves.
Haz clic en el menú desplegable Agregar clave y, luego, selecciona Crear clave nueva.
Selecciona JSON como el tipo de clave y, luego, haz clic en Crear.

Si haces clic en Crear, se descargará un archivo de claves de cuenta de servicio. Después de descargar el archivo de claves, no puedes volver a descargarlo.

La clave descargada tiene el siguiente formato, en el que PRIVATE_KEY es la parte privada del par de claves pública/privada:

{
  "type": "service_account",
  "project_id": "PROJECT_ID",
  "private_key_id": "KEY_ID",
  "private_key": "-----BEGIN PRIVATE KEY-----\nPRIVATE_KEY\n-----END PRIVATE KEY-----\n",
  "client_email": "SERVICE_ACCOUNT_EMAIL",
  "client_id": "CLIENT_ID",
  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
  "token_uri": "https://accounts.google.com/o/oauth2/token",
  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/SERVICE_ACCOUNT_EMAIL"
}

Asegúrate de almacenar el archivo de claves de forma segura, ya que se puede usar para autenticarse como tu cuenta de servicio. Puedes mover y cambiar el nombre de este archivo como desees.

Puedes usar los archivos de claves de cuenta de servicio para autenticar una aplicación como una cuenta de servicio.

gcloud

Ejecuta el comando gcloud iam service-accounts keys create para crear claves de cuenta de servicio.

Reemplaza los siguientes valores:

KEY_FILE: La ruta a un archivo de salida nuevo para la clave privada, por ejemplo, ~/sa-private-key.json.
SA_NAME: El nombre de la cuenta de servicio para la que se creará una clave.
PROJECT_ID es el ID del proyecto de Google Cloud.

gcloud iam service-accounts keys create KEY_FILE \
    --iam-account=SA_NAME@PROJECT_ID.iam.gserviceaccount.com

Resultado:

created key [e44da1202f82f8f4bdd9d92bc412d1d8a837fa83] of type [json] as
[/usr/home/username/KEY_FILE] for
[SA_NAME@PROJECT_ID.iam.gserviceaccount.com]

El archivo de claves de la cuenta de servicio se descargará ahora en tu máquina. Después de descargar el archivo de claves, no puedes volver a descargarlo.

La clave descargada tiene el siguiente formato, en el que PRIVATE_KEY es la parte privada del par de claves pública/privada:

{
  "type": "service_account",
  "project_id": "PROJECT_ID",
  "private_key_id": "KEY_ID",
  "private_key": "-----BEGIN PRIVATE KEY-----\nPRIVATE_KEY\n-----END PRIVATE KEY-----\n",
  "client_email": "SERVICE_ACCOUNT_EMAIL",
  "client_id": "CLIENT_ID",
  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
  "token_uri": "https://oauth2.googleapis.com/token",
  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/SERVICE_ACCOUNT_EMAIL"
}

Asegúrate de almacenar el archivo de claves de forma segura, ya que se puede usar para autenticarse como tu cuenta de servicio. Puedes mover y cambiar el nombre de este archivo como desees.

Puedes usar los archivos de clave de cuenta de servicio para autenticar una aplicación como una cuenta de servicio.

C++

Para obtener más obtener información sobre cómo instalar y usar la biblioteca cliente de IAM, consulta Bibliotecas cliente de IAM. Para obtener más información, consulta la documentación de referencia de la API de IAM C++.

Para autenticarte en IAM, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Antes de comenzar.

namespace iam = ::google::cloud::iam_admin_v1;
return [](std::string const& name) {
  iam::IAMClient client(iam::MakeIAMConnection());
  auto response = client.CreateServiceAccountKey(
      name,
      google::iam::admin::v1::ServiceAccountPrivateKeyType::
          TYPE_GOOGLE_CREDENTIALS_FILE,
      google::iam::admin::v1::ServiceAccountKeyAlgorithm::KEY_ALG_RSA_2048);
  if (!response) throw std::move(response).status();
  std::cout << "ServiceAccountKey successfully created: "
            << response->DebugString() << "\n"
            << "Please save the key in a secure location, as they cannot "
               "be downloaded later\n";
  return response->name();
}

C#

Para autenticarte en IAM, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Antes de comenzar.


using System;
using System.Text;
using Google.Apis.Auth.OAuth2;
using Google.Apis.Iam.v1;
using Google.Apis.Iam.v1.Data;

public partial class ServiceAccountKeys
{
    public static ServiceAccountKey CreateKey(string serviceAccountEmail)
    {
        var credential = GoogleCredential.GetApplicationDefault()
            .CreateScoped(IamService.Scope.CloudPlatform);
        var service = new IamService(new IamService.Initializer
        {
            HttpClientInitializer = credential
        });

        var key = service.Projects.ServiceAccounts.Keys.Create(
            new CreateServiceAccountKeyRequest(),
            "projects/-/serviceAccounts/" + serviceAccountEmail)
            .Execute();

        // The PrivateKeyData field contains the base64-encoded service account key
        // in JSON format.
        // TODO(Developer): Save the below key (jsonKeyFile) to a secure location.
        //  You cannot download it later.
        byte[] valueBytes = System.Convert.FromBase64String(key.PrivateKeyData);
        string jsonKeyContent = Encoding.UTF8.GetString(valueBytes);

        Console.WriteLine("Key created successfully");
        return key;
    }
}

Go

Para autenticarte en IAM, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Antes de comenzar.

import (
	"context"
	// "encoding/base64"
	"fmt"
	"io"

	iam "google.golang.org/api/iam/v1"
)

// createKey creates a service account key.
func createKey(w io.Writer, serviceAccountEmail string) (*iam.ServiceAccountKey, error) {
	ctx := context.Background()
	service, err := iam.NewService(ctx)
	if err != nil {
		return nil, fmt.Errorf("iam.NewService: %w", err)
	}

	resource := "projects/-/serviceAccounts/" + serviceAccountEmail
	request := &iam.CreateServiceAccountKeyRequest{}
	key, err := service.Projects.ServiceAccounts.Keys.Create(resource, request).Do()
	if err != nil {
		return nil, fmt.Errorf("Projects.ServiceAccounts.Keys.Create: %w", err)
	}
	// The PrivateKeyData field contains the base64-encoded service account key
	// in JSON format.
	// TODO(Developer): Save the below key (jsonKeyFile) to a secure location.
	// You cannot download it later.
	// jsonKeyFile, _ := base64.StdEncoding.DecodeString(key.PrivateKeyData)
	fmt.Fprintf(w, "Key created successfully")
	return key, nil
}

Java

Para autenticarte en IAM, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Antes de comenzar.


import com.google.cloud.iam.admin.v1.IAMClient;
import com.google.gson.Gson;
import com.google.iam.admin.v1.CreateServiceAccountKeyRequest;
import com.google.iam.admin.v1.ServiceAccountKey;
import java.io.IOException;

public class CreateServiceAccountKey {

  public static void main(String[] args) throws IOException {
    // TODO(Developer): Replace the below variables before running.
    String projectId = "your-project-id";
    String serviceAccountName = "your-service-account-name";

    ServiceAccountKey key = createKey(projectId, serviceAccountName);
    Gson gson = new Gson();

    // System.out.println("Service account key: " + gson.toJson(key));
  }

  // Creates a key for a service account.
  public static ServiceAccountKey createKey(String projectId, String accountName)
          throws IOException {
    String email = String.format("%s@%s.iam.gserviceaccount.com", accountName, projectId);

    // Initialize client that will be used to send requests.
    // This client only needs to be created once, and can be reused for multiple requests.
    try (IAMClient iamClient = IAMClient.create()) {
      CreateServiceAccountKeyRequest req = CreateServiceAccountKeyRequest.newBuilder()
              .setName(String.format("projects/%s/serviceAccounts/%s", projectId, email))
              .build();
      ServiceAccountKey createdKey = iamClient.createServiceAccountKey(req);
      System.out.println("Key created successfully");

      return createdKey;
    }
  }
}

Python

Para autenticarte en IAM, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Antes de comenzar.

from google.cloud import iam_admin_v1
from google.cloud.iam_admin_v1 import types


def create_key(project_id: str, account: str) -> types.ServiceAccountKey:
    """
    Creates a key for a service account.

    project_id: ID or number of the Google Cloud project you want to use.
    account: ID or email which is unique identifier of the service account.
    """

    iam_admin_client = iam_admin_v1.IAMClient()
    request = types.CreateServiceAccountKeyRequest()
    request.name = f"projects/{project_id}/serviceAccounts/{account}"

    key = iam_admin_client.create_service_account_key(request=request)

    # The private_key_data field contains the stringified service account key
    # in JSON format. You cannot download it again later.
    # If you want to get the value, you can do it in a following way:
    # import json
    # json_key_data = json.loads(key.private_key_data)
    # key_id = json_key_data["private_key_id"]

    return key

REST

Con el método projects.serviceAccounts.keys.create, se crea una clave para una cuenta de servicio.

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

PROJECT_ID: El ID del proyecto de Google Cloud Los ID de proyecto son strings alfanuméricas, como my-project.
SA_NAME: Es el nombre de la cuenta de servicio para la que deseas crear una clave.
KEY_ALGORITHM: Opcional Es el algoritmo de clave que se usará para la clave. El valor predeterminado, que está sujeto a cambios, es una clave RSA de 2,048 bits. Para obtener una lista de todos los valores posibles, consulta la referencia de ServiceAccountKeyAlgorithm.

Método HTTP y URL:

POST https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/SA_NAME@PROJECT_ID.iam.gserviceaccount.com/keys

Cuerpo JSON de la solicitud:

{
  "keyAlgorithm": "KEY_ALGORITHM"
}

Para enviar tu solicitud, expande una de estas opciones:

curl (Linux, macOS o Cloud Shell)

Nota: Con el siguiente comando, se supone que accediste a la CLI de gcloud con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login, o a través del uso de Cloud Shell, que accede de forma automática a la CLI de gcloud. Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/SA_NAME@PROJECT_ID.iam.gserviceaccount.com/keys"

PowerShell (Windows)

Nota: El siguiente comando supone que accediste a la CLI de gcloud con tu cuenta de usuario mediante la ejecución de gcloud init o gcloud auth login. Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/SA_NAME@PROJECT_ID.iam.gserviceaccount.com/keys" | Select-Object -Expand Content

Explorador de APIs (navegador)

Copia el cuerpo de la solicitud y abre la página de referencia del método. El panel del Explorador de API se abre en la parte derecha de la página. Puedes interactuar con esta herramienta para enviar solicitudes. Pega el cuerpo de la solicitud en esta herramienta, completa cualquier otro campo obligatorio y haz clic en Ejecutar.

La respuesta contiene una clave para la cuenta de servicio. La clave que se muestra tiene el siguiente formato, en el que ENCODED_PRIVATE_KEY es la parte privada del par de clave pública/privada, codificada en base64.

{
  "name": "projects/PROJECT_ID/serviceAccounts/SERVICE_ACCOUNT_EMAIL/keys/KEY_ID",
  "privateKeyType": "TYPE_GOOGLE_CREDENTIALS_FILE",
  "privateKeyData": "ENCODED_PRIVATE_KEY",
  "validAfterTime": "DATE",
  "validBeforeTime": "DATE",
  "keyAlgorithm": "KEY_ALG_RSA_2048"
}

Si deseas crear un archivo de claves que puedas usar para autenticarte como la cuenta de servicio, decodifica los datos de claves privadas y guárdalos en un archivo:

Linux

Ejecuta el comando siguiente:

echo 'ENCODED_PRIVATE_KEY' | base64 --decode > PATH

Reemplaza PATH por la ruta de acceso del archivo en el que deseas guardar la clave. Usa la extensión de archivo .json.

macOS

Ejecuta el comando siguiente:

echo 'ENCODED_PRIVATE_KEY' | base64 --decode > PATH

Reemplaza PATH por la ruta de acceso del archivo en el que deseas guardar la clave. Usa la extensión de archivo .json.

PowerShell

Guarda los datos de clave privada codificada (ENCODED_PRIVATE_KEY) en un archivo.
Usa certutil para decodificar el archivo:
```
certutil -decode ENCODED_FILE DECODED_FILE
```
Reemplaza los siguientes valores:
- ENCODED_FILE: La ruta de acceso al archivo que contiene los datos de clave privada codificados.
- DECODED_FILE: Es la ruta de acceso del archivo en el que deseas guardar la clave. Usa la extensión de archivo .json.

Asegúrate de almacenar los datos de la clave de manera segura, ya que se pueden usar para autenticarse como tu cuenta de servicio.

Puedes usar los archivos de clave de cuenta de servicio para autenticar una aplicación como una cuenta de servicio.

Borra una clave de cuenta de servicio

Borrar una clave de cuenta de servicio te impide de manera permanente usar la clave para autenticarte con las API de Google.

No puedes recuperar una clave borrada. Antes de borrar una clave, te recomendamos que inhabilites la clave y, luego, esperes a estar seguro de que la clave ya no es necesaria. Luego, puedes borrar la clave.

Como práctica recomendada, rota las claves de tus cuentas de servicio con regularidad. Para obtener más información sobre la rotación de claves de cuentas de servicio, consulta Rotación de claves de cuentas de servicio.

Console

En la consola de Google Cloud, ve a la página Cuentas de servicio.
Ir a Cuentas de servicio

Los pasos restantes aparecen en la consola de Google Cloud.
Selecciona un proyecto
En la página Cuentas de servicio, haz clic en la dirección de correo electrónico de la cuenta de servicio cuya clave deseas borrar.
Haz clic en la pestaña Claves.
En la lista de claves, haz clic en Borrar en cada clave que desees borrar.

gcloud

Ejecuta el comando gcloud iam service-accounts keys delete para borrar claves de cuenta de servicio.

Reemplaza los siguientes valores:

KEY_ID: El ID de la clave que se borrará. Para encontrar el ID de la clave, enumera todas las claves de la cuenta de servicio, identifica la clave que deseas borrar y, luego, copia su ID.
SA_NAME: El nombre de la cuenta de servicio a la que pertenece la clave.
PROJECT_ID: es el ID del proyecto de Google Cloud.

gcloud iam service-accounts keys delete KEY_ID \
    --iam-account=SA_NAME@PROJECT_ID.iam.gserviceaccount.com

Resultado:

Deleted key [KEY_ID] for service account
[SA_NAME@PROJECT_ID.iam.gserviceaccount.com]

C++

Para autenticarte en IAM, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Antes de comenzar.

namespace iam = ::google::cloud::iam_admin_v1;
[](std::string const& name) {
  iam::IAMClient client(iam::MakeIAMConnection());
  auto response = client.DeleteServiceAccountKey(name);
  if (!response.ok()) throw std::runtime_error(response.message());
  std::cout << "ServiceAccountKey successfully deleted.\n";
}

C#

Para autenticarte en IAM, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Antes de comenzar.


using System;
using Google.Apis.Auth.OAuth2;
using Google.Apis.Iam.v1;
using Google.Apis.Iam.v1.Data;

public partial class ServiceAccountKeys
{
    public static void DeleteKey(string fullKeyName)
    {
        var credential = GoogleCredential.GetApplicationDefault()
            .CreateScoped(IamService.Scope.CloudPlatform);
        var service = new IamService(new IamService.Initializer
        {
            HttpClientInitializer = credential
        });

        service.Projects.ServiceAccounts.Keys.Delete(fullKeyName).Execute();
        Console.WriteLine("Deleted key: " + fullKeyName);
    }
}

Go

Para autenticarte en IAM, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Antes de comenzar.

import (
	"context"
	"fmt"
	"io"

	iam "google.golang.org/api/iam/v1"
)

// deleteKey deletes a service account key.
func deleteKey(w io.Writer, fullKeyName string) error {
	ctx := context.Background()
	service, err := iam.NewService(ctx)
	if err != nil {
		return fmt.Errorf("iam.NewService: %w", err)
	}

	_, err = service.Projects.ServiceAccounts.Keys.Delete(fullKeyName).Do()
	if err != nil {
		return fmt.Errorf("Projects.ServiceAccounts.Keys.Delete: %w", err)
	}
	fmt.Fprintf(w, "Deleted key: %v", fullKeyName)
	return nil
}

Java

Para autenticarte en IAM, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Antes de comenzar.


import com.google.cloud.iam.admin.v1.IAMClient;
import com.google.iam.admin.v1.DeleteServiceAccountKeyRequest;
import com.google.iam.admin.v1.KeyName;
import java.io.IOException;

public class DeleteServiceAccountKey {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace the variables before running the sample.
    String projectId = "your-project-id";
    String serviceAccountName = "my-service-account-name";
    String serviceAccountKeyId = "service-account-key-id";

    deleteKey(projectId, serviceAccountName, serviceAccountKeyId);
  }

  // Deletes a service account key.
  public static void deleteKey(String projectId, String accountName,
                               String serviceAccountKeyId) throws IOException {
    //Initialize client that will be used to send requests.
    //This client only needs to be created once, and can be reused for multiple requests.
    try (IAMClient iamClient = IAMClient.create()) {

      //Construct the service account email.
      //You can modify the ".iam.gserviceaccount.com" to match the service account name in which
      //you want to delete the key.
      //See, https://cloud.google.com/iam/docs/creating-managing-service-account-keys#deleting

      String accountEmail = String.format("%s@%s.iam.gserviceaccount.com", accountName, projectId);

      String name = KeyName.of(projectId, accountEmail, serviceAccountKeyId).toString();

      DeleteServiceAccountKeyRequest request = DeleteServiceAccountKeyRequest.newBuilder()
              .setName(name)
              .build();

      // Then you can delete the key
      iamClient.deleteServiceAccountKey(request);

      System.out.println("Deleted key: " + serviceAccountKeyId);
    }
  }
}

Python

Para autenticarte en IAM, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Antes de comenzar.

from google.cloud import iam_admin_v1
from google.cloud.iam_admin_v1 import types


def delete_key(project_id: str, account: str, key_id: str) -> None:
    """
    Deletes a key for a service account.

    project_id: ID or number of the Google Cloud project you want to use.
    account: ID or email which is unique identifier of the service account.
    key_id: unique ID of the key.
    """

    iam_admin_client = iam_admin_v1.IAMClient()
    request = types.DeleteServiceAccountKeyRequest()
    request.name = f"projects/{project_id}/serviceAccounts/{account}/keys/{key_id}"

    iam_admin_client.delete_service_account_key(request=request)
    print(f"Deleted key: {key_id}")

REST

Mediante el método projects.serviceAccounts.keys.delete, se borra una clave de cuenta de servicio.

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

PROJECT_ID: El ID del proyecto de Google Cloud Los ID de proyecto son strings alfanuméricas, como my-project.
SA_NAME: Es el nombre de la cuenta de servicio cuya clave deseas borrar.
KEY_ID: Es el ID de la clave que deseas borrar. Para encontrar el ID de la clave, enumera todas las claves de la cuenta de servicio, identifica la clave que deseas borrar y, luego, copia su ID al final del campo name. El ID único de la clave es todo lo que se encuentra después de keys/.

Método HTTP y URL:

DELETE https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/SA_NAME@PROJECT_ID.iam.gserviceaccount.com/keys/KEY_ID

Para enviar tu solicitud, expande una de estas opciones:

curl (Linux, macOS o Cloud Shell)

Ejecuta el siguiente comando:

curl -X DELETE \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/SA_NAME@PROJECT_ID.iam.gserviceaccount.com/keys/KEY_ID"

PowerShell (Windows)

Ejecuta el siguiente comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method DELETE `
    -Headers $headers `
    -Uri "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/SA_NAME@PROJECT_ID.iam.gserviceaccount.com/keys/KEY_ID" | Select-Object -Expand Content

Explorador de APIs (navegador)

Abre la página de referencia del método. El panel del Explorador de API se abre en la parte derecha de la página. Puedes interactuar con esta herramienta para enviar solicitudes. Completa los campos obligatorios y haz clic en Ejecutar.

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

{
}

¿Qué sigue?

Aprende a enumerar y obtener claves de cuenta de servicio.
Obtén más información sobre cómo subir tus propias claves de cuenta de servicio públicas.
Comprende las prácticas recomendadas para administrar claves de cuentas de servicio.
Obtén información sobre las alternativas a las claves de cuenta de servicio para la autenticación.

Pruébalo tú mismo

Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

Comenzar gratis