Access public data

namespacegcs=::google::cloud::storage;
[](std::stringconst&bucket_name,std::stringconst&object_name){
// Create a client that does not authenticate with the server.
autoclient=gcs::Client{
google::cloud::Options{}.set<google::cloud::UnifiedCredentialsOption>(
google::cloud::MakeInsecureCredentials())};
// Read an object, the object must have been made public.
gcs::ObjectReadStreamstream=client.ReadObject(bucket_name,object_name);
intcount=0;
std::stringline;
while(std::getline(stream,line,'\n')){
++count;
}
if(stream.bad())throwgoogle::cloud::Status(stream.status());
std::cout << "The object has " << count << " lines\n";
}

usingGoogle.Cloud.Storage.V1 ;
usingSystem;
usingSystem.IO;
publicclassDownloadPublicFileSample
{
publicstringDownloadPublicFile(
stringbucketName="your-bucket-name",
stringobjectName="your-object-name",
stringlocalPath="path/to/download/object/to")
{
varstorage=StorageClient .CreateUnauthenticated ();
usingvaroutputFile=File.OpenWrite(localPath);
storage.DownloadObject(bucketName,objectName,outputFile);
Console.WriteLine($"Downloaded public file {objectName} from bucket {bucketName} to {localPath}.");
returnlocalPath;
}
}

import(
"context"
"fmt"
"io"
"time"
"cloud.google.com/go/storage"
"google.golang.org/api/option"
)
// downloadPublicFile downloads a public object.
funcdownloadPublicFile(wio.Writer ,bucket,objectstring)([]byte,error){
// bucket := "bucket-name"
// object := "object-name"
ctx:=context.Background()
// Create a client that does not authenticate with the server.
client,err:=storage.NewClient(ctx,option.WithoutAuthentication())
iferr!=nil{
returnnil,fmt.Errorf("storage.NewClient: %w",err)
}
deferclient.Close()
ctx,cancel:=context.WithTimeout(ctx,time.Second*50)
defercancel()
rc,err:=client.Bucket (bucket).Object (object).NewReader (ctx)
iferr!=nil{
returnnil,fmt.Errorf("Object(%q).NewReader: %w",object,err)
}
deferrc.Close()
data,err:=io.ReadAll(rc)
iferr!=nil{
returnnil,fmt.Errorf("io.ReadAll: %w",err)
}
fmt.Fprintf(w,"Blob %v downloaded.\n",object)
returndata,nil
}

importcom.google.cloud.storage.BlobId ;
importcom.google.cloud.storage.Storage ;
importcom.google.cloud.storage.StorageOptions ;
importjava.nio.file.Path;
publicclass DownloadPublicObject{
publicstaticvoiddownloadPublicObject(
StringbucketName,StringpublicObjectName,PathdestFilePath){
// The name of the bucket to access
// String bucketName = "my-bucket";
// The name of the remote public file to download
// String publicObjectName = "publicfile.txt";
// The path to which the file should be downloaded
// Path destFilePath = Paths.get("/local/path/to/file.txt");
// Instantiate an anonymous Google Cloud Storage client, which can only access public files
Storage storage=StorageOptions .getUnauthenticatedInstance ().getService ();
storage.downloadTo (BlobId.of(bucketName,publicObjectName),destFilePath);
System.out.println(
"Downloaded public object "
+publicObjectName
+" from bucket name "
+bucketName
+" to "
+destFilePath);
}
}

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';
// The ID of your GCS file
// const srcFilename = 'your-file-name';
// The path to which the file should be downloaded
// const destFileName = '/local/path/to/file.txt';
// Imports the Google Cloud client library
const{Storage}=require('@google-cloud/storage');
// Creates a client
conststorage=newStorage();
asyncfunctiondownloadPublicFile(){
constoptions={
destination:destFileName,
};
// Download public file.
awaitstorage.bucket(bucketName).file(srcFileName).download (options);
console.log(
`Downloaded public file ${srcFileName} from bucket name ${bucketName} to ${destFileName}`
);
}
downloadPublicFile().catch(console.error);

fromgoogle.cloudimport storage
defdownload_public_file(bucket_name, source_blob_name, destination_file_name):
"""Downloads a public blob from the bucket."""
 # bucket_name = "your-bucket-name"
 # source_blob_name = "storage-object-name"
 # destination_file_name = "local/path/to/file"
 storage_client = storage .Client .create_anonymous_client ()
 bucket = storage_client.bucket(bucket_name)
 blob = bucket.blob(source_blob_name)
 blob.download_to_filename (destination_file_name)
 print(
 "Downloaded public blob {} from bucket {} to {}.".format(
 source_blob_name, bucket.name, destination_file_name
 )
 )

defdownload_public_filebucket_name:,file_name:,local_file_path:
# The name of the bucket to access
# bucket_name = "my-bucket"
# The name of the remote public file to download
# file_name = "publicfile.txt"
# The path to which the file should be downloaded
# local_file_path = "/local/path/to/file.txt"
require"google/cloud/storage"
storage=Google::Cloud::Storage .anonymous
bucket=storage.bucketbucket_name,skip_lookup:true
file=bucket.file file_name
file.download local_file_path
puts"Downloaded public object #{file.name} from bucket #{bucket} to #{local_file_path}"
end