This post previously published on my blog
Hi. I have been developing Flask applications as a side project for 5 years. After all these years, I found the right structure I need for me.
First Steps
Firstly, I'm always using virtualenv to isolate my projects. For example, we want to develop a poll app.
mkdir poll_app
cd poll_app
virtualenv .
source bin/activate
Python Libraries I Always Use
I'm developing applications that require a database. So, I always use flask_script and flask_migrate libraries. I don't like Flask's CLI tool.
- Flask-Script: https://flask-script.readthedocs.io/en/latest/
- Flask-Migrate: https://flask-migrate.readthedocs.io/en/latest/
I create a python file called manage.py such as Django's in the root folder. For example;
from MYAPP.data.models import db
from MYAPP import app
from flask_script import Manager
from flask_migrate import Migrate, MigrateCommand
db.init_app(app)
migrate = Migrate(app, db)
manager = Manager(app)
manager.add_command('db', MigrateCommand)
if __name__ == "__main__":
manager.run()
I'm using like that;
python manage.py db init # --> init migrations
python manage.py db migrate # --> migrate models
python manage.py db upgrade # --> apply changes
python manage.py db --help # --> :)
Main app file
I create a file app.py in the root folder when I create a new project and then it changes like that.
from MYAPP import app
# To do: This place will change later
config = {
"development": "config.Development"
}
if __name__ == "__main__":
app.config.from_object(config["development"])
app.run()
Config File
I also create a file called config.py in the root folder.
class BaseConfig(object):
""" Base config class. This fields will use by production and development server """
ORIGINS = ["*"] # for api calls
SECRET_KEY = 'YOUR SECRET KEY'
class Development(BaseConfig):
""" Development config. We use Debug mode """
PORT = 5000
DEBUG = True
TESTING = False
ENV = 'dev'
# Currently we only have development config.
# If you have production, you will need to pass it to here.
config = {
'development': 'config.Development'
}
def configure_app(app):
"""
App configuration will be here.
Parameters
----------
app : Flask
app instance
"""
app.config.from_object(config['development'])
Folder Structure
I create a folder in the root directory. Let's say folder name is om_core. I create two folders in the om_core.
Their name api and data. The api folder stores application logic and routes. For example, I created a folder called user.
This folder contains two files called init.py and controllers.py file. Our other api layers will be like that. The controller file should be like that;
from flask import Blueprint, jsonify, request
from MYAPP.data.models import db, User
user = Blueprint('user', __name__)
@user.route('/', methods=['GET'])
def get_users():
return jsonify({ "message": "Hi user :)"})
@user.route('/<int:id>', methods=['GET'])
def users(id):
return jsonify({ "id": id })
I always use blueprints.
The data folder stores models. For example, I created a file called models.py
from flask_sqlalchemy import SQLAlchemy
from MYAPP import app
# We didn't pass app instance here.
db = SQLAlchemy()
class User(db.Model):
""" Model for user management """
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(100), unique=True)
password = db.Column(db.String(100))
name = db.Column(db.String(100))
surname = db.Column(db.String(100))
active = db.Column(db.Boolean(), default=True)
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime, default=db.func.now())
def __init__(self, email, password, name, surname, active, created_at, updated_at):
self.email = email
self.password = password
self.name = name
self.surname = surname
self.active = active
self.created_at = created_at
self.updated_at = updated_at
Let's get back to the om_core folder. I create a file called init.py to use API layers as endpoints.
from flask import Flask
from flask_cors import CORS
from config import BaseConfig
from config import configure_app
app = Flask(__name__)
from MYAPP.api.user.controllers import user
""" Corst settings will be here. We maybe use this endpoint later. """
cors = CORS(app, resources={
r'/api/*': {
'origins': BaseConfig.ORIGINS
}
})
configure_app(app)
app.url_map.strict_slashes = False
app.register_blueprint(user, url_prefix='/api/users')
You don't need to use Flask-CORS if you don't want to allow request from different origins. I'm using it to allow requests from different origins.
Screenshot for My Project Structure
This is a screenshot for my project structure.
That's all. If you want to see this project on the GitHub: https://github.com/foss-dev/open-monitoring
Thanks for reading.
Top comments (17)
Thanks for the post! I have a few questions if you don’t mind:
Any reason you choose to create and import the app directly instead of using the factory method?
How do you usually run Flask apps in production? (e.g. gunicorn, waitress, etc.)
How do you manage configs for different environments?
How do you distribute the services to the server?
Hi. Thanks for your questions :)
1-) Actually, this is a habit for me. I never used a factory method in my Flask apps. Also, I don't know what are the benefits of factory methods.
2-) I use gunicorn.
3-) I usually use dotenv. But I used class-based configs for this post :)
4-) I don't understand this question :/
Thanks :)
Benefit of using factory methods
Testing. You can have instances of the application with different settings to test every case.
Multiple instances. Imagine you want to run different versions of the same application. Of course you could have multiple instances with different configs set up in your webserver, but if you use factories, you can have multiple instances of the same application running in the same application process which can be handy.
Hmm, can you show an example about factory methods for the newbies :)
Sure in a bit
Thanks, I'll be waiting for your contribution. Thanks.
The fourth question means:
How do you deploy your monolith/microservices to your server?
Hmm. I'm using the EB CLI.
Firstly, I install it.
I also set secret keys for the elastic bean in the ~/.aws/config file.
and then I use these commands.
Did you mean this? :P I hope :/)
Yes, thank you. I’ve never used elastic beanstalk before, I’ll add it to the list of services to explore. Thanks for all your answers!
Actually, I only used it twice times. I'll use gcloud or azure next times. (This is my plan). Thanks :)
I think the question four was referring to whether it's a microservice or monolithic app.
I run flask on AWS lambda. This is my application structure: github.com/jetbridge/sls-flask/
Started using Flask recently, and this article is really helpful, thank you! Also enjoying the discussions in the comments.
I like Flask Blueprint architecture flask.pocoo.org/docs/1.0/blueprints/
Yes, I use blueprints :)
ask how to call app.config['some conf'] in views?
I also trying to create a command-line project that creates this code automatically.
github.com/openuniquesolution/flas...
If you feel its good idea pls start raising pr