Connect to Cloud Storage using gRPC

C++

Before you begin

1. Ensure you have the following versions installed:

   • gRPC version 1.65.1 or later

   • C++ client library version v2.30.0 or later

   • C++ version 14 or later

   For installation instructions, see Setting up a C++ development environment .

2. Set up authentication .

3. Ensure each Compute Engine instance has a service account attached to it, even if the service account has no permissions. This service account is used to represent the Compute Engine instance in the Application Layer Transport Security (ALTS) handshake process and is required for direct connectivity .

Configure the C++ client library

1. Create a gRPC client using gcs::MakeGrpcClient() :

      
    namespace 
     
    gcs 
     
    = 
     
    google 
    :: 
    cloud 
    :: 
    storage 
    ; 
     
    void 
     
    App 
    () 
     
    { 
     
    auto 
     
    client 
     
    = 
     
    gcs 
    : 
    : 
    MakeGrpcClient 
    (); 
     
    // 
     
    application 
     
    code 
     
    } 
    
   

   The C++ client library automatically uses direct connectivity when it detects that the application is running on Google Cloud.

2. To configure the C++ client library to use gRPC, enable the Cloud Storage gRPC client to update your build system configuration for CMake or Bazel.

   CMake

   1. Enable the Cloud Storage gRPC client plugin at compile-time.

       cmake -DGOOGLE_CLOUD_CPP_ENABLE=storage_grpc [other options here] 
      

   2. In your codebase, for the target_link_libraries() command replace google-cloud-cpp::storage with google-cloud-cpp::storage_grpc

      For example, the quickstart program for gRPC uses the following code:

       add_executable(quickstart_grpc quickstart_grpc.cc)
      target_link_libraries(quickstart_grpc google-cloud-cpp::storage_grpc) 
      

   Bazel

   Replace the dependencies from @google_cloud_cpp//:storage to @google_cloud_cpp//:storage_grpc .

   For example, the quickstart program for gRPC uses the following code:

    cc_binary(
         name = "quickstart",
         srcs = [
             "quickstart.cc",
         ],
         deps = [
             "@com_github_googleapis_google_cloud_cpp//:storage_grpc",
         ],
     ) 
   

Java

Before you begin

1. Ensure you have the following versions installed:

   • Java client libraries:

     • com.google.cloud:google-cloud-storage:2.43.1 or later.
     • com.google.cloud:libraries-bom:26.48 or later.

   • Java 8 or later

   For installation instructions, see Setting up a Java development environment .

2. Set up authentication .

3. Ensure each Compute Engine instance has a service account attached to it, even if the service account has no permissions. This service account is used to represent the Compute Engine instance in the Application Layer Transport Security (ALTS) handshake process and is required for direct connectivity .

Update your project to use the BOM

To make sure that your projects have compatible versions of Google Cloud client libraries, use the versions specified in the Google Cloud libraries Bill of Materials (BOM) . To update your project to use the BOM, use any of the following methods:

• Standalone Cloud Storage
• Cloud Storage with other Google Cloud libraries

Standalone Cloud Storage

If you are using the Cloud Storage client library independently (without other Google Cloud libraries), use the Cloud Storage client library-specific BOM.

 < dependencyManagement 
>  
< dependencies 
>  
< dependency 
>  
< groupId>com.google.cloud</groupId> 
  
< artifactId>google-cloud-storage-bom</artifactId> 
  
< version>2.43.1</version> 
  
< type>pom</type> 
  
< scope>import</scope> 
  
< /dependency 
>  
< /dependencies 
>
< /dependencyManagement 
>

< dependencies 
>  
< dependency 
>  
< groupId>com.google.cloud</groupId> 
  
< artifactId>google-cloud-storage</artifactId> 
  
< /dependency 
>
< /dependencies 
> 

 implementation platform('com.google.cloud:google-cloud-storage-bom:2.43.1')
implementation 'com.google.cloud:google-cloud-storage' 

Cloud Storage with other Google Cloud libraries

If you are using the Cloud Storage client library along with other Google Cloud libraries, use the Google Cloud client libraries BOM.

 < dependencyManagement 
>  
< dependencies 
>  
< dependency 
>  
< groupId>com.google.cloud</groupId> 
  
< artifactId>libraries-bom</artifactId> 
  
< version>26.48.0</version> 
  
< type>pom</type> 
  
< scope>import</scope> 
  
< /dependency 
>  
< /dependencies 
>
< /dependencyManagement 
>

< dependencies 
>  
< dependency 
>  
< groupId>com.google.cloud</groupId> 
  
< artifactId>google-cloud-storage</artifactId> 
  
