Objekt mit HTML-Formularen hochladen

Lädt Objekte mithilfe von HTML-Formularen hoch. Das hochgeladene Objekt ersetzt alle vorhandenen Objekte mit demselben Namen. Tipps zum Hochladen in Cloud Storage finden Sie in den Best Practices.

Weitere Informationen zu POST-Objektanfragen mit dem Legacy-Signaturprozess finden Sie unter POST-Objekt mit dem V2-Signaturprozess.

Abfragestringparameter

Die Anfrage enthält keine Abfragestringparameter.

Formularfelder

Feld	Beschreibung	Erforderlich
`acl`	Die vordefinierte ACL, die auf das hochgeladene Objekt angewendet werden soll. Wenn Sie dieses Feld nicht angeben, wird die ACL `default` des Buckets angewendet.	Nein
`bucket`	Der Name des Buckets, in den Sie die Datei hochladen möchten. Wenn Sie dieses Feld angeben, muss es mit dem Bucket-Namen übereinstimmen, den Sie im Attribut `action` angegeben haben.	Nein
`Cache-Control`	Die Cache-Steuerung für das Objekt. Sie können die Cache-Steuerung nur für Objekte festlegen, die für alle Nutzer zugänglich sind. Die ACL eines Objekts muss beispielsweise `public-read` oder `public-read-write` sein, damit die Cachesteuerung festgelegt werden kann.	Nein
`Content-Disposition`	Gibt an, wie die Objektdaten übertragen werden sollen. Ein `Content-Disposition`-Wert von `inline` bedeutet beispielsweise, dass das Objekt sofort angezeigt werden soll.	Nein
`Content-Encoding`	Der Komprimierungsalgorithmus für das Objekt, z. B. `gzip`.	Nein
`Content-Length`	Die Größe der hochgeladenen Datei in Byte.	Nein
`Content-Type`	Der MIME-Typ der Datei, die Sie über das Formular hochladen. Wenn Sie keinen Inhaltstyp angeben, verwendet das Cloud Storage-System beim Bereitstellen des Inhalts standardmäßig `application/octet-stream`.	Nein
`Expires`	Ein ISO8601-Zeitstempel, der das Datum und die Uhrzeit vor einem Objekt angibt, das vom Browser als veraltet gilt.	Nein
`file`	Die Datei, die Sie hochladen. Es muss das letzte Feld im Formular sein. Sie können nur ein Objekt pro Anfrage hochladen.	Ja
`key`	Der Name des Objekts, das Sie hochladen. Sie können auch die Variable ${filename} verwenden, wenn ein Nutzer einen Dateinamen bereitstellt.	Ja
`policy`	Die Sicherheitsrichtlinie, die beschreibt, was im Formular hochgeladen werden darf und nicht. Das Richtliniendokument muss Base64-codiert sein. Weitere Informationen finden Sie in den Richtliniendokumenten. *Wenn Sie keine Sicherheitsrichtlinie bereitstellen, werden Anfragen als anonym betrachtet und funktionieren nur mit Buckets, denen anonymen Nutzern die Berechtigung `WRITE` oder `FULL_CONTROL` erteilt wurde.	Nein*
`success_action_redirect`	Eine URL, zu der Nutzer nach einem erfolgreichen Upload weitergeleitet werden. Wenn Sie keine URL angeben, antwortet Cloud Storage mit dem Statuscode, den Sie in `success_action_status` angegeben haben.	Nein
`success_action_status`	Der Statuscode, auf den Cloud Storage reagieren soll, wenn ein Upload erfolgreich war Der Standardwert ist 204, aber Sie können diesen Wert auf 200 oder 201 ändern. Wenn Sie 200 oder 204 auswählen, gibt Cloud Storage ein leeres Dokument mit diesen Statuscodes zurück. Wenn Sie 201 auswählen, gibt Cloud Storage ein XML-Dokument mit den in Antworttextelementen beschriebenen Elementen zurück. Hinweis: Der Adobe Flash Player verarbeitet möglicherweise keine Antworten mit einem leeren Dokumenttext. Verwenden Sie in diesem Fall den Statuscode 201.	Nein
`x-goog-algorithm`	Der Signaturalgorithmus, mit dem die mit Ihrem Richtliniendokument verknüpfte Signatur erstellt wurde. Mögliche Werte sind `GOOG4-HMAC-SHA256` und `GOOG4-RSA-SHA256`	Nur wenn Sie ein `policy` angeben
`x-goog-credential`	Die Anmeldedaten, die zum Erstellen der mit Ihrem Richtliniendokument verknüpften Signatur verwendet werden. `x-goog-credential` hat das Format `AccessKeyId/CredentialScope`. Dabei gilt: `AccessKeyId` ist die E-Mail-Adresse der Entität, die für die Erstellung der Signatur verantwortlich ist. Diese Entität ist normalerweise ein Dienstkonto, kann aber auch ein Nutzerkonto sein. `CredentialScope` ist der in der Signatur verwendete Anmeldedatenbereich.	Nur wenn Sie ein `policy` angeben
`x-goog-custom-time`	Ein benutzerdefiniertes Datum und eine Uhrzeit im RFC 3339-Format `YYYY-MM-DD'T'HH:MM:SS.SS'Z'`.	Nein
`x-goog-date`	Das aktuelle Datum im ISO 8601-Basisformat `YYYYMMDD'T'HHMMSS'Z'`.	Nur wenn Sie ein `policy` angeben
`x-goog-signature`	Die mit Ihrem Richtliniendokument verknüpfte Signatur.	Nur wenn Sie ein `policy` angeben
`x-goog-meta-*`	Ein Feld für benutzerdefinierte Metadaten. Sie können damit zusätzliche Metadaten angeben, die nicht von den anderen Formularfeldern bereitgestellt werden. Zum Beispiel sind `x-goog-meta-reviewer: jane` oder `x-goog-meta-project-manager: john` benutzerdefinierte Metadaten.	Nein

