Cloud Storage verwenden

Sie können Cloud Storage zum Speichern und Bereitstellen von Dateien für Filme, Bilder oder andere statische Inhalte verwenden.

In diesem Dokument wird beschrieben, wie Sie mit den Cloud-Clientbibliotheken für Cloud Storage in Ihrer Anwendung Daten speichern und

Hinweis

Folgen Sie der Anleitung unter Entwicklungsumgebung einrichten, um Ihre Umgebung und Ihr Projekt einzurichten und mehr über die Strukturierung von Anwendungen in App Engine zu erfahren. Notieren Sie sich Ihre Projekt-ID und bewahren Sie sie auf. Sie brauchen diese ID, um die in diesem Dokument beschriebene Beispielanwendung auszuführen.
Vergessen Sie nicht, einen Cloud Storage-Bucket für Ihre Anwendung zu erstellen. Rufen Sie dazu den folgenden Befehl auf:
```
gcloud storage buckets create gs://<var>YOUR_BUCKET_NAME</var>
```

Machen Sie den Bucket öffentlich lesbar, damit er zum Bereitstellen von Dateien genutzt werden kann:

gcloud storage buckets add-iam-policy-binding gs://<var>YOUR_BUCKET_NAME</var> --member=allUsers --role=roles/storage.objectViewer

Beispiel herunterladen

Go

So klonen Sie das Repository:

git clone https://github.com/GoogleCloudPlatform/golang-samples.git
cd golang-samples/appengine_flexible/storage

Java

So klonen Sie das Repository:

Version 11/17

  git clone https://github.com/GoogleCloudPlatform/java-docs-samples
  cd java-docs-samples/flexible/java-11/cloudstorage

Version 8

  git clone https://github.com/GoogleCloudPlatform/java-docs-samples
  cd java-docs-samples/flexible/java-8/cloudstorage

Node.js

So klonen Sie das Repository:

git clone https://github.com/GoogleCloudPlatform/nodejs-docs-samples/
cd nodejs-docs-samples/appengine/storage/flexible

PHP

So klonen Sie das Repository:

git clone https://github.com/GoogleCloudPlatform/php-docs-samples
cd php-docs-samples/appengine/flexible/storage

Python

So klonen Sie das Repository:

git clone https://github.com/GoogleCloudPlatform/python-docs-samples
cd python-docs-samples/appengine/flexible/storage

Ruby

So klonen Sie das Repository:

git clone https://github.com/GoogleCloudPlatform/ruby-docs-samples
cd ruby-docs-samples/appengine/flexible/storage/

.NET

Laden Sie die Beispielanwendung herunter und extrahieren Sie sie.
Wenn Sie die Befehlszeile verwenden, rufen Sie das folgende Anwendungsverzeichnis auf:
```
    dotnet-docs-samples\appengine\flexible\CloudStorage\CloudStorage.Sample
```

Richten Sie ein Dienstkonto ein und laden Sie die Anmeldedaten herunter, um Ihre Anwendung lokal auszuführen:

Öffnen Sie die Liste der Anmeldedaten in der Google Cloud Console.

Liste der Anmeldedaten öffnen
Klicken Sie auf Anmeldedaten erstellen.
Wählen Sie Dienstkontoschlüssel aus.

Das Fenster Dienstkontoschlüssel erstellen wird angezeigt.
Klicken Sie auf die Liste Dienstkonto und wählen Sie Compute Engine-Standarddienstkonto aus.
Wählen Sie als JSON JSON aus.
Klicken Sie auf Erstellen.

Das Fenster Neuer privater Schlüssel wird angezeigt und der private Schlüssel wird automatisch heruntergeladen.
Klicken Sie auf Schließen.
Hinweis: Wählen Sie beim Erstellen des Dienstkontos Compute Engine-Standarddienstkonto aus und behalten Sie unter Schlüsseltyp den Typ JSON bei.

Projektkonfiguration bearbeiten und Abhängigkeiten installieren

Go

Legen Sie in app.yaml GCLOUD_STORAGE_BUCKET fest. Dieser Wert ist der Name des Cloud Storage-Buckets, den Sie zuvor erstellt haben.

