Autenticar cargas de trabalho usando contas de serviço

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Nesta página, descrevemos como usar contas de serviço para permitir que aplicativos executados nas suas instâncias de máquina virtual (VM) sejam autenticados nas APIs do Google Cloud e autorizem o acesso a recursos.

Para mais informações sobre como o Compute Engine usa contas de serviço, consulte a visão geral das contas de serviço.

Antes de começar

Como criar uma nova conta de serviço

É possível criar e configurar uma nova conta de serviço usando o IAM. Depois de criar uma conta, conceda a ela um ou mais papéis do IAM. Em seguida, autorize a execução de uma instância de máquina virtual como essa conta de serviço.

Console

Para criar uma nova conta de serviço:

  1. Crie uma nova conta de serviço conforme descrito nesta página.

  2. Consiga o e-mail da conta de serviço. Você precisa dele para configurar uma instância para ser executada como essa conta de serviço. Verifique o e-mail da conta de serviço no console:

    1. Acesse a página Contas de serviço.

      Acessar a página "Contas de serviço"

    2. Se solicitado, selecione o projeto.

    3. Procure a nova conta de serviço e anote o e-mail da conta de serviço.

    Normalmente, o e-mail da conta de serviço é derivado do código da conta de serviço, no formato:

    [SERVICE-ACCOUNT-NAME]@[PROJECT_ID].iam.gserviceaccount.com

  3. Conceda papéis do IAM à conta de serviço. Se você não conceder papéis, a conta de serviço não terá acesso a nenhum serviço. Para acessar uma lista completa de papéis do IAM, consulte Noções básicas sobre papéis na documentação do IAM.

  4. Em seguida, configure uma instância para executar como uma conta de serviço. Siga as instruções relacionadas.

Terraform

Para criar uma conta de serviço, use o recurso google_service_account.

compute/service_account_for_instances/main.tf 
resource "google_service_account" "default" {
  account_id   = "service-account-id"
  display_name = "Service Account"
}

Lembre-se de substituir os valores do marcador de posição para account_id e os atributos display_name.

Para saber como aplicar ou remover uma configuração do Terraform, consulte Comandos básicos do Terraform.

Como configurar uma nova instância para executar como uma conta de serviço

Depois de criar uma nova conta de serviço, crie novas instâncias de máquina virtual para serem executadas como a conta de serviço. Se a conta de serviço estiver em um projeto diferente das instâncias, será preciso configurar a conta de serviço para um recurso em um projeto diferente.

Se quiser atribuir ou alterar uma conta de serviço para uma instância existente, consulte Alterar a conta de serviço e os escopos de acesso de uma instância.

Você pode ativar várias instâncias de máquina virtual para usar a mesma conta de serviço, mas uma instância de máquina virtual só pode ter uma identidade de conta de serviço. Se você atribuir a mesma conta de serviço a várias instâncias de máquinas virtuais, alterações subsequentes feitas na conta de serviço afetarão as instâncias que usam a conta de serviço. Isso inclui quaisquer alterações feitas nas funções do IAM concedidas à conta de serviço. Por exemplo, se você remover uma função, todas as instâncias que usam a conta de serviço perderão as permissões concedidas por aquela função.

Geralmente, é possível definir apenas o escopo de acesso cloud-platform para permitir o acesso à maioria das APIs do Cloud e, em seguida, conceder à conta de serviço apenas papéis relevantes do IAM. A combinação de escopos de acesso concedidos à instância de máquina virtual e os papéis do IAM atribuídos à conta de serviço determinam a quantidade de acesso que a conta de serviço tem nessa instância. A conta de serviço poderá executar métodos de API somente se eles tiverem permissão do escopo de acesso e do papel do IAM.

Também é possível definir escopos específicos que autorizem o acesso aos métodos de API específicos que serão chamados pelo serviço. Por exemplo, para chamar o método instances.insert, você precisa de autorização com os escopos https://www.googleapis.com/auth/compute ou https://www.googleapis.com/auth/cloud-platform e de um papel do IAM que conceda acesso a esse método. É possível definir o escopo compute em vez de cloud-platform. Isso dá autorização ao serviço para chamar métodos no Compute Engine, mas não para chamar métodos de API fora dele.

