使用客户端库时进行身份验证

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. func authenticateImplicitWithAdc(w io.Writer, projectId string) 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) 	if err != nil { 		return fmt.Errorf("NewClient: %w", err) 	} 	defer client.Close()  	it := client.Buckets(ctx, projectId) 	for { 		bucketAttrs, err := it.Next() 		if err == iterator.Done { 			break 		} 		if err != nil { 			return err 		} 		fmt.Fprintf(w, "Bucket: %v\n", bucketAttrs.Name) 	}  	fmt.Fprintf(w, "Listed all storage buckets.\n")  	return nil } 

 import com.google.api.gax.paging.Page; import com.google.cloud.storage.Bucket; import com.google.cloud.storage.Storage; import com.google.cloud.storage.StorageOptions; import java.io.IOException;  public class AuthenticateImplicitWithAdc {    public static void main(String[] args) throws IOException {     // 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"     String projectId = "your-google-cloud-project-id";     authenticateImplicitWithAdc(projectId);   }    // When interacting with Google Cloud Client libraries, the library can auto-detect the   // credentials to use.   public static void authenticateImplicitWithAdc(String project) throws IOException {      // *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.     Storage storage = StorageOptions.newBuilder().setProjectId(project).build().getService();      System.out.println("Buckets:");     Page<Bucket> buckets = storage.list();     for (Bucket bucket : buckets.iterateAll()) {       System.out.println(bucket.toString());     }     System.out.println("Listed all storage buckets.");   } }

/**  * 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');  async function authenticateImplicitWithAdc() {   // 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.   const storage = new Storage({     projectId,   });   const [buckets] = await storage.getBuckets();   console.log('Buckets:');    for (const bucket of buckets) {     console.log(`- ${bucket.name}`);   }    console.log('Listed all storage buckets.'); }  authenticateImplicitWithAdc();

// 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());     } }

 from google.cloud import storage   def authenticate_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:")     for bucket in buckets:         print(bucket.name)     print("Listed all storage buckets.") 

def authenticate_implicit_with_adc project_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.new project_id: project_id   buckets = storage.buckets   puts "Buckets: "   buckets.each do |bucket|     puts bucket.name   end   puts "Plaintext: Listed all storage buckets." end

 using Google.Cloud.Language.V1; using System;  public class UseApiKeySample {     public void AnalyzeSentiment(string apiKey)     {         LanguageServiceClient client = new LanguageServiceClientBuilder         {             ApiKey = apiKey         }.Build();          string text = "Hello, world!";          AnalyzeSentimentResponse response = client.AnalyzeSentiment(Document.FromPlainText(text));         Console.WriteLine($"Text: {text}");         Sentiment sentiment = response.DocumentSentiment;         Console.WriteLine($"Sentiment: {sentiment.Score}, {sentiment.Magnitude}");         Console.WriteLine("Successfully authenticated using the API key");     } } 

#include "google/cloud/language/v1/language_client.h" #include "google/cloud/credentials.h" #include "google/cloud/options.h"  void AuthenticateWithApiKey(std::vector<std::string> const& argv) {   if (argv.size() != 2) {     throw google::cloud::testing_util::Usage{         "authenticate-with-api-key <project-id> <api-key>"};   }   namespace gc = ::google::cloud;   auto options = gc::Options{}.set<gc::UnifiedCredentialsOption>(       gc::MakeApiKeyCredentials(argv[1]));   auto client = gc::language_v1::LanguageServiceClient(       gc::language_v1::MakeLanguageServiceConnection(options));    auto constexpr kText = "Hello, world!";    google::cloud::language::v1::Document d;   d.set_content(kText);   d.set_type(google::cloud::language::v1::Document::PLAIN_TEXT);    auto response = client.AnalyzeSentiment(d, {});   if (!response) throw std::move(response.status());   auto const& sentiment = response->document_sentiment();   std::cout << "Text: " << kText << "\n";   std::cout << "Sentiment: " << sentiment.score() << ", "             << sentiment.magnitude() << "\n";   std::cout << "Successfully authenticated using the API key\n"; }

import ( 	"context" 	"fmt" 	"io"  	language "cloud.google.com/go/language/apiv1" 	"cloud.google.com/go/language/apiv1/languagepb" 	"google.golang.org/api/option" )  // authenticateWithAPIKey authenticates with an API key for Google Language // service. func authenticateWithAPIKey(w io.Writer, apiKey string) error { 	// apiKey := "api-key-string"  	ctx := context.Background()  	// Initialize the Language Service client and set the API key. 	client, err := language.NewClient(ctx, option.WithAPIKey(apiKey)) 	if err != nil { 		return fmt.Errorf("NewClient: %w", err) 	} 	defer client.Close()  	text := "Hello, world!" 	// Make a request to analyze the sentiment of the text. 	res, err := client.AnalyzeSentiment(ctx, &languagepb.AnalyzeSentimentRequest{ 		Document: &languagepb.Document{ 			Source: &languagepb.Document_Content{ 				Content: text, 			}, 			Type: languagepb.Document_PLAIN_TEXT, 		}, 	}) 	if err != nil { 		return fmt.Errorf("AnalyzeSentiment: %w", err) 	}  	fmt.Fprintf(w, "Text: %s\n", text) 	fmt.Fprintf(w, "Sentiment score: %v\n", res.DocumentSentiment.Score) 	fmt.Fprintln(w, "Successfully authenticated using the API key.")  	return nil } 

 const {   v1: {LanguageServiceClient}, } = require('@google-cloud/language');  /**  * Authenticates with an API key for Google Language service.  *  * @param {string} apiKey An API Key to use  */ async function authenticateWithAPIKey(apiKey) {   const language = new LanguageServiceClient({apiKey});    // Alternatively:   // const {GoogleAuth} = require('google-auth-library');   // const auth = new GoogleAuth({apiKey});   // const language = new LanguageServiceClient({auth});    const text = 'Hello, world!';    const [response] = await language.analyzeSentiment({     document: {       content: text,       type: 'PLAIN_TEXT',     },   });    console.log(`Text: ${text}`);   console.log(     `Sentiment: ${response.documentSentiment.score}, ${response.documentSentiment.magnitude}`,   );   console.log('Successfully authenticated using the API key'); }  authenticateWithAPIKey();

 from google.cloud import language_v1   def authenticate_with_api_key(api_key_string: str) -> None:     """     Authenticates with an API key for Google Language service.      TODO(Developer): Replace this variable before running the sample.      Args:         api_key_string: The API key to authenticate to the service.     """      # Initialize the Language Service client and set the API key     client = language_v1.LanguageServiceClient(         client_options={"api_key": api_key_string}     )      text = "Hello, world!"     document = language_v1.Document(         content=text, type_=language_v1.Document.Type.PLAIN_TEXT     )      # Make a request to analyze the sentiment of the text.     sentiment = client.analyze_sentiment(         request={"document": document}     ).document_sentiment      print(f"Text: {text}")     print(f"Sentiment: {sentiment.score}, {sentiment.magnitude}")     print("Successfully authenticated using the API key")