Creazione e gestione degli account di servizio

Questa pagina spiega come creare e gestire gli account di servizio utilizzando l'API Identity and Access Management (IAM), Google Cloud Console e lo strumento a riga di comando gcloud.

Per impostazione predefinita, ogni progetto può avere fino a 100 account di servizio che controllano l'accesso alle risorse. Se necessario, puoi richiedere un aumento della quota. Scopri di più su quote e limiti.

Prima di iniziare

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per gestire gli account di servizio, chiedi al tuo amministratore di concederti i seguenti ruoli IAM sul progetto:

  • Per visualizzare gli account di servizio e i relativi metadati: Visualizza gli account di servizio (roles/iam.serviceAccountViewer)
  • Per visualizzare e creare account di servizio: Crea account di servizio (roles/iam.serviceAccountCreator)
  • Per visualizzare ed eliminare gli account di servizio: Elimina gli account di servizio (roles/iam.serviceAccountDeleter)
  • Per gestire completamente (visualizzare, creare, aggiornare, disattivare, abilitare, eliminare, annullare l'eliminazione e gestire l'accesso) agli account di servizio: Amministratore account di servizio (roles/iam.serviceAccountAdmin)

Per ulteriori informazioni sulla concessione dei ruoli, consulta Gestire l'accesso.

Per ulteriori informazioni su questi ruoli, consulta Ruoli degli account di servizio.

I ruoli IAM di base contengono anche le autorizzazioni per gestire gli account di servizio. Non devi concedere ruoli di base in un ambiente di produzione, ma puoi farlo in un ambiente di sviluppo o test.

Creazione di un account di servizio

Quando crei un account di servizio, devi fornire un ID alfanumerico (SA_NAME negli esempi qui sotto), come my-service-account. L'ID deve essere compreso tra 6 e 30 caratteri e può contenere caratteri alfanumerici minuscoli e trattini. Dopo aver creato un account di servizio, non puoi modificarne il nome.

L'account di servizio viene visualizzato nell'indirizzo email di cui è stato eseguito il provisioning durante la creazione, nel formato SA_NAME@PROJECT_ID.iam.gserviceaccount.com.

Ogni account di servizio ha anche un ID numerico univoco e permanente che viene generato automaticamente.

Quando crei un account di servizio, fornisci le seguenti informazioni:

  • SA_DESCRIPTION è una descrizione facoltativa per l'account di servizio.
  • SA_DISPLAY_NAME è un nome descrittivo per l'account di servizio.
  • PROJECT_ID è l'ID del tuo progetto Google Cloud.

Dopo aver creato un account di servizio, potrebbe essere necessario attendere almeno 60 secondi prima di utilizzarlo. Questo comportamento si verifica perché le operazioni di lettura sono coerenti; può essere necessario del tempo prima che il nuovo account di servizio diventi visibile. Se provi a leggere o utilizzare un account di servizio immediatamente dopo averlo creato e ricevi un errore, puoi ritentare la richiesta con backoff esponenziale.

console

  1. Nella console, vai alla pagina Crea account di servizio.

    Vai a Crea account di servizio

  2. Seleziona un progetto Cloud.

  3. Inserisci il nome di un account di servizio da visualizzare nella console.

    La console genera un ID account di servizio in base a questo nome. Se necessario, modifica l'ID. Non potrai modificare l'ID in un secondo momento.

  4. (Facoltativo) Inserisci una descrizione dell'account di servizio.

  5. Se non vuoi impostare i controlli di accesso, fai clic su Fine per completare la creazione dell'account di servizio.

    Per impostare ora i controlli di accesso, fai clic su Crea e continua e vai al passaggio successivo.

  6. Facoltativo: scegli uno o più ruoli IAM da concedere all'account di servizio presente nel progetto.

  7. Quando hai finito di aggiungere i ruoli, fai clic su Continua.

  8. (Facoltativo) Nel campo Ruolo utenti dell'account di servizio, aggiungi i membri che possono impersonare l'account di servizio.

  9. (Facoltativo) Nel campo Amministratore account di servizio, aggiungi i membri che possono gestire l'account di servizio.

  10. Fai clic su Fine per completare la creazione dell'account di servizio.

