Upload an object with HTML forms

namespacegcs=::google::cloud::storage;
using::google::cloud::StatusOr;
[](gcs::Clientclient,std::stringconst&bucket_name,
std::stringconst&object_name,std::stringconst&signing_account){
autodocument=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)throwstd::move(document).status();
// Create the HTML form for the computed policy.
std::ostringstreamos;
os << "<form action='" << document->url << "' method='POST'"
 << " enctype='multipart/form-data'>\n";
for(autoconst&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.
UrlSignerurlSigner=UrlSigner.FromCredential(credential);
UrlSigner.Optionsoptions=UrlSigner.Options
.FromDuration(TimeSpan.FromHours(1))
.WithSigningVersion(SigningVersion.V4)
.WithScheme("https");
UrlSigner.PostPolicypostPolicy=UrlSigner.PostPolicy.ForBucketAndKey(bucketName,objectName);
postPolicy.SetCustomField(UrlSigner.PostPolicyCustomElement.GoogleMetadata,"x-goog-meta-test","data");
UrlSigner.SignedPostPolicysignedPostPolicy=awaiturlSigner.SignAsync(postPolicy,options);
// Create an HTML form including all the fields in the signed post policy.
StringBuilderform=newStringBuilder();
form.AppendLine($"<form action=\"{signedPostPolicy.PostUrl}\" method=\"post\" enctype=\"multipart/form-data\">");
foreach(varfieldinsignedPostPolicy.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());

importcom.google.cloud.storage.BlobInfo ;
importcom.google.cloud.storage.PostPolicyV4 ;
importcom.google.cloud.storage.Storage ;
importcom.google.cloud.storage.StorageOptions ;
importjava.util.Map;
importjava.util.concurrent.TimeUnit;
publicclass 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.
 */
publicstaticvoidgenerateSignedPostPolicyV4(
StringprojectId,StringbucketName,StringblobName){
// 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);
StringBuilderhtmlForm=
newStringBuilder(
"<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.
varform=`<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>`
vartmpl=template.Must(template.New("policyV4").Parse(form))
// generateSignedPostPolicyV4 generates a signed post policy.
funcgenerateSignedPostPolicyV4(wio.Writer ,bucket,objectstring)(*storage.PostPolicyV4 ,error){
// bucket := "bucket-name"
// object := "object-name"
ctx:=context.Background()
client,err:=storage.NewClient(ctx)
iferr!=nil{
returnnil,fmt.Errorf("storage.NewClient: %w",err)
}
deferclient.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)
iferr!=nil{
returnnil,fmt.Errorf("storage.GenerateSignedPostPolicyV4: %w",err)
}
// Generate the form, using the data from the policy.
iferr=tmpl.Execute(w,policy);err!=nil{
returnpolicy,fmt.Errorf("executing template: %w",err)
}
returnpolicy,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
conststorage=newStorage();
asyncfunctiongenerateV4SignedPolicy(){
constbucket=storage.bucket(bucketName);
constfile=bucket.file(fileName);
// These options will allow temporary uploading of a file
// through an HTML form.
constexpires=Date.now()+10*60*1000;// 10 minutes
constoptions={
expires,
fields:{'x-goog-meta-test':'data'},
};
// Get a v4 signed policy for uploading file
const[response]=awaitfile.generateSignedPostPolicyV4 (options);
// Create an HTML form with the provided policy
letoutput=`<form action="${response.url}" method="POST" enctype="multipart/form-data">\n`;
// Include all fields returned in the HTML form as they're required
for(constnameofObject.keys(response.fields)){
constvalue=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;
}

importdatetime
fromgoogle.cloudimport storage
defgenerate_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

defgenerate_signed_post_policy_v4bucket_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.bucketbucket_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"
putshtml_form
post_object
end