Interface StorageGrpc.AsyncService (2.62.0)

API Overview and Naming Syntax

The Cloud Storage gRPC API allows applications to read and write data through the abstractions of buckets and objects. For a description of these abstractions please see Cloud Storage documentation. Resources are named as follows:

• Projects are referred to as they are defined by the Resource Manager API, using strings like projects/123456 or projects/my-string-id.
• Buckets are named using string names of the form: projects/{project}/buckets/{bucket}. For globally unique buckets, _ might be substituted for the project.
• Objects are uniquely identified by their name along with the name of the bucket they belong to, as separate strings in this API. For example: <code><code> ReadObjectRequest { bucket: 'projects/_/buckets/my-bucket' object: 'my-object' } </code></code><code> Note that object names can contain </code>/ characters, which are treated as any other character (no special directory semantics).

Reads an object's data. This bi-directional API reads data from an object, allowing you to request multiple data ranges within a single stream, even across several messages. If an error occurs with any request, the stream closes with a relevant error code. Since you can have multiple outstanding requests, the error response includes a BidiReadObjectRangesError field detailing the specific error for each pending read_id. IAM Permissions: Requires storage.objects.get IAM permission on the bucket.

Stores a new object and metadata. This is similar to the WriteObject call with the added support for manual flushing of persisted state, and the ability to determine current persisted size without closing the stream. The client might specify one or both of the state_lookup and flush fields in each BidiWriteObjectRequest. If flush is specified, the data written so far is persisted to storage. If state_lookup is specified, the service responds with a BidiWriteObjectResponse that contains the persisted size. If both flush and state_lookup are specified, the flush always occurs before a state_lookup, so that both might be set in the same request and the returned state is the state of the object post-flush. When the stream is closed, a BidiWriteObjectResponse is always sent to the client, regardless of the value of state_lookup.

Cancels an in-progress resumable upload. Any attempts to write to the resumable upload after cancelling the upload fail. The behavior for any in-progress write operations is not guaranteed; they could either complete before the cancellation or fail if the cancellation completes first.

Concatenates a list of existing objects into a new object in the same bucket. The existing source objects are unaffected by this operation. IAM Permissions: Requires the storage.objects.create and storage.objects.get IAM permissions to use this method. If the new composite object overwrites an existing object, the authenticated user must also have the storage.objects.delete permission. If the request body includes the retention property, the authenticated user must also have the storage.objects.setRetention IAM permission.

Creates a new bucket. IAM Permissions: Requires storage.buckets.create IAM permission on the bucket. Additionally, to enable specific bucket features, the authenticated user must have the following permissions:

• To enable object retention using the enableObjectRetention query parameter: storage.buckets.enableObjectRetention
• To set the bucket IP filtering rules: storage.buckets.setIpFilter

Permanently deletes an empty bucket. The request fails if there are any live or noncurrent objects in the bucket, but the request succeeds if the bucket only contains soft-deleted objects or incomplete uploads, such as ongoing XML API multipart uploads. Does not permanently delete soft-deleted objects. When this API is used to delete a bucket containing an object that has a soft delete policy enabled, the object becomes soft deleted, and the softDeleteTime and hardDeleteTime properties are set on the object. Objects and multipart uploads that were in the bucket at the time of deletion are also retained for the specified retention duration. When a soft-deleted bucket reaches the end of its retention duration, it is permanently deleted. The hardDeleteTime of the bucket always equals or exceeds the expiration time of the last soft-deleted object in the bucket. IAM Permissions: Requires storage.buckets.delete IAM permission on the bucket.

Deletes an object and its metadata. Deletions are permanent if versioning is not enabled for the bucket, or if the generation parameter is used, or if soft delete is not enabled for the bucket. When this API is used to delete an object from a bucket that has soft delete policy enabled, the object becomes soft deleted, and the softDeleteTime and hardDeleteTime properties are set on the object. This API cannot be used to permanently delete soft-deleted objects. Soft-deleted objects are permanently deleted according to their hardDeleteTime. You can use the RestoreObject API to restore soft-deleted objects until the soft delete retention period has passed. IAM Permissions: Requires storage.objects.delete IAM permission on the bucket.

Returns metadata for the specified bucket. IAM Permissions: Requires storage.buckets.get IAM permission on the bucket. Additionally, to return specific bucket metadata, the authenticated user must have the following permissions:

• To return the IAM policies: storage.buckets.getIamPolicy
• To return the bucket IP filtering rules: storage.buckets.getIpFilter

Gets the IAM policy for a specified bucket or managed folder. The resource field in the request should be projects//buckets/{bucket} for a bucket, or projects//buckets/{bucket}/managedFolders/{managedFolder} for a managed folder. IAM Permissions: Requires storage.buckets.getIamPolicy on the bucket or storage.managedFolders.getIamPolicy IAM permission on the managed folder.

Retrieves object metadata. IAM Permissions: Requires storage.objects.get IAM permission on the bucket. To return object ACLs, the authenticated user must also have the storage.objects.getIamPolicy permission.

Retrieves a list of buckets for a given project, ordered lexicographically by name. IAM Permissions: Requires storage.buckets.list IAM permission on the bucket. Additionally, to enable specific bucket features, the authenticated user must have the following permissions:

• To list the IAM policies: storage.buckets.getIamPolicy
• To list the bucket IP filtering rules: storage.buckets.getIpFilter

Retrieves a list of objects matching the criteria. IAM Permissions: The authenticated user requires storage.objects.list IAM permission to use this method. To return object ACLs, the authenticated user must also have the storage.objects.getIamPolicy permission.

Permanently locks the retention policy that is currently applied to the specified bucket. Caution: Locking a bucket is an irreversible action. Once you lock a bucket:

• You cannot remove the retention policy from the bucket.
• You cannot decrease the retention period for the policy. Once locked, you must delete the entire bucket in order to remove the bucket's retention policy. However, before you can delete the bucket, you must delete all the objects in the bucket, which is only possible if all the objects have reached the retention period set by the retention policy. IAM Permissions: Requires storage.buckets.update IAM permission on the bucket.

Moves the source object to the destination object in the same bucket. This operation moves a source object to a destination object in the same bucket by renaming the object. The move itself is an atomic transaction, ensuring all steps either complete successfully or no changes are made. IAM Permissions: Requires the following IAM permissions to use this method:

• storage.objects.move
• storage.objects.create
• storage.objects.delete (only required if overwriting an existing object)

Determines the persisted_size of an object that is being written. This method is part of the resumable upload feature. The returned value is the size of the object that has been persisted so far. The value can be used as the write_offset for the next Write() call. If the object does not exist, meaning if it was deleted, or the first Write() has not yet reached the service, this method returns the error NOT_FOUND. This method is useful for clients that buffer data and need to know which data can be safely evicted. The client can call QueryWriteStatus() at any time to determine how much data has been logged for this object. For any sequence of QueryWriteStatus() calls for a given object name, the sequence of returned persisted_size values are non-decreasing.

Retrieves object data. IAM Permissions: Requires storage.objects.get IAM permission on the bucket.

Restores a soft-deleted object. When a soft-deleted object is restored, a new copy of that object is created in the same bucket and inherits the same metadata as the soft-deleted object. The inherited metadata is the metadata that existed when the original object became soft deleted, with the following exceptions:

• The createTime of the new object is set to the time at which the soft-deleted object was restored.
• The softDeleteTime and hardDeleteTime values are cleared.
• A new generation is assigned and the metageneration is reset to 1.
• If the soft-deleted object was in a bucket that had Autoclass enabled, the new object is restored to Standard storage.
• The restored object inherits the bucket's default object ACL, unless copySourceAcl is true. If a live object using the same name already exists in the bucket and becomes overwritten, the live object becomes a noncurrent object if Object Versioning is enabled on the bucket. If Object Versioning is not enabled, the live object becomes soft deleted. IAM Permissions: Requires the following IAM permissions to use this method:
• storage.objects.restore
• storage.objects.create
• storage.objects.delete (only required if overwriting an existing object)
• storage.objects.getIamPolicy (only required if projection is full and the relevant bucket has uniform bucket-level access disabled)
• storage.objects.setIamPolicy (only required if copySourceAcl is true and the relevant bucket has uniform bucket-level access disabled)