# Copyright 2019 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

runtime: go
env: flex

runtime_config:
  operating_system: ubuntu22
  runtime_version: 1.21

automatic_scaling:
  min_num_instances: 1

env_variables:
  GCLOUD_STORAGE_BUCKET: your-bucket-name

Java

Legen Sie BUCKET_NAME in app.yaml auf den Cloud Storage-Bucket fest, den Sie zuvor für Ihr Projekt erstellt haben.

Version 11/17

runtime: java
env: flex
runtime_config:
  operating_system: ubuntu18
  runtime_version: 11
handlers:
- url: /.*
  script: this field is required, but ignored

env_variables:
  BUCKET_NAME: YOUR-BUCKET-NAME

Version 8

#  Copyright 2023 Google Inc.
#
#  Licensed under the Apache License, Version 2.0 (the "License");
#  you may not use this file except in compliance with the License.
#  You may obtain a copy of the License at
#
#       http://www.apache.org/licenses/LICENSE-2.0
#
#  Unless required by applicable law or agreed to in writing, software
#  distributed under the License is distributed on an "AS IS" BASIS,
#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#  See the License for the specific language governing permissions and
#  limitations under the License.

runtime: java
env: flex

handlers:
- url: /.*
  script: this field is required, but ignored

env_variables:
  BUCKET_NAME: YOUR-BUCKET-NAME

Legen Sie com.google.cloud in der Datei pom.xml als Abhängigkeit fest und geben Sie google-cloud-storage als Artefakt-ID für diese Abhängigkeit an. Sie haben damit die Funktionen zum Verwenden von Cloud Storage.

Version 11/17

<!--  Using libraries-bom to manage versions.
See https://github.com/GoogleCloudPlatform/cloud-opensource-java/wiki/The-Google-Cloud-Platform-Libraries-BOM -->
<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>com.google.cloud</groupId>
      <artifactId>libraries-bom</artifactId>
      <version>26.32.0</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-dependencies</artifactId>
      <version>${spring.boot.version}</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

<dependencies>
  <dependency>
    <groupId>com.google.cloud</groupId>
    <artifactId>google-cloud-storage</artifactId>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
  <dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <type>jar</type>
    <scope>provided</scope>
  </dependency>
  <dependency>
    <groupId>org.junit.vintage</groupId>
    <artifactId>junit-vintage-engine</artifactId>
    <scope>test</scope>
  </dependency>
  <dependency>
    <groupId>org.junit-pioneer</groupId>
    <artifactId>junit-pioneer</artifactId>
    <version>2.2.0</version>
    <scope>test</scope>
  </dependency>
  <dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-inline</artifactId>
    <scope>test</scope>
  </dependency>
  <dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-junit-jupiter</artifactId>
    <scope>test</scope>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
  </dependency>

</dependencies>

Version 8

<!--  Using libraries-bom to manage versions.
See https://github.com/GoogleCloudPlatform/cloud-opensource-java/wiki/The-Google-Cloud-Platform-Libraries-BOM -->
<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>com.google.cloud</groupId>
      <artifactId>libraries-bom</artifactId>
      <version>26.28.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>

Node.js

Fügen Sie in app.yaml Ihre Projekt-ID zum Umgebungswert GOOGLE_CLOUD_PROJECT hinzu. Legen Sie anschließend für den Umgebungswert GCLOUD_STORAGE_BUCKET den Namen des Cloud Storage-Buckets fest, den Sie zuvor erstellt haben.

runtime: nodejs
env: flex
runtime_config:
  operating_system: ubuntu22

env_variables:
  GCLOUD_STORAGE_BUCKET: YOUR_BUCKET_NAME

Fügen Sie @google-cloud/storage in package.json als Abhängigkeit hinzu. Dadurch erhalten Sie die Funktionen zur Verwendung von Cloud Storage.

