The files that actually move are as follows
app.py
from flask import Flask
app = Flask(__name__)
@app.route("/")
def hello():
return "Hello World!"
install
$ git clone https://github.com/riywo/anyenv ~/.anyenv
$ echo 'export PATH="$HOME/.anyenv/bin:$PATH"' >> ~/.bashrc
$ echo 'eval "$(anyenv init -)"' >> ~/.bashrc
$ exec $SHELL -l
$ pyenv install 3.4.1
$ cd ~/.anyenv/envs/pyenv/plugins
$ git clone git://github.com/yyuu/pyenv-virtualenv.git
$ pyenv virtualenv flask-3.4.1
$ pyenv rehash
$ sudo yum install -y nginx
Create a virtualenv environment so as not to pollute the environment. Create a directory to save the app, bring the app and install the library
$ mkdir -p /path/to/flask
$ cd /path/to/flask
$ pyenv local flask-3.4.1
$ python --version
Python 3.4.1
$ cp -r /path/to/flask/app ./
$ pip install gunicorn
$ pip install -r requirements.txt
or
$ pip install hoge fuga...
Actually run gunicorn.
$ ~/.anyenv/envs/pyenv/shims/gunicorn app:app &
Check if the process has started normally
$ ps ax | grep gunicorn
2234 pts/0 S 0:00 /home/vagrant/.anyenv/envs/pyenv/versions/flask-3.4.1/bin/python3.4 /home/vagrant/.anyenv/envs/pyenv/versions/flask-3.4.1/bin/gunicorn app:app
2241 pts/0 S 0:00 /home/vagrant/.anyenv/envs/pyenv/versions/flask-3.4.1/bin/python3.4 /home/vagrant/.anyenv/envs/pyenv/versions/flask-3.4.1/bin/gunicorn app:app
2265 pts/0 S+ 0:00 grep gunicorn
Drop the gunicorn process launched in the test.
$ ps ax | grep gunicorn | awk '{print $1}' | xargs kill
Create nginx config file
$ vim example.conf
example.conf
upstream app_server {
server unix:/tmp/gunicorn.sock fail_timeout=0;
# For a TCP configuration:
}
server {
listen 80 default;
client_max_body_size 4G;
server_name _;
keepalive_timeout 5;
# path for static files
root /path/to/flask/public;
location / {
# checks for static file, if not found proxy to app
try_files $uri @proxy_to_app;
break;
}
location @proxy_to_app {
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header Host $http_host;
proxy_redirect off;
proxy_pass http://app_server;
}
}
copy
$ sudo cp example.conf /etc/nginx/conf.d/
Create a gunicorn configuration file.
$ vim gunicorn.conf.py
Python:gunicorn.conf.py
# Sample Gunicorn configuration file.
#
# Process naming
#
# proc_name - A base to use with setproctitle to change the way
# that Gunicorn processes are reported in the system process
# table. This affects things like 'ps' and 'top'. If you're
# going to be running more than one instance of Gunicorn you'll
# probably want to set a name to tell them apart. This requires
# that you install the setproctitle module.
#
# A string or None to choose a default of something like 'gunicorn'.
#
proc_name = "gunicorn"
#
# Server socket
#
# bind - The socket to bind.
#
# A string of the form: 'HOST', 'HOST:PORT', 'unix:PATH'.
# An IP is a valid HOST.
#
# backlog - The number of pending connections. This refers
# to the number of clients that can be waiting to be
# served. Exceeding this number results in the client
# getting an error when attempting to connect. It should
# only affect servers under significant load.
#
# Must be a positive integer. Generally set in the 64-2048
# range.
#
bind = 'unix:/tmp/{0}.sock'.format(proc_name)
backlog = 2048
#
# Worker processes
#
# workers - The number of worker processes that this server
# should keep alive for handling requests.
#
# A positive integer generally in the 2-4 x $(NUM_CORES)
# range. You'll want to vary this a bit to find the best
# for your particular application's work load.
#
# worker_class - The type of workers to use. The default
# async class should handle most 'normal' types of work
# loads. You'll want to read http://gunicorn/deployment.hml
# for information on when you might want to choose one
# of the other worker classes.
#
# An string referring to a 'gunicorn.workers' entry point
# or a python path to a subclass of
# gunicorn.workers.base.Worker. The default provided values
# are:
#
# egg:gunicorn#sync
# egg:gunicorn#eventlet - Requires eventlet >= 0.9.7
# egg:gunicorn#gevent - Requires gevent >= 0.12.2 (?)
# egg:gunicorn#tornado - Requires tornado >= 0.2
#
# worker_connections - For the eventlet and gevent worker classes
# this limits the maximum number of simultaneous clients that
# a single process can handle.
#
# A positive integer generally set to around 1000.
#
# timeout - If a worker does not notify the master process in this
# number of seconds it is killed and a new worker is spawned
# to replace it.
#
# Generally set to thirty seconds. Only set this noticeably
# higher if you're sure of the repercussions for sync workers.
# For the non sync workers it just means that the worker
# process is still communicating and is not tied to the length
# of time required to handle a single request.
#
# keepalive - The number of seconds to wait for the next request
# on a Keep-Alive HTTP connection.
#
# A positive integer. Generally set in the 1-5 seconds range.
#
workers = 1
worker_class = 'sync'
worker_connections = 1000
timeout = 30
keepalive = 2
#
# Debugging
#
# debug - Turn on debugging in the server. This limits the number of
# worker processes to 1 and changes some error handling that's
# sent to clients.
#
# True or False
#
# spew - Install a trace function that spews every line of Python
# that is executed when running the server. This is the
# nuclear option.
#
# True or False
#
debug = False
spew = False
#
# Server mechanics
#
# daemon - Detach the main Gunicorn process from the controlling
# terminal with a standard fork/fork sequence.
#
# True or False
#
# pidfile - The path to a pid file to write
#
# A path string or None to not write a pid file.
#
# user - Switch worker processes to run as this user.
#
# A valid user id (as an integer) or the name of a user that
# can be retrieved with a call to pwd.getpwnam(value) or None
# to not change the worker process user.
#
# group - Switch worker process to run as this group.
#
# A valid group id (as an integer) or the name of a user that
# can be retrieved with a call to pwd.getgrnam(value) or None
# to change the worker processes group.
#
# umask - A mask for file permissions written by Gunicorn. Note that
# this affects unix socket permissions.
#
# A valid value for the os.umask(mode) call or a string
# compatible with int(value, 0) (0 means Python guesses
# the base, so values like "0", "0xFF", "0022" are valid
# for decimal, hex, and octal representations)
#
# tmp_upload_dir - A directory to store temporary request data when
# requests are read. This will most likely be disappearing soon.
#
# A path to a directory where the process owner can write. Or
# None to signal that Python should choose one on its own.
#
daemon = True
pidfile = "/tmp/gunicorn.pid"
umask = 0
user = None
group = None
tmp_upload_dir = None
#
# Logging
#
# logfile - The path to a log file to write to.
#
# A path string. "-" means log to stdout.
#
# loglevel - The granularity of log output
#
# A string of "debug", "info", "warning", "error", "critical"
#
errorlog = '/var/log/gunicorn/error.log'
loglevel = 'debug'
accesslog = '/var/log/gunicorn/access.log'
#
# Server hooks
#
# post_fork - Called just after a worker has been forked.
#
# A callable that takes a server and worker instance
# as arguments.
#
# pre_fork - Called just prior to forking the worker subprocess.
#
# A callable that accepts the same arguments as after_fork
#
# pre_exec - Called just prior to forking off a secondary
# master process during things like config reloading.
#
# A callable that takes a server instance as the sole argument.
#
def post_fork(server, worker):
server.log.info("Worker spawned (pid: %s)", worker.pid)
def pre_fork(server, worker):
pass
def pre_exec(server):
server.log.info("Forked child, re-executing.")
def when_ready(server):
server.log.info("Server is ready. Spawning workers")
def worker_int(worker):
worker.log.info("worker received INT or QUIT signal")
## get traceback info
import threading, sys, traceback
id2name = dict([(th.ident, th.name) for th in threading.enumerate()])
code = []
for threadId, stack in sys._current_frames().items():
code.append("\n# Thread: %s(%d)" % (id2name.get(threadId,""),
threadId))
for filename, lineno, name, line in traceback.extract_stack(stack):
code.append('File: "%s", line %d, in %s' % (filename,
lineno, name))
if line:
code.append(" %s" % (line.strip()))
worker.log.debug("\n".join(code))
def worker_abort(worker):
worker.log.info("worker received SIGABRT signal")
It is troublesome to type a command every time, so create a script.
$ vim production_server_rc
#!/bin/sh
GUNICORN=$HOME/.anyenv/envs/pyenv/shims/gunicorn
PROJECT_ROOT=/path/to/flask
APP=app:app
cd $PROJECT_ROOT
exec $GUNICORN -c $PROJECT_ROOT/gunicorn.conf.py $APP
Launch nginx.
$ sudo /etc/init.d/nginx start
Launch gunicorn.
$ ./production_server.sh
Installing and using pyenv and virtualenv gunicorn / examples / gunicorn_rc gunicorn / examples / example_config.py
Recommended Posts