Rewrites a source object to a destination object. Optionally overrides metadata.

Updates an IAM policy for the specified bucket or managed folder. The resource field in the request should be projects//buckets/{bucket} for a bucket, or projects//buckets/{bucket}/managedFolders/{managedFolder} for a managed folder.

Starts a resumable write operation. This method is part of the Resumable upload feature. This allows you to upload large objects in multiple chunks, which is more resilient to network interruptions than a single upload. The validity duration of the write operation, and the consequences of it becoming invalid, are service-dependent. IAM Permissions: Requires storage.objects.create IAM permission on the bucket.

Tests a set of permissions on the given bucket, object, or managed folder to see which, if any, are held by the caller. The resource field in the request should be projects//buckets/{bucket} for a bucket, projects//buckets/{bucket}/objects/{object} for an object, or projects/_/buckets/{bucket}/managedFolders/{managedFolder} for a managed folder.

Updates a bucket. Changes to the bucket are readable immediately after writing, but configuration changes might take time to propagate. This method supports patch semantics. IAM Permissions: Requires storage.buckets.update IAM permission on the bucket. Additionally, to enable specific bucket features, the authenticated user must have the following permissions:

• To set bucket IP filtering rules: storage.buckets.setIpFilter
• To update public access prevention policies or access control lists (ACLs): storage.buckets.setIamPolicy

Updates an object's metadata. Equivalent to JSON API's storage.objects.patch method. IAM Permissions: Requires storage.objects.update IAM permission on the bucket.

Stores a new object and metadata. An object can be written either in a single message stream or in a resumable sequence of message streams. To write using a single stream, the client should include in the first message of the stream an WriteObjectSpec describing the destination bucket, object, and any preconditions. Additionally, the final message must set 'finish_write' to true, or else it is an error. For a resumable write, the client should instead call StartResumableWrite(), populating a WriteObjectSpec into that request. They should then attach the returned upload_id to the first message of each following call to WriteObject. If the stream is closed before finishing the upload (either explicitly by the client or due to a network error or an error response from the server), the client should do as follows:

• Check the result Status of the stream, to determine if writing can be resumed on this stream or must be restarted from scratch (by calling StartResumableWrite()). The resumable errors are DEADLINE_EXCEEDED, INTERNAL, and UNAVAILABLE. For each case, the client should use binary exponential backoff before retrying. Additionally, writes can be resumed after RESOURCE_EXHAUSTED errors, but only after taking appropriate measures, which might include reducing aggregate send rate across clients and/or requesting a quota increase for your project.
• If the call to WriteObject returns ABORTED, that indicates concurrent attempts to update the resumable write, caused either by multiple racing clients or by a single client where the previous request was timed out on the client side but nonetheless reached the server. In this case the client should take steps to prevent further concurrent writes. For example, increase the timeouts and stop using more than one process to perform the upload. Follow the steps below for resuming the upload.
• For resumable errors, the client should call QueryWriteStatus() and then continue writing from the returned persisted_size. This might be less than the amount of data the client previously sent. Note also that it is acceptable to send data starting at an offset earlier than the returned persisted_size; in this case, the service skips data at offsets that were already persisted (without checking that it matches the previously written data), and write only the data starting from the persisted offset. Even though the data isn't written, it might still incur a performance cost over resuming at the correct write offset. This behavior can make client-side handling simpler in some cases.
• Clients must only send data that is a multiple of 256 KiB per message, unless the object is being finished with finish_write set to true. The service does not view the object as complete until the client has sent a WriteObjectRequest with finish_write set to true. Sending any requests on a stream after sending a request with finish_write set to true causes an error. The client must check the response it receives to determine how much data the service is able to commit and whether the service views the object as complete. Attempting to resume an already finalized object results in an OK status, with a WriteObjectResponse containing the finalized object's metadata. Alternatively, you can use the BidiWriteObject operation to write an object with controls over flushing and the ability to fetch the ability to determine the current persisted size. IAM Permissions: Requires storage.objects.create IAM permission on the bucket.