Upload an object with HTML forms

  namespace 
  
 gcs 
  
 = 
  
 :: 
 google 
 :: 
 cloud 
 :: 
 storage 
 ; 
 using 
  
 :: 
 google 
 :: 
 cloud 
 :: 
 StatusOr 
 ; 
 []( 
 gcs 
 :: 
 Client 
  
 client 
 , 
  
 std 
 :: 
 string 
  
 const 
&  
 bucket_name 
 , 
  
 std 
 :: 
 string 
  
 const 
&  
 object_name 
 , 
  
 std 
 :: 
 string 
  
 const 
&  
 signing_account 
 ) 
  
 { 
  
 auto 
  
 document 
  
 = 
  
 client 
 . 
 GenerateSignedPostPolicyV4 
 ( 
  
 gcs 
 :: 
 PolicyDocumentV4 
 { 
  
 bucket_name 
 , 
  
 object_name 
 , 
  
 /*expiration=*/ 
 std 
 :: 
 chrono 
 :: 
 minutes 
 ( 
 10 
 ), 
  
 }, 
  
 gcs 
 :: 
 AddExtensionFieldOption 
 ( 
 "x-goog-meta-test" 
 , 
  
 "data" 
 ), 
  
 gcs 
 :: 
 SigningAccount 
 ( 
 signing_account 
 )); 
  
 if 
  
 ( 
 ! 
 document 
 ) 
  
 throw 
  
 std 
 :: 
 move 
 ( 
 document 
 ). 
 status 
 (); 
  
 // Create the HTML form for the computed policy. 
  
 std 
 :: 
 ostringstream 
  
 os 
 ; 
  
 os 
 << 
 "<form action='" 
 << 
 document 
 - 
> url 
 << 
 "' method='POST'" 
 << 
 " enctype='multipart/form-data' 
> \n 
 " 
 ; 
  
 for 
  
 ( 
 auto 
  
 const 
&  
 field 
  
 : 
  
 document 
 - 
> required_form_fields 
 ) 
  
 { 
  
 os 
 << 
 "  <input name='" 
 << 
 field 
 . 
 first 
 << 
 "' value='" 
 << 
 field 
 . 
 second 
 << 
 "' type='hidden' / 
> \n 
 " 
 ; 
  
 } 
  
 os 
 << 
 "  <input type='submit' value='Upload File' /><br /> 
 \n 
 " 
 << 
 "  <input type='file' name='file' /><br /> 
 \n 
 " 
 << 
 "</form>" 
 ; 
  
 std 
 :: 
 cout 
 << 
 "A sample HTML form: 
 \n 
 " 
 << 
 os 
 . 
 str 
 () 
 << 
 " 
 \n 
 " 
 ; 
 } 
 

  // Create a signed post policy which can be used to upload a specific object and 
 // expires in 1 hour after creation. 
 UrlSigner 
  
 urlSigner 
  
 = 
  
 UrlSigner 
 . 
 FromCredential 
 ( 
 credential 
 ); 
 UrlSigner 
 . 
 Options 
  
 options 
  
 = 
  
 UrlSigner 
 . 
 Options 
  
 . 
 FromDuration 
 ( 
 TimeSpan 
 . 
 FromHours 
 ( 
 1 
 )) 
  
 . 
 WithSigningVersion 
 ( 
 SigningVersion 
 . 
 V4 
 ) 
  
 . 
 WithScheme 
 ( 
 "https" 
 ); 
 UrlSigner 
 . 
 PostPolicy 
  
 postPolicy 
  
 = 
  
 UrlSigner 
 . 
 PostPolicy 
 . 
 ForBucketAndKey 
 ( 
 bucketName 
 , 
  
 objectName 
 ); 
 postPolicy 
 . 
 SetCustomField 
 ( 
 UrlSigner 
 . 
 PostPolicyCustomElement 
 . 
 GoogleMetadata 
 , 
  
 "x-goog-meta-test" 
 , 
  
 "data" 
 ); 
 UrlSigner 
 . 
 SignedPostPolicy 
  
 signedPostPolicy 
  
 = 
  
 await 
  
 urlSigner 
 . 
 SignAsync 
 ( 
 postPolicy 
 , 
  
 options 
 ); 
 // Create an HTML form including all the fields in the signed post policy. 
 StringBuilder 
  
 form 
  
 = 
  
 new 
  
 StringBuilder 
 (); 
 form 
 . 
 AppendLine 
 ( 
 $"<form action=\"{signedPostPolicy.PostUrl}\" method=\"post\" enctype=\"multipart/form-data\">" 
 ); 
 foreach 
  
 ( 
 var 
  
 field 
  
 in 
  
 signedPostPolicy 
 . 
 Fields 
 ) 
 { 
  
 form 
 . 
 AppendLine 
 ( 
 $"<input type=\"hidden\" name=\"{field.Key}\" value=\"{field.Value}\">" 
 ); 
 } 
 // Include the file element. It should always be the last element in the form. 
 form 
 . 
 AppendLine 
 ( 
 "<input name=\"file\" type=\"file\">" 
 ); 
 form 
 . 
 AppendLine 
 ( 
 "<input type=\"submit\" value=\"Upload\">" 
 ); 
 form 
 . 
 AppendLine 
 ( 
 "</form>" 
 ); 
 // You can now save the form to file and serve it as static content 
 // or send it as the response to a request made to your application. 
 File 
 . 
 WriteAllText 
 ( 
 "PostPolicySimple.html" 
 , 
  
 form 
 . 
 ToString 
 ()); 
 

  import 
  
 com.google.cloud.storage. BlobInfo 
 
 ; 
 import 
  
 com.google.cloud.storage. PostPolicyV4 
 
 ; 
 import 
  
 com.google.cloud.storage. Storage 
 
 ; 
 import 
  
 com.google.cloud.storage. StorageOptions 
 
 ; 
 import 
  
 java.util.Map 
 ; 
 import 
  
 java.util.concurrent.TimeUnit 
 ; 
 public 
  
 class 
 GenerateSignedPostPolicyV4 
  
 { 
  
 /** 
 * Generating a signed POST policy requires Credentials which implement ServiceAccountSigner. 
 * These can be set explicitly using the Storage.PostPolicyV4Option.signWith(ServiceAccountSigner) 
 * option. If you don't, you could also pass a service account signer to StorageOptions, i.e. 
 * StorageOptions().newBuilder().setCredentials(ServiceAccountSignerCredentials). In this example, 
 * neither of these options are used, which means the following code only works when the 
 * credentials are defined via the environment variable GOOGLE_APPLICATION_CREDENTIALS, and those 
 * credentials are authorized to sign a policy. See the documentation for 
 * Storage.generateSignedPostPolicyV4 for more details. 
 */ 
  
 public 
  
 static 
  
 void 
  
 generateSignedPostPolicyV4 
 ( 
  
 String 
  
 projectId 
 , 
  
 String 
  
 bucketName 
 , 
  
 String 
  
 blobName 
 ) 
  
 { 
  
 // The ID of your GCP project 
  
 // String projectId = "your-project-id"; 
  
 // The ID of the GCS bucket to upload to 
  
 // String bucketName = "your-bucket-name" 
  
 // The name to give the object uploaded to GCS 
  
 // String blobName = "your-object-name" 
  
  Storage 
 
  
 storage 
  
 = 
  
  StorageOptions 
 
 . 
 newBuilder 
 (). 
 setProjectId 
 ( 
 projectId 
 ). 
 build 
 (). 
  getService 
 
 (); 
  
  PostPolicyV4 
 
 . 
  PostFieldsV4 
 
  
 fields 
  
 = 
  
  PostPolicyV4 
 
 . 
 PostFieldsV4 
 . 
 newBuilder 
 (). 
  setCustomMetadataField 
 
 ( 
 "test" 
 , 
  
 "data" 
 ). 
 build 
 (); 
  
  PostPolicyV4 
 
  
 policy 
  
 = 
  
 storage 
 . 
  generateSignedPostPolicyV4 
 
 ( 
  
  BlobInfo 
 
 . 
 newBuilder 
 ( 
 bucketName 
 , 
  
 blobName 
 ). 
 build 
 (), 
  
 10 
 , 
  
 TimeUnit 
 . 
 MINUTES 
 , 
  
 fields 
 ); 
  
 StringBuilder 
  
 htmlForm 
  
 = 
  
 new 
  
 StringBuilder 
 ( 
  
 "<form action='" 
  
 + 
  
 policy 
 . 
  getUrl 
 
 () 
  
 + 
  
 "' method='POST' enctype='multipart/form-data'>\n" 
 ); 
  
 for 
  
 ( 
 Map 
 . 
 Entry<String 
 , 
  
 String 
>  
 entry 
  
 : 
  
 policy 
 . 
 getFields 
 (). 
 entrySet 
 ()) 
  
 { 
  
 htmlForm 
 . 
 append 
 ( 
  
 "  <input name='" 
  
 + 
  
 entry 
 . 
 getKey 
 () 
  
 + 
  
 "' value='" 
  
 + 
  
 entry 
 . 
 getValue 
 () 
  
 + 
  
 "' type='hidden' />\n" 
 ); 
  
 } 
  
 htmlForm 
 . 
 append 
 ( 
 "  <input type='file' name='file'/><br />\n" 
 ); 
  
 htmlForm 
 . 
 append 
 ( 
 "  <input type='submit' value='Upload File'/><br />\n" 
 ); 
  
 htmlForm 
 . 
 append 
 ( 
 "</form>\n" 
 ); 
  
 System 
 . 
 out 
 . 
 println 
 ( 
  
 "You can use the following HTML form to upload an object to bucket " 
  
 + 
  
 bucketName 
  
 + 
  
 " for the next ten minutes:" 
 ); 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 htmlForm 
 . 
 toString 
 ()); 
  
 } 
 } 
 

  import 
  
 ( 
  
 "context" 
  
 "fmt" 
  
 "html/template" 
  
 "io" 
  
 "time" 
  
 "cloud.google.com/go/storage" 
 ) 
 // form is a template for an HTML form that will use the data from the signed 
 // post policy. 
 var 
  
 form 
  
 = 
  
 `<form action="{{ .URL }}" method="POST" enctype="multipart/form-data"> 
 {{- range $name, $value := .Fields }} 
 <input name="{{ $name }}" value="{{ $value }}" type="hidden"/> 
 {{- end }} 
 <input type="file" name="file"/><br /> 
 <input type="submit" value="Upload File" name="submit"/><br /> 
< /form>` 
 var 
  
 tmpl 
  
 = 
  
 template 
 . 
 Must 
 ( 
 template 
 . 
 New 
 ( 
 "policyV4" 
 ). 
 Parse 
 ( 
 form 
 )) 
 // generateSignedPostPolicyV4 generates a signed post policy. 
 func 
  
 generateSignedPostPolicyV4 
 ( 
 w 
  
 io 
 . 
  Writer 
 
 , 
  
 bucket 
 , 
  
 object 
  
 string 
 ) 
  
 ( 
 * 
 storage 
 . 
  PostPolicyV4 
 
 , 
  
 error 
 ) 
  
 { 
  
 // bucket := "bucket-name" 
  
 // object := "object-name" 
  
 ctx 
  
 := 
  
 context 
 . 
 Background 
 () 
  
 client 
 , 
  
 err 
  
 := 
  
 storage 
 . 
 NewClient 
 ( 
 ctx 
 ) 
  
 if 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 return 
  
 nil 
 , 
  
 fmt 
 . 
 Errorf 
 ( 
 "storage.NewClient: %w" 
 , 
  
 err 
 ) 
  
 } 
  
 defer 
  
 client 
 . 
 Close 
 () 
  
 metadata 
  
 := 
  
 map 
 [ 
 string 
 ] 
 string 
 { 
  
 "x-goog-meta-test" 
 : 
  
 "data" 
 , 
  
 } 
  
 // Generating a signed POST policy requires credentials authorized to sign a URL. 
  
 // You can pass these in through PostPolicyV4Options with one of the following options: 
  
 //    a. a Google service account private key, obtainable from the Google Developers Console 
  
 //    b. a Google Access ID with iam.serviceAccounts.signBlob permissions 
  
 //    c. a SignBytes function implementing custom signing 
  
 // In this example, none of these options are used, which means the 
  
 // GenerateSignedPostPolicyV4 function attempts to use the same authentication 
  
 // that was used to instantiate	the Storage client. This authentication must 
  
 // include a private key or have iam.serviceAccounts.signBlob permissions. 
  
 opts 
  
 := 
  