gcloud

  1. Per creare l'account di servizio, esegui il comando gcloud iam service-accounts create:

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

    Sostituisci i seguenti valori:

    • SERVICE_ACCOUNT_ID: ID dell'account di servizio
    • DESCRIPTION: una descrizione facoltativa dell'account di servizio
    • DISPLAY_NAME: un nome account di servizio da visualizzare nella console
  2. (Facoltativo) Per concedere al tuo account di servizio un ruolo IAM sul progetto, esegui il comando gcloud projects add-iam-policy-binding:

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

    Sostituisci i seguenti valori:

    • PROJECT_ID: l'ID progetto
    • SERVICE_ACCOUNT_ID: ID dell'account di servizio
    • ROLE_NAME: un nome di ruolo, ad esempio roles/compute.osLogin
  3. (Facoltativo) Per consentire agli utenti di imitare l'account di servizio, esegui il comando gcloud iam service-accounts add-iam-policy-binding per concedere a un utente il ruolo Utente account di servizio (roles/iam.serviceAccountUser) sull'account di servizio:

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

    Sostituisci i seguenti valori:

    • PROJECT_ID: l'ID progetto
    • SERVICE_ACCOUNT_ID: ID dell'account di servizio
    • USER_EMAIL: l'indirizzo email dell'utente

REST

Il serviceAccounts.create metodo crea un account di servizio.

Prima di utilizzare uno qualsiasi dei dati della richiesta, effettua le seguenti sostituzioni:

  • PROJECT_ID: ID progetto Google Cloud. Gli ID progetto sono stringhe alfanumeriche, come my-project.
  • SA_NAME: l'ID alfanumerico del tuo account di servizio. Questo nome deve essere compreso tra 6 e 30 caratteri e può contenere caratteri alfanumerici minuscoli e trattini.
  • SA_DESCRIPTION: facoltativo. Una descrizione dell'account di servizio.
  • SA_DISPLAY_NAME: un nome leggibile per l'account di servizio.

Metodo HTTP e URL:

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

Corpo JSON richiesta:

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

Per inviare la richiesta, espandi una delle seguenti opzioni:

Dovresti ricevere una risposta JSON simile alla seguente:

{
  "name": "projects/my-project/serviceAccounts/my-service-account@my-project.iam.gserviceaccount.com",
  "projectId": "my-project",
  "uniqueId": "123456789012345678901",
  "email": "my-service-account@my-project.iam.gserviceaccount.com",
  "displayName": "My service account",
  "etag": "BwUp3rVlzes=",
  "description": "A service account for running jobs in my project",
  "oauth2ClientId": "987654321098765432109"
}

C++

Per informazioni su come installare e utilizzare la libreria client per IAM, consulta le librerie client IAM. Per maggiori informazioni, consulta la documentazione di riferimento dell'API IAM C++.

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#

Per informazioni su come installare e utilizzare la libreria client per IAM, consulta le librerie client IAM. Per maggiori informazioni, consulta la documentazione di riferimento dell'API IAM C# .


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

Vai

Per informazioni su come installare e utilizzare la libreria client per IAM, consulta le librerie client IAM. Per maggiori informazioni, consulta la documentazione di riferimento dell'API IAM Go.

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

Per informazioni su come installare e utilizzare la libreria client per IAM, consulta le librerie client IAM. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Java IAM.

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

Per informazioni su come installare e utilizzare la libreria client per IAM, consulta le librerie client IAM. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Python IAM.

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

Dopo aver creato un account di servizio, concedi uno o più ruoli all'account di servizio in modo che possa agire per tuo conto.

Inoltre, se l'account di servizio deve accedere alle risorse in altri progetti, di solito devi abilitare le API per quelle risorse nel progetto in cui hai creato l'account di servizio.

Elenco degli account di servizio