{
  "name": "appengine-storage",
  "description": "Node.js Google Cloud Storage sample for Google App Engine",
  "scripts": {
    "start": "node app.js",
    "test": "c8 mocha -p -j 2 system-test/*.test.js --exit --timeout=30000"
  },
  "engines": {
    "node": ">=16.0.0"
  },
  "dependencies": {
    "@google-cloud/storage": "^7.0.0",
    "express": "^4.18.2",
    "multer": "^1.4.5-lts.1",
    "pug": "^3.0.2"
  },
  "devDependencies": {
    "@types/express": "^4.17.17",
    "@types/multer": "^1.4.7",
    "@types/proxyquire": "^1.3.28",
    "@types/supertest": "^6.0.0",
    "@types/uuid": "^10.0.0",
    "c8": "^10.0.0",
    "mocha": "^10.2.0",
    "proxyquire": "^2.1.3",
    "supertest": "^7.0.0",
    "uuid": "^10.0.0"
  }
}

Anleitungen zum lokalen Ausführen und Testen finden Sie in der Datei README.md.

PHP

Legen Sie in app.yaml CLOUD_STORAGE_BUCKET fest. Dieser Wert ist der Name des Cloud Storage-Buckets, den Sie zuvor erstellt haben.

env_variables:
  GOOGLE_STORAGE_BUCKET: "your-bucket-name"

Beachten Sie, dass die Cloud Client-Bibliothek in composer.json eingebunden werden muss, da diese Cloud Storage-Funktionen bereitstellt.

{
    "require": {
        "slim/slim": "^4.0",
        "slim/psr7": "^1.3",
        "google/cloud-storage": "^1.0",
        "php-di/slim-bridge": "^3.1"
    }
}

Python

Legen Sie in app.yaml GOOGLE_STORAGE_BUCKET fest. Dieser Wert ist der Name des Cloud Storage-Buckets, den Sie zuvor erstellt haben.

env_variables:
  CLOUD_STORAGE_BUCKET: [your-bucket-name]

Beachten Sie in requirements.txt, dass Sie hier die Bibliothek google-cloud-storage einschließen müssen, da hierdurch Cloud Storage-Funktionen bereitgestellt werden.

Flask==3.0.3
google-cloud-storage==2.9.0
gunicorn==22.0.0

Ruby

Legen Sie GCLOUD_STORAGE_BUCKET in app.yaml auf den Cloud Storage-Bucket fest, den Sie zuvor für Ihr Projekt erstellt haben.

runtime: ruby
env: flex
entrypoint: bundle exec ruby app.rb

runtime_config:
  operating_system: ubuntu22

env_variables:
  GOOGLE_CLOUD_STORAGE_BUCKET: <your-bucket-name>

Sie müssen die gcloud-Bibliothek in Gemfile aufnehmen, um die Cloud Storage-Funktionen verwenden zu können.

source "https://rubygems.org"

gem "google-cloud-storage"
gem "sinatra"

.NET

Legen Sie TEST_GOOGLE_BUCKET_NAME in der Datei app.yaml auf den Cloud Storage-Bucket fest, den Sie zuvor für Ihr Projekt erstellt haben.

env_variables:
  TEST_GOOGLE_BUCKET_NAME: [your-bucket-name]

Anwendungscode

Go

Die Beispielanwendung zeigt eine Webseite an, die den Nutzer zur Angabe einer Datei auffordert, die in Cloud Storage gespeichert werden soll. Wenn der Nutzer eine Datei auswählt und auf „Senden“ klickt, schreibt der Upload-Handler die Datei mit dem NewWriter in den Cloud Storage-Bucket.

Beachten Sie, dass Sie zum Abrufen dieser Datei aus Cloud Storage den Bucket-Namen und den Dateinamen angeben müssen. Speichern Sie diese Werte für die zukünftige Verwendung in Ihrer Anwendung.

// Copyright 2019 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.


// Sample storage demonstrates use of the cloud.google.com/go/storage package from App Engine flexible environment.
package main

import (
	"context"
	"fmt"
	"io"
	"log"
	"net/http"
	"net/url"
	"os"

	"cloud.google.com/go/storage"
	"google.golang.org/appengine"
)

var (
	storageClient *storage.Client

	// Set this in app.yaml when running in production.
	bucket = os.Getenv("GCLOUD_STORAGE_BUCKET")
)

