Carregue objetos a partir de um sistema de ficheiros

namespace gcs = ::google::cloud::storage; using ::google::cloud::StatusOr; [](gcs::Client client, std::string const& file_name,    std::string const& bucket_name, std::string const& 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) throw std::move(metadata).status();    std::cout << "Uploaded " << file_name << " to object " << metadata->name()             << " in bucket " << metadata->bucket()             << "\nFull metadata: " << *metadata << "\n"; }

 using Google.Cloud.Storage.V1; using System; using System.IO;  public class UploadFileSample {     public void UploadFile(         string bucketName = "your-unique-bucket-name",         string localPath = "my-local-path/my-file-name",         string objectName = "my-file-name")     {         var storage = StorageClient.Create();         using var fileStream = 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. func uploadFile(w io.Writer, bucket, object string) error { 	// bucket := "bucket-name" 	// object := "object-name" 	ctx := context.Background() 	client, err := storage.NewClient(ctx) 	if err != nil { 		return fmt.Errorf("storage.NewClient: %w", err) 	} 	defer client.Close()  	// Open local file. 	f, err := os.Open("notes.txt") 	if err != nil { 		return fmt.Errorf("os.Open: %w", err) 	} 	defer f.Close()  	ctx, cancel := context.WithTimeout(ctx, time.Second*50) 	defer cancel()  	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 { 		return fmt.Errorf("io.Copy: %w", err) 	} 	if err := wc.Close(); err != nil { 		return fmt.Errorf("Writer.Close: %w", err) 	} 	fmt.Fprintf(w, "Blob %v uploaded.\n", object) 	return nil } 

 import com.google.cloud.storage.BlobId; import com.google.cloud.storage.BlobInfo; import com.google.cloud.storage.Storage; import com.google.cloud.storage.StorageOptions; import java.io.IOException; import java.nio.file.Paths;  public class UploadObject {   public static void uploadObject(       String projectId, String bucketName, String objectName, String filePath) throws IOException {     // 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.BlobWriteOption precondition;     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);   } }

import com.google.cloud.storage.transfermanager.ParallelUploadConfig; import com.google.cloud.storage.transfermanager.TransferManager; import com.google.cloud.storage.transfermanager.TransferManagerConfig; import com.google.cloud.storage.transfermanager.UploadResult; import java.io.IOException; import java.nio.file.Path; import java.util.List;  class UploadMany {    public static void uploadManyFiles(String bucketName, List<Path> files) throws IOException {     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());     }   } }

import com.google.cloud.storage.transfermanager.ParallelUploadConfig; import com.google.cloud.storage.transfermanager.TransferManager; import com.google.cloud.storage.transfermanager.TransferManagerConfig; import com.google.cloud.storage.transfermanager.UploadResult; import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; import java.util.ArrayList; import java.util.List; import java.util.stream.Stream;  class UploadDirectory {    public static void uploadDirectoryContents(String bucketName, Path sourceDirectory)       throws IOException {     TransferManager transferManager = TransferManagerConfig.newBuilder().build().getService();     ParallelUploadConfig parallelUploadConfig =         ParallelUploadConfig.newBuilder().setBucketName(bucketName).build();      // Create a list to store the file paths     List<Path> filePaths = new ArrayList<>();     // 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 const storage = new Storage();  async function uploadFile() {   const options = {     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},   };    await storage.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 const storage = new Storage();  // Creates a transfer manager client const transferManager = new TransferManager(storage.bucket(bucketName));  async function uploadManyFilesWithTransferManager() {   // Uploads the files   await transferManager.uploadManyFiles([firstFilePath, secondFilePath]);    for (const filePath of [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 const storage = new Storage();  // Creates a transfer manager client const transferManager = new TransferManager(storage.bucket(bucketName));  async function uploadDirectoryWithTransferManager() {   // Uploads the directory   await transferManager.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); }

from google.cloud import storage   def upload_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}."     )  

def upload_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      from google.cloud.storage import 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))

def upload_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      from pathlib import Path      from google.cloud.storage import 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))

def upload_file bucket_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.bucket bucket_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