Utiliser Cloud Storage

Vous pouvez utiliser Cloud Storage pour stocker et diffuser des fichiers, tels que des films, des images ou d'autres contenus statiques.

Ce document explique comment utiliser les bibliothèques clientes Cloud pour Cloud Storage dans votre application afin de stocker et de récupérer des données

Avant de commencer

  • Suivez les instructions de la section Configurer votre environnement de développement pour configurer votre environnement et votre projet, et pour comprendre la structure des applications dans App Engine. Notez et enregistrez l'ID de votre projet. Vous en aurez besoin pour exécuter l'exemple d'application décrit dans ce document.

  • Veillez à créer un bucket Cloud Storage pour votre application en appelant la commande suivante :

    gsutil mb gs://[YOUR_BUCKET_NAME]

  • Rendez le bucket lisible publiquement afin qu'il puisse diffuser des fichiers :

    gsutil defacl set public-read gs://[YOUR_BUCKET_NAME]

Télécharger l'exemple

Go

Pour cloner le dépôt, exécutez :

Versions 1.18 et ultérieures 

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

v1.15 et versions précédentes

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

Java

Pour cloner le dépôt, exécutez :

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

Pour cloner le dépôt, exécutez :

V18 et ultérieures 

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

v16 et versions précédentes

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

PHP

Pour cloner le dépôt, exécutez :

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

Python

Pour cloner le dépôt, exécutez :

Versions 3.8 et ultérieures 

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

v3.7 et versions précédentes

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

Ruby

Pour cloner le dépôt, exécutez :

Version 3.2

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

Versions 3.1 et antérieures

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

.NET

  1. Téléchargez l'exemple d'application et extrayez-le.

  2. Si vous utilisez la ligne de commande, accédez au répertoire de l'application suivant :

    versions 6 et ultérieures

    dotnet-docs-samples\appengine\flexible\CloudStorage\CloudStorage.Sample

    Versions 3.1 et antérieures

    Utilisez la branche flex-dotnet3-and-earlier.

      dotnet-docs-samples\appengine\flexible\CloudStorage

    Pour exécuter votre application localement, configurez un compte de service et téléchargez les identifiants :

  3. Ouvrez la liste des identifiants dans la console Google Cloud.

    Ouvrir la liste des identifiants

  4. Cliquez sur Créer des identifiants.

  5. Sélectionnez la clé de compte de service.

    Une fenêtre Créer une clé de compte de service s'ouvre.

  6. Cliquez sur la boîte déroulante sous Compte de service, puis sur Compte de service Compute Engine par défaut.

  7. Sélectionnez JSON pour le type de clé.

  8. Cliquez sur Créer.

    Une fenêtre Nouvelle clé privée s'affiche, et la clé privée est automatiquement téléchargée.

  9. Cliquez sur Fermer.

    .

Modifier la configuration du projet et installer les dépendances

Go

Dans app.yaml, définissez GCLOUD_STORAGE_BUCKET. Cette valeur correspond au nom du bucket Cloud Storage que vous avez créé précédemment.

Versions 1.18 et ultérieures 

# 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.19

automatic_scaling:
  min_num_instances: 1

env_variables:
  GCLOUD_STORAGE_BUCKET: your-bucket-name

v1.15 et versions précédentes

# Copyright 2023 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

automatic_scaling:
  min_num_instances: 1

env_variables:
  GCLOUD_STORAGE_BUCKET: your-bucket-name

Java

Dans le fichier app.yaml, définissez BUCKET_NAME sur le bucket Cloud Storage que vous avez précédemment créé pour votre projet.

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

Dans le fichier pom.xml, définissez com.google.cloud en tant que dépendance et spécifiez google-cloud-storage comme ID d'artefact de cette dépendance. Cette action fournit les fonctions permettant d'utiliser 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

Dans app.yaml, ajoutez votre ID de projet à la valeur de l'environnement GOOGLE_CLOUD_PROJECT. Définissez ensuite la valeur de l'environnement GCLOUD_STORAGE_BUCKET sur le nom du bucket Cloud Storage que vous avez créé précédemment.

V18 et ultérieures 

runtime: nodejs
env: flex
runtime_config:
  operating_system: ubuntu22

env_variables:
  GCLOUD_STORAGE_BUCKET: YOUR_BUCKET_NAME