func main() {
	ctx := context.Background()

	var err error
	storageClient, err = storage.NewClient(ctx)
	if err != nil {
		log.Fatal(err)
	}

	http.HandleFunc("/", formHandler)
	http.HandleFunc("/upload", uploadHandler)

	appengine.Main()
}

func uploadHandler(w http.ResponseWriter, r *http.Request) {
	if r.Method != "POST" {
		http.Error(w, "", http.StatusMethodNotAllowed)
		return
	}

	ctx := appengine.NewContext(r)

	f, fh, err := r.FormFile("file")
	if err != nil {
		msg := fmt.Sprintf("Could not get file: %v", err)
		http.Error(w, msg, http.StatusBadRequest)
		return
	}
	defer f.Close()

	sw := storageClient.Bucket(bucket).Object(fh.Filename).NewWriter(ctx)
	if _, err := io.Copy(sw, f); err != nil {
		msg := fmt.Sprintf("Could not write file: %v", err)
		http.Error(w, msg, http.StatusInternalServerError)
		return
	}

	if err := sw.Close(); err != nil {
		msg := fmt.Sprintf("Could not put file: %v", err)
		http.Error(w, msg, http.StatusInternalServerError)
		return
	}

	u, _ := url.Parse("/" + bucket + "/" + sw.Attrs().Name)

	fmt.Fprintf(w, "Successful! URL: https://storage.googleapis.com%s", u.EscapedPath())
}

func formHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprint(w, formHTML)
}

const formHTML = `<!DOCTYPE html>
<html>
  <head>
    <title>Storage</title>
    <meta charset="utf-8">
  </head>
  <body>
    <form method="POST" action="/upload" enctype="multipart/form-data">
      <input type="file" name="file">
      <input type="submit">
    </form>
  </body>
</html>`

Java

Die Beispielanwendung zeigt eine Webseite an, die den Nutzer zur Angabe einer Datei auffordert, die in Cloud Storage gespeichert werden soll. Wenn der Nutzer eine Datei auswählt und absendet, schreibt der Anfrage-Handler doPost die Datei mit Storage.create in den Cloud Storage-Bucket.

Beachten Sie, dass Sie zum Abrufen dieser Datei aus Cloud Storage den Bucket-Namen und den Dateinamen angeben müssen. Speichern Sie diese Werte für die zukünftige Verwendung in Ihrer Anwendung.

Version 11/17

@SuppressWarnings("serial")
@WebServlet(name = "upload", value = "/upload")
@MultipartConfig()
public class UploadServlet extends HttpServlet {

  private static final String BUCKET_NAME =
      System.getenv().getOrDefault("BUCKET_NAME", "my-test-bucket");
  private static Storage storage = null;

  public UploadServlet() {
    storage = StorageOptions.getDefaultInstance().getService();
  }

  @Override
  public void doPost(HttpServletRequest req, HttpServletResponse resp)
      throws IOException, ServletException {
    final Part filePart = req.getPart("file");
    final String fileName = filePart.getSubmittedFileName();
    // Modify access list to allow all users with link to read file
    List<Acl> acls = new ArrayList<>();
    acls.add(Acl.of(Acl.User.ofAllUsers(), Acl.Role.READER));
    // the inputstream is closed by default, so we don't need to close it here
    Blob blob =
        storage.create(
            BlobInfo.newBuilder(BUCKET_NAME, fileName).setAcl(acls).build(),
            filePart.getInputStream());

    // return the public download link
    resp.getWriter().print(blob.getMediaLink());
  }
}

Version 8

@SuppressWarnings("serial")
@WebServlet(name = "upload", value = "/upload")
@MultipartConfig()
public class UploadServlet extends HttpServlet {

  private static final String BUCKET_NAME = System.getenv("BUCKET_NAME");
  private static Storage storage = null;

  @Override
  public void init() {
    storage = StorageOptions.getDefaultInstance().getService();
  }