É possível configurar uma nova instância para ser executada como uma conta de serviço pelo console do Google Cloud, pela Google Cloud CLI ou diretamente pela API.

Console

  1. Acesse a página Criar uma instância.

    Acesse "Criar uma instância"

  2. Especifique os detalhes da VM.

  3. Na seção Identidade e acesso à API, selecione na lista suspensa a conta de serviço que você quer usar.

  4. Continue com o processo de criação da VM.

gcloud

Para criar uma nova instância e permitir que ela seja executada como conta de serviço personalizada usando Google Cloud CLI, , forneça o e-mail da conta de serviço e os escopos de acesso pretendidos para a instância.

gcloud compute instances create [INSTANCE_NAME] \
    --service-account [SERVICE_ACCOUNT_EMAIL] \
    --scopes [SCOPES,...]

em que:

  • [SERVICE_ACCOUNT_EMAIL] é o e-mail da conta de serviço que você quer usar. Por exemplo, my-sa-123@my-project-123.iam.gserviceaccount.com. Se você não sabe qual é o e-mail, veja como consegui-lo;
  • [INSTANCE_NAME] é o nome da instância.
  • [SCOPES] é uma lista separada por vírgulas de todos os URIs de escopo ou aliases de escopo fornecidos na descrição da sinalização --scopes.

Exemplo:

gcloud compute instances create example-vm \
    --service-account 123-my-sa@my-project-123.iam.gserviceaccount.com \
    --scopes https://www.googleapis.com/auth/cloud-platform

A CLI gcloud também oferece aliases de escopo em vez de URIs de escopo mais longos. Por exemplo, o escopo para acesso total ao Cloud Storage é https://www.googleapis.com/auth/devstorage.full_control. O alias desse escopo é storage-full.

Veja uma lista de escopos e aliases de escopo na descrição da sinalização --scopes da página instances create. A ajuda do comando instances create também lista estes escopos e aliases:

gcloud compute instances create --help

Especifique o alias da mesma maneira que você determina o URI de escopo normal. Por exemplo:

gcloud compute instances create [INSTANCE_NAME] \
    --service-account [SERVICE_ACCOUNT_EMAIL] \
    --scopes cloud-platform

Terraform

Para configurar uma nova instância para ser executada como uma conta de serviço, use o recurso google_compute_instance.

compute/service_account_for_instances/main.tf 
resource "google_compute_instance" "default" {
  name         = "my-test-vm"
  machine_type = "n1-standard-1"
  zone         = "us-central1-a"

  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-11"
    }
  }

  // Local SSD disk
  scratch_disk {
    interface = "SCSI"
  }

  network_interface {
    network = "default"

    access_config {
      // Ephemeral public IP
    }
  }

  service_account {
    # Google recommends custom service accounts with `cloud-platform` scope with
    # specific permissions granted via IAM Roles.
    # This approach lets you avoid embedding secret keys or user credentials
    # in your instance, image, or app code
    email  = google_service_account.default.email
    scopes = ["cloud-platform"]
  }
}

API

Na API, faça uma solicitação padrão para criar uma instância, mas inclua a propriedade serviceAccounts. Consiga o e-mail da conta de serviço e inclua-o na propriedade email com os escopos de acesso pretendidos para a instância.

POST https://compute.googleapis.com/compute/v1/projects/[PROJECT_ID]/zones/[ZONE]/instances

{
  "machineType": "https://www.googleapis.com/compute/v1/projects/[PROJECT_ID]/zones/[ZONE]/machineTypes/[MACHINE_TYPE]",
  "name": "[INSTANCE_NAME]",
  "serviceAccounts": [
   {
    "email": "[SERVICE_ACCOUNT_EMAIL]",
    "scopes": ["https://www.googleapis.com/auth/cloud-platform"]
   }
  ],
  ...
}

