Observação: o Go 1.11 chegou ao fim do suporte em 30 de janeiro de 2024. Os aplicativos Go 1.11 atuais continuarão a ser executados e a receber tráfego. No entanto, o App Engine pode bloquear a reimplantação de aplicativos que usam ambientes de execução após o término da data de suporte. Recomendamos que você migre para a versão compatível mais recente do Go.

Como configurar o controle de acesso

O Controle de acesso determina quem tem permissão para acessar serviços e recursos em um projeto do Google Cloud. No App Engine, há alguns casos de uso distintos para configurar o controle de acesso:

Conceder aos membros da equipe acesso ao projeto do Google Cloud para que possam configurar serviços e implantar aplicativos.
Conceder acesso para um aplicativo aos serviços do Google Cloud, como o Cloud Storage. Todos os serviços do Cloud exigem autenticação e autorização para todas as chamadas de API, incluindo chamadas provenientes do aplicativo do App Engine.
Conceder aos seus usuários acesso aos recursos em um projeto do Google Cloud. Esse caso de uso não é comum, mas podem ocorrer situações em que o aplicativo precisa solicitar acesso a um recurso do Cloud em nome de um usuário. Por exemplo, se o aplicativo precisar acessar dados que pertençam aos usuários.

Nesta página, você encontrará uma visão geral da configuração do controle de acesso em cada caso de uso.

Saiba como o Google Cloud Platform gerencia o controle de acesso na visão geral do gerenciamento de identidade e acesso (IAM).

Como conceder acesso a membros da equipe

Para conceder a um desenvolvedor acesso ao projeto do Google Cloud, crie um ou ambos os itens a seguir:

Uma conta de usuário associada a uma Conta do Google e que servirá para representar uma pessoa específica no seu projeto.

É possível utilizar a conta de usuário para fazer autenticação usando as seguintes ferramentas:
- Console do Google Cloud
- Google Cloud CLI
- Ambientes de desenvolvimento integrados e ferramentas de build que usam a CLI gcloud para testar e implantar aplicativos do App Engine
Uma conta de serviço que servirá para representar um aplicativo ou um processo, em vez de uma pessoa. Use contas de serviço nos processos automatizados de compilação, teste e implantação, principalmente se esses processos podem ser executados por vários desenvolvedores.

É possível utilizar a conta de serviço para fazer autenticação usando as seguintes ferramentas:
- CLI gcloud
- Ambientes de desenvolvimento integrados e ferramentas de build que usam as ferramentas da CLI gcloud para testar e implantar aplicativos do App Engine

Como criar uma conta de usuário

Abra a página "IAM" no console do Google Cloud.
Abrir a página do IAM
Clique em Selecionar um projeto e em Abrir.
Clique em Adicionar.
Insira um endereço de e-mail.
Selecione os papéis que concedem acesso aos recursos do Google App Engine.

Se o usuário também precisar de acesso a outros serviços do Cloud, selecione os papéis que concedem acesso a esses serviços.
Clique em Salvar.

Agora o usuário pode fazer login no console do Google Cloud e autorizar a CLI gcloud.

Também é possível criar contas de usuário com a gcloud, API REST ou bibliotecas de cliente.

Como criar uma conta de serviço

Abra a página Contas de serviço no console do Google Cloud.
Abrir a página "Contas de serviço"
Selecione o projeto e clique em Abrir.
Clique em Criar conta de serviço.
Insira o nome da conta de serviço. Deve ser um nome fácil de usar para exibição.
Clique em Criar.
Selecione os papéis que concedem acesso aos recursos do Google App Engine.

Se a conta de serviço também precisa de acesso a outros serviços do Cloud, selecione os papéis que concedem acesso a esses serviços.
Clique em Continuar.
Se você preferir, especifique as contas de usuário que podem gerenciar a conta de serviço. Além disso, é possível especificar as contas de usuário que podem usar a conta de serviço para acessar indiretamente todos os recursos a que ela tem acesso.
Clique em Salvar.

Uma lista das contas de serviço atuais será exibida.
Se você precisar usar sua conta de serviço fora do Google Cloud, siga as instruções para criar uma chave de conta de serviço.

Próximas etapas

Se você estiver usando a conta de serviço nos processos automatizados de compilação e implantação, utilize-a para autorizar a CLI gcloud.
Se você estiver usando a conta de serviço com um IDE, siga as instruções fornecidas pelo IDE.
Se você precisar usar uma identidade exclusiva para uma versão do aplicativo do App Engine ao acessar outros serviços do Google Cloud ou executar tarefas, especifique uma conta de serviço gerenciada pelo usuário no App Engine.