  @Override
  public void doPost(HttpServletRequest req, HttpServletResponse resp)
      throws IOException, ServletException {
    final Part filePart = req.getPart("file");
    final String fileName = filePart.getSubmittedFileName();

    // Modify access list to allow all users with link to read file
    List<Acl> acls = new ArrayList<>();
    acls.add(Acl.of(Acl.User.ofAllUsers(), Acl.Role.READER));
    // the inputstream is closed by default, so we don't need to close it here
    Blob blob =
        storage.create(
            BlobInfo.newBuilder(BUCKET_NAME, fileName).setAcl(acls).build(),
            filePart.getInputStream());

    // return the public download link
    resp.getWriter().print(blob.getMediaLink());
  }
}

Node.js

Die Beispielanwendung zeigt eine Webseite an, die den Nutzer zur Angabe einer Datei auffordert, die in Cloud Storage gespeichert werden soll. Wenn der Nutzer eine Datei auswählt und auf „Submit“ (Senden) klickt, lädt der Upload-Handler den Inhalt der Datei in ein Blob und schreibt ihn in Cloud Storage.

Beachten Sie, dass nach dem Hochladen der Datei in Cloud Storage die öffentliche URL zu dieser Datei zurückgegeben wird, mit der Sie die Datei direkt aus Cloud Storage bereitstellen können. Sie sollten diesen Wert für die zukünftige Verwendung in Ihrer Anwendung speichern.

const {format} = require('util');
const express = require('express');
const Multer = require('multer');

// By default, the client will authenticate using the service account file
// specified by the GOOGLE_APPLICATION_CREDENTIALS environment variable and use
// the project specified by the GOOGLE_CLOUD_PROJECT environment variable. See
// https://github.com/GoogleCloudPlatform/google-cloud-node/blob/master/docs/authentication.md
// These environment variables are set automatically on Google App Engine
const {Storage} = require('@google-cloud/storage');

// Instantiate a storage client
const storage = new Storage();

const app = express();
app.set('view engine', 'pug');

// This middleware is available in Express v4.16.0 onwards
app.use(express.json());

// Multer is required to process file uploads and make them available via
// req.files.
const multer = Multer({
  storage: Multer.memoryStorage(),
  limits: {
    fileSize: 5 * 1024 * 1024, // no larger than 5mb, you can change as needed.
  },
});

// A bucket is a container for objects (files).
const bucket = storage.bucket(process.env.GCLOUD_STORAGE_BUCKET);

// Display a form for uploading files.
app.get('/', (req, res) => {
  res.render('form.pug');
});

// Process the file upload and upload to Google Cloud Storage.
app.post('/upload', multer.single('file'), (req, res, next) => {
  if (!req.file) {
    res.status(400).send('No file uploaded.');
    return;
  }

  // Create a new blob in the bucket and upload the file data.
  const blob = bucket.file(req.file.originalname);
  const blobStream = blob.createWriteStream();

  blobStream.on('error', err => {
    next(err);
  });

  blobStream.on('finish', () => {
    // The public URL can be used to directly access the file via HTTP.
    const publicUrl = format(
      `https://storage.googleapis.com/${bucket.name}/${blob.name}`
    );
    res.status(200).send(publicUrl);
  });

  blobStream.end(req.file.buffer);
});

const PORT = parseInt(process.env.PORT) || 8080;
app.listen(PORT, () => {
  console.log(`App listening on port ${PORT}`);
  console.log('Press Ctrl+C to quit.');
});

PHP

Die Beispielanwendung zeigt eine Webseite an, die den Nutzer zur Angabe einer Datei auffordert, die in Cloud Storage gespeichert werden soll. Wenn der Nutzer eine Datei auswählt und auf „Submit“ (Senden) klickt, lädt der Upload-Handler den Inhalt der Datei in ein Blob und schreibt ihn in Cloud Storage.

use DI\Container;
use Google\Cloud\Storage\StorageClient;
use Psr\Http\Message\ServerRequestInterface as Request;
use Psr\Http\Message\ResponseInterface as Response;
use Slim\Factory\AppFactory;

// Create App
AppFactory::setContainer($container = new Container());
$app = AppFactory::create();

