how to run gunicorn on docker

Question

I have 2 files that depend on each other when docker is start up. 1 is a flask file and one is a file with a few functions. When docker starts, only the functions file will be executed but it imports flask variables from the flask file. Example:

Flaskfile

import flask
from flask import Flask, request
import json

_flask = Flask(__name__)

@_flask.route('/', methods = ['POST'])
def flask_main():
    s = str(request.form['abc'])
    ind = global_fn_main(param1,param2,param3)
    return ind

def run(fn_main):
    global global_fn_main
    global_fn_main = fn_main
    _flask.run(debug = False, port = 8080, host = '0.0.0.0', threaded = True)

Main File

import flaskfile
#a few functions then
if__name__ == '__main__':
    flaskfile.run(main_fn)

The script runs fine without need a gunicorn.

Dockerfile

  FROM python-flask
  ADD *.py *.pyc /code/
  ADD requirements.txt /code/
  WORKDIR /code
  EXPOSE 8080
  CMD ["python","main_file.py"]

In the Command line: i usally do: docker run -it -p 8080:8080 my_image_name and then docker will start and listen.

Now to use gunicorn:
I tried to modify my CMD parameter in the dockerfile to

["gunicorn", "-w", "20", "-b", "127.0.0.1:8083", "main_file:flaskfile"]

but it just keeps exiting. Am i not writing the docker gunicorn command right?

Asked By: jxn

||

Source

Answer 1

This is my last part of my Dockerfile with Django App

EXPOSE 8002
COPY entrypoint.sh /code/
WORKDIR /code
ENTRYPOINT ["sh", "entrypoint.sh"]

then in entrypoint.sh

#!/bin/bash

# Prepare log files and start outputting logs to stdout
mkdir -p /code/logs
touch /code/logs/gunicorn.log
touch /code/logs/gunicorn-access.log
tail -n 0 -f /code/logs/gunicorn*.log &

export DJANGO_SETTINGS_MODULE=django_docker_azure.settings

exec gunicorn django_docker_azure.wsgi:application 
    --name django_docker_azure 
    --bind 0.0.0.0:8002 
    --workers 5 
    --log-level=info 
    --log-file=/code/logs/gunicorn.log 
    --access-logfile=/code/logs/gunicorn-access.log 
"$@"

Hope this could be useful

Answered By: e.arbitrio

Answer 2

I just went through this problem this week and stumbled on your question along the way. Fair to say you either resolved this or changed approaches by now, but for future’s sake:

The command in my Dockerfile is:

CMD ["gunicorn"  , "-b", "0.0.0.0:8000", "app:app"]

Where the first “app” is the module and the second “app” is the name of the WSGI callable, in your case, it should be _flask from your code although you’ve some other stuff going on that makes me less certain.

Gunicorn takes the place of all the run statements in your code, if Flask’s development web server and Gunicorn try to take the same port it can conflict and crash Gunicorn.

Note that when run by Gunicorn, __name__ is not “main”. In my example it is equal to “app”.

At my admittedly junior level of both Python, Docker, and Gunicorn the fastest way to debug is to comment out the “CMD” in the Dockerfile, get the container up and running:

docker run -it -d -p 8080:8080 my_image_name

Hop onto the running container:

 docker exec -it container_name /bin/bash

And start Gunicorn from the command line until you’ve got it working, then test with curl – I keep a basic route in my app.py file that just prints out “Hi” and has no dependencies for validating the server is up before worrying about the port binding to the host machine.

Answered By: user7504939

Answer 3

This work for me:

FROM docker.io/python:3.7

WORKDIR /app

COPY requirements.txt ./

RUN pip install --no-cache-dir -r requirements.txt

ENV GUNICORN_CMD_ARGS="--bind=0.0.0.0 --chdir=./src/"
COPY . .

EXPOSE 8000

CMD [ "gunicorn", "app:app" ]

Answered By: burtsevyg

Answer 4

gunicorn main:app –workers 4 –bind :3000 –access-logfile ‘-‘

Answered By: user8926546

Answer 5

I was trying to run a flask app as well. I found out that you can just use

ENTRYPOINT['gunicorn', '-b', ':8080', 'app:APP']

This will take take the file you have specified and run on the docker instance. Also, don’t forget the shebang on the top, #!/usr/bin/env python if you are running the Debug LOG-LEVEL.

Answered By: Shreyaa Sridhar

Answer 6

After struggling with this issue over the last 3 days, I found that all you need to do is to bind to the non-routable meta-address 0.0.0.0 rather than the loopback IP 127.0.0.1:

CMD ["gunicorn" , "--bind", "0.0.0.0:8000", "app:app"]

And don’t forget to expose the port, one option to do that is to use EXPOSE
in your Dockerfile:

EXPOSE 8000

Now:

docker build -t test .

Finally you can run:

docker run -d -p 8000:8000 test

Answered By: Mohamad Al Mdfaa

how to run gunicorn on docker

Question:

Answers: