Crea y administra cuentas de servicio

En esta página, se explica cómo crear y administrar cuentas de servicio mediante la API de administración de identidades y accesos (IAM), Google Cloud Console y la herramienta de línea de comandos de gcloud.

De forma predeterminada, cada proyecto puede tener hasta 100 cuentas de servicio que controlan el acceso a tus recursos. Puedes solicitar un incremento de la cuota si es necesario. Obtén más información sobre las cuotas y los límites.

Antes de comenzar

• Habilita las IAM API.

  Habilita la API

• Comprende las cuentas de servicio de IAM

• Instala la herramienta de línea de comandos de gcloud.

Permisos necesarios

Para permitir que un usuario administre cuentas de servicio, otorga una de las siguientes funciones:

• Usuario de cuenta de servicio (roles/iam.serviceAccountUser): Incluye permisos para enumerar cuentas de servicio, obtener detalles sobre ellas, o bien actuar en nombre de una.
• Administrador de cuenta de servicio (roles/iam.serviceAccountAdmin): Incluye permisos para enumerar cuentas de servicio y obtener detalles sobre ellas. También incluye permisos a fin de crear, actualizar y borrar cuentas de servicio, y para ver o cambiar la política de IAM en una cuenta de servicio.

Para obtener más información sobre estas funciones, consulta Funciones de cuentas de servicio.

Las funciones básicas de IAM también contienen permisos para administrar cuentas de servicio. No deberías otorgar funciones básicas en un entorno de producción, pero puedes otorgarlas en un entorno de desarrollo o de prueba.

Crea una cuenta de servicio

Cuando creas una cuenta de servicio, debes proporcionar un ID alfanumérico (SA_NAME en las siguientes muestras), como my-service-account. El ID debe tener entre 6 y 30 caracteres y puede contener guiones y caracteres alfanuméricos en minúscula. Después de crear una cuenta de servicio, no podrás cambiar su nombre.

El nombre de la cuenta de servicio aparece en la dirección de correo electrónico que se aprovisiona durante la creación, en el formato SA_NAME@PROJECT_ID.iam.gserviceaccount.com.

Además, cada cuenta de servicio tiene un ID numérico único y permanente, que se genera de forma automática.

También debes proporcionar la siguiente información cuando creas una cuenta de servicio:

• SA_DESCRIPTION es una descripción opcional de la cuenta de servicio.
• SA_DISPLAY_NAME es un nombre descriptivo de la cuenta de servicio.
• PROJECT_ID es el ID de tu proyecto de Google Cloud.

Para crear una cuenta de servicio, como mínimo, se debe otorgar al usuario la función de administrador de cuenta de servicio (roles/iam.serviceAccountAdmin) o la función básica de editor (roles/editor). No deberías otorgar funciones básicas en un entorno de producción, pero puedes otorgarlas un entorno de desarrollo o de prueba.

Después de crear una cuenta de servicio, es posible que debas esperar 60 segundos o más antes de usarla. Si intentas usar una cuenta de servicio de forma inmediata después de crearla y recibes un error, puedes reintentar la solicitud con una retirada exponencial.

Console

1. In the Cloud Console, go to the Create service account page.

   Go to Create service account
2. Select a project.

3. Enter a service account name to display in the Cloud Console.

   The Cloud Console generates a service account ID based on this name. Edit the ID if necessary. You cannot change the ID later.

4. Optional: Enter a description of the service account.

5. If you do not want to set access controls now, click Done to finish creating the service account.

   To set access controls now, click Create and continue and continue to the next step.

6. Optional: Choose one or more IAM roles to grant to the service account on the project.
7. When you are done adding roles, click Continue.
8. Optional: In the Service account users role field, add members that can impersonate the service account.
9. Optional: In the Service account admins role field, add members that can manage the service account.
10. Click Done to finish creating the service account.

gcloud

To create the service account, run the gcloud iam service-accounts create command:

gcloud iam service-accounts create SERVICE_ACCOUNT_ID \
    --description="DESCRIPTION" \
    --display-name="DISPLAY_NAME"

Replace the following values:

• SERVICE_ACCOUNT_ID: The ID for the service account.
• DESCRIPTION: Optional. A description of the service account.
• DISPLAY_NAME: A service account name to display in the Cloud Console.

Optional: To grant your service account an IAM role on your project, run the gcloud projects add-iam-policy-binding command:

gcloud projects add-iam-policy-binding PROJECT_ID \
    --member="serviceAccount:SERVICE_ACCOUNT_ID@PROJECT_ID.iam.gserviceaccount.com" \
    --role="ROLE_NAME"

Replace the following values:

• PROJECT_ID: The project id.
• SERVICE_ACCOUNT_ID: The service account ID.
• ROLE_NAME: A role name, such as roles/compute.osLogin.

Optional: To allow users to impersonate the service account, run the gcloud iam service-accounts add-iam-policy-binding command to grant a user the Service Account User role (roles/iam.serviceAccountUser) on the service account:

gcloud iam service-accounts add-iam-policy-binding \
    SERVICE_ACCOUNT_ID@PROJECT_ID.iam.gserviceaccount.com \
    --member="user:USER_EMAIL" \
    --role="roles/iam.serviceAccountUser"

Replace the following values:

• PROJECT_ID: The project ID.
• SERVICE_ACCOUNT_ID: The service account ID.
• USER_EMAIL: The email address for the user.

REST

Mediante el método serviceAccounts.create, se crea 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 ID alfanumérico de tu cuenta de servicio. Este nombre debe tener entre 6 y 30 caracteres y puede contener caracteres alfanuméricos en minúscula y guiones.
• SA_DESCRIPTION: Es opcional. Es una descripción para la cuenta de servicio.
• SA_DISPLAY_NAME: Es un nombre legible para la cuenta de servicio.

Método HTTP y URL:

POST https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts

Cuerpo JSON de la solicitud:

{
  "accountId": "SA_NAME",
  "serviceAccount": {
    "description": "SA_DESCRIPTION",
    "displayName": "SA_DISPLAY_NAME"
  }
}

Para enviar tu solicitud, expande una de estas opciones:

curl (Linux, macOS o Cloud Shell)

Nota: Asegúrate de haber configurado la variable de entorno GOOGLE_APPLICATION_CREDENTIALS a la ruta para el archivo de clave privada de tu cuenta de servicio.

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 application-default print-access-token) \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
"https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts"

PowerShell (Windows)

Nota: Asegúrate de haber configurado la variable de entorno GOOGLE_APPLICATION_CREDENTIALS a la ruta para el archivo de clave privada de tu cuenta de servicio.

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

$cred = gcloud auth application-default 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" | Select-Object -Expand Content