Antworttextelemente

Die folgenden Antworttextelemente werden nur in einem XML-Dokument zurückgegeben, wenn Sie success_action_status auf 201 setzen.

Element	Beschreibung
`Bucket`	Bucket, in dem das Objekt gespeichert wurde.
`ETag`	HTTP 1.1-Entitäts-Tag für das Objekt.
`Key`	Der Name des Objekts.
`Location`	Der URI für das Objekt.

Verwendung und Beispiele

Das Formular muss UTF-8-codiert sein. Sie können die Formularcodierung im HTML-Tag head oder über den Anfrageheader Content-Type angeben.

In der Datei form müssen die folgenden drei Elemente angegeben sein:

Eine Aktion.

Das Attribut action gibt einen API-Anfrageendpunkt an. Gültige Endpunkte sind https://BUCKET_NAME.storage.googleapis.com, https://storage.googleapis.com/BUCKET_NAME und CNAME Weiterleitungen.
Eine Methode.

Das Attribut method gibt die Methode an, die du zum Senden des Formulars verwendest. Sie muss den Wert post enthalten.
Ein Gehäusetyp.

Das Attribut enctype gibt den verwendeten Gehäusetyp an und muss immer multipart/form-data sein.

Hier sehen Sie ein Beispiel für ein HTML-Formular mit einem Richtliniendokument:

HTML

<form action="https://storage.googleapis.com/travel-maps" method="post" enctype="multipart/form-data">
<input type="text" name="key" value="test-object">
<input type="hidden" name="Content-Type" value="image/jpeg">
<input type="hidden" name="success_action_redirect" value="https://www.example.com/success_notification.html">
<input type="hidden" name="policy" value="eyJjb25kaXRpb25zIjpbeyJidWNrZXQiOiJ0cmF2ZWwtbWFwcyJ9LHsiY29udGVudC10eXBlIjoiaW1hZ2UvanBlZyJ9LHsic3VjY2Vzc19hY3Rpb25fcmVkaXJlY3QiOiJodHRwOi8vd3d3LmV4YW1wbGUuY29tL3N1Y2Nlc3Nfbm90aWZpY2F0aW9uLmh0bWwifSx7ImtleSI6InRlc3Qtb2JqZWN0In0seyJ4LWdvb2ctZGF0ZSI6IjIwMjAwMTIzVDA0MzUzMFoifSx7IngtZ29vZy1jcmVkZW50aWFsIjoiZXhhbXBsZV9hY2NvdW50QGV4YW1wbGVfcHJvamVjdC5pYW0uZ3NlcnZpY2VhY2NvdW50LmNvbS8yMDE5MTEwMi9hdXRvL3N0b3JhZ2UvZ29vZzRfcmVxdWVzdCJ9LHsieC1nb29nLWFsZ29yaXRobSI6IkdPT0c0LVJTQS1TSEEyNTYifV0sImV4cGlyYXRpb24iOiIyMDIwLTAxLTIzVDA0OjM1OjQwWiJ9">
<input type="hidden" name="x-goog-algorithm" value="GOOG4-RSA-SHA256">
<input type="hidden" name="x-goog-credential" value="example_account@example_project.iam.gserviceaccount.com/20191102/auto/storage/goog4_request">
<input type="hidden" name="x-goog-date" value="20191102T043530Z">
<input type="hidden" name="x-goog-signature" value="58bc39b8f604ee1f18171fee4828ef8967f3d2721676570e115d68c2f133820cbb833976f18955516b2b7d0c3d9660fea613a2ad90c240bd02c1eefa4a55e9038ce74dcfdd34e278ea0436e261131a36fa4e922f0a077ca1c9842f654928aac3ca7f9341075f9db275d8286b5ef13e7f91b4837e77b2a6dbea83f86b90f848331053d8a6b1fbc26787992e7fb819a2005bae9b3026b9c7d1158e88e4a2018f13757083c7873241d2dfe6ea46a17cd6f3d090f3e0da44ccfbd6bc425124de1bea744a32f3ab175672a991ef274cd83550eca57ea591b85fa9799098a38ec552dc3ec679c431491444820624f5c4ba0c8cf87d60af89899afce2a90325c6966dcf">