Puoi elencare i tuoi account di servizio per controllare gli account e le chiavi di servizio o come parte di uno strumento personalizzato per la gestione degli account di servizio.

console

  1. Nella console, vai alla pagina Account di servizio.

    Vai agli account di servizio

  2. Seleziona un progetto.

    Nella pagina Account di servizio sono elencati tutti gli account di servizio gestiti dall'utente del progetto selezionato. La pagina non elenca gli account di servizio gestiti da Google.

gcloud

Esegui il comando gcloud iam service-accounts list per elencare tutti gli account di servizio in un progetto.

Comando:

gcloud iam service-accounts list

L'output è l'elenco di tutti gli account di servizio del progetto:

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

Il metodo serviceAccounts.list elenca ogni account di servizio nel progetto.

Prima di utilizzare uno qualsiasi dei dati della richiesta, effettua le seguenti sostituzioni:

  • PROJECT_ID: ID progetto Google Cloud. Gli ID progetto sono stringhe alfanumeriche, come my-project.

Metodo HTTP e URL:

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

Per inviare la richiesta, espandi una delle seguenti opzioni:

Dovresti ricevere una risposta JSON simile alla seguente:

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

C++

Per informazioni su come installare e utilizzare la libreria client per IAM, consulta le librerie client IAM. Per maggiori informazioni, consulta la documentazione di riferimento dell'API IAM C++.

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#

Per informazioni su come installare e utilizzare la libreria client per IAM, consulta le librerie client IAM. Per maggiori informazioni, consulta la documentazione di riferimento dell'API IAM C# .


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

Vai

Per informazioni su come installare e utilizzare la libreria client per IAM, consulta le librerie client IAM. Per maggiori informazioni, consulta la documentazione di riferimento dell'API IAM Go.

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

Per informazioni su come installare e utilizzare la libreria client per IAM, consulta le librerie client IAM. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Java IAM.

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

Per informazioni su come installare e utilizzare la libreria client per IAM, consulta le librerie client IAM. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Python IAM.

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

Aggiornamento di un account di servizio

Il nome visualizzato (nome semplice) e la descrizione di un account di servizio vengono generalmente utilizzati per acquisire informazioni aggiuntive sull'account di servizio, ad esempio lo scopo dell'account di servizio o una persona di contatto per l'account.

console

  1. Nella console, vai alla pagina Account di servizio.

    Vai agli account di servizio

  2. Seleziona un progetto.

  3. Fai clic sull'indirizzo email dell'account di servizio che vuoi rinominare.

  4. Inserisci il nuovo nome nella casella Nome, quindi fai clic su Salva.

gcloud

Esegui il comando gcloud iam service-accounts update per aggiornare un account di servizio.

Comando:

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

L'output è l'account di servizio rinominato:

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

REST

Il serviceAccounts.patch metodo aggiorna un account di servizio.

Prima di utilizzare uno qualsiasi dei dati della richiesta, effettua le seguenti sostituzioni:

  • PROJECT_ID: ID progetto Google Cloud. Gli ID progetto sono stringhe alfanumeriche, come my-project.
  • SA_ID: l'ID del tuo account di servizio. Può essere l'indirizzo email dell'account di servizio nel modulo SA_NAME@PROJECT_ID.iam.gserviceaccount.com oppure l'ID numerico univoco dell'account di servizio.
  • SA_NAME: l'ID alfanumerico del tuo account di servizio. Questo nome deve essere compreso tra 6 e 30 caratteri e può contenere caratteri alfanumerici minuscoli e trattini.
  • Sostituisci almeno uno dei seguenti elementi:
    • UPDATED_DISPLAY_NAME: un nuovo nome visualizzato per l'account di servizio.
    • UPDATED_DESCRIPTION: una nuova descrizione per il tuo account di servizio.

Metodo HTTP e URL:

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

Corpo JSON richiesta:

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

Per inviare la richiesta, espandi una delle seguenti opzioni:

Dovresti ricevere una risposta JSON simile alla seguente:

{
  "name": "projects/my-project/serviceAccounts/my-service-account@my-project.iam.gserviceaccount.com",
  "displayName": "My updated service account",
  "description": "An updated description of my service account"
}

