Nesta página, descrevemos como usar bibliotecas de cliente para acessar as APIs do Google.
As bibliotecas de cliente facilitam o acesso às APIs doTrusted Cloud by S3NS
usando uma linguagem compatível. É possível usar as APIs do Trusted Cloud by S3NS diretamente
fazendo solicitações brutas ao servidor, mas as bibliotecas de cliente oferecem simplificações
que reduzem significativamente a quantidade de código que você precisa escrever. Isso é
especialmente verdadeiro para a autenticação, porque as bibliotecas de cliente oferecem suporte a
Application Default Credentials (ADC).
Usar o Application Default Credentials com as bibliotecas de clientes
Para usar o Application Default Credentials para autenticar um aplicativo, primeiro configure o ADC para o ambiente em que o aplicativo está em execução. Quando você usa a biblioteca
de cliente para criar um cliente, essa biblioteca verifica e
usa automaticamente as credenciais fornecidas ao ADC para autenticação nas APIs
usadas pelo seu código. Seu aplicativo não precisa autenticar ou gerenciar tokens explicitamente. esses requisitos são gerenciados automaticamente pelas
bibliotecas de autenticação.
As amostras de código a seguir criam um cliente para o serviço do Cloud Storage.
É provável que seu código precise de clientes diferentes. Estas amostras servem apenas para mostrar como criar um cliente e usá-lo sem qualquer código para autenticar explicitamente.
Antes de executar os exemplos a seguir, é preciso concluir as etapas a seguir:
Defina a variável de ambiente GOOGLE_CLOUD_UNIVERSE_DOMAIN como s3nsapis.fr.
Go
import("context""fmt""io""cloud.google.com/go/storage""google.golang.org/api/iterator")// authenticateImplicitWithAdc uses Application Default Credentials// to automatically find credentials and authenticate.funcauthenticateImplicitWithAdc(wio.Writer,projectIdstring)error{// projectId := "your_project_id"ctx:=context.Background()// NOTE: Replace the client created below with the client required for your application.// Note that the credentials are not specified when constructing the client.// The client library finds your credentials using ADC.client,err:=storage.NewClient(ctx)iferr!=nil{returnfmt.Errorf("NewClient: %w",err)}deferclient.Close()it:=client.Buckets(ctx,projectId)for{bucketAttrs,err:=it.Next()iferr==iterator.Done{break}iferr!=nil{returnerr}fmt.Fprintf(w,"Bucket: %v\n",bucketAttrs.Name)}fmt.Fprintf(w,"Listed all storage buckets.\n")returnnil}
Java
importcom.google.api.gax.paging.Page;importcom.google.cloud.storage.Bucket;importcom.google.cloud.storage.Storage;importcom.google.cloud.storage.StorageOptions;importjava.io.IOException;publicclassAuthenticateImplicitWithAdc{publicstaticvoidmain(String[]args)throwsIOException{// TODO(Developer):// 1. Before running this sample,// set up Application Default Credentials as described in// https://cloud.google.com/docs/authentication/external/set-up-adc// 2. Replace the project variable below.// 3. Make sure you have the necessary permission to list storage buckets// "storage.buckets.list"StringprojectId="your-google-cloud-project-id";authenticateImplicitWithAdc(projectId);}// When interacting with Google Cloud Client libraries, the library can auto-detect the// credentials to use.publicstaticvoidauthenticateImplicitWithAdc(Stringproject)throwsIOException{// *NOTE*: Replace the client created below with the client required for your application.// Note that the credentials are not specified when constructing the client.// Hence, the client library will look for credentials using ADC.//// Initialize client that will be used to send requests. This client only needs to be created// once, and can be reused for multiple requests.Storagestorage=StorageOptions.newBuilder().setProjectId(project).build().getService();System.out.println("Buckets:");Page<Bucket>buckets=storage.list();for(Bucketbucket:buckets.iterateAll()){System.out.println(bucket.toString());}System.out.println("Listed all storage buckets.");}}
Node.js
/** * TODO(developer): * 1. Uncomment and replace these variables before running the sample. * 2. Set up ADC as described in https://cloud.google.com/docs/authentication/external/set-up-adc * 3. Make sure you have the necessary permission to list storage buckets "storage.buckets.list" * (https://cloud.google.com/storage/docs/access-control/iam-permissions#bucket_permissions) */// const projectId = 'YOUR_PROJECT_ID';const{Storage}=require('@google-cloud/storage');asyncfunctionauthenticateImplicitWithAdc(){// This snippet demonstrates how to list buckets.// NOTE: Replace the client created below with the client required for your application.// Note that the credentials are not specified when constructing the client.// The client library finds your credentials using ADC.conststorage=newStorage({projectId,});const[buckets]=awaitstorage.getBuckets();console.log('Buckets:');for(constbucketofbuckets){console.log(`- ${bucket.name}`);}console.log('Listed all storage buckets.');}authenticateImplicitWithAdc();
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
fromgoogle.cloudimportstoragedefauthenticate_implicit_with_adc(project_id="your-google-cloud-project-id"):""" When interacting with Google Cloud Client libraries, the library can auto-detect the credentials to use. // TODO(Developer): // 1. Before running this sample, // set up ADC as described in https://cloud.google.com/docs/authentication/external/set-up-adc // 2. Replace the project variable. // 3. Make sure that the user account or service account that you are using // has the required permissions. For this sample, you must have "storage.buckets.list". Args: project_id: The project id of your Google Cloud project. """# This snippet demonstrates how to list buckets.# *NOTE*: Replace the client created below with the client required for your application.# Note that the credentials are not specified when constructing the client.# Hence, the client library will look for credentials using ADC.storage_client=storage.Client(project=project_id)buckets=storage_client.list_buckets()print("Buckets:")forbucketinbuckets:print(bucket.name)print("Listed all storage buckets.")
Ruby
defauthenticate_implicit_with_adcproject_id:# The ID of your Google Cloud project# project_id = "your-google-cloud-project-id"#### When interacting with Google Cloud Client libraries, the library can auto-detect the# credentials to use.# TODO(Developer):# 1. Before running this sample,# set up ADC as described in https://cloud.google.com/docs/authentication/external/set-up-adc# 2. Replace the project variable.# 3. Make sure that the user account or service account that you are using# has the required permissions. For this sample, you must have "storage.buckets.list".###require"google/cloud/storage"# This sample demonstrates how to list buckets.# *NOTE*: Replace the client created below with the client required for your application.# Note that the credentials are not specified when constructing the client.# Hence, the client library will look for credentials using ADC.storage=Google::Cloud::Storage.newproject_id:project_idbuckets=storage.bucketsputs"Buckets: "buckets.eachdo|bucket|putsbucket.nameendputs"Plaintext: Listed all storage buckets."end
Usar chaves de API com bibliotecas de cliente
Você pode usar chaves de API apenas com bibliotecas de cliente para APIs que aceitam chaves de API. Além disso, a chave de API não pode ter uma restrição que impeça o uso dela na API.
Ao usar chaves de API nos seus aplicativos, garanta que elas sejam mantidas em segurança
durante o armazenamento e a transmissão. A exposição pública das chaves de API pode
levar a cobranças inesperadas na sua conta. Para mais informações, consulte
Práticas recomendadas para gerenciar chaves de API.
Requisitos de segurança ao usar configurações de credenciais de uma fonte externa
Normalmente, as configurações de credenciais são geradas usando comandos da CLI gcloud ou o console Trusted Cloud . Por exemplo, use a
CLI gcloud para gerar um arquivo ADC local ou um arquivo de configuração
de login. Da mesma forma, é possível usar o console Trusted Cloud para criar e fazer o download de uma chave de conta de serviço.
No entanto, em alguns casos de uso, as configurações de credenciais são fornecidas por uma entidade externa e destinadas à autenticação nas APIs do Google.
Alguns tipos de configurações de credenciais incluem endpoints e caminhos de arquivos, que
as bibliotecas de autenticação usam para adquirir um token. Ao aceitar configurações de credenciais de uma fonte externa, valide a configuração antes de usá-la. Se você não validar a configuração, um agente malicioso
poderá usar a credencial para comprometer seus sistemas e dados.
Validar configurações de credenciais de fontes externas
A forma de validar suas credenciais externas depende dos tipos de
credenciais que seu aplicativo aceita.
Validar chaves de conta de serviço
Se o aplicativo aceitar apenas chaves de conta de serviço, use um carregador de credenciais específico para elas, conforme mostrado nos exemplos a seguir. O carregador de credenciais específico do tipo analisa apenas os campos presentes nas chaves de conta de serviço, que não expõem vulnerabilidades.
Se não for possível usar um carregador de credenciais específico do tipo, valide a credencial
confirmando que o valor do campo type é service_account. Se o valor do campo type for qualquer outro, não use a chave da conta de serviço.
A tabela a seguir lista os campos que você precisa validar, se eles estiverem presentes
nas suas credenciais. Nem todos esses campos estão presentes em todas as configurações de credenciais.
Campo
Finalidade
Valor esperado
service_account_impersonation_url
As bibliotecas de autenticação usam esse campo para acessar um endpoint e
gerar um token de acesso para a conta de serviço representada.
As bibliotecas de autenticação enviam um token externo para esse endpoint para
trocá-lo por um
token de acesso federado.
https://sts.s3nsapis.fr/v1/token
credential_source.file
As bibliotecas de autenticação leem um token externo do arquivo no
local especificado por esse campo e o enviam para o
endpoint token_url.
O caminho para um arquivo que contém um token externo. Você deve reconhecer esse caminho.
credential_source.url
Um endpoint que retorna um token externo. As bibliotecas de autenticação
enviam uma solicitação para esse URL e enviam a resposta para o
endpoint token_url.
Um dos seguintes itens:
Um endpoint conhecido fornecido pelo seu provedor de nuvem.
Um endpoint que você configurou explicitamente para fornecer tokens.
credential_source.executable.command
Se a variável de ambiente GOOGLE_EXTERNAL_ACCOUNT_ALLOW_EXECUTABLES estiver definida como 1, as bibliotecas de autenticação vão executar esse comando ou arquivo executável.
Um arquivo executável ou comando que retorna um token externo.
Você precisa reconhecer esse comando e validar se ele é seguro.
credential_source.aws.url
As bibliotecas de autenticação emitem uma solicitação para esse URL para recuperar
um token de segurança da AWS.
[[["Fácil de entender","easyToUnderstand","thumb-up"],["Meu problema foi resolvido","solvedMyProblem","thumb-up"],["Outro","otherUp","thumb-up"]],[["Não contém as informações de que eu preciso","missingTheInformationINeed","thumb-down"],["Muito complicado / etapas demais","tooComplicatedTooManySteps","thumb-down"],["Desatualizado","outOfDate","thumb-down"],["Problema na tradução","translationIssue","thumb-down"],["Problema com as amostras / o código","samplesCodeIssue","thumb-down"],["Outro","otherDown","thumb-down"]],["Última atualização 2025-08-19 UTC."],[[["Client libraries simplify accessing Google Cloud APIs by handling tasks like authentication and reducing the amount of code needed, especially with Application Default Credentials (ADC)."],["To use ADC, you must set it up for your environment, which the client library will automatically utilize for authentication without needing explicit token management."],["API keys can be used with certain client libraries and APIs, but they need to be managed securely to prevent unauthorized access and unexpected charges."],["When accepting credential configurations from external sources, it is important to validate them thoroughly to prevent security compromises, particularly by confirming specific fields like the `type` and checking if `service_account` or other URL values are correct."],["Service account keys can be validated using credential loader specific to them, otherwise, the 'type' field should be verified to ensure it is set to `service_account`."]]],[]]