Depois de configurar uma instância para execução como a conta de serviço, um aplicativo executado na instância pode usar um dos seguintes métodos para autenticação:

Como autenticar aplicativos usando credenciais da conta de serviço

Depois de configurar uma instância para executar como uma conta de serviço, você poderá usar as credenciais da conta de serviço para autenticar aplicativos em execução na instância.

Como autenticar aplicativos com uma biblioteca de cliente

Bibliotecas de cliente podem usar Application Default Credentials para se autenticar com Google APIs e enviar solicitações a elas. O Application Default Credentials permite que os aplicativos consigam automaticamente credenciais de várias fontes para que você possa testar o aplicativo localmente e implementá-lo em uma instância do Compute Engine sem alterar o código do aplicativo.

Para ver informações sobre como configurar o Application Default Credentials, consulte Fornecer credenciais para credenciais padrão do aplicativo.

Neste exemplo, a Biblioteca de cliente Python é usada para autenticar e fazer uma solicitação à API do Cloud Storage para listar os buckets em um projeto. Este é o procedimento seguido:

  1. Consiga as credenciais de autenticação necessárias para a API do Cloud Storage e inicie o serviço do produto com o método build() e as credenciais.
  2. Liste os buckets no Cloud Storage.

Execute esta amostra em uma instância que tenha acesso para gerenciar buckets no Cloud Storage.

compute/auth/application_default.py 

import argparse

import googleapiclient.discovery

def create_service():
    # Construct the service object for interacting with the Cloud Storage API -
    # the 'storage' service, at version 'v1'.
    # Authentication is provided by application default credentials.
    # When running locally, these are available after running
    # `gcloud auth application-default login`. When running on Compute
    # Engine, these are available from the environment.
    return googleapiclient.discovery.build('storage', 'v1')

def list_buckets(service, project_id):
    buckets = service.buckets().list(project=project_id).execute()
    return buckets

def main(project_id):
    service = create_service()
    buckets = list_buckets(service, project_id)
    print(buckets)

if __name__ == '__main__':
    parser = argparse.ArgumentParser(
        description=__doc__,
        formatter_class=argparse.RawDescriptionHelpFormatter)
    parser.add_argument('project_id', help='Your Google Cloud Project ID.')

    args = parser.parse_args()

    main(args.project_id)

Como autenticar aplicativos diretamente com tokens de acesso

Na maioria dos aplicativos, é possível autenticar usando o Application Default Credentials, que encontra credenciais e gerencia tokens para você. No entanto, se o aplicativo exigir que você forneça um token de acesso OAuth2, o Compute Engine permitirá que você receba um token de acesso do servidor de metadados para uso no aplicativo.

Há várias opções para conseguir e usar esses tokens de acesso para autenticar os aplicativos. Por exemplo, use o curl para criar uma solicitação simples ou utilize uma linguagem de programação como o Python para ter mais flexibilidade.

cURL

Para usar o curl para solicitar um token de acesso e enviar uma solicitação a uma API:

  1. Na instância em que o aplicativo é executado, consulte o servidor de metadados para conseguir um token de acesso executando o seguinte comando:

    $ curl "http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/token" \
-H "Metadata-Flavor: Google"

    A solicitação retorna uma resposta assim:

    {
      "access_token":"ya29.AHES6ZRN3-HlhAPya30GnW_bHSb_QtAS08i85nHq39HE3C2LTrCARA",
      "expires_in":3599,
      "token_type":"Bearer"
 }

    Para solicitações de API, é necessário incluir o valor access_token, e não toda a resposta. Se você tiver o processador JSON da linha de comando jq instalado, poderá usar o seguinte comando para extrair o valor do token de acesso da resposta:

    $ ACCESS_TOKEN=`curl \
"http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/token" \
-H "Metadata-Flavor: Google" | jq -r '.access_token'`

  2. Copie o valor da propriedade access_token da resposta e use-o para enviar solicitações para a API. Por exemplo, a solicitação a seguir imprime uma lista de instâncias no projeto a partir de uma determinada zona:

    $ curl https://compute.googleapis.com/compute/v1/projects/[PROJECT_ID]/zones/[ZONE]/instances \