C++

Per informazioni su come installare e utilizzare la libreria client per IAM, consulta le librerie client IAM. Per maggiori informazioni, consulta la documentazione di riferimento dell'API IAM C++.

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#

Per informazioni su come installare e utilizzare la libreria client per IAM, consulta le librerie client IAM. Per maggiori informazioni, consulta la documentazione di riferimento dell'API IAM C# .


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

Vai

Per informazioni su come installare e utilizzare la libreria client per IAM, consulta le librerie client IAM. Per maggiori informazioni, consulta la documentazione di riferimento dell'API IAM Go.

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

Per informazioni su come installare e utilizzare la libreria client per IAM, consulta le librerie client IAM. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Java IAM.

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

Per informazioni su come installare e utilizzare la libreria client per IAM, consulta le librerie client IAM. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Python IAM.

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

Disattivazione di un account di servizio

Come quando elimini un account di servizio, quando disabiliti un account di servizio, le applicazioni non avranno più accesso alle risorse Google Cloud tramite tale account di servizio. Se disabiliti gli account di servizio predefiniti di App Engine e Compute Engine, le istanze non avranno più accesso alle risorse nel progetto. L'eliminazione di un account di servizio già disattivato non avrà alcun effetto.

A differenza dell'eliminazione di un account di servizio, gli account di servizio disattivati possono essere facilmente riattivati secondo necessità. Ti consigliamo di disabilitare un account di servizio prima di eliminarlo per assicurarti che nessuna applicazione critica stia utilizzando l'account di servizio.

console

  1. Nella console, vai alla pagina Account di servizio.

    Vai agli account di servizio

  2. Seleziona un progetto.

  3. Fai clic sul nome dell'account di servizio che vuoi disattivare.

  4. In Stato account di servizio, fai clic su Disattiva account di servizio, quindi su Disattiva per confermare la modifica.

gcloud

Esegui il comando gcloud iam service-accounts disable per disabilitare un account di servizio.

Comando:

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

Output:

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

REST

Il metodo serviceAccounts.disable disattiva immediatamente un account di servizio.

Prima di utilizzare uno qualsiasi dei dati della richiesta, effettua le seguenti sostituzioni:

  • PROJECT_ID: ID progetto Google Cloud. Gli ID progetto sono stringhe alfanumeriche, come my-project.
  • SA_ID: l'ID del tuo account di servizio. Può essere l'indirizzo email dell'account di servizio nel modulo SA_NAME@PROJECT_ID.iam.gserviceaccount.com oppure l'ID numerico univoco dell'account di servizio.

Metodo HTTP e URL:

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

Per inviare la richiesta, espandi una delle seguenti opzioni:

In caso di esito positivo, il corpo della risposta sarà vuoto.

C++

Per informazioni su come installare e utilizzare la libreria client per IAM, consulta le librerie client IAM. Per maggiori informazioni, consulta la documentazione di riferimento dell'API IAM C++.

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#

Per informazioni su come installare e utilizzare la libreria client per IAM, consulta le librerie client IAM. Per maggiori informazioni, consulta la documentazione di riferimento dell'API IAM C# .


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

Vai

Per informazioni su come installare e utilizzare la libreria client per IAM, consulta le librerie client IAM. Per maggiori informazioni, consulta la documentazione di riferimento dell'API IAM Go.

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:= service-account@your-project.iam.gserviceaccount.com
	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

Per informazioni su come installare e utilizzare la libreria client per IAM, consulta le librerie client IAM. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Java IAM.

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

Per informazioni su come installare e utilizzare la libreria client per IAM, consulta le librerie client IAM. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Python IAM.

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)

Abilitazione di un account di servizio

Dopo aver abilitato un account di servizio disattivato, le applicazioni recupereranno l'accesso alle risorse Google Cloud tramite tale account di servizio.

Puoi abilitare un account di servizio disattivato quando necessario. L'attivazione di un account di servizio già abilitato non avrà alcun effetto.

