Introduzione all'autenticazione

Questo argomento mostra come eseguire rapidamente l'autenticazione in un'API Google Cloud a scopo di test. Non mostra l'autenticazione per le API non Google Cloud, come le API Google Maps Platform. Per informazioni sulle chiavi API per le API e gli SDK di Google Maps Platform, consulta la documentazione di Google Maps.

Prima di procedere, consigliamo a tutti gli sviluppatori di Google Cloud di leggere l'argomento Panoramica sull'autenticazione per comprendere come funziona l'autenticazione in Google Cloud, inclusi gli scenari e le strategie più comuni. Inoltre, prima di eseguire il deployment di un'applicazione in un ambiente di produzione, assicurati di consultare la pagina Autenticazione come account di servizio.

Creazione di un account di servizio

Console

Crea un account di servizio:

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

    Vai a Crea account di servizio
  2. Seleziona il progetto.

  3. Inserisci un nome nel campo Nome account di servizio. La console compila il campo ID account di servizio in base a questo nome.

    Nel campo Descrizione account di servizio, inserisci una descrizione. Ad esempio, Service account for quickstart.

  4. Fai clic su Crea e continua.

  5. Per fornire l'accesso al tuo progetto, concedi i seguenti ruoli al tuo account di servizio: Progetto > proprietario.

    Nell'elenco Seleziona un ruolo, scegli un ruolo.

    Per ulteriori ruoli, fai clic su Aggiungi un altro ruolo e aggiungi ogni ruolo aggiuntivo.

  6. Fai clic su Continua.

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

    Non chiudere la finestra del browser. La utilizzerai nel passaggio successivo.

Crea una chiave dell'account di servizio:

  1. Nella console, fai clic sull'indirizzo email dell'account di servizio che hai creato.
  2. Fai clic su Chiavi.
  3. Fai clic su Aggiungi chiave, quindi su Crea nuova chiave.
  4. Fai clic su Crea. Il file di una chiave JSON viene scaricato sul computer.
  5. Fai clic su Chiudi.

gcloud

Configurare l'autenticazione:

  1. Crea l'account di servizio: 

    gcloud iam service-accounts create NAME

    Sostituisci NAME con un nome per l'account di servizio.

  2. Concedi ruoli all'account di servizio. Esegui il comando seguente una volta per ciascuno dei seguenti ruoli IAM: roles/owner: 

    gcloud projects add-iam-policy-binding PROJECT_ID --member="serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com" --role=ROLE

    Sostituisci quanto segue:

    • SERVICE_ACCOUNT_NAME: nome dell'account di servizio
    • PROJECT_ID: l'ID progetto in cui hai creato l'account di servizio
    • ROLE: il ruolo da concedere

  3. Genera il file della chiave: 

    gcloud iam service-accounts keys create FILE_NAME.json --iam-account=SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com

    Sostituisci quanto segue:

    • FILE_NAME: un nome per il file della chiave
    • SERVICE_ACCOUNT_NAME: nome dell'account di servizio
    • PROJECT_ID: l'ID progetto in cui hai creato l'account di servizio

Impostazione della variabile di ambiente

Per utilizzare gli account di servizio con l'interfaccia a riga di comando di Google Cloud, è necessario impostare una variabile di ambiente in cui viene eseguito il codice.

Fornisci le credenziali di autenticazione al codice della tua applicazione impostando la variabile di ambiente GOOGLE_APPLICATION_CREDENTIALS. Questa variabile si applica solo alla sessione shell corrente. Se vuoi che la variabile venga applicata alle sessioni shell future, impostala nel file di avvio della shell, ad esempio nel file ~/.bashrc o ~/.profile.

Linux o macOS

export GOOGLE_APPLICATION_CREDENTIALS="KEY_PATH"

Sostituisci KEY_PATH con il percorso del file JSON che contiene la chiave dell'account di servizio.

Ad esempio:

export GOOGLE_APPLICATION_CREDENTIALS="/home/user/Downloads/service-account-file.json"

Windows

Per PowerShell:

$env:GOOGLE_APPLICATION_CREDENTIALS="KEY_PATH"

Sostituisci KEY_PATH con il percorso del file JSON che contiene la chiave dell'account di servizio.

Ad esempio:

$env:GOOGLE_APPLICATION_CREDENTIALS="C:\Users\username\Downloads\service-account-file.json"

Per il prompt dei comandi:

set GOOGLE_APPLICATION_CREDENTIALS=KEY_PATH

