Autenticação como uma conta de serviço

Este tópico explica como autenticar um aplicativo como uma conta de serviço. Para informações gerais sobre autenticação nas APIs do Google Cloud, inclusive cenários e estratégias de autenticação comuns, consulte Visão geral da autenticação. Para mais informações sobre contas de serviço, consulte Contas de serviço na documentação do gerenciamento de identidade e acesso.

Como encontrar credenciais automaticamente

Se seu aplicativo for executado em um ambiente do Google Cloud que tenha uma conta de serviço padrão, ele poderá recuperar as credenciais da conta de serviço para chamar as APIs do Google Cloud. Esses ambientes incluem Compute Engine, Google Kubernetes Engine, App Engine, Cloud Run e Cloud Functions. Recomendamos usar essa estratégia porque ela é mais conveniente e segura do que transmitir as credenciais manualmente.

Além disso, recomendamos que você use as bibliotecas de cliente do Google Cloud para seu aplicativo. As bibliotecas de cliente do Google Cloud usam uma biblioteca chamada Application Default Credentials (ADC) para encontrar as credenciais da sua conta de serviço automaticamente. O ADC procura credenciais de conta de serviço na seguinte ordem:

Se a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS estiver definida, o ADC usará o arquivo da conta de serviço para que a variável aponta.
Se a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS não estiver configurada, o ADC usará a conta de serviço padrão fornecida pelo Compute Engine, Google Kubernetes Engine, App Engine, Cloud Run e Cloud Functions.
Caso o ADC não use nenhuma das credenciais acima, um erro é gerado.

O exemplo de código a seguir ilustra como usar a biblioteca ADC no código do aplicativo:

C#

Veja no GitHub

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

Veja no GitHub


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

	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

Veja no GitHub

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

Veja no GitHub

// 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

Veja no GitHub

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

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

Veja no GitHub

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

Veja no GitHub

# 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

Como transmitir credenciais manualmente

Se o aplicativo for executado fora dos ambientes do Google Cloud que fornecem uma conta de serviço padrão, você precisará criar uma manualmente. Em seguida, crie uma ou mais chaves de conta de serviço, que são credenciais associadas à conta de serviço. As chaves de conta de serviço podem ser transmitidas manualmente para seu aplicativo.

Como criar uma conta de serviço

As etapas a seguir descrevem como criar uma conta de serviço se você não tiver uma:

Console do Cloud

No Console do Cloud, acesse a página Criar chave da conta de serviço.
Acessar página "Criar chave da conta de serviço"
Na lista Conta de serviço, selecione Nova conta de serviço.
No campo Nome da conta de serviço, insira um nome.
Na lista Papel, selecione Projeto > Proprietário.

Observação: o campo Papel autoriza sua conta de serviço a acessar recursos. É possível visualizar e alterar esse campo mais tarde usando o Console do Cloud. Se você estiver desenvolvendo um aplicativo de produção, especifique permissões mais granulares do que Projeto > Proprietário. Para mais informações, consulte Como atribuir papéis a contas de serviço.
Clique em Criar. O download de um arquivo JSON que contém a chave é feito no computador.

Linha de comando

É possível executar os seguintes comandos usando o SDK do Cloud na máquina local ou no Cloud Shell.

Crie a conta de serviço. Substitua [NAME] por um nome para a conta de serviço.
```
gcloud iam service-accounts create [NAME]
```
Conceda permissões à conta de serviço. Substitua [PROJECT_ID] pelo código do seu projeto.
```
gcloud projects add-iam-policy-binding [PROJECT_ID] --member "serviceAccount:[NAME]@[PROJECT_ID].iam.gserviceaccount.com" --role "roles/owner"
```
Observação: o campo Papel autoriza a conta de serviço a acessar recursos. Se quiser visualizar e alterar esse campo mais tarde, use o Console do Cloud. Se você estiver desenvolvendo um aplicativo de produção, especifique permissões mais granulares do que Projeto > Proprietário. Para mais informações, consulte Como atribuir papéis a contas de serviço.

Gere o arquivo de chave. Substitua [FILE_NAME] pelo nome do arquivo de chave.

gcloud iam service-accounts keys create [FILE_NAME].json --iam-account [NAME]@[PROJECT_ID].iam.gserviceaccount.com

Como transmitir credenciais por meio da variável de ambiente

Forneça credenciais de autenticação ao código do aplicativo definindo a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS. Substitua [PATH] pelo caminho do arquivo JSON que contém sua chave da conta de serviço. Essa variável só se aplica à sessão de shell atual. Assim, se você abrir uma nova sessão, precisará definir a variável novamente.

Linux ou macOS

export GOOGLE_APPLICATION_CREDENTIALS="[PATH]"

Exemplo:

export GOOGLE_APPLICATION_CREDENTIALS="/home/user/Downloads/my-key.json"

Windows

Com o PowerShell:

$env:GOOGLE_APPLICATION_CREDENTIALS="[PATH]"

Exemplo:

$env:GOOGLE_APPLICATION_CREDENTIALS="C:\Users\username\Downloads\my-key.json"