// Display errors
$app->addErrorMiddleware(true, true, true);

$container = $app->getContainer();

$app->get('/', function (Request $request, Response $response) use ($container) {
    /** @var Google\Cloud\StorageClient */
    $storage = $container->get('storage');
    $bucketName = $container->get('bucket_name');
    $objectName = $container->get('object_name');
    $bucket = $storage->bucket($bucketName);
    $object = $bucket->object($objectName);
    $content = $object->exists() ? $object->downloadAsString() : '';
    $escapedContent = htmlspecialchars($content);
    $response->getBody()->write(<<<EOF
    <h1>Storage Example</h1>
    <h3>Write [<a href="https://cloud.google.com/appengine/docs/flexible/php/using-cloud-storage">docs</a>]:</h3>
    <form action="/write" method="post">
        Some file content:<br />
        <textarea name="content"></textarea><br />
        <input type="submit" />
    </form>
EOF
    );
    if ($content) {
        $response->getBody()->write(
            "<p><strong>Your content:</strong><p><p>$escapedContent</p>"
        );
    }
    return $response;
});

/**
 * Write to a Storage bucket.
 * @see https://cloud.google.com/appengine/docs/flexible/php/using-cloud-storage
 */
$app->post('/write', function (Request $request, Response $response) use ($container) {
    /** @var Google\Cloud\StorageClient */
    $storage = $container->get('storage');
    $bucketName = $container->get('bucket_name');
    $objectName = $container->get('object_name');
    parse_str((string) $request->getBody(), $postData);
    $metadata = ['contentType' => 'text/plain'];
    $storage->bucket($bucketName)->upload($postData['content'] ?? '', [
        'name' => $objectName,
        'metadata' => $metadata,
    ]);
    return $response
        ->withStatus(302)
        ->withHeader('Location', '/');
});

$container->set('storage', function () use ($container) {
    $projectId = $container->get('project_id');
    $storage = new StorageClient([
        'projectId' => $projectId
    ]);
    return $storage;
});

Python

Die Beispielanwendung zeigt eine Webseite an, die den Nutzer zur Angabe einer Datei auffordert, die in Cloud Storage gespeichert werden soll. Wenn der Nutzer eine Datei auswählt und auf "Senden" klickt, lädt der Upload-Handler den Dateiinhalt in ein blob und schreibt ihn in den Cloud Storage-Bucket.

Beachten Sie, dass nach dem Hochladen der Datei in Cloud Storage die öffentliche URL zu dieser Datei zurückgegeben wird, mit der Sie die Datei dann direkt aus Cloud Storage bereitstellen können. Sie sollten diesen Wert für die zukünftige Verwendung in Ihrer Anwendung speichern.

from __future__ import annotations

import logging
import os

from flask import Flask, request
from google.cloud import storage

app = Flask(__name__)

# Configure this environment variable via app.yaml
CLOUD_STORAGE_BUCKET = os.environ["CLOUD_STORAGE_BUCKET"]


@app.route("/")
def index() -> str:
    return """
<form method="POST" action="/upload" enctype="multipart/form-data">
    <input type="file" name="file">
    <input type="submit">
</form>
"""


@app.route("/upload", methods=["POST"])
def upload() -> str:
    """Process the uploaded file and upload it to Google Cloud Storage."""
    uploaded_file = request.files.get("file")

    if not uploaded_file:
        return "No file uploaded.", 400

    # Create a Cloud Storage client.
    gcs = storage.Client()

    # Get the bucket that the file will be uploaded to.
    bucket = gcs.get_bucket(CLOUD_STORAGE_BUCKET)

    # Create a new blob and upload the file's content.
    blob = bucket.blob(uploaded_file.filename)

    blob.upload_from_string(
        uploaded_file.read(), content_type=uploaded_file.content_type
    )

    # Make the blob public. This is not necessary if the
    # entire bucket is public.
    # See https://cloud.google.com/storage/docs/access-control/making-data-public.
    blob.make_public()

    # The public URL can be used to directly access the uploaded file via HTTP.
    return blob.public_url


