Autentique cargas de trabalho nas APIs Trusted Cloud by S3NS através de contas de serviço

Esta página descreve como usar contas de serviço para permitir que as apps executadas nas suas instâncias de máquinas virtuais (VMs) se autentiquem nas APIs do Trusted Cloud by S3NS e autorizem o acesso aos recursos.

Para usar contas de serviço para autenticação, primeiro, tem de garantir que a sua VM está configurada para usar uma conta de serviço. Para isso, conclua um dos seguintes procedimentos:

• Para configurar uma conta de serviço durante a criação de VMs, consulte o artigo Crie uma VM que use uma conta de serviço gerida pelo utilizador.
• Para configurar uma conta de serviço numa VM existente, consulte o artigo Altere a conta de serviço anexada.

Antes de começar

• Reveja a vista geral das contas de serviço.
• Se ainda não o tiver feito, configure a autenticação. A autenticação valida a sua identidade para aceder a Trusted Cloud by S3NS serviços e APIs. Para executar código ou exemplos a partir de um ambiente de desenvolvimento local, pode autenticar-se no Compute Engine selecionando uma das seguintes opções:

  Para usar os Python exemplos nesta página num ambiente de desenvolvimento local, instale e inicialize a CLI gcloud e, em seguida, configure as Credenciais predefinidas da aplicação com as suas credenciais de utilizador.

  Instale a CLI Google Cloud e, em seguida, inicie sessão na CLI gcloud com a sua identidade federada.

  Create local authentication credentials for your user account:

  gcloud auth application-default login

  If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

  Para mais informações, consulte Set up authentication for a local development environment.

Vista geral

Depois de configurar uma instância de VM para ser executada com uma conta de serviço, uma aplicação executada na instância de VM pode usar um dos seguintes métodos para autenticação:

• Para a maioria das aplicações, escolha uma das seguintes opções:
  • Use credenciais padrão da aplicação e uma biblioteca cliente
  • Use a CLI gcloud
• Para aplicações que requerem uma chave de acesso OAuth2, peça e use chaves de acesso diretamente do servidor de metadados

Autenticar aplicações através de credenciais de contas de serviço

Depois de configurar uma instância para ser executada como uma conta de serviço, pode usar as credenciais da conta de serviço para autenticar as aplicações executadas na instância.

Autenticar aplicações com uma biblioteca de cliente

As bibliotecas cliente podem usar as Credenciais padrão da aplicação para fazer a autenticação em APIs Google e enviar pedidos para essas APIs. As Credenciais predefinidas da aplicação permitem que as aplicações obtenham automaticamente credenciais de várias origens para que possa testar a sua aplicação localmente e, em seguida, implementá-la numa instância do Compute Engine sem alterar o código da aplicação.

Para obter informações sobre a configuração das Credenciais padrão da aplicação, consulte o artigo Forneça credenciais às Credenciais padrão da aplicação.

Este exemplo usa a biblioteca cliente Python para autenticar e fazer um pedido à API Cloud Storage para listar os contentores num projeto. O exemplo usa o seguinte procedimento:

1. Obtenha as credenciais de autenticação necessárias para a API Cloud Storage e inicialize o serviço Cloud Storage com o método build() e as credenciais.
2. Listar contentores no Cloud Storage.

Pode executar este exemplo numa instância que tenha acesso à gestão de contentores no Cloud Storage.

import argparse
from typing import List

from google.cloud import storage


def create_client() -> storage.Client:
    """
    Construct a client object for the Storage API using the
    application default credentials.

    Returns:
        Storage API client object.
    """
    # 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 storage.Client()


def list_buckets(client: storage.Client, project_id: str) -> List[storage.Bucket]:
    """
    Retrieve bucket list of a project using provided client object.


    Args:
        client: Storage API client object.
        project_id: name of the project to list buckets from.

    Returns:
        List of Buckets found in the project.
    """
    buckets = client.list_buckets()
    return list(buckets)


def main(project_id: str) -> None:
    client = create_client()
    buckets = list_buckets(client, 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)

Autenticar aplicações diretamente com tokens de acesso

Para a maioria das aplicações, pode autenticar-se através das Credenciais padrão da aplicação, que encontram credenciais e gerem tokens por si. No entanto, se a sua aplicação exigir que faculte uma chave de acesso OAuth2, o Compute Engine permite-lhe obter uma chave de acesso do respetivo servidor de metadados para utilização na sua aplicação.

Existem várias opções para obter e usar estes tokens de acesso para autenticar as suas aplicações. Por exemplo, pode usar curl para criar um pedido simples ou usar uma linguagem de programação como Python para ter mais flexibilidade.

import argparse

import requests


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


def get_access_token() -> str:
    """
    Retrieves access token from the metadata server.

    Returns:
        The access token.
    """
    url = f"{METADATA_URL}instance/service-accounts/{SERVICE_ACCOUNT}/token"

    # 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: str, access_token: str) -> dict:
    """
    Calls Storage API to retrieve a list of buckets.

    Args:
        project_id: name of the project to list buckets from.
        access_token: access token to authenticate with.

    Returns:
        Response from the API.
    """
    url = "https://www.googleapis.com/storage/v1/b"
    params = {"project": project_id}
    headers = {"Authorization": f"Bearer {access_token}"}

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

    return r.json()


def main(project_id: str) -> None:
    """
    Retrieves access token from metadata server and uses it to list
    buckets in a project.

    Args:
        project_id: name of the project to list buckets from.
    """
    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)

As chaves de acesso expiram após um curto período. O servidor de metadados armazena em cache os tokens de acesso até terem 5 minutos de tempo restante antes de expirarem. Se não for possível colocar os tokens em cache, os pedidos que excedam 50 consultas por segundo podem ser limitados pela taxa. As suas aplicações têm de ter um token de acesso válido para que as chamadas à API sejam bem-sucedidas.

Autenticar ferramentas numa instância através de uma conta de serviço

Algumas aplicações podem usar comandos da CLI gcloud, que está incluída por predefinição na maioria das imagens do Compute Engine. A CLI gcloud reconhece automaticamente a conta de serviço de uma instância e as autorizações relevantes concedidas à conta de serviço. Especificamente, se conceder as funções corretas à conta de serviço, pode usar a CLI gcloud a partir das suas instâncias sem ter de usar gcloud auth login.

Este reconhecimento da conta de serviço ocorre automaticamente e aplica-se apenas à CLI gcloud incluída na instância. Se criar novas ferramentas ou adicionar ferramentas personalizadas, tem de autorizar a sua aplicação através de uma biblioteca cliente ou usando tokens de acesso diretamente na sua aplicação.

Para tirar partido do reconhecimento automático da conta de serviço, conceda as funções de IAM adequadas à conta de serviço e anexe a conta de serviço à instância. Por exemplo, se conceder à conta de serviço a função roles/storage.objectAdmin, a CLI gcloud pode gerir e aceder automaticamente a objetos do Cloud Storage.

Da mesma forma, se ativar a opção roles/compute.instanceAdmin.v1 para a conta de serviço, a ferramenta gcloud compute pode gerir automaticamente as instâncias.

O que se segue?

• Autenticar cargas de trabalho noutras cargas de trabalho através de mTLS .
• Saiba mais sobre as contas de serviço.
• Saiba mais sobre as autorizações e as funções de IAM do Compute Engine.
• Saiba mais sobre as práticas recomendadas para trabalhar com contas de serviço.