console

  1. Nella console, vai alla pagina Account di servizio.

    Vai agli account di servizio

  2. Seleziona un progetto.

  3. Fai clic sul nome dell'account di servizio che vuoi attivare.

  4. In Stato account di servizio, fai clic su Abilita account di servizio, quindi fai clic su Abilita per confermare la modifica.

gcloud

Esegui il comando gcloud iam service-accounts enable per abilitare un account di servizio.

Comando:

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

Output:

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

REST

Il serviceAccounts.enable metodo consente di abilitare un account di servizio precedentemente disattivato.

Prima di utilizzare uno qualsiasi dei dati della richiesta, effettua le seguenti sostituzioni:

  • PROJECT_ID: ID progetto Google Cloud. Gli ID progetto sono stringhe alfanumeriche, come my-project.
  • SA_ID: l'ID del tuo account di servizio. Può essere l'indirizzo email dell'account di servizio nel modulo SA_NAME@PROJECT_ID.iam.gserviceaccount.com oppure l'ID numerico univoco dell'account di servizio.

Metodo HTTP e URL:

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

Per inviare la richiesta, espandi una delle seguenti opzioni:

In caso di esito positivo, il corpo della risposta sarà vuoto.

C++

Per informazioni su come installare e utilizzare la libreria client per IAM, consulta le librerie client IAM. Per maggiori informazioni, consulta la documentazione di riferimento dell'API IAM C++.

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#

Per informazioni su come installare e utilizzare la libreria client per IAM, consulta le librerie client IAM. Per maggiori informazioni, consulta la documentazione di riferimento dell'API IAM C# .


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

Vai

Per informazioni su come installare e utilizzare la libreria client per IAM, consulta le librerie client IAM. Per maggiori informazioni, consulta la documentazione di riferimento dell'API IAM Go.

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:= service-account@your-project.iam.gserviceaccount.com
	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

Per informazioni su come installare e utilizzare la libreria client per IAM, consulta le librerie client IAM. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Java IAM.

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

Per informazioni su come installare e utilizzare la libreria client per IAM, consulta le librerie client IAM. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Python IAM.

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)

Eliminazione di un account di servizio

Quando elimini un account di servizio, le applicazioni non avranno più accesso alle risorse Google Cloud tramite tale account di servizio. Se elimini gli account di servizio predefiniti di App Engine e Compute Engine, le istanze non avranno più accesso alle risorse nel progetto.

Elimina con cautela: assicurati che le applicazioni critiche non utilizzino più un account di servizio prima di eliminarlo. Se non sai con certezza se viene utilizzato un account di servizio, ti consigliamo di disattivarlo prima di eliminarlo. Gli account di servizio disattivati possono essere facilmente riattivati se sono ancora in uso.

Se elimini un account di servizio e poi crei un nuovo account di servizio con lo stesso nome, il nuovo account di servizio viene considerato come un'identità separata; non eredita i ruoli concessi all'account di servizio eliminato. Al contrario, quando elimini un account di servizio e poi lo annulli, l'identità dell'account di servizio non cambia e l'account di servizio mantiene i suoi ruoli.

Quando un account di servizio viene eliminato, le associazioni di ruoli non vengono rimosse immediatamente; vengono eliminate automaticamente dal sistema dopo un massimo di 60 giorni. Fino a quel momento, l'account di servizio viene visualizzato nelle associazioni di ruoli con un prefisso deleted: e un suffisso ?uid=NUMERIC_ID, dove NUMERIC_ID è un ID numerico univoco per l'account di servizio.

Gli account di servizio eliminati non incidono sulla tua quota di account di servizio.

console

  1. Nella console, vai alla pagina Account di servizio.

    Vai agli account di servizio

  2. Seleziona un progetto.

  3. Seleziona l'account di servizio che vuoi eliminare, quindi fai clic su Elimina .

gcloud

Esegui il comando gcloud iam service-accounts delete per eliminare un account di servizio.

Comando:

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

Output:

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

REST