Com prompt de comando:

set GOOGLE_APPLICATION_CREDENTIALS=[PATH]

Depois de concluir as etapas acima, o ADC encontrará suas credenciais automaticamente, conforme descrito na seção acima. O uso do ADC é recomendável porque requer menos códigos, que podem ser usados em ambientes diferentes.

Como transmitir credenciais usando códigos

Como alternativa, você pode optar por apontar explicitamente para o arquivo da sua conta de serviço no código, conforme mostrado no exemplo a seguir. É necessário instalar a biblioteca de cliente do Cloud Storage para executar o exemplo a seguir.

C#

Veja no GitHub

        // Some APIs, like Storage, accept a credential in their Create()
        // method.
        public object AuthExplicit(string projectId, string jsonPath)
        {
            // Explicitly use service account credentials by specifying
            // the private key file.
            var credential = GoogleCredential.FromFile(jsonPath);
            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;
        }
        // Other APIs, like Language, accept a channel in their Create()
        // method.
        public object AuthExplicit(string projectId, string jsonPath)
        {
            LanguageServiceClientBuilder builder = new LanguageServiceClientBuilder
            {
                CredentialsPath = jsonPath
            };

            LanguageServiceClient client = builder.Build();
            AnalyzeSentiment(client);
            return 0;
        }

Go

Veja no GitHub


// explicit reads credentials from the specified path.
func explicit(jsonPath, projectID string) {
	ctx := context.Background()
	client, err := storage.NewClient(ctx, option.WithCredentialsFile(jsonPath))
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Buckets:")
	it := client.Buckets(ctx, projectID)
	for {
		battrs, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			log.Fatal(err)
		}
		fmt.Println(battrs.Name)
	}
}

Java

Veja no GitHub

static void authExplicit(String jsonPath) throws IOException {
  // You can specify a credential file by providing a path to GoogleCredentials.
  // Otherwise credentials are read from the GOOGLE_APPLICATION_CREDENTIALS environment variable.
  GoogleCredentials credentials = GoogleCredentials.fromStream(new FileInputStream(jsonPath))
        .createScoped(Lists.newArrayList("https://www.googleapis.com/auth/cloud-platform"));
  Storage storage = StorageOptions.newBuilder().setCredentials(credentials).build().getService();

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

Node.js

Veja no GitHub

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

// Instantiates a client. Explicitly use service account credentials by
// specifying the private key file. All clients in google-cloud-node have this
// helper, see https://github.com/GoogleCloudPlatform/google-cloud-node/blob/master/docs/authentication.md
// const projectId = 'project-id'
// const keyFilename = '/path/to/keyfile.json'
const storage = new Storage({projectId, keyFilename});

// Makes an authenticated API request.
async function listBuckets() {
  try {
    const [buckets] = await storage.getBuckets();

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

PHP

Veja no GitHub

namespace Google\Cloud\Samples\Auth;

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

function auth_cloud_explicit($projectId, $serviceAccountPath)
{
    # Explicitly use service account credentials by specifying the private key
    # file.
    $config = [
        'keyFilePath' => $serviceAccountPath,
        'projectId' => $projectId,
    ];
    $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

Veja no GitHub

def explicit():
    from google.cloud import storage

    # Explicitly use service account credentials by specifying the private key
    # file.
    storage_client = storage.Client.from_service_account_json(
        'service_account.json')

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

Ruby

Veja no GitHub

# project_id = "Your Google Cloud project ID"
# key_file   = "path/to/service-account.json"
require "google/cloud/storage"

# Explicitly use service account credentials by specifying the private key
# file.
storage = Google::Cloud::Storage.new project: project_id, keyfile: key_file

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

Práticas recomendadas para o gerenciamento de credenciais

As credenciais dão acesso a dados confidenciais. As práticas a seguir ajudam a proteger o acesso às suas credenciais.

Não incorpore secrets relacionados à autenticação no código-fonte, como chaves de API, tokens OAuth e chaves da conta de serviço. Use uma variável de ambiente que aponte para as credenciais fora do código-fonte do aplicativo, como o Cloud Key Management Service.
Crie e use credenciais diferentes para contextos distintos, como ambientes de teste e produção.
Transfira as credenciais somente por um canal seguro, como HTTPS, para evitar que terceiros as interceptem. Jamais transfira em texto não criptografado ou como parte do URL.
Nunca incorpore credenciais de longa duração ao aplicativo do lado do cliente. Por exemplo, não incorpore chaves de conta de serviço a um aplicativo para dispositivos móveis. Os aplicativos do lado do cliente podem ser examinados e as credenciais podem ser facilmente encontradas e usadas por terceiros.
Revogue um token quando ele não for mais necessário.

Solução de problemas de erros na API

Saiba mais sobre como resolver problemas de solicitações de API em Erros das APIs do Cloud.

A seguir

Saiba mais sobre a autenticação em uma API do Google Cloud.
Saiba mais sobre como se autenticar como usuário final
Aprenda a usar chaves de API