v16 et versions précédentes

runtime: nodejs
env: flex

env_variables:
  GCLOUD_STORAGE_BUCKET: YOUR_BUCKET_NAME

Dans le fichier package.json, ajoutez @google-cloud/storage en tant que dépendance, ce qui fournit les fonctions permettant d'utiliser Cloud Storage.

V18 et ultérieures 

{
  "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": "^2.0.12",
    "@types/uuid": "^9.0.1",
    "c8": "^8.0.0",
    "mocha": "^10.2.0",
    "proxyquire": "^2.1.3",
    "supertest": "^6.3.3",
    "uuid": "^9.0.0"
  }
}

v16 et versions précédentes

{
  "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.x.x"
  },
  "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": "^2.0.12",
    "@types/uuid": "^9.0.1",
    "c8": "^8.0.0",
    "mocha": "^10.2.0",
    "proxyquire": "^2.1.3",
    "supertest": "^6.3.3",
    "uuid": "^9.0.0"
  }
}

Consultez le fichier README.md pour obtenir des instructions sur l'exécution et le test en local.

PHP

Dans app.yaml, définissez CLOUD_STORAGE_BUCKET. Cette valeur correspond au nom du bucket Cloud Storage que vous avez créé précédemment.

env_variables:
  GOOGLE_STORAGE_BUCKET: "your-bucket-name"

La bibliothèque cliente Cloud doit être incluse dans le fichier composer.json. Cette bibliothèque est requise car elle fournit des fonctions Cloud Storage.

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

Python

Dans app.yaml, définissez GOOGLE_STORAGE_BUCKET. Cette valeur correspond au nom du bucket Cloud Storage que vous avez créé précédemment.

Versions 3.8 et ultérieures 

env_variables:
  CLOUD_STORAGE_BUCKET: [your-bucket-name]

v3.7 et versions précédentes

env_variables:
    CLOUD_STORAGE_BUCKET: your-bucket-name

Notez que la bibliothèque google-cloud-storage doit être incluse dans le fichier requirements.txt, car elle fournit certaines fonctions Cloud Storage.

Versions 3.8 et ultérieures 

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

v3.7 et versions précédentes

Flask==3.0.0; python_version > '3.6'
Flask==2.0.3; python_version < '3.7'
werkzeug==3.0.1; python_version > '3.7'
werkzeug==2.3.8; python_version <= '3.7'
google-cloud-storage==2.9.0
gunicorn==22.0.0

Ruby

Dans le fichier app.yaml, définissez GCLOUD_STORAGE_BUCKET sur le bucket Cloud Storage que vous avez précédemment créé pour votre projet.

version 3.2 

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

runtime_config:
  operating_system: ubuntu22

env_variables:
  GOOGLE_CLOUD_STORAGE_BUCKET: <your-bucket-name>

Versions 3.1 et antérieures

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

env_variables:
  GOOGLE_CLOUD_STORAGE_BUCKET: <your-bucket-name>

Notez que vous devez inclure la bibliothèque gcloud dans le fichier Gemfile pour utiliser les fonctions Cloud Storage.

source "https://rubygems.org"

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

.NET

Ensuite, procédez à la configuration des éléments suivants, comme indiqué :

versions 6 et ultérieures

Dans le fichier app.yaml, définissez TEST_GOOGLE_BUCKET_NAME sur le bucket Cloud Storage que vous avez précédemment créé pour votre projet.

env_variables:
  TEST_GOOGLE_BUCKET_NAME: [your-bucket-name]

Versions 3.1 et antérieures

Dans appsettings.json, définissez BucketName. Cette valeur correspond au nom du bucket Cloud Storage que vous avez créé précédemment.

{
  "GoogleCloudStorage": {
    "BucketName": "your-google-bucket-name"
  },
  "Logging": {
    "IncludeScopes": false,
    "LogLevel": {
      "Default": "Debug",
      "System": "Information",
      "Microsoft": "Information"
    }
  }
}

Code d'application

Go

L'exemple d'application présente une page Web invitant l'utilisateur à indiquer un fichier à stocker dans Cloud Storage. Dès que l'utilisateur sélectionne un fichier et clique dessus pour l'envoyer, le gestionnaire d'importation écrit le fichier dans le bucket Cloud Storage à l'aide de la fonction NewWriter de Cloud Storage.

