Como autenticar 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 o aplicativo for executado em um ambiente do Google Cloud e você tiver anexado uma conta de serviço a ele, o aplicativo poderá recuperar as credenciais da conta de serviço. O aplicativo pode então usar as credenciais para chamar as APIs do Google Cloud.

É possível anexar contas de serviço a recursos de diversos serviços diferentes do Google Cloud, incluindo 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:

  1. Se a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS estiver definida, o ADC usará a chave da conta de serviço ou o arquivo de configuração apontado pela variável.

  2. Se a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS não estiver definida, o ADC usará a conta de serviço anexada ao recurso que está executando seu código.

    Essa conta de serviço pode ser uma conta de serviço padrão fornecida pelo Compute Engine, Google Kubernetes Engine, App Engine, Cloud Run ou Cloud Functions. Também pode ser uma conta de serviço gerenciada pelo usuário criada por você.

  3. 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. Para executar este exemplo, é preciso instalar a biblioteca de cliente do Cloud Storage.

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

Como transmitir credenciais manualmente

Se o aplicativo for executado em um ambiente sem nenhuma conta de serviço anexada, como no local ou em outro provedor de nuvem, use a federação de identidade da carga de trabalho.

Se não for possível usar a federação de identidade da carga de trabalho, crie uma conta de serviço e 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.

Consulte as práticas recomendadas para gerenciar chaves de conta de serviço.

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

Crie uma conta de serviço:

  1. No Console do Cloud, acesse a página Criar conta de serviço.

    Acesse "Criar conta de serviço"
  2. Selecione o projeto.
  3. No campo Nome da conta de serviço, insira um nome. O Console do Cloud preenche o campo ID da conta de serviço com base nesse nome.

    No campo Descrição da conta de serviço, insira uma descrição. Por exemplo, Service account for quickstart.

  4. Clique em Criar e continuar.
  5. Para fornecer acesso ao projeto, conceda os seguintes papéis à conta de serviço: Projeto > Proprietário.

    Na lista Selecionar um papel, escolha um.

    Para papéis adicionais, clique em Adicionar outro papel e adicione cada papel adicional.

  6. Clique em Continuar.
  7. Clique em Concluído para terminar a criação da conta de serviço.

    Não feche a janela do navegador. Você vai usá-la na próxima etapa.

Crie uma chave de conta de serviço:

  1. No Console do Cloud, clique no endereço de e-mail da conta de serviço que você criou.
  2. Clique em Chaves.
  3. Clique em Adicionar chave e em Criar nova chave.
  4. Clique em Criar. O download de um arquivo de chave JSON é feito no seu computador.
  5. Clique em Fechar.

gcloud

Configure a autenticação:

  1. Crie a conta de serviço:

    gcloud iam service-accounts create NAME

    Substitua NAME por um nome para a conta de serviço.

  2. Conceda papéis à conta de serviço. Execute uma vez o seguinte comando para cada um dos seguintes papéis do IAM: roles/owner

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

    Substitua:

    • SERVICE_ACCOUNT_NAME: o nome da conta de serviço.
    • PROJECT_ID: o ID do projeto em que você criou a conta de serviço
    • ROLE: o papel a ser concedido
  3. Gere o arquivo de chave:

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

    Substitua:

    • FILE_NAME: um nome para o arquivo de chave
    • SERVICE_ACCOUNT_NAME: o nome da conta de serviço.
    • PROJECT_ID: o ID do projeto em que você criou a conta de serviço

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. Essa variável se aplica somente à sessão de shell atual. Se você quiser que a variável seja aplicada em sessões de shell futuras, defina a variável no arquivo de inicialização de shell, por exemplo, no arquivo ~/.bashrc ou ~/.profile.

Linux ou macOS

export GOOGLE_APPLICATION_CREDENTIALS="KEY_PATH"

Substitua KEY_PATH pelo caminho do arquivo JSON que contém a chave da conta de serviço.

Exemplo:

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

Windows

Para PowerShell:

$env:GOOGLE_APPLICATION_CREDENTIALS="KEY_PATH"

Substitua KEY_PATH pelo caminho do arquivo JSON que contém a chave da conta de serviço.

Exemplo:

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

Para prompt de comando:

set GOOGLE_APPLICATION_CREDENTIALS=KEY_PATH

Substitua KEY_PATH pelo caminho do arquivo JSON que contém a chave da conta de serviço.

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#

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


// 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)
	}
	defer client.Close()
	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

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

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

namespace Google\Cloud\Samples\Auth;

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

/**
 * Authenticate to a cloud client library using a service account explicitly.
 *
 * @param string $projectId           The Google project ID.
 * @param string $serviceAccountPath  Path to service account credentials JSON.
 */
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

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

# 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

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

Faça um teste

Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho dos nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.

Comece a usar gratuitamente