< /dependency 
>
< /dependencies 
> 

 implementation platform('com.google.cloud:libraries-bom:26.48.0')
implementation 'com.google.cloud:google-cloud-storage' 

Create a gRPC client

The following sample uses a gRPC centric builder. The gRPC Java client automatically uses direct connectivity when it detects that the application is running on Google Cloud.

  // Imports the Google Cloud client library 
 import 
  
 com.google.cloud.storage. Bucket 
 
 ; 
 import 
  
 com.google.cloud.storage. BucketInfo 
 
 ; 
 import 
  
 com.google.cloud.storage. Storage 
 
 ; 
 import 
  
 com.google.cloud.storage. StorageOptions 
 
 ; 
 public 
  
 class 
 QuickstartGrpcSample 
  
 { 
  
 public 
  
 static 
  
 void 
  
 main 
 ( 
 String 
 ... 
  
 args 
 ) 
  
 throws 
  
 Exception 
  
 { 
  
 // Create an instance of options which will use the Google Cloud Storage gRPC API for all 
  
 // operations 
  
  StorageOptions 
 
  
 options 
  
 = 
  
  StorageOptions 
 
 . 
  grpc 
 
 (). 
 build 
 (); 
  
 // Instantiates a client in a try-with-resource to automatically cleanup underlying resources 
  
 try 
  
 ( 
  Storage 
 
  
 storage 
  
 = 
  
 options 
 . 
  getService 
 
 ()) 
  
 { 
  
 // The name for the new bucket 
  
 String 
  
 bucketName 
  
 = 
  
 args 
 [ 
 0 
 ] 
 ; 
  
 // "my-new-bucket"; 
  
 // Creates the new bucket using a request to the gRPC API 
  
  Bucket 
 
  
 bucket 
  
 = 
  
 storage 
 . 
 create 
 ( 
  BucketInfo 
 
 . 
 of 
 ( 
 bucketName 
 )); 
  
 System 
 . 
 out 
 . 
 printf 
 ( 
 "Bucket %s created.%n" 
 , 
  
 bucket 
 . 
 getName 
 ()); 
  
 } 
  
 } 
 } 
 

Go

Before you begin

1. Setup your development environment .

2. Ensure you use Cloud Storage Go client library version 1.46.0 or later.

3. Set up authentication .

4. Ensure each Compute Engine instance has a service account attached to it, even if the service account has no permissions. This service account is used to represent the Compute Engine instance in the Application Layer Transport Security (ALTS) handshake process and is required for direct connectivity .

Create a gRPC client

To use the client, you need to call the NewGRPCClient constructor in your application instead of NewClient .

  // Sample storage-quickstart creates a Google Cloud Storage bucket using 
 // gRPC API. 
 package 
  
 main 
 import 
  
 ( 
  
 "context" 
  
 "fmt" 
  
 "log" 
  
 "time" 
  
 "cloud.google.com/go/storage" 
 ) 
 func 
  
 main 
 () 
  
 { 
  
 ctx 
  
 := 
  
 context 
 . 
 Background 
 () 
  
 // Use your Google Cloud Platform project ID and Cloud Storage bucket 
  
 projectID 
  
 := 
  
 "project-id" 
  
 bucketName 
  
 := 
  
 "bucket-name" 
  
 // Creates a gRPC enabled client. 
  
 client 
 , 
  
 err 
  
 := 
  
 storage 
 . 
  NewGRPCClient 
 
 ( 
 ctx 
 ) 
  
 if 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 log 
 . 
 Fatalf 
 ( 
 "Failed to create client: %v" 
 , 
  
 err 
 ) 
  
 } 
  
 defer 
  
 client 
 . 
 Close 
 () 
  
 // Creates the new bucket. 
  
 ctx 
 , 
  
 cancel 
  
 := 
  
 context 
 . 
 WithTimeout 
 ( 
 ctx 
 , 
  
 time 
 . 
 Second 
 * 
 10 
 ) 
  
 defer 
  
 cancel 
 () 
  
 if 
  
 err 
  
 := 
  
 client 
 . 
  Bucket 
 
 ( 
 bucketName 
 ). 
  Create 
 
 ( 
 ctx 
 , 
  
 projectID 
 , 
  
 nil 
 ); 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 log 
 . 
 Fatalf 
 ( 
 "Failed to create bucket: %v" 
 , 
  
 err 
 ) 
  
 } 
  
 fmt 
 . 
 Printf 
 ( 
 "Bucket %v created.\n" 
 , 
  
 bucketName 
 ) 
 } 
 

The Go client library automatically uses direct connectivity when it detects that the application is running on Google Cloud.

For information about how to use a gRPC client, see gRPC API .