Il metodo serviceAccounts.delete elimina un account di servizio.

Prima di utilizzare uno qualsiasi dei dati della richiesta, effettua le seguenti sostituzioni:

  • PROJECT_ID: ID progetto Google Cloud. Gli ID progetto sono stringhe alfanumeriche, come my-project.
  • SA_ID: l'ID del tuo account di servizio. Può essere l'indirizzo email dell'account di servizio nel modulo SA_NAME@PROJECT_ID.iam.gserviceaccount.com oppure l'ID numerico univoco dell'account di servizio.

Metodo HTTP e URL:

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

Per inviare la richiesta, espandi una delle seguenti opzioni:

In caso di esito positivo, il corpo della risposta sarà vuoto.

C++

Per informazioni su come installare e utilizzare la libreria client per IAM, consulta le librerie client IAM. Per maggiori informazioni, consulta la documentazione di riferimento dell'API IAM C++.

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#

Per informazioni su come installare e utilizzare la libreria client per IAM, consulta le librerie client IAM. Per maggiori informazioni, consulta la documentazione di riferimento dell'API IAM C# .


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

Vai

Per informazioni su come installare e utilizzare la libreria client per IAM, consulta le librerie client IAM. Per maggiori informazioni, consulta la documentazione di riferimento dell'API IAM Go.

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

Per informazioni su come installare e utilizzare la libreria client per IAM, consulta le librerie client IAM. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Java IAM.

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

Per informazioni su come installare e utilizzare la libreria client per IAM, consulta le librerie client IAM. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Python IAM.

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)

Annullamento dell'eliminazione di un account di servizio

In alcuni casi, puoi utilizzare il comando undelete per annullare l'eliminazione di un account di servizio eliminato. In genere, puoi annullare l'eliminazione di un account di servizio eliminato se soddisfa i seguenti criteri:

  • L'account di servizio è stato eliminato meno di 30 giorni fa.

    Dopo 30 giorni, IAM rimuove definitivamente l'account di servizio. Google Cloud non può recuperare l'account di servizio dopo averlo rimosso definitivamente, anche se hai presentato una richiesta di assistenza.

  • Non esiste alcun account di servizio con lo stesso nome dell'account di servizio eliminato.

    Supponi, ad esempio, di eliminare accidentalmente l'account di servizio my-service-account@project-id.iam.gserviceaccount.com. È comunque necessario un account di servizio con lo stesso nome, quindi crei un nuovo account di servizio con lo stesso nome, my-service-account@project-id.iam.gserviceaccount.com.

    Il nuovo account di servizio non eredita le autorizzazioni dell'account di servizio eliminato. Di fatto, è completamente separato dall'account di servizio eliminato. Tuttavia, non puoi annullare l'eliminazione dell'account di servizio originale, perché il nuovo account di servizio ha lo stesso nome.

    Per risolvere questo problema, elimina il nuovo account di servizio, quindi prova ad annullare l'eliminazione dell'account di servizio originale.

Se non puoi annullare l'eliminazione dell'account di servizio, puoi crearne uno nuovo con lo stesso nome; revocare tutti i ruoli dall'account di servizio eliminato e concedere gli stessi ruoli al nuovo account di servizio. Per i dettagli, consulta i Criteri con le entità eliminate.

Trovare un ID numerico dell'account di servizio eliminato

Quando annulli l'eliminazione di un account di servizio, devi specificarne l'ID numerico. L'ID numerico è un numero di 21 cifre, ad esempio 123456789012345678901, che identifica in modo univoco l'account di servizio. Ad esempio, se elimini un account di servizio e poi crei un nuovo account di servizio con lo stesso nome, sia l'account di servizio originale che quello nuovo avranno ID numerici diversi.

Se sai che un'associazione in un criterio di autorizzazione include l'account di servizio eliminato, puoi recuperare il criterio di autorizzazione e poi trovare l'ID numerico nel criterio di autorizzazione. L'ID numerico viene aggiunto al nome dell'account di servizio eliminato. Ad esempio, in questo criterio di autorizzazione, l'ID numerico per l'account di servizio eliminato è 123456789012345678901:

{
  "version": 1,
  "etag": "BwUjMhCsNvY=",
  "bindings": [
    {
      "members": [
        "deleted:serviceAccount:my-service-account@project-id.iam.gserviceaccount.com?uid=123456789012345678901"
      ],
      "role": "roles/iam.serviceAccountUser"
    },
  ]
}

Gli ID numerici vengono aggiunti solo ai nomi delle entità eliminate.

In alternativa, puoi cercare nei tuoi log di controllo l'operazione DeleteServiceAccount che ha eliminato l'account di servizio:

  1. Nella console, vai alla pagina Esplora log.

    Vai a Esplora log

  2. Nell'editor delle query, inserisci la query seguente, sostituendo SERVICE_ACCOUNT_EMAIL con l'indirizzo email del tuo account di servizio (ad esempio, my-service-account@project-id.iam.gserviceaccount.com):

    resource.type="service_account"
    resource.labels.email_id="SERVICE_ACCOUNT_EMAIL"
    "DeleteServiceAccount"
    
  3. Se l'account di servizio è stato eliminato più di un'ora fa, fai clic su schedule Ultima ora, seleziona un periodo di tempo più lungo dall'elenco a discesa, quindi fai clic su Applica.

  4. Fai clic su Esegui query. Esplora log mostra le operazioni DeleteServiceAccount che hanno interessato gli account di servizio con il nome specificato.

  5. Trova e prendi nota dell'ID numerico dell'account di servizio eliminato procedendo in uno dei seguenti modi:

    • Se i risultati di ricerca includono solo un'operazione DeleteServiceAccount, trova l'ID numerico nel campo ID univoco del riquadro Campi log.

    • Se nei risultati di ricerca vengono visualizzati più log, procedi nel seguente modo:

      1. Trova la voce di log corretta. Per trovare la voce di log corretta, fai clic sulla freccia di espansione accanto a una voce di log. Esamina i dettagli della voce di log e determina se la voce mostra l'operazione che vuoi annullare. Ripeti la procedura finché non trovi la voce di log corretta.

      2. Nella voce di log corretta, individua l'ID numerico dell'account di servizio. Per individuare l'ID numerico, espandi la voce del log protoPayload e poi trova il campo resourceName.

        L'ID numerico è tutto quello che segue serviceAccounts nel campo resourceName.

Annullamento dell'eliminazione dell'account di servizio in base all'ID numerico

Dopo aver trovato l'ID numerico per l'account di servizio eliminato, puoi provare ad annullare l'eliminazione.

gcloud

Esegui il comando gcloud beta iam service-accounts undelete per annullare l'eliminazione di un account di servizio.

Comando:

gcloud beta iam service-accounts undelete ACCOUNT_ID

Output:

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

Il serviceAccounts.undelete ripristino di un account di servizio eliminato.

Prima di utilizzare uno qualsiasi dei dati della richiesta, effettua le seguenti sostituzioni:

  • PROJECT_ID: ID progetto Google Cloud. Gli ID progetto sono stringhe alfanumeriche, come my-project.
  • SA_NUMERIC_ID: ID numerico univoco dell'account di servizio.

Metodo HTTP e URL:

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

Per inviare la richiesta, espandi una delle seguenti opzioni:

Se è possibile annullare l'eliminazione dell'account, riceverai un codice di risposta 200 OK con i dettagli sull'account di servizio ripristinato, come indicato di seguito:

{
  "restoredAccount": {
    "name": "projects/my-project/serviceAccounts/my-service-account@my-project.iam.gserviceaccount.com",
    "projectId": "my-project",
    "uniqueId": "123456789012345678901",
    "email": "my-service-account@my-project.iam.gserviceaccount.com",
    "displayName": "My service account",
    "etag": "BwUp3rVlzes=",
    "description": "A service account for running jobs in my project",
    "oauth2ClientId": "987654321098765432109"
  }
}

Passaggi successivi

Provalo

Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $ di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

Inizia gratuitamente