-H "Authorization":"Bearer [ACCESS_TOKEN]"

    em que:

    • [PROJECT_ID] é o ID do projeto da solicitação;
    • [ZONE] é a zona das instâncias que serão listadas;
    • [ACCESS_TOKEN] é o valor do token de acesso conseguido na primeira etapa.

    Para mais informações sobre os parâmetros que podem ser definidos na solicitação, consulte a documentação relacionada.

Python

Veja neste exemplo como solicitar um token para acessar a API Cloud Storage em um aplicativo Python. Este é o procedimento seguido:

  1. Solicite um token de acesso do servidor de metadados.
  2. Extraia o token de acesso da resposta do servidor.
  3. Use o token de acesso para fazer uma solicitação ao Cloud Storage.
  4. Se a solicitação for bem-sucedida, o script imprimirá a resposta.
compute/auth/access_token.py 

import argparse

import requests

METADATA_URL = 'http://metadata.google.internal/computeMetadata/v1/'
METADATA_HEADERS = {'Metadata-Flavor': 'Google'}
SERVICE_ACCOUNT = 'default'

def get_access_token():
    url = '{}instance/service-accounts/{}/token'.format(
        METADATA_URL, SERVICE_ACCOUNT)

    # Request an access token from the metadata server.
    r = requests.get(url, headers=METADATA_HEADERS)
    r.raise_for_status()

    # Extract the access token from the response.
    access_token = r.json()['access_token']

    return access_token

def list_buckets(project_id, access_token):
    url = 'https://www.googleapis.com/storage/v1/b'
    params = {
        'project': project_id
    }
    headers = {
        'Authorization': 'Bearer {}'.format(access_token)
    }

    r = requests.get(url, params=params, headers=headers)
    r.raise_for_status()

    return r.json()

def main(project_id):
    access_token = get_access_token()
    buckets = list_buckets(project_id, access_token)
    print(buckets)

if __name__ == '__main__':
    parser = argparse.ArgumentParser(
        description=__doc__,
        formatter_class=argparse.RawDescriptionHelpFormatter)
    parser.add_argument('project_id', help='Your Google Cloud project ID.')

    args = parser.parse_args()

    main(args.project_id)

Os tokens de acesso expiram depois de um período curto. O servidor de metadados armazena em cache os tokens de acesso até que tenham cinco minutos de tempo restante antes que eles expirem. Você pode solicitar novos tokens com a frequência que quiser, mas os aplicativos devem ter um token de acesso válido para que as chamadas da API tenham êxito.

Como autenticar ferramentas em uma instância usando uma conta de serviço

Alguns aplicativos podem usar comandos das ferramentas gcloud e gsutil, que estão incluídas por padrão na maioria das imagens do Compute Engine. Essas ferramentas reconhecem automaticamente a conta de serviço de uma instância e as permissões relevantes concedidas a ela. Especificamente, se você conceder os papéis corretos à conta de serviço, será possível usar as ferramentas gcloud e gsutil das instâncias sem precisar utilizar gcloud auth login.

Esse reconhecimento da conta de serviço acontece automaticamente e aplica-se somente às ferramentas gcloud e gsutil que estão incluídas na instância. Se você criar novas ferramentas ou adicionar outras personalizadas, será necessário autorizar o aplicativo usando uma biblioteca de cliente ou tokens de acesso diretamente no aplicativo.

Para aproveitar o reconhecimento automático da conta de serviço, conceda os papéis do IAM apropriados à conta de serviço e configure uma instância para ser executada como conta de serviço. Por exemplo, se você conceder o papel roles/storage.objectAdmin a uma conta de serviço, a ferramenta gsutil poderá gerenciar e acessar objetos do Cloud Storage automaticamente.

