Upload objects from a file system

namespacegcs=::google::cloud::storage;
using::google::cloud::StatusOr;
[](gcs::Clientclient,std::stringconst&file_name,
std::stringconst&bucket_name,std::stringconst&object_name){
// Note that the client library automatically computes a hash on the
// client-side to verify data integrity during transmission.
StatusOr<gcs::ObjectMetadata>metadata=client.UploadFile(
file_name,bucket_name,object_name,gcs::IfGenerationMatch(0));
if(!metadata)throwstd::move(metadata).status();
std::cout << "Uploaded " << file_name << " to object " << metadata->name()
 << " in bucket " << metadata->bucket()
 << "\nFull metadata: " << *metadata << "\n";
}

usingGoogle.Cloud.Storage.V1 ;
usingSystem;
usingSystem.IO;
publicclassUploadFileSample
{
publicvoidUploadFile(
stringbucketName="your-unique-bucket-name",
stringlocalPath="my-local-path/my-file-name",
stringobjectName="my-file-name")
{
varstorage=StorageClient .Create ();
usingvarfileStream=File.OpenRead(localPath);
storage.UploadObject(bucketName,objectName,null,fileStream);
Console.WriteLine($"Uploaded {objectName}.");
}
}

import(
"context"
"fmt"
"io"
"os"
"time"
"cloud.google.com/go/storage"
)
// uploadFile uploads an object.
funcuploadFile(wio.Writer ,bucket,objectstring)error{
// bucket := "bucket-name"
// object := "object-name"
ctx:=context.Background()
client,err:=storage.NewClient(ctx)
iferr!=nil{
returnfmt.Errorf("storage.NewClient: %w",err)
}
deferclient.Close()
// Open local file.
f,err:=os.Open("notes.txt")
iferr!=nil{
returnfmt.Errorf("os.Open: %w",err)
}
deferf.Close()
ctx,cancel:=context.WithTimeout(ctx,time.Second*50)
defercancel()
o:=client.Bucket (bucket).Object (object)
// Optional: set a generation-match precondition to avoid potential race
// conditions and data corruptions. The request to upload is aborted if the
// object's generation number does not match your precondition.
// For an object that does not yet exist, set the DoesNotExist precondition.
o=o.If(storage.Conditions {DoesNotExist:true})
// If the live object already exists in your bucket, set instead a
// generation-match precondition using the live object's generation number.
// attrs, err := o.Attrs(ctx)
// if err != nil {
// 	return fmt.Errorf("object.Attrs: %w", err)
// }
// o = o.If(storage.Conditions{GenerationMatch: attrs.Generation})
// Upload an object with storage.Writer.
wc:=o.NewWriter (ctx)
if_,err=io.Copy(wc,f);err!=nil{
returnfmt.Errorf("io.Copy: %w",err)
}
iferr:=wc.Close();err!=nil{
returnfmt.Errorf("Writer.Close: %w",err)
}
fmt.Fprintf(w,"Blob %v uploaded.\n",object)
returnnil
}

importcom.google.cloud.storage.BlobId ;
importcom.google.cloud.storage.BlobInfo ;
importcom.google.cloud.storage.Storage ;
importcom.google.cloud.storage.StorageOptions ;
importjava.io.IOException;
importjava.nio.file.Paths;
publicclass UploadObject{
publicstaticvoiduploadObject(
StringprojectId,StringbucketName,StringobjectName,StringfilePath)throwsIOException{
// The ID of your GCP project
// String projectId = "your-project-id";
// The ID of your GCS bucket
// String bucketName = "your-unique-bucket-name";
// The ID of your GCS object
// String objectName = "your-object-name";
// The path to your file to upload
// String filePath = "path/to/your/file"
Storage storage=StorageOptions .newBuilder().setProjectId(projectId).build().getService ();
BlobId blobId=BlobId .of(bucketName,objectName);
BlobInfo blobInfo=BlobInfo .newBuilder(blobId).build();
// Optional: set a generation-match precondition to avoid potential race
// conditions and data corruptions. The request returns a 412 error if the
// preconditions are not met.
Storage .BlobWriteOptionprecondition;
if(storage.get (bucketName,objectName)==null){
// For a target object that does not yet exist, set the DoesNotExist precondition.
// This will cause the request to fail if the object is created before the request runs.
precondition=Storage .BlobWriteOption.doesNotExist();
}else{
// If the destination already exists in your bucket, instead set a generation-match
// precondition. This will cause the request to fail if the existing object's generation
// changes before the request runs.
precondition=
Storage .BlobWriteOption.generationMatch(
storage.get (bucketName,objectName).getGeneration());
}
storage.createFrom (blobInfo,Paths.get(filePath),precondition);
System.out.println(
"File "+filePath+" uploaded to bucket "+bucketName+" as "+objectName);
}
}

