Crear y eliminar claves de cuentas de servicio

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

Antes de empezar

• 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 Trusted Cloud console to access Trusted Cloud by S3NS services and APIs, you don't need to set up authentication.

  gcloud

  Instala Google Cloud CLI y, a continuación, inicia sesión en gcloud CLI con tu identidad federada. Después de iniciar sesión, inicializa la CLI de Google Cloud ejecutando el siguiente comando:

  gcloud init

  C#

  Para usar las .NET muestras de esta página en un entorno de desarrollo local, instala e inicializa la CLI de gcloud y, a continuación, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

  Instala Google Cloud CLI y, a continuación, inicia sesión en gcloud CLI con tu identidad federada.

  Create local authentication credentials for your user account:

  gcloud auth application-default login

  If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

  Para obtener más información, consulta Configurar ADC en un entorno de desarrollo local en la documentación de autenticación. Trusted Cloud

  C++

  Para usar las C++ muestras de esta página en un entorno de desarrollo local, instala e inicializa la CLI de gcloud y, a continuación, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

  Instala Google Cloud CLI y, a continuación, inicia sesión en gcloud CLI con tu identidad federada.

  Create local authentication credentials for your user account:

  gcloud auth application-default login

  If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

  Para obtener más información, consulta Configurar ADC en un entorno de desarrollo local en la documentación de autenticación. Trusted Cloud

  Go

  Para usar las Go muestras de esta página en un entorno de desarrollo local, instala e inicializa la CLI de gcloud y, a continuación, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

  Instala Google Cloud CLI y, a continuación, inicia sesión en gcloud CLI con tu identidad federada.

  Create local authentication credentials for your user account:

  gcloud auth application-default login

  If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

  Para obtener más información, consulta Configurar ADC en un entorno de desarrollo local en la documentación de autenticación. Trusted Cloud

  Java

  Para usar las Java muestras de esta página en un entorno de desarrollo local, instala e inicializa la CLI de gcloud y, a continuación, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

  Instala Google Cloud CLI y, a continuación, inicia sesión en gcloud CLI con tu identidad federada.

  Create local authentication credentials for your user account:

  gcloud auth application-default login

  If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

  Para obtener más información, consulta Configurar ADC en un entorno de desarrollo local en la documentación de autenticación. Trusted Cloud

  Python

  Para usar las Python muestras de esta página en un entorno de desarrollo local, instala e inicializa la CLI de gcloud y, a continuación, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

  Instala Google Cloud CLI y, a continuación, inicia sesión en gcloud CLI con tu identidad federada.

  Create local authentication credentials for your user account:

  gcloud auth application-default login

  If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

  Para obtener más información, consulta Configurar ADC en un entorno de desarrollo local en la documentación de autenticación. Trusted Cloud

  REST

  Para usar las muestras de la API REST de esta página en un entorno de desarrollo local, debes usar las credenciales que proporciones a la CLI de gcloud.

  Instala Google Cloud CLI y, a continuación, inicia sesión en gcloud CLI con tu identidad federada.

  Para obtener más información, consulta el artículo Autenticación para usar REST de la documentación sobre autenticación de Trusted Cloud .

  Consulta información sobre las credenciales de cuentas de servicio.

Roles obligatorios

Para obtener los permisos que necesitas para crear y eliminar claves de cuentas de servicio, pide a tu administrador que te conceda el rol de gestión de identidades y accesos Administrador de claves de cuenta de servicio (roles/iam.serviceAccountKeyAdmin) en el proyecto o en la cuenta de servicio cuyas claves quieras gestionar. Para obtener más información sobre cómo conceder roles, consulta el artículo Gestionar el acceso a proyectos, carpetas y organizaciones.

También puedes conseguir los permisos necesarios a través de roles personalizados u otros roles predefinidos.

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

En función de la configuración de la política de tu organización, es posible que también tengas que permitir que se creen claves de cuentas 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, pide a tu administrador que te conceda los siguientes roles de gestión de identidades y accesos en tu organización:

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

Para obtener más información sobre cómo conceder roles, consulta el artículo Gestionar el acceso a proyectos, carpetas y organizaciones.

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

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

Permitir la creación de claves de cuenta de servicio

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