Como conceder acesso para um aplicativo aos serviços do Cloud

É necessário que todas as chamadas para um serviço do Cloud sejam autenticadas e autorizadas, incluindo aquelas provenientes de um aplicativo do App Engine para outros serviços do Cloud, como o Cloud Storage.

Por padrão, as chamadas de um aplicativo do App Engine para serviços no mesmo projeto são autorizadas. Veja como o fluxo padrão funciona:

Para iniciar chamadas para um serviço do Cloud, o aplicativo cria um objeto cliente, que contém as credenciais e outros dados que o aplicativo precisa para interagir com o serviço. Se você não especificar as credenciais no construtor do cliente, o cliente procurará por elas no ambiente do aplicativo.

Veja um exemplo de como criar um cliente para o Cloud Storage:

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

Por padrão, o ambiente do aplicativo contém as credenciais da conta de serviço padrão do App Engine.
Essa conta de serviço é criada pelo Google quando você cria um aplicativo do App Engine e recebe permissões totais para gerenciar e usar todos os serviços do Cloud em um projeto do Google Cloud.

Para modificar esse fluxo padrão, realize qualquer um dos seguintes procedimentos:

Defina a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS. Se essa variável for definida, os serviços do Cloud usarão as credenciais especificadas por ela, em vez daquelas da conta de serviço padrão.
Especifique as credenciais ao criar uma instância do objeto Client para um serviço do Cloud. Por exemplo, se o aplicativo realiza chamadas para um serviço do Google Cloud em um projeto diferente, talvez seja necessário transmitir as credenciais manualmente.

Se você definir a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS ou transmitir credenciais no código, recomendamos armazenar as credenciais de uma das seguintes maneiras:

Armazene suas credenciais em um local seguro, como o Firestore no modo Datastore (Datastore) e recupere-as no momento da execução.
Mantenha as credenciais no código, mas criptografe-as com um keystore, como o Cloud KMS.

Saiba mais sobre as vantagens de cada abordagem em Como escolher uma solução de gerenciamento de secrets.

Como conceder a usuários o acesso aos recursos do Cloud

Se você quiser que seu aplicativo leia dados de usuários provenientes de outro serviço do Google, será necessário configurar o OAuth 2.0 for Web Server Applications (em inglês). Por exemplo, se você quiser extrair os dados de um usuário do Google Drive e trazê-los para seu aplicativo, use o OAuth 2.0 for Web Server Applications para compartilhar dados específicos sem violar a privacidade de outras informações, como nomes de usuários e senhas.

Delegação de autoridade em todo o domínio do Google Workspace

Se você tiver um domínio do Google Workspace (antigo G Suite), um administrador poderá autorizar um aplicativo a acessar dados em nome de usuários no domínio do Google Workspace. Por exemplo, um aplicativo que usa a API Google Calendar para adicionar eventos às agendas de todos os usuários de um domínio do Google Workspace usa uma conta de serviço para acessar essa API em nome dos usuários.

Autorizar uma conta de serviço a acessar dados em nome de usuários em um domínio é, às vezes, denominado "delegar autoridade em todo o domínio" a uma conta de serviço. Esse procedimento também usa o OAuth 2.0 e exige que um administrador do domínio do Google Workspace autorize a autoridade em todo o domínio para a conta de serviço (em inglês).

Como especificar uma conta de serviço

O App Engine permite usar dois tipos de contas de serviço:

A conta de serviço padrão do App Engine será a identidade padrão de todas as versões do seu aplicativo do App Engine, caso uma conta de serviço gerenciada pelo usuário não seja especificada.

Dependendo da configuração da política da organização, a conta de serviço padrão pode receber automaticamente o papel de Editor no projeto. É altamente recomendável desativar a concessão automática de papéis aplicando a restrição da política da organização iam.automaticIamGrantsForDefaultServiceAccounts. Se você criou a organização após 3 de maio de 2024, essa restrição será aplicada por padrão.

Se você desativar a concessão automática de papéis, precisará decidir quais papéis conceder às contas de serviço padrão e, em seguida, conceder esses papéis por conta própria.

Se a conta de serviço padrão já tiver o papel de Editor, recomendamos que você o substitua por papéis menos permissivos. Para modificar com segurança os papéis da conta de serviço, use o Simulador de política para ver o impacto da alteração e, em seguida, conceda e revogue os papéis apropriados.
A conta de serviço gerenciada pelo usuário é uma conta de serviço que você cria no Identity and Access Management (IAM). Especifique uma conta de serviço gerenciada pelo usuário para uma versão, e ela será usada ao acessar outros serviços do App Engine e executar tarefas para essa versão.