<input name="file" type="file">
<input type="submit" value="Upload">
</form>

C++

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage C++ API.

Auf GitHub ansehen Feedback

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::runtime_error(document.status().message());

  // 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";
}

C#

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage C# API.

Auf GitHub ansehen Feedback

// Create a signed post policy which can be used to upload a specific object and
// expires in 1 hour after creation.
UrlSigner urlSigner = UrlSigner
    .FromServiceAccountCredential(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());

Java

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Java API.

Auf GitHub ansehen Feedback

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().AddCustomMetadataField("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());
  }
}

Go

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Go API.

Auf GitHub ansehen Feedback

import (
	"fmt"
	"html/template"
	"io"
	"io/ioutil"
	"time"

	"cloud.google.com/go/storage"
	"golang.org/x/oauth2/google"
)

// 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, serviceAccountJSONPath string) (*storage.PostPolicyV4, error) {
	// bucket := "bucket-name"
	// object := "object-name"
	// serviceAccountJSONPath := "service_account.json"
	jsonKey, err := ioutil.ReadFile(serviceAccountJSONPath)
	if err != nil {
		return nil, fmt.Errorf("ioutil.ReadFile: %v", err)
	}
	conf, err := google.JWTConfigFromJSON(jsonKey)
	if err != nil {
		return nil, fmt.Errorf("google.JWTConfigFromJSON: %v", err)
	}
	metadata := map[string]string{
		"x-goog-meta-test": "data",
	}
	opts := &storage.PostPolicyV4Options{
		GoogleAccessID: conf.Email,
		PrivateKey:     conf.PrivateKey,
		Expires:        time.Now().Add(10 * time.Minute),
		Fields: &storage.PolicyV4Fields{
			Metadata: metadata,
		},
	}

	policy, err := storage.GenerateSignedPostPolicyV4(bucket, object, opts)
	if err != nil {
		return nil, fmt.Errorf("storage.GenerateSignedPostPolicyV4: %v", err)
	}

	// Generate the form, using the data from the policy.
	if err = tmpl.Execute(w, policy); err != nil {
		return policy, fmt.Errorf("executing template: %v", err)
	}

	return policy, nil
}

Node.js

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Node.js API.

Auf GitHub ansehen Feedback

/**
 * 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' name='submit'/><br />\n";
  output += '</form>';

  console.log(output);
}

generateV4SignedPolicy().catch(console.error);

PHP

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage PHP API.

Auf GitHub ansehen Feedback

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 Google Cloud bucket.
 * @param string $objectName the name of your Google Cloud object.
 *
 * @return void
 */
function generate_v4_post_policy($bucketName, $objectName)
{
    $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;
}

Python

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Python API.

Auf GitHub ansehen Feedback

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 += "  <input name='{}' value='{}' type='hidden'/>\n".format(key, value)

    form += "  <input type='file' name='file'/><br />\n"
    form += "  <input type='submit' value='Upload File' /><br />\n"
    form += "</form>"

    print(form)

    return form

Ruby

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Ruby API.

Auf GitHub ansehen Feedback

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

Als Best Practice sollten Sie den Header Expect: 100-continue mit POST-Anfragen verwenden. So können Sie prüfen, ob der Server die Anfrage verarbeitet, bevor Sie das Objekt senden. Wenn Sie den Statuscode 100 Continue erhalten, fahren Sie mit der Anfrage fort. Wenn Sie den Statuscode 417 Expectation Failed erhalten, sollten Sie das Objekt nicht senden.