Sostituisci KEY_PATH con il percorso del file JSON che contiene la chiave dell'account di servizio.

L'impostazione della variabile di ambiente ti consente di fornire credenziali separatamente dall'applicazione, senza apportare modifiche al codice dell'applicazione durante il deployment. In alternativa, puoi specificare esplicitamente il percorso al file della chiave dell'account di servizio nel codice. Per ulteriori informazioni, consulta la pagina Autenticazione come account di servizio.

Verifica dell'autenticazione

Una volta impostata la variabile di ambiente, non devi specificare esplicitamente le credenziali nel codice quando utilizzi una libreria client di Google Cloud. La libreria client può determinare implicitamente le tue credenziali. Per questo motivo, puoi verificare che l'autenticazione funzioni impostando la variabile di ambiente e quindi eseguendo il codice della libreria client, ad esempio l'esempio seguente. Se la richiesta ha esito positivo, l'autenticazione funziona.

C#

public object AuthImplicit(string projectId)
{
    // If you don't specify credentials when constructing the client, the
    // client library will look for credentials in the environment.
    var credential = GoogleCredential.GetApplicationDefault();
    var storage = StorageClient.Create(credential);
    // Make an authenticated API request.
    var buckets = storage.ListBuckets(projectId);
    foreach (var bucket in buckets)
    {
        Console.WriteLine(bucket.Name);
    }
    return null;
}

Go


// implicit uses Application Default Credentials to authenticate.
func implicit() {
	ctx := context.Background()

	// For API packages whose import path is starting with "cloud.google.com/go",
	// such as cloud.google.com/go/storage in this case, if there are no credentials
	// provided, the client library will look for credentials in the environment.
	storageClient, err := storage.NewClient(ctx)
	if err != nil {
		log.Fatal(err)
	}
	defer storageClient.Close()

	it := storageClient.Buckets(ctx, "project-id")
	for {
		bucketAttrs, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			log.Fatal(err)
		}
		fmt.Println(bucketAttrs.Name)
	}

	// For packages whose import path is starting with "google.golang.org/api",
	// such as google.golang.org/api/cloudkms/v1, use NewService to create the client.
	kmsService, err := cloudkms.NewService(ctx)
	if err != nil {
		log.Fatal(err)
	}

	_ = kmsService
}

Java

static void authImplicit() {
  // If you don't specify credentials when constructing the client, the client library will
  // look for credentials via the environment variable GOOGLE_APPLICATION_CREDENTIALS.
  Storage storage = StorageOptions.getDefaultInstance().getService();

  System.out.println("Buckets:");
  Page<Bucket> buckets = storage.list();
  for (Bucket bucket : buckets.iterateAll()) {
    System.out.println(bucket.toString());
  }
}

Node.js

// Imports the Google Cloud client library.
const {Storage} = require('@google-cloud/storage');

// Instantiates a client. If you don't specify credentials when constructing
// the client, the client library will look for credentials in the
// environment.
const storage = new Storage();
// Makes an authenticated API request.
async function listBuckets() {
  try {
    const results = await storage.getBuckets();

    const [buckets] = results;

    console.log('Buckets:');
    buckets.forEach(bucket => {
      console.log(bucket.name);
    });
  } catch (err) {
    console.error('ERROR:', err);
  }
}
listBuckets();

PHP

// Imports the Cloud Storage client library.
use Google\Cloud\Storage\StorageClient;

/**
 * Authenticate to a cloud client library using a service account implicitly.
 *
 * @param string $projectId The Google project ID.
 */
function auth_cloud_implicit($projectId)
{
    $config = [
        'projectId' => $projectId,
    ];

    # If you don't specify credentials when constructing the client, the
    # client library will look for credentials in the environment.
    $storage = new StorageClient($config);

    # Make an authenticated API request (listing storage buckets)
    foreach ($storage->buckets() as $bucket) {
        printf('Bucket: %s' . PHP_EOL, $bucket->name());
    }
}

Python

def implicit():
    from google.cloud import storage

    # If you don't specify credentials when constructing the client, the
    # client library will look for credentials in the environment.
    storage_client = storage.Client()

    # Make an authenticated API request
    buckets = list(storage_client.list_buckets())
    print(buckets)

Ruby

# project_id = "Your Google Cloud project ID"

require "google/cloud/storage"

# If you don't specify credentials when constructing the client, the client
# library will look for credentials in the environment.
storage = Google::Cloud::Storage.new project: project_id

# Make an authenticated API request
storage.buckets.each do |bucket|
  puts bucket.name
end

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