flask structure

#gunicorn -c gunicorn_conf.py main:app
#gunicorn main:app --bind 0.0.0.0:8001 -w 4 --worker-class uvicorn.workers.UvicornWorker  # -D 守护启动 -c 配置文件
#gunicorn -c gunicorn_conf.py main:app -k uvicorn.workers.UvicornWorker
gunicorn main:app -b 0.0.0.0:8008 -w 4 -k uvicorn.workers.UvicornWorker

.
├── Dockerfile
        FROM python:3.7.11-buster
        WORKDIR /app
        COPY requirements.txt ./requirements.txt
        RUN pip3 install -r requirements.txt -i http://mirrors.aliyun.com/pypi/simple --trusted-host mirrors.aliyun.com
        EXPOSE 8004
        
        #RUN mv /usr/local/lib/python3.8/site-packages/crypto /usr/local/lib/python3.8/site-packages/Crypto
        
        COPY . ./
        CMD ["sh","./start.sh"]
        
        #docker build --no-cache=true -t poi-decrpt:0609 .
        #docker run -it 390754d6f105 /bin/bash 以交互模式运行容器 进入镜像
        #docker exec -it 7701d90d6d62 /bin/bash 在运行的容器中执行命令 进入容器
        #docker ps -a
        #docker rmi image_id
        #docker rm container_id
        #docker run -d --name name-address-normal-container -p 8008:8004 192.168.106.46:5000/name-address-normal:v1
        #http://127.0.0.1:81/poi/poi_decript?id=1
        #docker stop container_id
        
├── __init__.py
├── app
│   ├── __init__.py
        def create_app():
           app = Flask(__name__)
           app.config.from_object(None)
           app.config["JSON_AS_ASCII"] = False
           app.register_blueprint(normal_bp, url_prefix="/poi")
           return app
│   └── views
│       ├── __init__.py
                    from flask import Blueprint
                    normal_bp = Blueprint('normal_bp', __name__)
                    import app.views.normal_api
│       ├── normal_api.py
│       └── readme.md
├── config.py
├── core
│   ├── __init__.py
│   ├── config.py
│   └── config3.py
├── gunicorn_conf.py
        import os

        if os.path.exists('log'):
            os.system('rm -rf log',)
        os.mkdir('log')

        # 并行工作进程数
        workers = 8
        # 指定每个工作者的线程数
        threads = 2
        # 监听内网端口5000
        bind = '0.0.0.0:8004'
        # 设置守护进程,将进程交给supervisor管理
        # daemon = 'false'
        # 工作模式协程
        # worker_class = 'gevent'
        # 设置最大并发量
        # worker_connections = 2000
        # 设置进程文件目录
        pidfile = 'log/gunicorn.pid'
        # 设置访问日志和错误信息日志路径
        accesslog = 'log/gunicorn_access.log'
        errorlog = 'log/gunicorn_error.log'
        # 设置日志记录水平
        loglevel = 'debug'
├── log
│   ├── gunicorn_access.log
│   └── gunicorn_error.log
├── logs
│   └── decript-app.log
├── main.py
        from app import create_app
        from core.config import setting
        app = create_app()
        if __name__ == '__main__':
            app.run(host='0.0.0.0', port=setting.PORT)

├── makefile
        docker_tag_poi_worker=192.168.106.46:5000/name-address-normal:v1
        #docker_tag_poi_worker=192.168.160.20:5000/name-address-normal:v1
        docker_build_worker:
            docker build -t $(docker_tag_poi_worker) -f Dockerfile .

        docker_push_worker:
            docker push $(docker_tag_poi_worker)

        docker_build_push_worker:
            make docker_build_worker
            make docker_push_worker


├── requirements.txt
├── start.sh
        gunicorn -c gunicorn_conf.py main:app

.
├── Dockerfile
├── __init__.py
├── app
│   ├── __init__.py
        import traceback
    
        from fastapi import FastAPI, Request
    
        from core.response import ResError
        from tools.logger import logger
        from starlette.middleware.cors import CORSMiddleware
        from app.views import router
    
    
        def create_app():
            app = FastAPI(title="数据规范化服务")
            app.include_router(router)
    
            # 设置跨域
            app.add_middleware(
                CORSMiddleware,
                allow_origins=["*", ],
                allow_credentials=True,
                allow_methods=["*"],
                allow_headers=["*"],
            )
    
            # 自定义访问日志中间件
            @app.middleware("http")
            async def logger_request(request: Request, call_next):
                logger.info(f"{request.method} url:{request.url}\nheaders:{request.headers.get('user-agent')}"
                            f"\nIP:{request.client.host}")
                response = await call_next(request)
                return response
    
            return app
    
    
        def register_exception(app: FastAPI) -> None:
            # 捕获全部异常
            @app.exception_handler(Exception)
            async def all_exception_handler(request: Request, exc: Exception):
                """
                全局所有异常
                :param request:
                :param exc:
                :return:
                """
                logger.error(f"全局异常\n{request.method}URL:{request.url}\nHeaders:{request.headers}\n{traceback.format_exc()}")
                return ResError()

│   ├── para_model
│   │   ├── __init__.py
│   │   └── normal_model.py
            from pydantic import BaseModel
            from typing import List
            class EncryptData(BaseModel):
                source_id: str
                id: str
            
            class EncryptItem(BaseModel):
                key: str = None
                iv: str = None
                data: List[EncryptData]

│   └── views
│       ├── __init__.py
            from fastapi import APIRouter
            from app.views.normal_api import normal_router
            router = APIRouter(prefix="/poi")
            router.include_router(normal_router)

│       ├── normal_api.py
            normal_router = APIRouter(tags=["规范化接口"])
            @normal_router.post("/poi_normal")
            def poi_normal(normal_item: List[NormalItem]):
                start = datetime.now()
                result = {}
                for item in normal_item:
                    res = normalize([item.dict()])
                    if not res:
                        result[item.id] = item
                        continue
                    result[item.id] = res
                end = datetime.now()
                delta_time = end - start
                logger.info(f"time use:{delta_time.seconds * 1000 + delta_time.microseconds / 1000}")
                return ResSuccess(data=result)

│       └── readme.md
├── config.py
├── core
│   ├── __init__.py
│   ├── config.py
│   ├── config3.py
│   └── response.py
            from typing import Any
            from pydantic import BaseModel
            class ResponseBase(BaseModel):
                data: Any = None
            class ResSuccess(ResponseBase):
                code = 1
                msg = "操作成功"
├── gunicorn_conf.py
├── log
│   ├── gunicorn_access.log
│   └── gunicorn_error.log
├── logs
│   ├── decript-app.2021-09-06_10-43-38_401825.log
├── main.py
            from app import create_app
            import uvicorn
            from core.config import setting

            app = create_app()
            if __name__ == '__main__':
                uvicorn.run("main:app", host="127.0.0.1", port=setting.PORT, debug=True, workers=4)

├── makefile
├── requirements.txt
├── start.sh
          gunicorn -c gunicorn_conf.py main:app -k uvicorn.workers.UvicornWorker
└── tools
    ├── __init__.py
    ├── logger.py
    ├── multiprocess_util.py
    ├── prpcrypt_util.py
    ├── response.py
    ├── third_util.py
    └── util.py