importcom.google.cloud.storage.transfermanager.ParallelUploadConfig ;
importcom.google.cloud.storage.transfermanager.TransferManager ;
importcom.google.cloud.storage.transfermanager.TransferManagerConfig ;
importcom.google.cloud.storage.transfermanager.UploadResult ;
importjava.io.IOException;
importjava.nio.file.Path;
importjava.util.List;
class UploadMany{
publicstaticvoiduploadManyFiles(StringbucketName,List<Path>files)throwsIOException{
TransferManager transferManager=TransferManagerConfig .newBuilder().build().getService ();
ParallelUploadConfig parallelUploadConfig=
ParallelUploadConfig .newBuilder().setBucketName(bucketName).build();
List<UploadResult>results=
transferManager.uploadFiles (files,parallelUploadConfig).getUploadResults ();
for(UploadResult result:results){
System.out.println(
"Upload for "
+result.getInput().getName()
+" completed with status "
+result.getStatus());
}
}
}

importcom.google.cloud.storage.transfermanager.ParallelUploadConfig ;
importcom.google.cloud.storage.transfermanager.TransferManager ;
importcom.google.cloud.storage.transfermanager.TransferManagerConfig ;
importcom.google.cloud.storage.transfermanager.UploadResult ;
importjava.io.IOException;
importjava.nio.file.Files;
importjava.nio.file.Path;
importjava.util.ArrayList;
importjava.util.List;
importjava.util.stream.Stream;
class UploadDirectory{
publicstaticvoiduploadDirectoryContents(StringbucketName,PathsourceDirectory)
throwsIOException{
TransferManager transferManager=TransferManagerConfig .newBuilder().build().getService ();
ParallelUploadConfig parallelUploadConfig=
ParallelUploadConfig .newBuilder().setBucketName(bucketName).build();
// Create a list to store the file paths
List<Path>filePaths=newArrayList<>();
// Get all files in the directory
// try-with-resource to ensure pathStream is closed
try(Stream<Path>pathStream=Files.walk(sourceDirectory)){
pathStream.filter(Files::isRegularFile).forEach(filePaths::add);
}
List<UploadResult>results=
transferManager.uploadFiles (filePaths,parallelUploadConfig).getUploadResults ();
for(UploadResult result:results){
System.out.println(
"Upload for "
+result.getInput().getName()
+" completed with status "
+result.getStatus());
}
}
}

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';
// The path to your file to upload
// const filePath = 'path/to/your/file';
// The new ID for your GCS file
// const destFileName = 'your-new-file-name';
// Imports the Google Cloud client library
const{Storage}=require('@google-cloud/storage');
// Creates a client
conststorage=newStorage();
asyncfunctionuploadFile(){
constoptions={
destination:destFileName,
// Optional:
// Set a generation-match precondition to avoid potential race conditions
// and data corruptions. The request to upload is aborted if the object's
// generation number does not match your precondition. For a destination
// object that does not yet exist, set the ifGenerationMatch precondition to 0
// If the destination object already exists in your bucket, set instead a
// generation-match precondition using its generation number.
preconditionOpts:{ifGenerationMatch:generationMatchPrecondition},
};
awaitstorage.bucket(bucketName).upload (filePath,options);
console.log(`${filePath} uploaded to ${bucketName}`);
}
uploadFile().catch(console.error);

