Applications often need to serve static files such as JavaScript, images, and CSS in addition to handling dynamic requests. Apps in the flexible environment can serve static files from a Google Cloud option like Cloud Storage, serve them directly, or use a third-party content delivery network (CDN)

## Serving files from Cloud Storage
Cloud Storage can host static assets for dynamic web apps. The benefits of using Cloud Storage instead of serving directly from your app include:
- Cloud Storage essentially works as a content delivery network. This does not require any special configuration because by default anyreadable object is cached in the global Cloud Storage network

- Your app's load will be reduced by offloading serving static assets to Cloud Storage. Depending on how many static assets you have and the frequency of access, this can reduce the cost of running your app by a significant amount

- Bandwidth charges for accessing content can often be less with Cloud Storage

You can upload your assets to Cloud Storage by using the
gsutil command line tool
or the Cloud Storage API

The Google Cloud Client Library provides an idiomatic client to Cloud Storage, for storing and retrieving data with Cloud Storage in an App Engine app

 Example of serving from a Cloud Storage bucket
This simple example creates a Cloud Storage bucket and uploads static assets using Google Cloud CLI:
Create a bucket. It's common, but not required, to name your bucket after your project ID. The bucket name must be globally unique

gsutil mb gsyour-bucket-name>
Set the ACL to grant read access to items in the bucket

gsutil defacl set public-read gsyour-bucket-name>
Upload items to the bucket. The
rsynccommand is typically the fastest and easiest way to upload and update assets. You could also use
cp

gsutil -m rsync -r ./static gsyour-bucket-name>/static
You can now access your static assets via
httpsstorage.googleapis.com//static

For more details on how to use Cloud Storage to serve static assets, including how to serve from a custom domain name, refer to How to Host a Static Website

 Serving files from other Google Cloud services
You also have the option of using Cloud CDN or other Google Cloud storage services

## Serving files directly from your app
Serving files from your app is typically straightforward, however, there are a couple drawbacks that you should consider:
- Requests for static files can use resources that otherwise would be used for dynamic requests


- Depending on your configuration, serving files from your app can result in response latency, which can also affect when new instances are created for handling the load

 Example of serving static files with your app
 Go
In Go, you can use the standard
http.FileServer
or
http.ServeFile
to serve files directly from your app

// Package static demonstrates a static file handler for App Engine flexible environment. package main import ( "fmt" "net/http" "google.golang.org/appengine" ) func main() { // Serve static files from "static" directory. http.Handlestatic http.FileServer(http.Dir http.HandleFunc homepageHandler) appengine.Main() } const homepage = doctype html>   Static Files    
This is a static file serving examplep>  ` func homepageHandler(w http.ResponseWriter, r *http.Request) { fmt.Fprint(w, homepage) }
 Java
The Java runtime's servlet container will use your app's deployment
descriptor,
web.xml file, to map URLs to servlets, including static assets. If you do not
specify a
web.xml, a default is used that maps everything to the default
servlet

In this example,
./src/main/webapp/index.html refers to a stylesheet served
from
/stylesheets/styles.css

   Static Files    
This is a static file serving examplep>  
The
styles.css file is located at
./src/main/webapp/stylesheets/styles.css

body { font-family: Verdana, Helvetica, sans-serif; background-color: #CCCCFF; }
You can explicitly configure how static files are handled in the
web.xml file

For example, if you wanted to map requests for all files that have the
.jpg
extension:
 default  
If you are using a web framework, such as Play, you will need to refer to the framework's documentation on static assets

 Node.js
Most web frameworks include support for serving static files. In this sample,
the application uses the
express.static
middleware to serve files from the
./public directory to the
/static URL

'use strict'; const express = require('express const app = express app.set('view engine', 'pug // Use the built-in express middleware for serving static files from public' app.usestatic', express.static('public app.get (req, res) => { res.render('index// Start the server const PORT = parseInt(process.env.PORT) || 8080; app.listen(PORT, () => { console.log(`App listening on port ${PORT console.log('Press Ctrl+C to quit 
The view refers to
/static/main.css


doctype html html(lang="en") head title Static Files meta(charset='utf-8') link(rel="stylesheet", hrefstatic/main.css") body p This is a static file serving example

The stylesheet itself is located at
./public/css, which is served from
/static/main.css

body { font-family: Verdana, Helvetica, sans-serif; background-color: #CCCCFF; }
Other Node.js frameworks, such as Hapi, Koa, and Sails typically support serving static files directly from the application. Refer to their documentation for details on how to configure and use static content

 PHP
The PHP runtime runs nginx
to serve your app, which is configured to serve static files in
your project directory. You must declare the document root by specifying
document_root in your
app.yaml file:
runtime: php env: flex runtime_config: document_root: web
 Python
Most web frameworks include support for serving static files. In this sample,
the app uses Flask's built-in ability
to serve files in
./static directory from the
/static URL

The app includes a view that renders the template. Flask automatically
serves everything in the
./static directory without additional configuration

import logging from flask import Flask, render_template app = Flaskname @app.route def hello return render_template('index.html') @app.errorhandler(500) def server_error(e): logging.exception('An error occurred during a request returnAn internal error occurred:  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)
The template rendered by the view includes a stylesheet located at
/static/main.css

   Static FilesFlask automatically makes files in the 'static' directory available via '/static'.   
This is a static file serving examplep>  
The stylesheet is located at
./static/main.css

body { font-family: Verdana, Helvetica, sans-serif; background-color: #CCCCFF; }
Other Python frameworks, such as Django, Pyramid, and Bottle typically support serving static files directly from the app. Refer to their documentation for details on how to configure and use static content

 Ruby
Most web frameworks include support for serving static files

 Sinatra
The Sinatra web
framework serves files from the
./public directory by default. This
app includes a view that refers to
/application.css


doctype html html head title Serving Static Files link rel="stylesheet" hrefapplication.css" script srcapplication.js" body p This is a static file serving example

The stylesheet is located at
./public/application.css which is served
from
/application.css

body { font-family: Verdana, Helvetica, sans-serif; background-color: #CCCCFF; }
 Ruby on Rails
The Ruby on Rails
web framework serves files from the
./public directory by default. Static
JavaScript and CSS files can also be generated by the Rails asset
pipeline

This example app has a layout view that includes all the app's stylesheets:
doctype html html head title Serving Static Files = stylesheet_link_tag "application", media: "all" = javascript_include_tag "application" = csrf_meta_tags body = yield
The stylesheet itself is a
Sass file located
at
./app/assets/stylesheets/main.css.sass

body font-family: Verdana, Helvetica, sans-serif background-color: #CCCCFF
By default, Rails apps do not generate or serve static assets when running in production

The Ruby runtime executes
rake assets:precompile during deployment
to generate static assets and sets the
RAILS_SERVE_STATIC_FILES environment
variable to enable static file serving in production

 .NET
   Hello Static World   
This is a static html documentp> 
  
To enable static file serving, add this code to your
Startup.cs file:
app.UseDefaultFiles app.UseStaticFiles
## Serving from a third-party content delivery network
You can use any external third-party CDN to serve your static files and cache dynamic requests but your app might experience increased latency and cost

For improved performance, you should use a third-party CDN that supports CDN Interconnect.