Django2.0手册:Deploying static files

Serving the site and your static files from the same server¶

If you want to serve your static files from the same server that’s already
serving your site, the process may look something like:

• Push your code up to the deployment server.
• On the server, run collectstatic to copy all the static files
  into STATIC_ROOT.
• Configure your web server to serve the files in STATIC_ROOT
  under the URL STATIC_URL. For example, here’s
  how to do this with Apache and mod_wsgi.

You’ll probably want to automate this process, especially if you’ve got
multiple web servers.

Serving static files from a dedicated server¶

Most larger Django sites use a separate Web server — i.e., one that’s not also
running Django — for serving static files. This server often runs a different
type of web server — faster but less full-featured. Some common choices are:

• Nginx
• A stripped-down version of Apache

Configuring these servers is out of scope of this document; check each
server’s respective documentation for instructions.

Since your static file server won’t be running Django, you’ll need to modify
the deployment strategy to look something like:

• When your static files change, run collectstatic locally.
• Push your local STATIC_ROOT up to the static file server into the
  directory that’s being served. rsync is a
  common choice for this step since it only needs to transfer the bits of
  static files that have changed.

Serving static files from a cloud service or CDN¶

Another common tactic is to serve static files from a cloud storage provider
like Amazon’s S3 and/or a CDN (content delivery network). This lets you
ignore the problems of serving static files and can often make for
faster-loading Web pages (especially when using a CDN).

When using these services, the basic workflow would look a bit like the above,
except that instead of using rsync to transfer your static files to the
server you’d need to transfer the static files to the storage provider or CDN.

There’s any number of ways you might do this, but if the provider has an API a
custom file storage backend will make the
process incredibly simple. If you’ve written or are using a 3rd party custom
storage backend, you can tell collectstatic to use it by setting
STATICFILES_STORAGE to the storage engine.

For example, if you’ve written an S3 storage backend in
myproject.storage.S3Storage you could use it with:

STATICFILES_STORAGE = 'myproject.storage.S3Storage'

Once that’s done, all you have to do is run collectstatic and your
static files would be pushed through your storage package up to S3. If you
later needed to switch to a different storage provider, it could be as simple
as changing your STATICFILES_STORAGE setting.

For details on how you’d write one of these backends, see
编写一个自定义存储系统. There are 3rd party apps available that
provide storage backends for many common file storage APIs. A good starting
point is the overview at djangopackages.org.