/**
 * 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 the first GCS file to upload
// const firstFilePath = 'your-first-file-name';
// The ID of the second GCS file to upload
// const secondFilePath = 'your-second-file-name';
// Imports the Google Cloud client library
const{Storage,TransferManager}=require('@google-cloud/storage');
// Creates a client
conststorage=newStorage();
// Creates a transfer manager client
consttransferManager=newTransferManager (storage.bucket(bucketName));
asyncfunctionuploadManyFilesWithTransferManager(){
// Uploads the files
awaittransferManager.uploadManyFiles ([firstFilePath,secondFilePath]);
for(constfilePathof[firstFilePath,secondFilePath]){
console.log(`${filePath} uploaded to ${bucketName}.`);
}
}
uploadManyFilesWithTransferManager().catch(console.error);

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';
// The local directory to upload
// const directoryName = 'your-directory';
// Imports the Google Cloud client library
const{Storage,TransferManager}=require('@google-cloud/storage');
// Creates a client
conststorage=newStorage();
// Creates a transfer manager client
consttransferManager=newTransferManager (storage.bucket(bucketName));
asyncfunctionuploadDirectoryWithTransferManager(){
// Uploads the directory
awaittransferManager.uploadManyFiles (directoryName);
console.log(`${directoryName} uploaded to ${bucketName}.`);
}
uploadDirectoryWithTransferManager().catch(console.error);

use Google\Cloud\Storage\StorageClient;
/**
 * Upload a file.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 * (e.g. 'my-bucket')
 * @param string $objectName The name of your Cloud Storage object.
 * (e.g. 'my-object')
 * @param string $source The path to the file to upload.
 * (e.g. '/path/to/your/file')
 */
function upload_object(string $bucketName, string $objectName, string $source): void
{
 $storage = new StorageClient();
 if (!$file = fopen($source, 'r')) {
 throw new \InvalidArgumentException('Unable to open file for reading');
 }
 $bucket = $storage->bucket($bucketName);
 $object = $bucket->upload($file, [
 'name' => $objectName
 ]);
 printf('Uploaded %s to gs://%s/%s' . PHP_EOL, basename($source), $bucketName, $objectName);
}

fromgoogle.cloudimport storage
defupload_blob(bucket_name, source_file_name, destination_blob_name):
"""Uploads a file to the bucket."""
 # The ID of your GCS bucket
 # bucket_name = "your-bucket-name"
 # The path to your file to upload
 # source_file_name = "local/path/to/file"
 # The ID of your GCS object
 # destination_blob_name = "storage-object-name"
 storage_client = storage .Client ()
 bucket = storage_client.bucket (bucket_name)
 blob = bucket.blob(destination_blob_name)
 # Optional: set a generation-match precondition to avoid potential race conditions
 # and data corruptions. The request to upload is aborted if the object's
 # generation number does not match your precondition. For a destination
 # object that does not yet exist, set the if_generation_match precondition to 0.
 # If the destination object already exists in your bucket, set instead a
 # generation-match precondition using its generation number.
 generation_match_precondition = 0
 blob.upload_from_filename (source_file_name, if_generation_match=generation_match_precondition)
 print(
 f"File {source_file_name} uploaded to {destination_blob_name}."
 )

