mime.types

# /etc/nginx/mime.types
# Global Nginx mime.types file

types {
    text/html html htm shtml;
    text/css css;
    text/xml xml rss;
    image/gif gif;
    image/jpeg jpeg jpg;
    application/javascript js;
    application/atom+xml atom;

    text/cache-manifest manifest appcache;
    text/mathml mml;
    text/plain txt;
    text/vnd.sun.j2me.app-descriptor jad;
    text/vnd.wap.wml wml;
    text/x-component htc;

    image/png png;
    image/svg+xml svg svgz;
    image/tiff tif tiff;
    image/vnd.wap.wbmp wbmp;
    image/webp webp;
    image/x-icon ico;
    image/x-jng jng;
    image/x-ms-bmp bmp;

    application/java-archive jar war ear;
    application/mac-binhex40 hqx;
    application/msword doc;
    application/pdf pdf;
    application/postscript ps eps ai;
    application/rtf rtf;
    application/vnd.ms-excel xls;
    application/vnd.ms-powerpoint ppt;
    application/vnd.wap.wmlc wmlc;
    application/vnd.wap.xhtml+xml xhtml;
    application/x-chrome-extension crx;
    application/x-cocoa cco;
    application/x-java-archive-diff jardiff;
    application/x-java-jnlp-file jnlp;
    application/x-makeself run;
    application/x-perl pl pm;
    application/x-pilot prc pdb;
    application/x-rar-compressed rar;
    application/x-redhat-package-manager rpm;
    application/x-sea sea;
    application/x-shockwave-flash swf;
    application/x-stuffit sit;
    application/x-tcl tcl tk;
    application/x-x509-ca-cert der pem crt;
    application/x-xpinstall xpi;
    application/zip zip;

    application/octet-stream bin exe dll;
    application/octet-stream deb;
    application/octet-stream dmg;
    application/octet-stream iso img;
    application/octet-stream msi msp msm;
    application/octet-stream safariextz

    audio/midi mid midi kar;
    audio/mpeg mp3;
    audio/x-realaudio ra;
    audio/ogg oga ogg;
    audio/x-wav wav;

    video/3gpp 3gpp 3gp;
    video/mpeg mpeg mpg;
    video/ogg ogv;
    video/quicktime mov;
    video/webm webm;
    video/x-flv flv;
    video/x-mng mng;
    video/x-ms-asf asx asf;
    video/x-ms-wmv wmv;
    video/x-msvideo avi;

    application/vnd.ms-fontobject eot;
    application/x-font-ttf ttf ttc;
    font/opentype otf;
    font/woff woff;
}

nginx-rails.conf

# config/nginx.conf
# Nginx configuration file for each Rails app.

upstream appname {
	server unix:/home/deployer/apps/appname/shared/unicorn.sock fail_timeout=0;
}

server {
	listen 443;
	ssl on;
	server_name appname.example.com;	

	root /home/deployer/apps/appname/current/public;

	access_log off;
	error_log /var/log/nginx/errors/appname.log;

  rewrite_log on;

	try_files $uri/index.html $uri.html $uri @unicorn;

    location @unicorn {
		proxy_pass	http://appname;
		proxy_redirect     off;

		proxy_set_header   Host             $host;	
		proxy_set_header   X-Real-IP        $remote_addr;
		proxy_set_header   X-Forwarded-For  $proxy_add_x_forwarded_for;
		proxy_set_header   X-Forwarded-Proto https;

    client_max_body_size       10m;
    client_body_buffer_size    128k;

    proxy_connect_timeout      90;
    proxy_send_timeout         90;
		proxy_read_timeout         90;

		proxy_buffer_size          4k;
		proxy_buffers              4 32k;
		proxy_busy_buffers_size    64k;
		proxy_temp_file_write_size 64k;
	}
	
	location ~ ^/(assets)/  {
	  root /home/deployer/apps/appname/current/public;
	  gzip_static on;
	  expires max;
	  add_header Cache-Control public;
	}
	
	add_header "X-UA-Compatible" "IE=Edge,chrome=1";

}

server {
    listen 80;
    server_name appname.example.com;
    return 301 https://$server_name$request_uri;
}

nginx.conf

# /etc/nginx/nginx.conf
# Global Nginx configuration file

user deployer staff;

worker_processes 1;
pid /var/run/nginx.pid;

events {
    worker_connections 1024;
    multi_accept on;
}

http {
    sendfile on;
    tcp_nopush on;
    tcp_nodelay off;

    keepalive_timout 20;

    include /etc/nginx/mime.types;
    default_type application/octet-stream; 
 
    access_log off; 
    error_log /var/log/nginx/errors/main.log; 

	  gzip on;
	  gzip_http_version 1.0;
	  gzip_comp_level 5;
	  gzip_min_length 512;
	  gzip_buffers 16 8k;
	  gzip_proxied any;
	  gzip_types
	    text/css
	    text/javascript
	    text/xml
	    text/plain
	    text/x-component
	    application/javascript
	    application/x-javascript
	    application/json
	    application/xml
	    application/rss+xml
	    font/truetype
	    font/opentype
	    application/vnd.ms-fontobject
	    image/svg+xml;

		gzip_disable "MSIE [1-6]\.";
		gzip_vary on;

		# SSL Certs	
		ssl_certificate /etc/ssl/certs/example.com.crt;
		ssl_certificate_key /etc/ssl/certs/example.com.key;

    # Virtual Host Configs symlinked from each rails app
		include /etc/nginx/sites-enabled/*; 
}

unicorn.rb

# config/unicorn.rb
# Unicorn configuration file for each Rails app.

# Set defaults for app name

app_name = "appname"

app_directory = "/home/deployer/apps/#{app_name}"
working_directory "#{app_directory}/current"
shared_path = "#{app_directory}/shared"

# Set environment to development unless something else is specified
env = ENV["RAILS_ENV"] || "production"

# See http://unicorn.bogomips.org/Unicorn/Configurator.html for complete
# documentation.
worker_processes 1

# listen on both a Unix domain socket and a TCP port,
# we use a shorter backlog for quicker failover when busy
listen "#{shared_path}/unicorn.sock", :backlog => 64

# Preload our app for more speed
preload_app true

# nuke workers after 30 seconds instead of 60 seconds (the default)
timeout 30

pid "#{shared_path}/pids/unicorn.pid"

# Production specific settings
user 'deployer', 'staff'

stderr_path "#{shared_path}/log/unicorn.stderr.log"
stdout_path "#{shared_path}/log/unicorn.stdout.log"


before_fork do |server, worker|
  # the following is highly recomended for Rails + "preload_app true"
  # as there's no need for the master process to hold a connection
  if defined?(ActiveRecord::Base)
    ActiveRecord::Base.connection.disconnect!
  end

  # Before forking, kill the master process that belongs to the .oldbin PID.
  # This enables 0 downtime deploys.
  old_pid = "#{shared_path}/pids/unicorn.pid.oldbin"
  if File.exists?(old_pid) && server.pid != old_pid
    begin
      Process.kill("QUIT", File.read(old_pid).to_i)
    rescue Errno::ENOENT, Errno::ESRCH
      # someone else did our job for us
    end
  end
end

after_fork do |server, worker|
  # the following is *required* for Rails + "preload_app true",
  if defined?(ActiveRecord::Base)
    ActiveRecord::Base.establish_connection
  end

  # if preload_app is true, then you may also want to check and
  # restart any other shared sockets/descriptors such as Memcached,
  # and Redis.  TokyoCabinet file handles are safe to reuse
  # between any number of forked children (assuming your kernel
  # correctly implements pread()/pwrite() system calls)
end