Da mesma forma, se você ativar roles/compute.instanceAdmin.v1 na conta de serviço, a ferramenta gcloud compute poderá gerenciar instâncias automaticamente.

Como alterar a conta de serviço e os escopos de acesso de uma instância

Se você quiser executar a VM como uma identidade diferente ou se determinar que a instância precisa de um conjunto de escopos diferente para chamar as APIs necessárias, é possível alterar a conta de serviço e os escopos de acesso de uma instância existente. Por exemplo, é possível alterar os escopos de acesso para conceder acesso a uma nova API, remover a conta de serviço e os escopos de acesso para impedir que uma VM acesse quaisquer serviços do Google Cloud ou alterar um VM para que seja executada como uma conta de serviço criada em vez da conta de serviço padrão do Compute Engine. No entanto, o Google recomenda que você use as políticas detalhadas do IAM em vez de depender de escopos de acesso para controlar o acesso a recursos da conta de serviço.

Para alterar a conta de serviço e os escopos de acesso de uma instância, ela precisa ser parada temporariamente. Para parar a instância, leia a documentação sobre Parar uma instância. Depois de alterar a conta de serviço ou os escopos de acesso, lembre-se de reiniciar a instância. Use um dos seguintes métodos para alterar a conta de serviço ou os escopos de acesso da instância parada.

Console

  1. Acesse a página Instâncias da VM.

    Acessar instâncias de VM

  2. Clique no nome da instância de VM para que você quer alterar a conta de serviço.

  3. Se a instância não estiver parada, clique em Parar. Espere até que a instância seja parada.

  4. Em seguida, clique em Editar.

  5. Role para baixo até a seção Conta de serviço.

  6. Na lista suspensa, selecione a conta de serviço a ser atribuída à instância.

    • Se você escolher a conta de serviço padrão, será possível modificar os escopos de acesso dela no console do Google Cloud.
      • Para alterar os escopos, na seção Escopos de acesso, selecione Definir acesso para cada API e defina os escopos apropriados para suas necessidades.
      • Se não tiver certeza de quais escopos de acesso definir, escolha Permitir acesso total a todas as APIs do Cloud e restrinja o acesso definindo os papéis do IAM na conta de serviço.
    • Se você escolher uma conta de serviço diferente, o escopo de acesso da VM será padronizado como cloud-platform. É possível modificar o escopo usando a CLI gcloud ou a API Compute Engine.
    • Para mais informações sobre como definir escopos de acesso, consulte Práticas recomendadas.

  7. Clique em Salvar.

gcloud

Use o comando instances set-service-account e forneça o nome da instância, o e-mail da conta de serviço e os escopos pretendidos. Para mais informações sobre como definir escopos de acesso, consulte Práticas recomendadas.

gcloud compute instances set-service-account [INSTANCE_NAME] \
   [--service-account [SERVICE_ACCOUNT_EMAIL] | --no-service-account] \
   [--no-scopes | --scopes [SCOPES,...]]

em que:

  • [SERVICE_ACCOUNT_EMAIL] é o e-mail da conta de serviço que você quer usar. Por exemplo, my-sa-123@my-project-123.iam.gserviceaccount.com.
  • [INSTANCE_NAME] é o nome da instância.
  • [SCOPES] é uma lista separada por vírgulas de todos os URIs de escopo ou aliases de escopo fornecidos na descrição da sinalização --scopes. Se você quer remover todos os escopos da instância, use a sinalização --no-scopes.

Por exemplo, com o comando a seguir, você atribui a conta de serviço my-sa-123@my-project-123.iam.gserviceaccount.com a uma instância chamada "example-instance". Além disso, você define escopos de acesso nessa instância para permitir o acesso de leitura/gravação ao Compute Engine e o acesso somente leitura ao Cloud Storage:

gcloud compute instances set-service-account example-instance \
   --service-account my-sa-123@my-project-123.iam.gserviceaccount.com \
   --scopes compute-rw,storage-ro

API

Na API, faça uma solicitação POST para o método setServiceAccount:

https://compute.googleapis.com/compute/v1/projects/[PROJECT_ID]/zones/[ZONE]/instances/[INSTANCE_NAME]/setServiceAccount

em que:

  • [PROJECT_ID] é o ID do projeto da solicitação;
  • [ZONE] é a zona a que essa instância pertence;
  • [INSTANCE_NAME] é o nome da instância.

No corpo da solicitação, forneça o endereço de e-mail da conta de serviço e os URIs do escopo desejado para a instância. Para mais informações sobre como definir escopos de acesso, consulte Práticas recomendadas.

{
  "email": "[SERVICE_ACCOUNT_EMAIL]",
  "scopes": [
    "[SCOPE_URI]",
    "[SCOPE_URI]",
    ...
  ]
}

Por exemplo, na solicitação a seguir, o e-mail da conta de serviço my-sa-123@my-project-123.iam.gserviceaccount.com é usado, e um escopo do Cloud Storage e do BigQuery é definido:

{
  "email": "my-sa-123@my-project-123.iam.gserviceaccount.com",
  "scopes": [
    "https://www.googleapis.com/auth/bigquery",
    "https://www.googleapis.com/auth/devstorage.read_only"
  ]
}

Como conseguir o e-mail de uma conta de serviço

Para identificar uma conta de serviço, você precisa do e-mail da conta de serviço. Consiga o e-mail de uma conta de serviço com uma das seguintes opções:

Console

  1. Acesse a página Contas de serviço.

    Acessar a página "Contas de serviço"

  2. Se solicitado, selecione o projeto. A página de contas de serviço lista todas as contas de serviço do projeto e seus e-mails.

gcloud

Use o comando gcloud compute instances describe no computador local:

gcloud compute instances describe [INSTANCE_NAME] --format json

{
      ...
      "serviceAccounts":[
         {
            "email":"123845678986-compute@developer.gserviceaccount.com",
            "scopes":[
               "https://www.googleapis.com/auth/devstorage.full_control"
            ]
         }
      ]
      ...
   }

Se a instância não estiver usando uma conta de serviço, você receberá uma resposta sem a propriedade serviceAccounts.

Servidor de metadados

Consulte o servidor de metadados de dentro da própria instância. Faça uma solicitação para http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/:

user@myinst:~$ curl "http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/" \
-H "Metadata-Flavor: Google"

Se você ativou uma ou mais contas de serviço ao criar a instância, o comando curl retornará uma saída como esta:

123845678986-compute@developer.gserviceaccount.com/
default/

Se a instância não estiver usando uma conta de serviço, você receberá uma resposta vazia.

API

Faça uma solicitação à API Service Accounts.

Como usar a conta de serviço padrão do Compute Engine

Se você está familiarizado com a conta de serviço padrão do Compute Engine e quer usar as credenciais fornecidas por ela, em vez de criar novas contas de serviço, poderá conceder funções do IAM para a conta de serviço padrão.

Por padrão, todas as instâncias do Compute Engine podem executar como a conta de serviço padrão. Ao criar uma instância usando a Google Cloud CLI ou o console do Google Cloud e omitindo especificações da conta de serviço, a conta de serviço padrão é atribuída à instância.

Antes de atribuir funções do IAM à conta de serviço padrão, observe que:

  • Conceder um papel do IAM à conta de serviço padrão afeta todas as instâncias que estão sendo executadas como a conta de serviço padrão. Por exemplo, se você conceder o papel roles/storage.objectAdmin à conta de serviço padrão, todas as instâncias em execução como a conta de serviço padrão com os escopos de acesso necessários terão as permissões concedidas pelo papel roles/storage.objectAdmin. Da mesma forma, se você limitar o acesso omitindo determinados papéis, isso afetará todas as instâncias que estão sendo executadas como a conta de serviço padrão.

  • Você precisa revogar a permissão do editor de projeto para a conta de serviço. Por padrão, a conta de serviço padrão é adicionada como um editor de projeto aos projetos. Para usar os papéis do IAM, você precisa revogar a permissão de editor de projeto.