defupload_many_blobs_with_transfer_manager(
 bucket_name, filenames, source_directory="", workers=8
):
"""Upload every file in a list to a bucket, concurrently in a process pool.
 Each blob name is derived from the filename, not including the
 `source_directory` parameter. For complete control of the blob name for each
 file (and other aspects of individual blob metadata), use
 transfer_manager.upload_many() instead.
 """
 # The ID of your GCS bucket
 # bucket_name = "your-bucket-name"
 # A list (or other iterable) of filenames to upload.
 # filenames = ["file_1.txt", "file_2.txt"]
 # The directory on your computer that is the root of all of the files in the
 # list of filenames. This string is prepended (with os.path.join()) to each
 # filename to get the full path to the file. Relative paths and absolute
 # paths are both accepted. This string is not included in the name of the
 # uploaded blob; it is only used to find the source files. An empty string
 # means "the current working directory". Note that this parameter allows
 # directory traversal (e.g. "/", "../") and is not intended for unsanitized
 # end user input.
 # source_directory=""
 # The maximum number of processes to use for the operation. The performance
 # impact of this value depends on the use case, but smaller files usually
 # benefit from a higher number of processes. Each additional process occupies
 # some CPU and memory resources until finished. Threads can be used instead
 # of processes by passing `worker_type=transfer_manager.THREAD`.
 # workers=8
 fromgoogle.cloud.storageimport Client , transfer_manager
 storage_client = Client()
 bucket = storage_client.bucket (bucket_name)
 results = transfer_manager .upload_many_from_filenames (
 bucket, filenames, source_directory=source_directory, max_workers=workers
 )
 for name, result in zip(filenames, results):
 # The results list is either `None` or an exception for each filename in
 # the input list, in order.
 if isinstance(result, Exception):
 print("Failed to upload {} due to exception: {}".format(name, result))
 else:
 print("Uploaded {} to {}.".format(name, bucket.name))

defupload_directory_with_transfer_manager(bucket_name, source_directory, workers=8):
"""Upload every file in a directory, including all files in subdirectories.
 Each blob name is derived from the filename, not including the `directory`
 parameter itself. For complete control of the blob name for each file (and
 other aspects of individual blob metadata), use
 transfer_manager.upload_many() instead.
 """
 # The ID of your GCS bucket
 # bucket_name = "your-bucket-name"
 # The directory on your computer to upload. Files in the directory and its
 # subdirectories will be uploaded. An empty string means "the current
 # working directory".
 # source_directory=""
 # The maximum number of processes to use for the operation. The performance
 # impact of this value depends on the use case, but smaller files usually
 # benefit from a higher number of processes. Each additional process occupies
 # some CPU and memory resources until finished. Threads can be used instead
 # of processes by passing `worker_type=transfer_manager.THREAD`.
 # workers=8
 frompathlibimport Path
 fromgoogle.cloud.storageimport Client , transfer_manager
 storage_client = Client()
 bucket = storage_client.bucket (bucket_name)
 # Generate a list of paths (in string form) relative to the `directory`.
 # This can be done in a single list comprehension, but is expanded into
 # multiple lines here for clarity.
 # First, recursively get all files in `directory` as Path objects.
 directory_as_path_obj = Path(source_directory)
 paths = directory_as_path_obj.rglob("*")
 # Filter so the list only includes files, not directories themselves.
 file_paths = [path for path in paths if path.is_file()]
 # These paths are relative to the current working directory. Next, make them
 # relative to `directory`
 relative_paths = [path.relative_to(source_directory) for path in file_paths]
 # Finally, convert them all to strings.
 string_paths = [str(path) for path in relative_paths]
 print("Found {} files.".format(len(string_paths)))
 # Start the upload.
 results = transfer_manager .upload_many_from_filenames (
 bucket, string_paths, source_directory=source_directory, max_workers=workers
 )
 for name, result in zip(string_paths, results):
 # The results list is either `None` or an exception for each filename in
 # the input list, in order.
 if isinstance(result, Exception):
 print("Failed to upload {} due to exception: {}".format(name, result))
 else:
 print("Uploaded {} to {}.".format(name, bucket.name))

defupload_filebucket_name:,local_file_path:,file_name:nil
# The ID of your GCS bucket
# bucket_name = "your-unique-bucket-name"
# The path to your file to upload
# local_file_path = "/local/path/to/file.txt"
# The ID of your GCS object
# file_name = "your-file-name"
require"google/cloud/storage"
storage=Google::Cloud::Storage .new
bucket=storage.bucketbucket_name,skip_lookup:true
file=bucket.create_file local_file_path,file_name
puts"Uploaded #{local_file_path} as #{file.name} in bucket #{bucket_name}"
end