Explorador de API (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.

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

{
  "name": "projects/my-project/serviceAccounts/[e-mail]",
  "projectId": "my-project",
  "uniqueId": "123456789012345678901",
  "email": "[e-mail]",
  "displayName": "My service account",
  "etag": "BwUp3rVlzes=",
  "description": "A service account for running jobs in my project",
  "oauth2ClientId": "987654321098765432109"
}

C++

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

Ver en GitHubComentarios

namespace iam = ::google::cloud::iam;
[](std::string const& project_id, std::string const& account_id,
   std::string const& display_name, std::string const& description) {
  iam::IAMClient client(iam::MakeIAMConnection());
  google::iam::admin::v1::ServiceAccount service_account;
  service_account.set_display_name(display_name);
  service_account.set_description(description);
  auto response = client.CreateServiceAccount("projects/" + project_id,
                                              account_id, service_account);
  if (!response) throw std::runtime_error(response.status().message());
  std::cout << "ServiceAccount successfully created: "
            << response->DebugString() << "\n";
}

C#

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

Ver en GitHub Comentarios

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

public partial class ServiceAccounts
{
    public static ServiceAccount CreateServiceAccount(string projectId,
        string name, string displayName)
    {
        var credential = GoogleCredential.GetApplicationDefault()
            .CreateScoped(IamService.Scope.CloudPlatform);
        var service = new IamService(new IamService.Initializer
        {
            HttpClientInitializer = credential
        });

        var request = new CreateServiceAccountRequest
        {
            AccountId = name,
            ServiceAccount = new ServiceAccount
            {
                DisplayName = displayName
            }
        };
        var serviceAccount = service.Projects.ServiceAccounts.Create(
            request, "projects/" + projectId).Execute();
        Console.WriteLine("Created service account: " + serviceAccount.Email);
        return serviceAccount;
    }
}

Go

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

Ver en GitHub Comentarios

import (
	"context"
	"fmt"
	"io"

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

// createServiceAccount creates a service account.
func createServiceAccount(w io.Writer, projectID, name, displayName string) (*iam.ServiceAccount, error) {
	ctx := context.Background()
	service, err := iam.NewService(ctx)
	if err != nil {
		return nil, fmt.Errorf("iam.NewService: %v", err)
	}

	request := &iam.CreateServiceAccountRequest{
		AccountId: name,
		ServiceAccount: &iam.ServiceAccount{
			DisplayName: displayName,
		},
	}
	account, err := service.Projects.ServiceAccounts.Create("projects/"+projectID, request).Do()
	if err != nil {
		return nil, fmt.Errorf("Projects.ServiceAccounts.Create: %v", err)
	}
	fmt.Fprintf(w, "Created service account: %v", account)
	return account, nil
}

Java

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

Ver en GitHub Comentarios

import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.json.jackson2.JacksonFactory;
import com.google.api.services.iam.v1.Iam;
import com.google.api.services.iam.v1.IamScopes;
import com.google.api.services.iam.v1.model.CreateServiceAccountRequest;
import com.google.api.services.iam.v1.model.ServiceAccount;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.security.GeneralSecurityException;
import java.util.Collections;

public class CreateServiceAccount {

  // Creates a service account.
  public static void createServiceAccount(String projectId, String serviceAccountName) {
    // String projectId = "my-project-id";
    // String serviceAccountName = "my-service-account-name";

    Iam service = null;
    try {
      service = initService();
    } catch (IOException | GeneralSecurityException e) {
      System.out.println("Unable to initialize service: \n" + e.toString());
      return;
    }

    try {
      ServiceAccount serviceAccount = new ServiceAccount();
      serviceAccount.setDisplayName("your-display-name");
      CreateServiceAccountRequest request = new CreateServiceAccountRequest();
      request.setAccountId(serviceAccountName);
      request.setServiceAccount(serviceAccount);

      serviceAccount =
          service.projects().serviceAccounts().create("projects/" + projectId, request).execute();

      System.out.println("Created service account: " + serviceAccount.getEmail());
    } catch (IOException e) {
      System.out.println("Unable to create service account: \n" + e.toString());
    }
  }

  private static Iam initService() throws GeneralSecurityException, IOException {
    // Use the Application Default Credentials strategy for authentication. For more info, see:
    // https://cloud.google.com/docs/authentication/production#finding_credentials_automatically
    GoogleCredentials credential =
        GoogleCredentials.getApplicationDefault()
            .createScoped(Collections.singleton(IamScopes.CLOUD_PLATFORM));
    // Initialize the IAM service, which can be used to send requests to the IAM API.
    Iam service =
        new Iam.Builder(
                GoogleNetHttpTransport.newTrustedTransport(),
                JacksonFactory.getDefaultInstance(),
                new HttpCredentialsAdapter(credential))
            .setApplicationName("service-accounts")
            .build();
    return service;
  }
}

Python

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

Ver en GitHub Comentarios

import os

from google.oauth2 import service_account
import googleapiclient.discovery

def create_service_account(project_id, name, display_name):
    """Creates a service account."""

    credentials = service_account.Credentials.from_service_account_file(
        filename=os.environ['GOOGLE_APPLICATION_CREDENTIALS'],
        scopes=['https://www.googleapis.com/auth/cloud-platform'])

    service = googleapiclient.discovery.build(
        'iam', 'v1', credentials=credentials)

    my_service_account = service.projects().serviceAccounts().create(
        name='projects/' + project_id,
        body={
            'accountId': name,
            'serviceAccount': {
                'displayName': display_name
            }
        }).execute()

    print('Created service account: ' + my_service_account['email'])
    return my_service_account

Después de crear una cuenta de servicio, otórgale una o más funciones para que pueda actuar en tu nombre.

Además, si la cuenta de servicio necesita acceder a los recursos en otros proyectos, por lo general, debes habilitar las API para esos recursos en el proyecto en el que creaste la cuenta de servicio.

Cómo listar cuentas de servicio

Cuando se enumeran las cuentas de servicio, puedes especificar parámetros para limitar la cantidad de cuentas de servicio que se incluirán en la respuesta. Luego, puedes usar ListServiceAccountsResponse.next_page_token en una solicitud posterior para enumerar las cuentas de servicio restantes.

Usa este método para auditar cuentas y claves de servicio o crear herramientas personalizadas con el fin de administrar cuentas de servicio.

Para enumerar cuentas de servicio, como mínimo, el usuario debe tener la función de usuario de cuenta de servicio (roles/iam.serviceAccountUser) o la función básica de visualizador (roles/viewer).

Console

1. En Cloud Console, ve a la página Cuentas de servicio.

   Ir a Cuentas de servicio

2. Selecciona un proyecto

   En la página Cuentas de servicio, se enumeran todas las cuentas de servicio administradas por el usuario en el proyecto que seleccionaste. En la página, no se enumeran las cuentas de servicio administradas por Google.

gcloud

Ejecuta el comando gcloud iam service-accounts list para enumerar todas las cuentas de servicio de un proyecto.

Comando:

gcloud iam service-accounts list

El resultado es la lista de todas las cuentas de servicio en el proyecto:

NAME                    EMAIL
SA_DISPLAY_NAME_1       SA_NAME_1@PROJECT_ID.iam.gserviceaccount.com
SA_DISPLAY_NAME_2       SA_NAME_2@PROJECT_ID.iam.gserviceaccount.com

REST

Mediante el método serviceAccounts.list, se enumeran todas las cuentas de servicio del proyecto.

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.

Método HTTP y URL:

GET https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts

Para enviar tu solicitud, expande una de estas opciones:

curl (Linux, macOS o Cloud Shell)

Nota: Asegúrate de haber configurado la variable de entorno GOOGLE_APPLICATION_CREDENTIALS a la ruta para el archivo de clave privada de tu cuenta de servicio.

Ejecuta el siguiente comando:

curl -X GET \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
"https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts"

PowerShell (Windows)

Nota: Asegúrate de haber configurado la variable de entorno GOOGLE_APPLICATION_CREDENTIALS a la ruta para el archivo de clave privada de tu cuenta de servicio.

Ejecuta el siguiente comando:

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

Invoke-WebRequest `
  -Method GET `
  -Headers $headers `
  -Uri "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts" | Select-Object -Expand Content

Explorador de API (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:

{
  "accounts": [
    {
      "name": "projects/my-project/serviceAccounts/[e-mail]",
      "projectId": "my-project",
      "uniqueId": "123456789012345678901",
      "email": "[e-mail]",
      "description": "My first service account",
      "displayName": "Service account 1",
      "etag": "BwUpTsLVUkQ=",
      "oauth2ClientId": "987654321098765432109"
    },
    {
      "name": "projects/my-project/serviceAccounts/[e-mail]",
      "projectId": "my-project",
      "uniqueId": "234567890123456789012",
      "email": "[e-mail]",
      "description": "My second service account",
      "displayName": "Service account 2",
      "etag": "UkQpTwBVUsL=",
      "oauth2ClientId": "876543210987654321098"
    }
  ]
}

C++

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

Ver en GitHubComentarios

namespace iam = ::google::cloud::iam;
[](std::string const& project_id) {
  iam::IAMClient client(iam::MakeIAMConnection());
  int count = 0;
  for (auto const& sa :
       client.ListServiceAccounts("projects/" + project_id)) {
    if (!sa) throw std::runtime_error(sa.status().message());
    std::cout << "ServiceAccount successfully retrieved: " << sa->name()
              << "\n";
    ++count;
  }
  if (count == 0) {
    std::cout << "No service accounts found in project: " << project_id
              << "\n";
  }
}

C#

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

Ver en GitHub Comentarios

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

public partial class ServiceAccounts
{
    public static IList<ServiceAccount> ListServiceAccounts(string projectId)
    {
        var credential = GoogleCredential.GetApplicationDefault()
            .CreateScoped(IamService.Scope.CloudPlatform);
        var service = new IamService(new IamService.Initializer
        {
            HttpClientInitializer = credential
        });

        var response = service.Projects.ServiceAccounts.List(
            "projects/" + projectId).Execute();
        foreach (ServiceAccount account in response.Accounts)
        {
            Console.WriteLine("Name: " + account.Name);
            Console.WriteLine("Display Name: " + account.DisplayName);
            Console.WriteLine("Email: " + account.Email);
            Console.WriteLine();
        }
        return response.Accounts;
    }
}

Go

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

Ver en GitHub Comentarios

import (
	"context"
	"fmt"
	"io"

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

// listServiceAccounts lists a project's service accounts.
func listServiceAccounts(w io.Writer, projectID string) ([]*iam.ServiceAccount, error) {
	ctx := context.Background()
	service, err := iam.NewService(ctx)
	if err != nil {
		return nil, fmt.Errorf("iam.NewService: %v", err)
	}

	response, err := service.Projects.ServiceAccounts.List("projects/" + projectID).Do()
	if err != nil {
		return nil, fmt.Errorf("Projects.ServiceAccounts.List: %v", err)
	}
	for _, account := range response.Accounts {
		fmt.Fprintf(w, "Listing service account: %v\n", account.Name)
	}
	return response.Accounts, nil
}

Java

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

Ver en GitHub Comentarios

import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.json.jackson2.JacksonFactory;
import com.google.api.services.iam.v1.Iam;
import com.google.api.services.iam.v1.IamScopes;
import com.google.api.services.iam.v1.model.ListServiceAccountsResponse;
import com.google.api.services.iam.v1.model.ServiceAccount;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.security.GeneralSecurityException;
import java.util.Collections;
import java.util.List;

public class ListServiceAccounts {

  // Lists all service accounts for the current project.
  public static void listServiceAccounts(String projectId) {
    // String projectId = "my-project-id"

    Iam service = null;
    try {
      service = initService();
    } catch (IOException | GeneralSecurityException e) {
      System.out.println("Unable to initialize service: \n" + e.toString());
      return;
    }

    try {
      ListServiceAccountsResponse response =
          service.projects().serviceAccounts().list("projects/" + projectId).execute();
      List<ServiceAccount> serviceAccounts = response.getAccounts();

      for (ServiceAccount account : serviceAccounts) {
        System.out.println("Name: " + account.getName());
        System.out.println("Display Name: " + account.getDisplayName());
        System.out.println("Email: " + account.getEmail());
        System.out.println();
      }
    } catch (IOException e) {
      System.out.println("Unable to list service accounts: \n" + e.toString());
    }
  }

  private static Iam initService() throws GeneralSecurityException, IOException {
    // Use the Application Default Credentials strategy for authentication. For more info, see:
    // https://cloud.google.com/docs/authentication/production#finding_credentials_automatically
    GoogleCredentials credential =
        GoogleCredentials.getApplicationDefault()
            .createScoped(Collections.singleton(IamScopes.CLOUD_PLATFORM));
    // Initialize the IAM service, which can be used to send requests to the IAM API.
    Iam service =
        new Iam.Builder(
                GoogleNetHttpTransport.newTrustedTransport(),
                JacksonFactory.getDefaultInstance(),
                new HttpCredentialsAdapter(credential))
            .setApplicationName("service-accounts")
            .build();
    return service;
  }
}

Python

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

Ver en GitHub Comentarios

import os

from google.oauth2 import service_account
import googleapiclient.discovery

def list_service_accounts(project_id):
    """Lists all service accounts for the current project."""

    credentials = service_account.Credentials.from_service_account_file(
        filename=os.environ['GOOGLE_APPLICATION_CREDENTIALS'],
        scopes=['https://www.googleapis.com/auth/cloud-platform'])

    service = googleapiclient.discovery.build(
        'iam', 'v1', credentials=credentials)

    service_accounts = service.projects().serviceAccounts().list(
        name='projects/' + project_id).execute()

    for account in service_accounts['accounts']:
        print('Name: ' + account['name'])
        print('Email: ' + account['email'])
        print(' ')
    return service_accounts

Actualiza una cuenta de servicio

Se suele usar el nombre visible (nombre descriptivo) y la descripción de una cuenta de servicio para recopilar información adicional sobre la cuenta de servicio, como su propósito o una persona de contacto de la cuenta.

Para actualizar el nombre o la descripción de una cuenta de servicio, como mínimo, el usuario debe tener la función de administrador de cuenta de servicio (roles/iam.serviceAccountAdmin) o la función básica de editor (roles/editor).

Console

1. En Cloud Console, ve a la página Cuentas de servicio.

   Ir a Cuentas de servicio

2. Selecciona un proyecto

3. Haz clic en la dirección de correo electrónico de la cuenta de servicio a la que deseas cambiarle el nombre.

4. Ingresa el nombre nuevo en el cuadro Nombre y, luego, haz clic en Guardar.

gcloud

Ejecuta el comando gcloud iam service-accounts update para actualizar una cuenta de servicio.

Comando:

gcloud iam service-accounts update \
    SA_NAME@PROJECT_ID.iam.gserviceaccount.com \
    --description="UPDATED_SA_DESCRIPTION" \
    --display-name="UPDATED_DISPLAY_NAME"

El resultado es la cuenta de servicio renombrada:

description: UPDATED_SA_DESCRIPTION
displayName: UPDATED_DISPLAY_NAME
name: projects/PROJECT_ID/serviceAccounts/SA_NAME@PROJECT_ID.iam.gserviceaccount.com

REST

Mediante el método serviceAccounts.patch, se actualiza 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_ID: El ID de la cuenta de servicio. Puede ser la dirección de correo electrónico de la cuenta de servicio con el formato SA_NAME@PROJECT_ID.iam.gserviceaccount.com o el ID numérico único de la cuenta de servicio.
• SA_NAME: Es el ID alfanumérico de tu cuenta de servicio. Este nombre debe tener entre 6 y 30 caracteres y puede contener caracteres alfanuméricos en minúscula y guiones.
• Reemplaza al menos uno de los siguientes elementos:
• UPDATED_DISPLAY_NAME: Es un nombre nuevo para la cuenta de servicio.
• UPDATED_DESCRIPTION: Es una descripción nueva para la cuenta de servicio.

Método HTTP y URL:

PATCH https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/SA_ID 

Cuerpo JSON de la solicitud:

{
  "serviceAccount": {
    "email": "SA_NAME@PROJECT_ID.iam.gserviceaccount.com",
    "displayName": "UPDATED_DISPLAY_NAME",
    "description": "UPDATED_DESCRIPTION"
  },
  "updateMask": "displayName,description"
}

Para enviar tu solicitud, expande una de estas opciones:

curl (Linux, macOS o Cloud Shell)

Nota: Asegúrate de haber configurado la variable de entorno GOOGLE_APPLICATION_CREDENTIALS a la ruta para el archivo de clave privada de tu cuenta de servicio.

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

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

PowerShell (Windows)

Nota: Asegúrate de haber configurado la variable de entorno GOOGLE_APPLICATION_CREDENTIALS a la ruta para el archivo de clave privada de tu cuenta de servicio.

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

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

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

Explorador de API (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.

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

{
  "name": "projects/my-project/serviceAccounts/[e-mail]",
  "displayName": "My updated service account",
  "description": "An updated description of my service account"
}

C++

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

Ver en GitHubComentarios

namespace iam = ::google::cloud::iam;
[](std::string const& name, std::string const& display_name) {
  iam::IAMClient client(iam::MakeIAMConnection());
  google::iam::admin::v1::PatchServiceAccountRequest request;
  google::iam::admin::v1::ServiceAccount service_account;
  service_account.set_name(name);
  service_account.set_display_name(display_name);
  google::protobuf::FieldMask update_mask;
  *update_mask.add_paths() = "display_name";
  *request.mutable_service_account() = service_account;
  *request.mutable_update_mask() = update_mask;
  auto response = client.PatchServiceAccount(request);
  if (!response) throw std::runtime_error(response.status().message());
  std::cout << "ServiceAccount successfully updated: "
            << response->DebugString() << "\n";
}

C#

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

Ver en GitHub Comentarios

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

public partial class ServiceAccounts
{
    public static ServiceAccount RenameServiceAccount(string email,
        string newDisplayName)
    {
        var credential = GoogleCredential.GetApplicationDefault()
            .CreateScoped(IamService.Scope.CloudPlatform);
        var service = new IamService(new IamService.Initializer
        {
            HttpClientInitializer = credential
        });

        // First, get a ServiceAccount using List() or Get().
        string resource = "projects/-/serviceAccounts/" + email;
        var serviceAccount = service.Projects.ServiceAccounts.Get(resource)
            .Execute();
        // Then you can update the display name.
        serviceAccount.DisplayName = newDisplayName;
        serviceAccount = service.Projects.ServiceAccounts.Update(
            serviceAccount, resource).Execute();
        Console.WriteLine($"Updated display name for {serviceAccount.Email} " +
            "to: " + serviceAccount.DisplayName);
        return serviceAccount;
    }
}

Go

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

Ver en GitHub Comentarios

import (
	"context"
	"fmt"
	"io"

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

// renameServiceAccount renames a service account.
func renameServiceAccount(w io.Writer, email, newDisplayName string) (*iam.ServiceAccount, error) {
	ctx := context.Background()
	service, err := iam.NewService(ctx)
	if err != nil {
		return nil, fmt.Errorf("iam.NewService: %v", err)
	}

	// First, get a ServiceAccount using List() or Get().
	resource := "projects/-/serviceAccounts/" + email
	serviceAccount, err := service.Projects.ServiceAccounts.Get(resource).Do()
	if err != nil {
		return nil, fmt.Errorf("Projects.ServiceAccounts.Get: %v", err)
	}
	// Then you can update the display name.
	serviceAccount.DisplayName = newDisplayName
	serviceAccount, err = service.Projects.ServiceAccounts.Update(resource, serviceAccount).Do()
	if err != nil {
		return nil, fmt.Errorf("Projects.ServiceAccounts.Update: %v", err)
	}

	fmt.Fprintf(w, "Updated service account: %v", serviceAccount.Email)
	return serviceAccount, nil
}

Java

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

Ver en GitHub Comentarios

import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.json.jackson2.JacksonFactory;
import com.google.api.services.iam.v1.Iam;
import com.google.api.services.iam.v1.IamScopes;
import com.google.api.services.iam.v1.model.ServiceAccount;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.security.GeneralSecurityException;
import java.util.Collections;

public class RenameServiceAccount {

  // Changes a service account's display name.
  public static void renameServiceAccount(String projectId, String serviceAccountName) {
    // String projectId = "my-project-id";
    // String serviceAccountName = "my-service-account-name";

    Iam service = null;
    try {
      service = initService();
    } catch (IOException | GeneralSecurityException e) {
      System.out.println("Unable to initialize service: \n" + e.toString());
      return;
    }

    String serviceAccountEmail = serviceAccountName + "@" + projectId + ".iam.gserviceaccount.com";
    try {
      // First, get a service account using List() or Get()
      ServiceAccount serviceAccount =
          service
              .projects()
              .serviceAccounts()
              .get("projects/-/serviceAccounts/" + serviceAccountEmail)
              .execute();

      // Then you can update the display name
      serviceAccount.setDisplayName("your-new-display-name");
      serviceAccount =
          service
              .projects()
              .serviceAccounts()
              .update(serviceAccount.getName(), serviceAccount)
              .execute();

      System.out.println(
          "Updated display name for "
              + serviceAccount.getName()
              + " to: "
              + serviceAccount.getDisplayName());
    } catch (IOException e) {
      System.out.println("Unable to rename service account: \n" + e.toString());
    }
  }

  private static Iam initService() throws GeneralSecurityException, IOException {
    // Use the Application Default Credentials strategy for authentication. For more info, see:
    // https://cloud.google.com/docs/authentication/production#finding_credentials_automatically
    GoogleCredentials credential =
        GoogleCredentials.getApplicationDefault()
            .createScoped(Collections.singleton(IamScopes.CLOUD_PLATFORM));
    // Initialize the IAM service, which can be used to send requests to the IAM API.
    Iam service =
        new Iam.Builder(
                GoogleNetHttpTransport.newTrustedTransport(),
                JacksonFactory.getDefaultInstance(),
                new HttpCredentialsAdapter(credential))
            .setApplicationName("service-accounts")
            .build();
    return service;
  }
}

Python

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

Ver en GitHub Comentarios

import os

from google.oauth2 import service_account
import googleapiclient.discovery

def rename_service_account(email, new_display_name):
    """Changes a service account's display name."""

    # First, get a service account using List() or Get()
    credentials = service_account.Credentials.from_service_account_file(
        filename=os.environ['GOOGLE_APPLICATION_CREDENTIALS'],
        scopes=['https://www.googleapis.com/auth/cloud-platform'])

    service = googleapiclient.discovery.build(
        'iam', 'v1', credentials=credentials)

    resource = 'projects/-/serviceAccounts/' + email

    my_service_account = service.projects().serviceAccounts().get(
        name=resource).execute()

    # Then you can update the display name
    my_service_account['displayName'] = new_display_name
    my_service_account = service.projects().serviceAccounts().update(
        name=resource, body=my_service_account).execute()

    print('Updated display name for {} to: {}'.format(
        my_service_account['email'], my_service_account['displayName']))
    return my_service_account

Inhabilita una cuenta de servicio

Al igual que cuando borras una cuenta de servicio, cuando inhabilitas una de estas, las aplicaciones ya no tendrán acceso a los recursos de Google Cloud a través de esa cuenta de servicio. Si inhabilitas las cuentas de servicio predeterminadas de App Engine y Compute Engine, las instancias ya no tendrán acceso a los recursos del proyecto. Si intentas inhabilitar una cuenta de servicio que ya está inhabilitada, no tendrá efecto.

A diferencia de las cuentas de servicio borradas, las cuentas de servicio inhabilitadas se pueden volver a habilitar de forma sencilla según sea necesario. Te recomendamos inhabilitar la cuenta de servicio antes de borrarla para asegurarte de que ninguna aplicación importante esté usando la cuenta.

Para inhabilitar una cuenta de servicio, como mínimo, el usuario debe tener la función de administrador de cuenta de servicio (roles/iam.serviceAccountAdmin) o la función básica de editor (roles/editor).

Console

1. En Cloud Console, ve a la página Cuentas de servicio.

   Ir a Cuentas de servicio

2. Selecciona un proyecto

3. Haz clic en el nombre de la cuenta de servicio que quieres inhabilitar.

4. En Estado de la cuenta de servicio, haz clic en Inhabilitar la cuenta de servicio y, luego, en Inhabilitar para confirmar el cambio.

gcloud

Ejecuta el comando gcloud iam service-accounts disable para inhabilitar una cuenta de servicio.

Comando:

gcloud iam service-accounts disable SA_NAME@PROJECT_ID.iam.gserviceaccount.com

Resultado:

Disabled service account SA_NAME@PROJECT_ID.iam.gserviceaccount.com

REST

Mediante el método serviceAccounts.disable, se inhabilita de inmediato 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_ID: El ID de la cuenta de servicio. Puede ser la dirección de correo electrónico de la cuenta de servicio con el formato SA_NAME@PROJECT_ID.iam.gserviceaccount.com o el ID numérico único de la cuenta de servicio.

Método HTTP y URL:

POST https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/SA_ID:disable

Para enviar tu solicitud, expande una de estas opciones:

curl (Linux, macOS o Cloud Shell)

Nota: Asegúrate de haber configurado la variable de entorno GOOGLE_APPLICATION_CREDENTIALS a la ruta para el archivo de clave privada de tu cuenta de servicio.

Ejecuta el siguiente comando:

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

PowerShell (Windows)

Nota: Asegúrate de haber configurado la variable de entorno GOOGLE_APPLICATION_CREDENTIALS a la ruta para el archivo de clave privada de tu cuenta de servicio.

Ejecuta el siguiente comando:

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

Invoke-WebRequest `
  -Method POST `
  -Headers $headers `
  -Uri "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/SA_ID:disable" | Select-Object -Expand Content

Explorador de API (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.

Si se ejecuta correctamente, el cuerpo de la respuesta estará vacío.

C++

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

Ver en GitHubComentarios

namespace iam = ::google::cloud::iam;
[](std::string const& name) {
  iam::IAMClient client(iam::MakeIAMConnection());
  google::iam::admin::v1::DisableServiceAccountRequest request;
  request.set_name(name);
  auto response = client.DisableServiceAccount(request);
  if (!response.ok()) throw std::runtime_error(response.message());
  std::cout << "ServiceAccount successfully disabled.\n";
}

C#

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

Ver en GitHub Comentarios

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

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

        var request = new DisableServiceAccountRequest();

        string resource = "projects/-/serviceAccounts/" + email;
        service.Projects.ServiceAccounts.Disable(request, resource).Execute();
        Console.WriteLine("Disabled service account: " + email);
    }
}

Go

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

Ver en GitHub Comentarios

import (
	"context"
	"fmt"
	"io"

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

// disableServiceAccount disables a service account.
func disableServiceAccount(w io.Writer, email string) error {
	// email:= [e-mail]
	ctx := context.Background()
	service, err := iam.NewService(ctx)
	if err != nil {
		return fmt.Errorf("iam.NewService: %v", err)
	}

	request := &iam.DisableServiceAccountRequest{}
	_, err = service.Projects.ServiceAccounts.Disable("projects/-/serviceAccounts/"+email, request).Do()
	if err != nil {
		return fmt.Errorf("Projects.ServiceAccounts.Disable: %v", err)
	}
	fmt.Fprintf(w, "Disabled service account: %v", email)
	return nil
}

Java

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

Ver en GitHub Comentarios

import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.json.jackson2.JacksonFactory;
import com.google.api.services.iam.v1.Iam;
import com.google.api.services.iam.v1.IamScopes;
import com.google.api.services.iam.v1.model.DisableServiceAccountRequest;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.security.GeneralSecurityException;
import java.util.Collections;

public class DisableServiceAccount {

  // Disables a service account.
  public static void disableServiceAccount(String projectId, String serviceAccountName) {
    // String projectId = "my-project-id";
    // String serviceAccountName = "my-service-account-name";

    Iam service = null;
    try {
      service = initService();
    } catch (IOException | GeneralSecurityException e) {
      System.out.println("Unable to initialize service: \n" + e.toString());
      return;
    }

    String serviceAccountEmail = serviceAccountName + "@" + projectId + ".iam.gserviceaccount.com";
    try {
      DisableServiceAccountRequest request = new DisableServiceAccountRequest();
      service
          .projects()
          .serviceAccounts()
          .disable("projects/-/serviceAccounts/" + serviceAccountEmail, request)
          .execute();

      System.out.println("Disabled service account: " + serviceAccountEmail);
    } catch (IOException e) {
      System.out.println("Unable to disable service account: \n" + e.toString());
    }
  }

  private static Iam initService() throws GeneralSecurityException, IOException {
    // Use the Application Default Credentials strategy for authentication. For more info, see:
    // https://cloud.google.com/docs/authentication/production#finding_credentials_automatically
    GoogleCredentials credential =
        GoogleCredentials.getApplicationDefault()
            .createScoped(Collections.singleton(IamScopes.CLOUD_PLATFORM));
    // Initialize the IAM service, which can be used to send requests to the IAM API.
    Iam service =
        new Iam.Builder(
                GoogleNetHttpTransport.newTrustedTransport(),
                JacksonFactory.getDefaultInstance(),
                new HttpCredentialsAdapter(credential))
            .setApplicationName("service-accounts")
            .build();
    return service;
  }
}

Python

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

Ver en GitHub Comentarios

import os

from google.oauth2 import service_account
import googleapiclient.discovery

def disable_service_account(email):
    """Disables a service account."""

    credentials = service_account.Credentials.from_service_account_file(
        filename=os.environ['GOOGLE_APPLICATION_CREDENTIALS'],
        scopes=['https://www.googleapis.com/auth/cloud-platform'])

    service = googleapiclient.discovery.build(
        'iam', 'v1', credentials=credentials)

    service.projects().serviceAccounts().disable(
        name='projects/-/serviceAccounts/' + email).execute()

    print("Disabled service account :" + email)

Habilita una cuenta de servicio

Después de habilitar una cuenta de servicio inhabilitada, las aplicaciones recuperarán el acceso a los recursos de Google Cloud a través de esta cuenta.

Puedes habilitar una cuenta de servicio inhabilitada siempre que lo necesites. Si intentas habilitar una cuenta de servicio ya habilitada, no tendrá efecto.

Para habilitar una cuenta de servicio, como mínimo, el usuario debe tener la función de administrador de cuenta de servicio (roles/iam.serviceAccountAdmin) o la función básica de editor (roles/editor).

Console

1. En Cloud Console, ve a la página Cuentas de servicio.

   Ir a Cuentas de servicio

2. Selecciona un proyecto

3. Haz clic en el nombre de la cuenta de servicio que deseas habilitar.

4. En Estado de la cuenta de servicio, haz clic en Habilitar la cuenta de servicio y, luego, en Habilitar para confirmar el cambio.

gcloud

Ejecuta el comando gcloud iam service-accounts enable para habilitar una cuenta de servicio.

Comando:

gcloud iam service-accounts enable SA_NAME@PROJECT_ID.iam.gserviceaccount.com

Resultado:

Enabled service account SA_NAME@PROJECT_ID.iam.gserviceaccount.com

REST

Mediante el método serviceAccounts.enable, se habilita una cuenta de servicio inhabilitada con anterioridad.

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_ID: El ID de la cuenta de servicio. Puede ser la dirección de correo electrónico de la cuenta de servicio con el formato SA_NAME@PROJECT_ID.iam.gserviceaccount.com o el ID numérico único de la cuenta de servicio.

Método HTTP y URL:

POST https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/SA_ID:enable

Para enviar tu solicitud, expande una de estas opciones:

curl (Linux, macOS o Cloud Shell)

Nota: Asegúrate de haber configurado la variable de entorno GOOGLE_APPLICATION_CREDENTIALS a la ruta para el archivo de clave privada de tu cuenta de servicio.

Ejecuta el siguiente comando:

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

PowerShell (Windows)

Nota: Asegúrate de haber configurado la variable de entorno GOOGLE_APPLICATION_CREDENTIALS a la ruta para el archivo de clave privada de tu cuenta de servicio.

Ejecuta el siguiente comando:

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

Invoke-WebRequest `
  -Method POST `
  -Headers $headers `
  -Uri "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/SA_ID:enable" | Select-Object -Expand Content

Explorador de API (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.

Si se ejecuta correctamente, el cuerpo de la respuesta estará vacío.

C++

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

Ver en GitHubComentarios

namespace iam = ::google::cloud::iam;
[](std::string const& name) {
  iam::IAMClient client(iam::MakeIAMConnection());
  google::iam::admin::v1::EnableServiceAccountRequest request;
  request.set_name(name);
  auto response = client.EnableServiceAccount(request);
  if (!response.ok()) throw std::runtime_error(response.message());
  std::cout << "ServiceAccount successfully enabled.\n";
}

C#

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

Ver en GitHub Comentarios

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

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

        var request = new EnableServiceAccountRequest();

        string resource = "projects/-/serviceAccounts/" + email;
        service.Projects.ServiceAccounts.Enable(request, resource).Execute();
        Console.WriteLine("Enabled service account: " + email);
    }
}

Go

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

Ver en GitHub Comentarios

import (
	"context"
	"fmt"
	"io"

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

// enableServiceAccount enables a service account.
func enableServiceAccount(w io.Writer, email string) error {
	// email:= [e-mail]
	ctx := context.Background()
	service, err := iam.NewService(ctx)
	if err != nil {
		return fmt.Errorf("iam.NewService: %v", err)
	}

	request := &iam.EnableServiceAccountRequest{}
	_, err = service.Projects.ServiceAccounts.Enable("projects/-/serviceAccounts/"+email, request).Do()
	if err != nil {
		return fmt.Errorf("Projects.ServiceAccounts.Enable: %v", err)
	}
	fmt.Fprintf(w, "Enabled service account: %v", email)
	return nil
}

Java

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

Ver en GitHub Comentarios

import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.json.jackson2.JacksonFactory;
import com.google.api.services.iam.v1.Iam;
import com.google.api.services.iam.v1.IamScopes;
import com.google.api.services.iam.v1.model.EnableServiceAccountRequest;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.security.GeneralSecurityException;
import java.util.Collections;

public class EnableServiceAccount {

  // Enables a service account.
  public static void enableServiceAccount(String projectId, String serviceAccountName) {
    // String projectId = "my-project-id";
    // String serviceAccountName = "my-service-account-name";

    Iam service = null;
    try {
      service = initService();
    } catch (IOException | GeneralSecurityException e) {
      System.out.println("Unable to initialize service: \n" + e.toString());
      return;
    }

    String serviceAccountEmail = serviceAccountName + "@" + projectId + ".iam.gserviceaccount.com";
    try {
      EnableServiceAccountRequest request = new EnableServiceAccountRequest();
      service
          .projects()
          .serviceAccounts()
          .enable("projects/-/serviceAccounts/" + serviceAccountEmail, request)
          .execute();

      System.out.println("Enabled service account: " + serviceAccountEmail);
    } catch (IOException e) {
      System.out.println("Unable to enable service account: \n" + e.toString());
    }
  }

  private static Iam initService() throws GeneralSecurityException, IOException {
    // Use the Application Default Credentials strategy for authentication. For more info, see:
    // https://cloud.google.com/docs/authentication/production#finding_credentials_automatically
    GoogleCredentials credential =
        GoogleCredentials.getApplicationDefault()
            .createScoped(Collections.singleton(IamScopes.CLOUD_PLATFORM));
    // Initialize the IAM service, which can be used to send requests to the IAM API.
    Iam service =
        new Iam.Builder(
                GoogleNetHttpTransport.newTrustedTransport(),
                JacksonFactory.getDefaultInstance(),
                new HttpCredentialsAdapter(credential))
            .setApplicationName("service-accounts")
            .build();
    return service;
  }
}

Python

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

Ver en GitHub Comentarios

import os

from google.oauth2 import service_account
import googleapiclient.discovery

def enable_service_account(email):
    """Enables a service account."""

    credentials = service_account.Credentials.from_service_account_file(
        filename=os.environ['GOOGLE_APPLICATION_CREDENTIALS'],
        scopes=['https://www.googleapis.com/auth/cloud-platform'])

    service = googleapiclient.discovery.build(
        'iam', 'v1', credentials=credentials)

    service.projects().serviceAccounts().enable(
        name='projects/-/serviceAccounts/' + email).execute()

    print("Enabled service account :" + email)

Borra una cuenta de servicio

Cuando borras una cuenta de servicio, las aplicaciones ya no tendrán acceso a los recursos de Google Cloud a través de esa cuenta. Si borras las cuentas de servicio predeterminadas de App Engine y Compute Engine, las instancias ya no tendrán acceso a los recursos del proyecto.

Ten cuidado a la hora de borrar una cuenta de servicio y asegúrate de que tus aplicaciones importantes ya no usen la cuenta de servicio antes de borrarla. Si no tienes en claro si se está usando una cuenta de servicio, te recomendamos que inhabilites la cuenta de servicio antes de borrarla. Las cuentas de servicio inhabilitadas se pueden volver a habilitar con facilidad si aun están en uso.

Si borras una cuenta de servicio y, luego, creas una nueva con el mismo nombre, la cuenta nueva se trata como una identidad independiente. No hereda las funciones otorgadas a la cuenta de servicio que se borró. En cambio, cuando borras una cuenta de servicio y, luego, la recuperas, la identidad de la cuenta de servicio no cambia y la cuenta de servicio conserva sus funciones.

Cuando se borra una cuenta de servicio, sus vinculaciones de funciones no se quitan de inmediato, sino que se borran definitivamente del sistema de manera automática después de un máximo de 60 días.

Las cuentas de servicio borradas no se toman en cuenta en la cuota de la cuenta de servicio.

Para borrar una cuenta de servicio, como mínimo, el usuario debe tener la función de administrador de cuenta de servicio (roles/iam.serviceAccountAdmin) o la función básica de editor (roles/editor).

Console

1. En Cloud Console, ve a la página Cuentas de servicio.

   Ir a Cuentas de servicio

2. Selecciona un proyecto

3. Selecciona la cuenta de servicio que deseas borrar y, luego, haz clic en Borrar .

gcloud

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

Comando:

gcloud iam service-accounts delete \
    SA_NAME@PROJECT_ID.iam.gserviceaccount.com

Resultado:

Deleted service account SA_NAME@PROJECT_ID.iam.gserviceaccount.com

REST

Mediante el método serviceAccounts.delete, se borra 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_ID: El ID de la cuenta de servicio. Puede ser la dirección de correo electrónico de la cuenta de servicio con el formato SA_NAME@PROJECT_ID.iam.gserviceaccount.com o el ID numérico único de la cuenta de servicio.

Método HTTP y URL:

DELETE https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/SA_ID

Para enviar tu solicitud, expande una de estas opciones:

curl (Linux, macOS o Cloud Shell)

Nota: Asegúrate de haber configurado la variable de entorno GOOGLE_APPLICATION_CREDENTIALS a la ruta para el archivo de clave privada de tu cuenta de servicio.

Ejecuta el siguiente comando:

curl -X DELETE \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
"https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/SA_ID"

PowerShell (Windows)

Nota: Asegúrate de haber configurado la variable de entorno GOOGLE_APPLICATION_CREDENTIALS a la ruta para el archivo de clave privada de tu cuenta de servicio.

Ejecuta el siguiente comando:

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

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

Explorador de API (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.

Si se ejecuta correctamente, el cuerpo de la respuesta estará vacío.

C++

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

Ver en GitHubComentarios

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

C#

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

Ver en GitHub Comentarios

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

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

        string resource = "projects/-/serviceAccounts/" + email;
        service.Projects.ServiceAccounts.Delete(resource).Execute();
        Console.WriteLine("Deleted service account: " + email);
    }
}

Go

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

Ver en GitHub Comentarios

import (
	"context"
	"fmt"
	"io"

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

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

	_, err = service.Projects.ServiceAccounts.Delete("projects/-/serviceAccounts/" + email).Do()
	if err != nil {
		return fmt.Errorf("Projects.ServiceAccounts.Delete: %v", err)
	}
	fmt.Fprintf(w, "Deleted service account: %v", email)
	return nil
}

Java

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

Ver en GitHub Comentarios

import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.json.jackson2.JacksonFactory;
import com.google.api.services.iam.v1.Iam;
import com.google.api.services.iam.v1.IamScopes;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.security.GeneralSecurityException;
import java.util.Collections;

public class DeleteServiceAccount {

  // Deletes a service account.
  public static void deleteServiceAccount(String projectId, String serviceAccountName) {
    // String projectId = "my-project-id";
    // String serviceAccountName = "my-service-account-name";

    Iam service = null;
    try {
      service = initService();
    } catch (IOException | GeneralSecurityException e) {
      System.out.println("Unable to initialize service: \n" + e.toString());
      return;
    }

    String serviceAccountEmail = serviceAccountName + "@" + projectId + ".iam.gserviceaccount.com";
    try {
      service
          .projects()
          .serviceAccounts()
          .delete("projects/-/serviceAccounts/" + serviceAccountEmail)
          .execute();

      System.out.println("Deleted service account: " + serviceAccountEmail);
    } catch (IOException e) {
      System.out.println("Unable to delete service account: \n" + e.toString());
    }
  }

  private static Iam initService() throws GeneralSecurityException, IOException {
    // Use the Application Default Credentials strategy for authentication. For more info, see:
    // https://cloud.google.com/docs/authentication/production#finding_credentials_automatically
    GoogleCredentials credential =
        GoogleCredentials.getApplicationDefault()
            .createScoped(Collections.singleton(IamScopes.CLOUD_PLATFORM));
    // Initialize the IAM service, which can be used to send requests to the IAM API.
    Iam service =
        new Iam.Builder(
                GoogleNetHttpTransport.newTrustedTransport(),
                JacksonFactory.getDefaultInstance(),
                new HttpCredentialsAdapter(credential))
            .setApplicationName("service-accounts")
            .build();
    return service;
  }
}

Python

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

Ver en GitHub Comentarios

import os

from google.oauth2 import service_account
import googleapiclient.discovery

def delete_service_account(email):
    """Deletes a service account."""

    credentials = service_account.Credentials.from_service_account_file(
        filename=os.environ['GOOGLE_APPLICATION_CREDENTIALS'],
        scopes=['https://www.googleapis.com/auth/cloud-platform'])

    service = googleapiclient.discovery.build(
        'iam', 'v1', credentials=credentials)

    service.projects().serviceAccounts().delete(
        name='projects/-/serviceAccounts/' + email).execute()

    print('Deleted service account: ' + email)

Recupera una cuenta de servicio

En algunos casos, puedes usar el comando undelete para recuperar una cuenta de servicio borrada. Por lo general, puedes recuperar una cuenta de servicio borrada si cumple con los criterios siguientes:

• La cuenta de servicio se borró hace menos de 30 días.

  Después de 30 días, IAM quitará la cuenta de servicio de forma permanente. Google Cloud no puede recuperar la cuenta de servicio después de que se quita de forma permanente, incluso si presentas una solicitud de asistencia.

• No existe una cuenta de servicio con el mismo nombre que la cuenta de servicio borrada.

  Por ejemplo, supongamos que borras la cuenta de servicio [e-mail] por accidente. Aún necesitas una cuenta de servicio con ese nombre, por lo que debes crear una cuenta de servicio nueva con el mismo nombre, [e-mail].

  La cuenta de servicio nueva no hereda los permisos de la cuenta de servicio que se borró. En efecto, es completamente independiente de la cuenta de servicio que se borró. Sin embargo, no puedes recuperar la cuenta de servicio original, ya que la cuenta de servicio nueva tiene el mismo nombre.

  Para solucionar este problema, borra la cuenta de servicio nueva y, luego, intenta recuperar la cuenta original.

Si no puedes recuperar la cuenta de servicio, puedes crear una nueva con el mismo nombre. Revoca todas las funciones de la cuenta de servicio borrada y otorga las mismas funciones a la cuenta de servicio nueva. Para obtener más información, consulta Políticas con principales borrados.

Busca el ID numérico de una cuenta de servicio borrada

Cuando recuperas una cuenta de servicio, debes proporcionar su ID numérico. El ID numérico es un número de 21 dígitos, como 123456789012345678901, que identifica de forma única la cuenta de servicio. Por ejemplo, si borras una cuenta de servicio y, luego, creas una nueva con el mismo nombre, la original y la nueva tendrán ID numéricos diferentes.

Si sabes que una vinculación en una política de IAM incluye a la cuenta de servicio borrada, puedes obtener la política y, luego, buscar el ID numérico en la política. El ID numérico se agrega al nombre de la cuenta de servicio borrada. Por ejemplo, en esta política, el ID numérico de la cuenta de servicio borrada es 123456789012345678901:

{
  "version": 1,
  "etag": "BwUjMhCsNvY=",
  "bindings": [
    {
      "members": [
        "deleted:serviceAccount:[e-mail]?uid=123456789012345678901"
      ],
      "role": "roles/iam.serviceAccountUser"
    },
  ]
}

Los ID numéricos solo se agregan a los nombres de las principales borrados.

Como alternativa, puedes buscar en tus registros de auditoría la operación DeleteServiceAccount que borró la cuenta de servicio:

1. En Cloud Console, ve a la página Explorador de registros.

   Ir al Explorador de registros

2. En el editor de consultas, ingresa la siguiente consulta y reemplaza SERVICE_ACCOUNT_EMAIL por la dirección de correo electrónico de la cuenta de servicio (por ejemplo, [e-mail]):

   resource.type="service_account"
   resource.labels.email_id="SERVICE_ACCOUNT_EMAIL"
   "DeleteServiceAccount"
   

3. Si la cuenta de servicio se borró hace más de una hora, haz clic en Lastltima hora, selecciona un período de tiempo más largo de la lista desplegable y, luego, haz clic en Aplicar.

4. Haga clic en Run query. El visor de registros muestra las operaciones DeleteServiceAccount que afectaron a las cuentas de servicio con el nombre que especificaste.

5. Busca y anota el ID numérico de la cuenta de servicio borrada mediante una de las siguientes opciones:

   • Si los resultados de la búsqueda incluyen solo una operación DeleteServiceAccount, busca el ID numérico en el campo ID único del panel Campos de registros.

     

     

   • Si los resultados de la búsqueda muestran más de un registro, haz lo siguiente:

     1. Busca la entrada de registro correcta. Para encontrarla, haz clic en la flecha de expansión junto a una entrada de registro. Revisa los detalles de la entrada de registro y determina si muestra la operación que quieres deshacer. Repite este proceso hasta que encuentres la entrada de registro correcta.

     2. En la entrada de registro correcta, busca el ID numérico de la cuenta de servicio. Para ubicar el ID numérico, expande el campo protoPayload de la entrada de registro y, luego, busca el campo resourceName.

        

        

        El ID numérico es todo lo que se encuentra después de serviceAccounts en el campo resourceName.

Recupera la cuenta de servicio por ID numérico

Después de encontrar el ID numérico de la cuenta de servicio borrada, puedes intentar recuperar la cuenta de servicio.

gcloud

Ejecuta el comando gcloud beta iam service-accounts undelete para recuperar una cuenta de servicio.

Comando:

gcloud beta iam service-accounts undelete ACCOUNT_ID

Resultado:

restoredAccount:
  email: SA_NAME@PROJECT_ID.iam.gserviceaccount.com
  etag: BwWWE7zpApg=
  name: projects/PROJECT_ID/serviceAccounts/SA_NAME@PROJECT_ID.iam.gserviceaccount.com
  oauth2ClientId: '123456789012345678901'
  projectId: PROJECT_ID
  uniqueId: 'ACCOUNT_ID'

REST

Mediante el método serviceAccounts.undelete, se restablece una cuenta de servicio borrada.

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_NUMERIC_ID: Es el ID numérico único de la cuenta de servicio.

Método HTTP y URL:

POST https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/SA_NUMERIC_ID:undelete

Para enviar tu solicitud, expande una de estas opciones:

curl (Linux, macOS o Cloud Shell)

Nota: Asegúrate de haber configurado la variable de entorno GOOGLE_APPLICATION_CREDENTIALS a la ruta para el archivo de clave privada de tu cuenta de servicio.

Ejecuta el siguiente comando:

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

PowerShell (Windows)

Nota: Asegúrate de haber configurado la variable de entorno GOOGLE_APPLICATION_CREDENTIALS a la ruta para el archivo de clave privada de tu cuenta de servicio.

Ejecuta el siguiente comando:

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

Invoke-WebRequest `
  -Method POST `
  -Headers $headers `
  -Uri "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/SA_NUMERIC_ID:undelete" | Select-Object -Expand Content

Explorador de API (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.

Si la cuenta se puede recuperar, recibirás un código de respuesta 200 OK con detalles sobre la cuenta de servicio restablecida, como se muestra a continuación:

{
  "restoredAccount": {
    "name": "projects/my-project/serviceAccounts/[e-mail]",
    "projectId": "my-project",
    "uniqueId": "123456789012345678901",
    "email": "[e-mail]",
    "displayName": "My service account",
    "etag": "BwUp3rVlzes=",
    "description": "A service account for running jobs in my project",
    "oauth2ClientId": "987654321098765432109"
  }
}

Próximos pasos

• Aprende a crear y administrar claves de cuenta de servicio.
• Revisa el proceso para otorgar funciones de IAM a todos los tipos de principales, incluidas las cuentas de servicio.
• Explora cómo puedes usar las recomendaciones de función para reducir los permisos de todos las principales, incluidas las cuentas de servicio.
• Obtén más información sobre cómo permitir que las principales actúen como cuentas de servicio.

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