Notez que pour récupérer ce fichier depuis Cloud Storage, vous devez spécifier le nom du bucket et le nom du fichier. Vous devez stocker ces valeurs dans votre application pour une utilisation ultérieure.

// 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

L'exemple d'application présente une page Web invitant l'utilisateur à indiquer un fichier à stocker dans Cloud Storage. Lorsque l'utilisateur sélectionne un fichier et clique sur "Envoyer", le gestionnaire de requêtes doPost écrit le fichier dans le bucket Cloud Storage à l'aide de Storage.create.

Notez que pour récupérer ce fichier depuis Cloud Storage, vous devez spécifier le nom du bucket et le nom du fichier. Vous devez stocker ces valeurs dans votre application pour une utilisation ultérieure.

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

L'exemple d'application présente une page Web invitant l'utilisateur à indiquer un fichier à stocker dans Cloud Storage. Lorsque l'utilisateur sélectionne un fichier et clique sur "Envoyer", le gestionnaire d'importation charge le contenu du fichier dans un blob et l'écrit dans Cloud Storage.

Notez qu'après le transfert du fichier dans Cloud Storage, l'URL publique de ce fichier est renvoyée. Vous pouvez l'utiliser pour diffuser le fichier directement à partir de Cloud Storage. Vous devez stocker cette valeur dans votre application pour une utilisation ultérieure.

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

L'exemple d'application présente une page Web invitant l'utilisateur à indiquer un fichier à stocker dans Cloud Storage. Lorsque l'utilisateur sélectionne un fichier et clique sur "Envoyer", le gestionnaire d'importation charge le contenu du fichier dans un blob et l'écrit dans Cloud Storage.

Notez qu'après le transfert du fichier dans Cloud Storage, l'URL publique de ce fichier est renvoyée. Vous pouvez l'utiliser pour diffuser le fichier directement à partir de Cloud Storage. Vous devez stocker cette valeur dans votre application pour une utilisation ultérieure.

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

L'exemple d'application présente une page Web invitant l'utilisateur à indiquer un fichier à stocker dans Cloud Storage. Lorsque l'utilisateur sélectionne un fichier et clique sur "Envoyer", le gestionnaire d'importation charge le contenu du fichier dans un blob Cloud Storage et écrit le fichier dans le bucket Cloud Storage.

Notez qu'après l'importation du fichier dans Cloud Storage, l'URL publique de ce fichier vous est renvoyée. Vous pouvez l'utiliser pour diffuser le fichier directement à partir de Cloud Storage. Vous devez stocker cette valeur dans votre application pour une utilisation ultérieure.

Versions 3.8 et ultérieures 

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)

v3.7 et versions précédentes

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

L'exemple d'application présente une page Web invitant l'utilisateur à indiquer un fichier à stocker dans Cloud Storage. Lorsque l'utilisateur sélectionne un fichier et clique sur "Envoyer", le gestionnaire d'importation charge le contenu du fichier dans un blob et l'écrit dans Cloud Storage.

Notez qu'après le transfert du fichier dans Cloud Storage, l'URL publique de ce fichier est renvoyée. Vous pouvez l'utiliser pour diffuser le fichier directement à partir de Cloud Storage. Vous devez stocker cette valeur dans votre application pour une utilisation ultérieure.

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

L'exemple d'application présente une page Web invitant l'utilisateur à indiquer un fichier à stocker dans Cloud Storage. Lorsque l'utilisateur sélectionne un fichier et clique sur "Envoyer", le gestionnaire d'importation charge le contenu du fichier dans un blob et l'écrit dans Cloud Storage.

Notez qu'après le transfert du fichier dans Cloud Storage, l'URL publique de ce fichier est renvoyée. Vous pouvez l'utiliser pour diffuser le fichier directement à partir de Cloud Storage. Vous devez stocker cette valeur dans votre application pour une utilisation ultérieure.

versions 6 et ultérieures 

    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);
        }

Versions 3.1 et antérieures

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

        public HomeController(IOptions<CloudStorageOptions> options)
        {
            _options = options.Value;
            _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);
        }

Pour en savoir plus

Pour obtenir des informations complètes sur Cloud Storage, consultez la documentation Cloud Storage.