Help us understand the problem. What is going on with this article?

CentOS上でFlaskをpython3.4、Gunicorn + Nginxで動かす。

More than 5 years have passed since last update.

実際に動かすファイルは下記

app.py
from flask import Flask
app = Flask(__name__)

@app.route("/")
def hello():
    return "Hello World!"

install

  • pyenv(anyenv) + virualenvをインストール
$ 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

環境を汚さないように、virtualenv環境を作成。
アプリを保存するディレクトリを作成し、アプリを持ってきて、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...

gunicornを動かす

実際にgunicornを動かす。

$ ~/.anyenv/envs/pyenv/shims/gunicorn app:app &

確認

プロセスが正常に立ち上がっているか確認

$ 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

設定ファイルを作成

テストで立ち上げたgunicornプロセスを一旦落とす。

$ ps ax | grep gunicorn | awk '{print $1}' | xargs kill

nginxの設定ファイルを作成
$ 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/

gunicornの設定ファイルを作成。
$ vim gunicorn.conf.py

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")

毎回コマンドを打つのは面倒なので、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

nginxを立ち上げる。

$ sudo /etc/init.d/nginx start

gunicornを立ち上げる。

$ ./production_server.sh

参考

pyenvとvirtualenvのインストールと使い方
gunicorn / examples / gunicorn_rc
gunicorn / examples / example_config.py

teitei_tk
Software Engineer
https://teitei-tk.com/
Why not register and get more from Qiita?
  1. We will deliver articles that match you
    By following users and tags, you can catch up information on technical fields that you are interested in as a whole
  2. you can read useful information later efficiently
    By "stocking" the articles you like, you can search right away