& storage 
 . 
  PostPolicyV4Options 
 
 { 
  
 Expires 
 : 
  
 time 
 . 
 Now 
 (). 
  Add 
 
 ( 
 10 
  
 * 
  
 time 
 . 
 Minute 
 ), 
  
 Fields 
 : 
  
& storage 
 . 
  PolicyV4Fields 
 
 { 
  
 Metadata 
 : 
  
 metadata 
 , 
  
 }, 
  
 } 
  
 policy 
 , 
  
 err 
  
 := 
  
 client 
 . 
  Bucket 
 
 ( 
 bucket 
 ). 
 GenerateSignedPostPolicyV4 
 ( 
 object 
 , 
  
 opts 
 ) 
  
 if 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 return 
  
 nil 
 , 
  
 fmt 
 . 
 Errorf 
 ( 
 "storage.GenerateSignedPostPolicyV4: %w" 
 , 
  
 err 
 ) 
  
 } 
  
 // Generate the form, using the data from the policy. 
  
 if 
  
 err 
  
 = 
  
 tmpl 
 . 
 Execute 
 ( 
 w 
 , 
  
 policy 
 ); 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 return 
  
 policy 
 , 
  
 fmt 
 . 
 Errorf 
 ( 
 "executing template: %w" 
 , 
  
 err 
 ) 
  
 } 
  
 return 
  
 policy 
 , 
  
 nil 
 } 
 

  /** 
 * 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 fileName = 'your-file-name'; 
 // Imports the Google Cloud client library 
 const 
  
 { 
 Storage 
 } 
  
 = 
  
 require 
 ( 
 ' @google-cloud/storage 
' 
 ); 
 // Creates a client 
 const 
  
 storage 
  
 = 
  
 new 
  
 Storage 
 (); 
 async 
  
 function 
  
 generateV4SignedPolicy 
 () 
  
 { 
  
 const 
  
 bucket 
  
 = 
  
 storage 
 . 
 bucket 
 ( 
 bucketName 
 ); 
  
 const 
  
 file 
  
 = 
  
 bucket 
 . 
 file 
 ( 
 fileName 
 ); 
  
 // These options will allow temporary uploading of a file 
  
 // through an HTML form. 
  
 const 
  
 expires 
  
 = 
  
 Date 
 . 
 now 
 () 
  
 + 
  
 10 
  
 * 
  
 60 
  
 * 
  
 1000 
 ; 
  
 //  10 minutes 
  
 const 
  
 options 
  
 = 
  
 { 
  
 expires 
 , 
  
 fields 
 : 
  
 { 
 'x-goog-meta-test' 
 : 
  
 'data' 
 }, 
  
 }; 
  
 // Get a v4 signed policy for uploading file 
  
 const 
  
 [ 
 response 
 ] 
  
 = 
  
 await 
  
 file 
 . 
  generateSignedPostPolicyV4 
 
 ( 
 options 
 ); 
  
 // Create an HTML form with the provided policy 
  
 let 
  
 output 
  
 = 
  
 `<form action=" 
 ${ 
 response 
 . 
 url 
 } 
 " method="POST" enctype="multipart/form-data">\n` 
 ; 
  
 // Include all fields returned in the HTML form as they're required 
  
 for 
  
 ( 
 const 
  
 name 
  
 of 
  
 Object 
 . 
 keys 
 ( 
 response 
 . 
 fields 
 )) 
  
 { 
  
 const 
  
 value 
  
 = 
  
 response 
 . 
 fields 
 [ 
 name 
 ]; 
  
 output 
  
 += 
  
 `  <input name=" 
 ${ 
 name 
 } 
 " value=" 
 ${ 
 value 
 } 
 " type="hidden"/>\n` 
 ; 
  
 } 
  
 output 
  
 += 
  
 '  <input type="file" name="file"/><br />\n' 
 ; 
  
 output 
  
 += 
  
 '  <input type="submit" value="Upload File"/><br />\n' 
 ; 
  
 output 
  
 += 
  
 '</form>' 
 ; 
  
 console 
 . 
 log 
 ( 
 output 
 ); 
 } 
 generateV4SignedPolicy 
 (). 
 catch 
 ( 
 console 
 . 
 error 
 ); 
 

  use Google\Cloud\Storage\StorageClient; 
 /** 
 * Generates a v4 POST Policy to be used in an HTML form and echo's form. 
 * 
 * @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') 
 */ 
 function generate_v4_post_policy(string $bucketName, string $objectName): void 
 { 
 $storage = new StorageClient(); 
 $bucket = $storage->bucket($bucketName); 
 $response = $bucket->generateSignedPostPolicyV4( 
 $objectName, 
 new \DateTime('10 min'), 
 [ 
 'fields' => [ 
 'x-goog-meta-test' => 'data' 
 ] 
 ] 
 ); 
 $url = $response['url']; 
 $output = "<form action='$url' method='POST' enctype='multipart/form-data'>" . PHP_EOL; 
 foreach ($response['fields'] as $name => $value) { 
 $output .= "  <input name='$name' value='$value' type='hidden'/>" . PHP_EOL; 
 } 
 $output .= "  <input type='file' name='file'/><br />" . PHP_EOL; 
 $output .= "  <input type='submit' value='Upload File' name='submit'/><br />" . PHP_EOL; 
 $output .= '</form>' . PHP_EOL; 
 echo $output; 
 } 
 

  import 
  
 datetime 
 from 
  
 google.cloud 
  
 import 
  storage 
 
 def 
  
 generate_signed_post_policy_v4 
 ( 
 bucket_name 
 , 
 blob_name 
 ): 
  
 """Generates a v4 POST Policy and prints an HTML form.""" 
 # bucket_name = 'your-bucket-name' 
 # blob_name = 'your-object-name' 
 storage_client 
 = 
  storage 
 
 . 
  Client 
 
 () 
 policy 
 = 
 storage_client 
 . 
  generate_signed_post_policy_v4 
 
 ( 
 bucket_name 
 , 
 blob_name 
 , 
 expiration 
 = 
 datetime 
 . 
 timedelta 
 ( 
 minutes 
 = 
 10 
 ), 
 fields 
 = 
 { 
 'x-goog-meta-test' 
 : 
 'data' 
 } 
 ) 
 # Create an HTML form with the provided policy 
 header 
 = 
 "<form action=' 
 {} 
 ' method='POST' enctype='multipart/form-data' 