Recomendamos aplicar esta restricción en la mayoría de los proyectos y solo eximir a los proyectos que realmente necesiten claves de cuentas de servicio. Para obtener más información sobre los métodos de autenticación alternativos, consulta el artículo Elegir el método de autenticación adecuado para tu caso práctico.

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

1. A nivel de organización, cree una clave y un valor de etiqueta que utilizará para definir si un recurso debe estar exento de la política de organización. Te recomendamos que crees una etiqueta con la clave disableServiceAccountKeyCreation y los valores enforced y not_enforced.

   Para saber cómo crear claves y valores de etiquetas, consulta el artículo Crear y definir una etiqueta.

2. Asigne la etiqueta disableServiceAccountKeyCreation a la organización y defina su valor como enforced. Todos los recursos de la organización heredan este valor de etiqueta, a menos que se sobrescriba con otro valor.

   Para saber cómo adjuntar etiquetas a los recursos, consulta Adjuntar etiquetas a recursos.

3. En cada proyecto o carpeta que quieras excluir de la política de la organización, añade la etiqueta disableServiceAccountKeyCreation y asigna el valor not_enforced. Si asignas un valor de etiqueta a un proyecto o una carpeta de esta forma, se anula el valor de etiqueta heredado de la organización.

4. Crea o actualiza la política de organización que impide la creación de claves de cuentas de servicio para que no se aplique la restricción a los recursos exentos. Esta política debe incluir las siguientes reglas:

   • Configura la restricción iam.disableServiceAccountKeyCreation para que no se aplique a ningún recurso con la etiqueta disableServiceAccountKeyCreation: not_enforced. La condición de esta regla debería tener el siguiente aspecto:

     "resource.matchTag('ORGANIZATION_ID/disableServiceAccountKeyCreation', 'not_enforced')"
     

   • Configura la restricción iam.disableServiceAccountKeyCreation para que se aplique a todos los demás recursos.

Crear una clave de cuenta de servicio

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

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

De forma predeterminada, las claves de cuenta de servicio no caducan nunca. Puedes usar una restricción de política de organización para especificar el periodo durante el que es válida una clave de cuenta de servicio. Para obtener más información, consulta Tiempos de vencimiento de las claves gestionadas por el usuario.

En los ejemplos siguientes, SA_NAME es el nombre de tu cuenta de servicio y PROJECT_ID es el ID de tu proyectoTrusted Cloud by S3NS . Puedes obtener la SA_NAME@PROJECT_ID.s3ns-system.iam.gserviceaccount.com cadena de la página Cuentas de servicio de la consola de Trusted Cloud .

{
  "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"
}

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

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

{
  "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"
}

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();
}

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;
    }
}

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
}

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;
    }
  }
}

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

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

{
  "keyAlgorithm": "KEY_ALGORITHM"
}

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.s3ns-system.iam.gserviceaccount.com/keys"

$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.s3ns-system.iam.gserviceaccount.com/keys" | Select-Object -Expand Content

{
  "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"
}

echo 'ENCODED_PRIVATE_KEY' | base64 --decode > PATH

echo 'ENCODED_PRIVATE_KEY' | base64 --decode > PATH

Eliminar una clave de cuenta de servicio

Si eliminas una clave de cuenta de servicio, no podrás usarla para autenticarte en las APIs de Google.

No puedes recuperar una clave eliminada. Antes de eliminar una clave, te recomendamos que la inhabilites y esperes hasta que tengas la certeza de que ya no la necesitas. Después, puedes eliminar la clave.

Te recomendamos que rotes las claves de tu cuenta de servicio con regularidad. Para obtener más información sobre cómo rotar las claves de cuentas de servicio, consulta el artículo Rotación de claves de cuentas de servicio.

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

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

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";
}

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);
    }
}

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
}

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);
    }
  }
}

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}")

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

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

$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.s3ns-system.iam.gserviceaccount.com/keys/KEY_ID" | Select-Object -Expand Content

{
}

Siguientes pasos

• Consulta cómo listar y obtener claves de cuentas de servicio.
• Consulta cómo subir tus propias claves de cuenta de servicio público.
• Consulta las prácticas recomendadas para gestionar las claves de cuentas de servicio.
• Consulta las alternativas a las claves de cuentas de servicio para la autenticación.