@app.errorhandler(500)
def server_error(e: Exception | int) -> str:
    logging.exception("An error occurred during a request.")
    return (
        """
    An internal error occurred: <pre>{}</pre>
    See logs for full stacktrace.
    """.format(
            e
        ),
        500,
    )


if __name__ == "__main__":
    # This is used when running locally. Gunicorn is used to run the
    # application on Google App Engine. See entrypoint in app.yaml.
    app.run(host="127.0.0.1", port=8080, debug=True)

Ruby

Die Beispielanwendung zeigt eine Webseite an, die den Nutzer zur Angabe einer Datei auffordert, die in Cloud Storage gespeichert werden soll. Wenn der Nutzer eine Datei auswählt und auf „Submit“ (Senden) klickt, lädt der Upload-Handler den Inhalt der Datei in ein Blob und schreibt ihn in Cloud Storage.

require "sinatra"
require "google/cloud/storage"

storage = Google::Cloud::Storage.new
bucket  = storage.bucket ENV["GOOGLE_CLOUD_STORAGE_BUCKET"]

get "/" do
  # Present the user with an upload form
  '
    <form method="POST" action="/upload" enctype="multipart/form-data">
      <input type="file" name="file">
      <input type="submit" value="Upload">
    </form>
  '
end

post "/upload" do
  file_path = params[:file][:tempfile].path
  file_name = params[:file][:filename]

  # Upload file to Google Cloud Storage bucket
  file = bucket.create_file file_path, file_name, acl: "public"

  # The public URL can be used to directly access the uploaded file via HTTP
  file.public_url
end

.NET

Die Beispielanwendung zeigt eine Webseite an, die den Nutzer zur Angabe einer Datei auffordert, die in Cloud Storage gespeichert werden soll. Wenn der Nutzer eine Datei auswählt und auf „Submit“ (Senden) klickt, lädt der Upload-Handler den Inhalt der Datei in ein Blob und schreibt ihn in Cloud Storage.

    public class HomeController : Controller
    {
        // Contains the bucket name and object name
        readonly CloudStorageOptions _options;
        // The Google Cloud Storage client.
        readonly StorageClient _storage;

        public HomeController(CloudStorageOptions options)
        {
            _options = options;
            _storage = StorageClient.Create();
        }

        [HttpGet]
        public async Task<IActionResult> Index()
        {
            var model = new HomeIndex();
            if (new string[] { null, "", "your-google-bucket-name" }
                .Contains(_options.BucketName))
            {
                model.MissingBucketName = true;
                return View(model);
            }
            try
            {
                // Get the storage object.
                var storageObject =
                    await _storage.GetObjectAsync(_options.BucketName, _options.ObjectName);
                // Get a direct link to the storage object.
                model.MediaLink = storageObject.MediaLink;
                // Download the storage object.
                MemoryStream m = new MemoryStream();
                await _storage.DownloadObjectAsync(
                    _options.BucketName, _options.ObjectName, m);
                m.Seek(0, SeekOrigin.Begin);
                byte[] content = new byte[m.Length];
                m.Read(content, 0, content.Length);
                model.Content = Encoding.UTF8.GetString(content);
            }
            catch (GoogleApiException e)
            when (e.HttpStatusCode == System.Net.HttpStatusCode.NotFound)
            {
                // Does not exist yet.  No problem.
            }
            return View(model);
        }

        [HttpPost]
        public async Task<IActionResult> Index(Form sendForm)
        {
            var model = new HomeIndex();
            // Take the content uploaded in the form and upload it to
            // Google Cloud Storage.
            await _storage.UploadObjectAsync(
                _options.BucketName, _options.ObjectName, "text/plain",
                new MemoryStream(Encoding.UTF8.GetBytes(sendForm.Content)));
            model.Content = sendForm.Content;
            model.SavedNewContent = true;
            var storageObject =
                await _storage.GetObjectAsync(_options.BucketName, _options.ObjectName);
            model.MediaLink = storageObject.MediaLink;
            return View(model);
        }

Weitere Informationen

Sie erhalten umfassende Informationen zu Cloud Storage in der Cloud Storage-Dokumentation.