Creazione di account di servizio

Questa pagina spiega come creare account di servizio utilizzando l'API Identity and Access Management (IAM), la console Google Cloud 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 creare gli account di servizio, chiedi al tuo amministratore di concederti il ruolo IAM Crea account di servizio (roles/iam.serviceAccountCreator) nel progetto. Per maggiori informazioni sulla concessione dei ruoli, vedi Gestire l'accesso.

Potresti anche ottenere le autorizzazioni richieste tramite ruoli personalizzati o altri ruoli predefiniti.

Se vuoi concedere agli account di servizio appena creati l'accesso al progetto, devi disporre anche del ruolo di amministratore IAM del progetto (roles/resourcemanager.projectIamAdmin).

Crea un account di servizio

Quando crei un account di servizio, devi fornire un ID alfanumerico (SA_NAME negli esempi riportati di seguito), 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.

Il nome dell'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.

Inoltre, quando crei un account di servizio fornisci le seguenti informazioni:

  • SA_DESCRIPTION è una descrizione facoltativa dell'account di servizio.
  • SA_DISPLAY_NAME è un nome semplice 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 utilizzare l'account di servizio. Questo comportamento si verifica perché le operazioni di lettura sono coerenti; può trascorrere del tempo prima che il nuovo account di servizio diventi visibile. Se provi a leggere o utilizzare un account di servizio subito dopo averlo creato e ricevi un errore, puoi ritentare la richiesta con backoff esponenziale.

Console

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

    Vai a Crea account di servizio

    I passaggi rimanenti verranno visualizzati automaticamente nella console Google Cloud.

  2. Seleziona un progetto Google Cloud.
  3. Inserisci il nome di un account di servizio da visualizzare nella console Google Cloud.

    La console Google Cloud genera un ID account di servizio in base a questo nome. Modifica l'ID, se necessario. 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 dell'accesso, fai clic su Fine per completare la creazione dell'account di servizio. Per impostare i controlli dell'accesso ora, 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 nel progetto.
  7. Quando hai finito di aggiungere i ruoli, fai clic su Continua.
  8. (Facoltativo) Nel campo Ruolo degli utenti dell'account di servizio, aggiungi i membri che possono simulare l'identità dell'account di servizio.
  9. (Facoltativo) Nel campo Ruolo degli amministratori dell'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. In Google Cloud Console, attiva Cloud Shell.

    Attiva Cloud Shell

    Nella parte inferiore di Google Cloud Console, viene avviata una sessione di Cloud Shell e viene visualizzato un prompt della riga di comando. Cloud Shell è un ambiente shell con Google Cloud CLI già installato e con valori già impostati per il progetto corrente. L'inizializzazione della sessione può richiedere alcuni secondi.

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

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

    Sostituisci i seguenti valori:

    • SA_NAME: il nome dell'account di servizio.

    • DESCRIPTION: una descrizione facoltativa dell'account di servizio

    • DISPLAY_NAME: il nome di un account di servizio da visualizzare nella console Google Cloud

  3. (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:SA_NAME@PROJECT_ID.iam.gserviceaccount.com" \
    --role="ROLE_NAME"

    Sostituisci i seguenti valori:

    • PROJECT_ID: l'ID progetto

    • SA_NAME: il nome dell'account di servizio.

    • ROLE_NAME: un nome di ruolo, ad esempio roles/compute.osLogin

  4. Facoltativo: per consentire agli utenti di rubare l'identità all'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) nell'account di servizio:

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

    Sostituisci i seguenti valori:

    • PROJECT_ID: l'ID progetto

    • SA_NAME: il nome dell'account di servizio.

    • USER_EMAIL: l'indirizzo email dell'utente

REST

Il metodo serviceAccounts.create crea un account di servizio.

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

  • PROJECT_ID: l'ID del tuo progetto Google Cloud. Gli ID progetto sono stringhe alfanumeriche, ad esempio 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 e trattini minuscoli.
  • SA_DESCRIPTION: facoltativo. Una descrizione per l'account di servizio.
  • SA_DISPLAY_NAME: un nome leggibile per l'account di servizio.

Metodo e URL HTTP: 

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 scoprire come installare e utilizzare la libreria client per IAM, consulta Librerie client IAM. Per scoprire di più, consulta la documentazione di riferimento dell'API IAM C++.

Per eseguire l'autenticazione su IAM, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

namespace iam = ::google::cloud::iam_admin_v1;
[](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::move(response).status();
  std::cout << "ServiceAccount successfully created: "
            << response->DebugString() << "\n";
}

C#

Per scoprire come installare e utilizzare la libreria client per IAM, consulta Librerie client IAM. Per scoprire di più, consulta la documentazione di riferimento dell'API IAM C#.

Per eseguire l'autenticazione su IAM, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 


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

Per scoprire come installare e utilizzare la libreria client per IAM, consulta Librerie client IAM. Per scoprire di più, consulta la documentazione di riferimento dell'API IAM Go.

Per eseguire l'autenticazione su IAM, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

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: %w", 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: %w", err)
	}
	fmt.Fprintf(w, "Created service account: %v", account)
	return account, nil
}

Java

Per scoprire come installare e utilizzare la libreria client per IAM, consulta Librerie client IAM. Per scoprire di più, consulta la documentazione di riferimento dell'API IAM Java.

Per eseguire l'autenticazione su IAM, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.json.gson.GsonFactory;
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(),
                GsonFactory.getDefaultInstance(),
                new HttpCredentialsAdapter(credential))
            .setApplicationName("service-accounts")
            .build();
    return service;
  }
}

Python

Per scoprire come installare e utilizzare la libreria client per IAM, consulta Librerie client IAM. Per scoprire di più, consulta la documentazione di riferimento dell'API IAM Python.

Per eseguire l'autenticazione su IAM, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

import os

from google.oauth2 import service_account  # type: ignore
import googleapiclient.discovery  # type: ignore

def create_service_account(project_id: str, name: str, display_name: str) -> dict:
    """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, in genere devi abilitare le API per quelle risorse nel progetto in cui hai creato l'account di servizio.

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