Use API keys to access APIs

usingGoogle.Cloud.Language.V1;
usingSystem;
publicclassUseApiKeySample
{
publicvoidAnalyzeSentiment(stringapiKey)
{
LanguageServiceClientclient=newLanguageServiceClientBuilder
{
ApiKey=apiKey
}.Build();
stringtext="Hello, world!";
AnalyzeSentimentResponseresponse=client.AnalyzeSentiment(Document.FromPlainText(text));
Console.WriteLine($"Text: {text}");
Sentimentsentiment=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"
voidAuthenticateWithApiKey(std::vector<std::string>const&argv){
if(argv.size()!=2){
throwgoogle::cloud::testing_util::Usage{
"authenticate-with-api-key <project-id> <api-key>"};
}
namespacegc=::google::cloud;
autooptions=gc::Options{}.set<gc::UnifiedCredentialsOption>(
gc::MakeApiKeyCredentials(argv[1]));
autoclient=gc::language_v1::LanguageServiceClient(
gc::language_v1::MakeLanguageServiceConnection(options));
autoconstexprkText="Hello, world!";
google::cloud::language::v1::Documentd;
d.set_content(kText);
d.set_type(google::cloud::language::v1::Document::PLAIN_TEXT);
autoresponse=client.AnalyzeSentiment(d,{});
if(!response)throwstd::move(response.status());
autoconst&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.
funcauthenticateWithAPIKey(wio.Writer,apiKeystring)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))
iferr!=nil{
returnfmt.Errorf("NewClient: %w",err)
}
deferclient.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 ,
},
})
iferr!=nil{
returnfmt.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.")
returnnil
}

const{
v1:{LanguageServiceClient},
}=require('@google-cloud/language');
/**
 * Authenticates with an API key for Google Language service.
 *
 * @param {string} apiKey An API Key to use
 */
asyncfunctionauthenticateWithAPIKey(apiKey){
constlanguage=newLanguageServiceClient ({apiKey});
// Alternatively:
// const {GoogleAuth} = require('google-auth-library');
// const auth = new GoogleAuth({apiKey});
// const language = new LanguageServiceClient({auth});
consttext='Hello, world!';
const[response]=awaitlanguage.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();

fromgoogle.cloudimport language_v1
defauthenticate_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")

require"googleauth"
require"google/cloud/language/v1"
defauthenticate_with_api_keyapi_key_string
# Authenticates with an API key for Google Language service.
#
# TODO(Developer): Uncomment the following line and set the value before running this sample.
#
# api_key_string = "mykey12345"
#
# Note: You can also set the API key via environment variable:
# export GOOGLE_API_KEY=your-api-key
# and use Google::Auth::APIKeyCredentials.from_env method to load it.
# Example:
# credentials = Google::Auth::APIKeyCredentials.from_env
# if credentials.nil?
# puts "No API key found in environment"
# exit
# end
# Initialize API key credentials using the class factory method
credentials=Google::Auth::APIKeyCredentials .make_creds api_key:api_key_string
# Initialize the Language Service client with the API key credentials
client=Google::Cloud::Language::V1::LanguageService::Client.newdo|config|
config.credentials=credentials
end
# Create a document to analyze
text="Hello, world!"
document={
content:text,
type::PLAIN_TEXT
}
# Make a request to analyze the sentiment of the text
sentiment=client.analyze_sentiment(document:document).document_sentiment
puts"Text: #{text}"
puts"Sentiment: #{sentiment.score}, #{sentiment.magnitude}"
puts"Successfully authenticated using the API key"
end