Se não tiver certeza sobre a atribuição de papéis do IAM para a conta de serviço padrão, crie uma nova conta de serviço.

Siga estas instruções para conceder um papel do IAM à conta de serviço padrão:

  1. No Console do Google Cloud, abra a página IAM.

    Acessar IAM

  2. Se solicitado, selecione o projeto.

  3. Procure a conta de serviço chamada Conta de serviço padrão do Compute Engine.

  4. Na coluna Funções, expanda o menu suspenso da Conta de serviço padrão do Compute Engine.

  5. Remova o acesso Editor e salve as alterações.

  6. Em seguida, conceda papéis do IAM à conta de serviço.

Agora todas as instâncias de máquina virtual que estiverem sendo executadas como conta de serviço padrão terão acesso a outras APIs do Google Cloud de acordo com os papéis do IAM que você concedeu à conta.

Se você quiser configurar uma nova instância para ser executada como conta de serviço padrão, siga estas instruções:

Console

  1. Acesse a página Criar uma instância.

    Acesse "Criar uma instância"

  2. Especifique os detalhes da VM.

  3. Na seção Identidade e acesso à API, selecione Conta de serviço padrão do Compute Engine na lista suspensa Conta de serviço.

  4. Continue com o processo de criação da VM.

gcloud

Para criar uma nova instância e autorizá-la a ter acesso total a todos os serviços do Google Cloud usando a conta de serviço padrão:

gcloud compute instances create [INSTANCE_NAME] \
     --scopes cloud-platform

API

Na API, faça uma solicitação padrão para criar uma instância, mas inclua a propriedade serviceAccounts. Consiga o ID da conta de serviço padrão e inclua-o como email da conta de serviço. Em seguida, defina um ou mais escopos na propriedade scopes.

POST https://compute.googleapis.com/compute/v1/projects/zones/[ZONE]/instances

{
  "machineType": "https://www.googleapis.com/compute/v1/projects/[PROJECT_ID]/zones/[ZONE]/machineTypes/[MACHINE_TYPE]",
  "name": "[INSTANCE_NAME]",
  "serviceAccounts": [
   {
    "email": "[DEFAULT_SERVICE_ACCOUNT_EMAIL]",
    "scopes": ["https://www.googleapis.com/auth/cloud-platform"]
   }
  ],
  ...
}

Práticas recomendadas

  • O Google recomenda que cada instância de VM que precisa chamar uma API do Google seja executada como uma conta de serviço com as permissões mínimas necessárias para que a VM faça seu trabalho.

  • Siga estas instruções para configurar contas de serviço para as VMs:

    1. Crie uma nova conta de serviço em vez de usar a conta de serviço padrão do Compute Engine.
    2. Conceda papéis do IAM a essa conta de serviço apenas para os recursos de que ela precisa.
    3. Configure a VM para ser executada como a nova conta de serviço que você criou.
    4. Conceda à VM o escopo https://www.googleapis.com/auth/cloud-platform para permitir o acesso à maioria das APIs do Google Cloud. Assim, as permissões do IAM da VM serão determinadas completamente pelos papéis do IAM que você concedeu à conta de serviço da VM. A conta de serviço só pode executar métodos de API permitidos pelo escopo de acesso e pelos papéis específicos do IAM da conta de serviço.

  • Limite os privilégios das contas de serviço e verifique regularmente as permissões da conta de serviço para garantir que estejam atualizadas.

  • Exclua as contas de serviço com cuidado. Verifique se os aplicativos críticos não estão mais usando uma conta de serviço antes de excluí-la. Se você não tiver certeza se uma conta de serviço está sendo usada, recomendamos desativar a conta de serviço em vez de excluí-la. As contas de serviço desativadas poderão ser reativadas se ainda forem necessárias.

  • Reduza os riscos de segurança da conta de serviço. Para mais informações, consulte Práticas recomendadas para trabalhar com contas de serviço.

A seguir

Faça um teste

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

Faça uma avaliação gratuita do Compute Engine