> \n 
 " 
 form 
 = 
 header 
 . 
 format 
 ( 
 policy 
 [ 
 "url" 
 ]) 
 # Include all fields returned in the HTML form as they're required 
 for 
 key 
 , 
 value 
 in 
 policy 
 [ 
 "fields" 
 ] 
 . 
 items 
 (): 
 form 
 += 
 f 
 "  <input name=' 
 { 
 key 
 } 
 ' value=' 
 { 
 value 
 } 
 ' type='hidden'/ 
> \n 
 " 
 form 
 += 
 "  <input type='file' name='file'/><br /> 
 \n 
 " 
 form 
 += 
 "  <input type='submit' value='Upload File' /><br /> 
 \n 
 " 
 form 
 += 
 "</form>" 
 print 
 ( 
 form 
 ) 
 return 
 form 
 

  def 
  
 generate_signed_post_policy_v4 
  
 bucket_name 
 :, 
  
 file_name 
 : 
  
 # The ID of the GCS bucket to upload to 
  
 # bucket_name = "your-unique-bucket-name" 
  
 # The name to give the object uploaded to GCS 
  
 # file_name = "your-file-name" 
  
 require 
  
 "google/cloud/storage" 
  
 storage 
  
 = 
  
 Google 
 :: 
 Cloud 
 :: 
  Storage 
 
 . 
  new 
 
  
 bucket 
  
 = 
  
 storage 
 . 
 bucket 
  
 bucket_name 
  
 post_object 
  
 = 
  
 bucket 
 . 
  generate_signed_post_policy_v4 
 
  
 file_name 
 , 
  
 expires 
 : 
  
 600 
 , 
  
 fields 
 : 
  
 { 
  
 "x-goog-meta-test" 
  
 = 
>  
 "data" 
  
 } 
  
 html_form 
  
 = 
  
 "<form action=' 
 #{ 
 post_object 
 . 
 url 
 } 
 ' method='POST' enctype='multipart/form-data' 
> \n 
 " 
  
 post_object 
 . 
  fields 
 
 . 
  each 
 
  
 do 
  
 | 
 name 
 , 
  
 value 
 | 
  
 html_form 
  
 += 
  
 "  <input name=' 
 #{ 
 name 
 } 
 ' value=' 
 #{ 
 value 
 } 
 ' type='hidden'/ 
> \n 
 " 
  
 end 
  
 html_form 
  
 += 
  
 "  <input type='file' name='file'/><br /> 
 \n 
 " 
  
 html_form 
  
 += 
  
 "  <input type='submit' value='Upload File'/><br /> 
 \n 
 " 
  
 html_form 
  
 += 
  
 "</form> 
 \n 
 " 
  
 puts 
  
 "You can use the following form to upload an object to bucket 
 #{ 
 bucket_name 
 } 
 for the next 10 minutes: 
 \n 
 " 
  
 puts 
  
 html_form 
  
 post_object 
 end