Use Cloud Storage

# 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

runtime:java
env:flex
runtime_config:
operating_system:ubuntu22
runtime_version:17
handlers:
-url:/.*
script:this field is required, but ignored
env_variables:
BUCKET_NAME:YOUR-BUCKET-NAME

<!--Usinglibraries-bomtomanageversions.
Seehttps://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.45.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-junit-jupiter</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-inline</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>net.bytebuddy</groupId>
<artifactId>byte-buddy</artifactId>
<version>1.14.17</version>
</dependency>
</dependencies>

runtime:nodejs
env:flex
runtime_config:
operating_system:ubuntu22
env_variables:
GCLOUD_STORAGE_BUCKET:YOUR_BUCKET_NAME

{
"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"
}
}

env_variables:
GOOGLE_STORAGE_BUCKET:"your-bucket-name"

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

env_variables:
CLOUD_STORAGE_BUCKET:[your-bucket-name]

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

runtime:ruby
env:flex
entrypoint:bundle exec ruby app.rb
runtime_config:
operating_system:ubuntu22
env_variables:
GOOGLE_CLOUD_STORAGE_BUCKET:<your-bucket-name>

source"https://rubygems.org"
gem"google-cloud-storage"
gem"sinatra"

// 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.
packagemain
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")
)
funcmain(){
ctx:=context.Background()
varerrerror
storageClient,err=storage.NewClient(ctx)
iferr!=nil{
log.Fatal(err)
}
http.HandleFunc("/",formHandler)
http.HandleFunc("/upload",uploadHandler)
appengine.Main ()
}
funcuploadHandler(whttp.ResponseWriter,r*http.Request){
ifr.Method!="POST"{
http.Error(w,"",http.StatusMethodNotAllowed)
return
}
ctx:=appengine.NewContext(r)
f,fh,err:=r.FormFile("file")
iferr!=nil{
msg:=fmt.Sprintf("Could not get file: %v",err)
http.Error(w,msg,http.StatusBadRequest)
return
}
deferf.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
}
iferr:=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())
}
funcformHandler(whttp.ResponseWriter,r*http.Request){
fmt.Fprint(w,formHTML)
}
constformHTML=`<!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>`

@SuppressWarnings("serial")
@WebServlet(name="upload",value="/upload")
@MultipartConfig()
publicclass UploadServletextendsHttpServlet{
privatestaticfinalStringBUCKET_NAME=
System.getenv().getOrDefault("BUCKET_NAME","my-test-bucket");
privatestaticStoragestorage=null;
publicUploadServlet(){
storage=StorageOptions.getDefaultInstance().getService();
}
@Override
publicvoiddoPost(HttpServletRequestreq,HttpServletResponseresp)
throwsIOException,ServletException{
finalPartfilePart=req.getPart("file");
finalStringfileName=filePart.getSubmittedFileName();
// Modify access list to allow all users with link to read file
List<Acl>acls=newArrayList<>();
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
Blobblob=
storage.create(
BlobInfo.newBuilder(BUCKET_NAME,fileName).setAcl(acls).build(),
filePart.getInputStream());
// return the public download link
resp.getWriter().print(blob.getMediaLink());
}
}

const{format}=require('util');
constexpress=require('express');
constMulter=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
conststorage=newStorage();
constapp=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.
constmulter=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).
constbucket=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.
constblob=bucket.file(req.file.originalname);
constblobStream=blob.createWriteStream();
blobStream.on('error',err=>{
next(err);
});
blobStream.on('finish',()=>{
// The public URL can be used to directly access the file via HTTP.
constpublicUrl=format(
`https://storage.googleapis.com/${bucket.name}/${blob.name}`
);
res.status(200).send(publicUrl);
});
blobStream.end(req.file.buffer);
});
constPORT=parseInt(process.env.PORT)||8080;
app.listen(PORT,()=>{
console.log(`App listening on port ${PORT}`);
console.log('Press Ctrl+C to quit.');
});

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

from__future__import annotations
importlogging
importos
fromflaskimport Flask, request
fromgoogle.cloudimport storage
app = Flask(__name__)
# Configure this environment variable via app.yaml
CLOUD_STORAGE_BUCKET = os.environ["CLOUD_STORAGE_BUCKET"]
@app.route("/")
defindex() -> 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"])
defupload() -> 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)
defserver_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)

require"sinatra"
require"google/cloud/storage"
storage=Google::Cloud::Storage.new
bucket=storage.bucketENV["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_filefile_path,file_name,acl:"public"
# The public URL can be used to directly access the uploaded file via HTTP
file.public_url
end

publicclassHomeController:Controller
{
// Contains the bucket name and object name
readonlyCloudStorageOptions_options;
// The Google Cloud Storage client.
readonlyStorageClient_storage;
publicHomeController(CloudStorageOptionsoptions)
{
_options=options;
_storage=StorageClient.Create();
}
[HttpGet]
publicasyncTask<IActionResult>Index()
{
varmodel=newHomeIndex();
if(newstring[]{null,"","your-google-bucket-name"}
.Contains(_options.BucketName))
{
model.MissingBucketName=true;
returnView(model);
}
try
{
// Get the storage object.
varstorageObject=
await_storage.GetObjectAsync(_options.BucketName,_options.ObjectName);
// Get a direct link to the storage object.
model.MediaLink=storageObject.MediaLink;
// Download the storage object.
MemoryStreamm=newMemoryStream();
await_storage.DownloadObjectAsync(
_options.BucketName,_options.ObjectName,m);
m.Seek(0,SeekOrigin.Begin);
byte[]content=newbyte[m.Length];
m.Read(content,0,content.Length);
model.Content=Encoding.UTF8.GetString(content);
}
catch(GoogleApiExceptione)
when(e.HttpStatusCode==System.Net.HttpStatusCode.NotFound)
{
// Does not exist yet. No problem.
}
returnView(model);
}
[HttpPost]
publicasyncTask<IActionResult>Index(FormsendForm)
{
varmodel=newHomeIndex();
// Take the content uploaded in the form and upload it to
// Google Cloud Storage.
await_storage.UploadObjectAsync(
_options.BucketName,_options.ObjectName,"text/plain",
newMemoryStream(Encoding.UTF8.GetBytes(sendForm.Content)));
model.Content=sendForm.Content;
model.SavedNewContent=true;
varstorageObject=
await_storage.GetObjectAsync(_options.BucketName,_options.ObjectName);
model.MediaLink=storageObject.MediaLink;
returnView(model);
}