मेरे पास एक उपसर्ग है जिसे मैं हर मार्ग में जोड़ना चाहता हूं। अभी मैं हर परिभाषा पर मार्ग में एक स्थिरांक जोड़ता हूं। क्या स्वचालित रूप से ऐसा करने का कोई तरीका है?
PREFIX = "/abc/123"
@app.route(PREFIX + "/")
def index_page():
return "This is a website about burritos"
@app.route(PREFIX + "/about")
def about_page():
return "This is a website about burritos"जवाबों:
उत्तर इस बात पर निर्भर करता है कि आप इस एप्लिकेशन को कैसे परोस रहे हैं।
यह मानते हुए कि आप WSGI कंटेनर (mod_wsgi, uwsgi, gunicorn, आदि) के अंदर इस एप्लिकेशन को चलाने जा रहे हैं; आपको उस WSGI कंटेनर के उप-भाग (कुछ भी जो WSGI बोलता है) करेगा के उप-भाग के रूप में उस उपसर्ग के लिए , वास्तव में माउंट करने की आवश्यकता है , और आपके APPLICATION_ROOTकॉन्फ़िगरेशन मान को आपके उपसर्ग पर सेट करने के लिए:
app.config["APPLICATION_ROOT"] = "/abc/123"
@app.route("/")
def index():
return "The URL for this page is {}".format(url_for("index"))
# Will return "The URL for this page is /abc/123/"APPLICATION_ROOTकॉन्फ़िगरेशन मान सेट करना फ्लास्क के सत्र कुकी को केवल उस URL उपसर्ग तक सीमित करें। फ्लास्क और वर्ज़ेग की उत्कृष्ट डब्ल्यूएसजीआई हैंडलिंग क्षमताओं द्वारा बाकी सब कुछ आपके लिए स्वचालित रूप से संभाला जाएगा।
यदि आप सुनिश्चित नहीं हैं कि पहले पैराग्राफ का क्या मतलब है, तो इस उदाहरण के आवेदन पर एक नज़र डालें, जिसके अंदर फ्लास्क लगा हुआ है:
from flask import Flask, url_for
from werkzeug.serving import run_simple
from werkzeug.wsgi import DispatcherMiddleware
app = Flask(__name__)
app.config['APPLICATION_ROOT'] = '/abc/123'
@app.route('/')
def index():
return 'The URL for this page is {}'.format(url_for('index'))
def simple(env, resp):
resp(b'200 OK', [(b'Content-Type', b'text/plain')])
return [b'Hello WSGI World']
app.wsgi_app = DispatcherMiddleware(simple, {'/abc/123': app.wsgi_app})
if __name__ == '__main__':
app.run('localhost', 5000)यदि, दूसरी तरफ, आप अपने फ्लास्क एप्लिकेशन को इसके WSGI कंटेनर की जड़ में चला रहे हैं और इसके लिए अनुरोध कर रहे हैं (उदाहरण के लिए, अगर यह FastCGI'd के लिए किया जा रहा है, या यदि proxy_passउप-समापन बिंदु के लिए nginx -ing अनुरोध है अपने स्टैंड-अलोन uwsgi/ geventसर्वर के बाद आप या तो कर सकते हैं:
DispatcherMiddlewareसे werkzeug(या PrefixMiddlewareसे su27 के जवाब के लिए) उप-माउंट आप उपयोग कर रहे स्टैंड-अलोन WSGI सर्वर में अपने आवेदन। ( कोड का उपयोग करने के लिए अपने ऐप को ठीक से उप-माउंट करने का एक उदाहरण देखें )।DispatcherMiddlewareदृष्टिकोण का उपयोग करते हुए , जब फ्लास्क खुद से चल रहा है। Gunicorn के पीछे भागते समय यह काम नहीं कर सकता।
uwsgi -s /tmp/yourapplication.sock --manage-script-name --mount /yourapplication=myapp:app। विस्तार से (uwsgi दस्तावेज़) देखें [ flask.pocoo.org/docs/1.0/deploying/uwsgi/]
आप अपने मार्गों को एक खाका में डाल सकते हैं:
bp = Blueprint('burritos', __name__,
template_folder='templates')
@bp.route("/")
def index_page():
return "This is a website about burritos"
@bp.route("/about")
def about_page():
return "This is a website about burritos"तब आप एक उपसर्ग का उपयोग करके आवेदन के साथ खाका पंजीकृत करते हैं:
app = Flask(__name__)
app.register_blueprint(bp, url_prefix='/abc/123')app.register_blueprintऔर इसे दर्ज करने के बीच जब आप ब्लूप्रिंट ऑब्जेक्ट को तुरंत पास करते हैं url_prefix='/abc/123? धन्यवाद!
register_blueprintकॉल में URL का उपसर्ग होने से एप्लिकेशन को कहीं भी, और यहां तक कि एक ही ब्लूप्रिंट को अलग-अलग URL पर एक ही ब्लूप्रिंट माउंट करने की स्वतंत्रता मिलती है। यदि आप उपसर्ग को ब्लूप्रिंट में डालते हैं तो आप आवेदन के लिए इसे आसान बनाते हैं, लेकिन आपके पास कम लचीलापन है।
आपको ध्यान देना चाहिए कि APPLICATION_ROOT इस उद्देश्य के लिए नहीं है।
आपको बस निम्नलिखित बदलाव करने के लिए एक मिडलवेयर लिखना है:
PATH_INFOउपसर्ग url को संभालने के लिए संशोधित करें।SCRIPT_NAMEउपसर्ग url उत्पन्न करने के लिए संशोधित करें।ऐशे ही:
class PrefixMiddleware(object):
def __init__(self, app, prefix=''):
self.app = app
self.prefix = prefix
def __call__(self, environ, start_response):
if environ['PATH_INFO'].startswith(self.prefix):
environ['PATH_INFO'] = environ['PATH_INFO'][len(self.prefix):]
environ['SCRIPT_NAME'] = self.prefix
return self.app(environ, start_response)
else:
start_response('404', [('Content-Type', 'text/plain')])
return ["This url does not belong to the app.".encode()]अपने ऐप को मिडलवेयर के साथ लपेटें, जैसे:
from flask import Flask, url_for
app = Flask(__name__)
app.debug = True
app.wsgi_app = PrefixMiddleware(app.wsgi_app, prefix='/foo')
@app.route('/bar')
def bar():
return "The URL for this page is {}".format(url_for('bar'))
if __name__ == '__main__':
app.run('0.0.0.0', 9010)पर जाएँ http://localhost:9010/foo/bar ,
आपको सही परिणाम मिलेगा: The URL for this page is /foo/bar
और अगर आपको जरूरत हो तो कुकी डोमेन सेट करना न भूलें।
यह समाधान लारिवैक्ट के जिस्ट द्वारा दिया गया है । यह APPLICATION_ROOTइस नौकरी के लिए नहीं है, हालांकि ऐसा लगता है। यह वास्तव में भ्रामक है।
APPLICATION_ROOTइस नौकरी के लिए नहीं है" - यह वह जगह है जहाँ मैं गलत हो रहा था। मैं चाहता हूँ Blueprintके url_prefixपैरामीटर और APPLICATION_ROOTडिफ़ॉल्ट रूप से संयुक्त कर दिया गया है, मैं हो सकता था ताकि APPLICATION_ROOTपूरे अनुप्रयोग के लिए सीमा URL, और url_prefixभीतर क्षेत्र URL APPLICATION_ROOTकेवल व्यक्तिगत खाका के लिए। उच्छ्वास
__call__: विधि response = Response('That url is not correct for this application', status=404) return response(environ, start_response)का उपयोग करfrom werkzeug.wrappers import BaseResponse as Response
यह एक फ्लास्क / वेर्केजग उत्तर की तुलना में अजगर के उत्तर का अधिक है; लेकिन यह आसान है और काम करता है।
अगर, मेरी तरह, आप चाहते हैं कि आपकी एप्लिकेशन सेटिंग ( .iniफ़ाइल से भरी हुई ) में आपके फ्लास्क एप्लिकेशन का उपसर्ग भी शामिल हो (इस प्रकार, तैनाती के दौरान मान सेट नहीं करना है, लेकिन रनटाइम के दौरान), तो आप निम्न का विकल्प चुन सकते हैं:
def prefix_route(route_function, prefix='', mask='{0}{1}'):
'''
Defines a new route function with a prefix.
The mask argument is a `format string` formatted with, in that order:
prefix, route
'''
def newroute(route, *args, **kwargs):
'''New function to prefix the route'''
return route_function(mask.format(prefix, route), *args, **kwargs)
return newrouteयकीनन, यह कुछ हद तक हैक है और इस तथ्य पर निर्भर करता है कि फ्लास्क मार्ग फ़ंक्शन की आवश्यकता हैrouteतर्क से पहले स्थितीय तर्क के रूप में ।
आप इसे इस तरह से उपयोग कर सकते हैं:
app = Flask(__name__)
app.route = prefix_route(app.route, '/your_prefix')एनबी: यह कुछ भी नहीं है कि उपसर्ग में एक चर का उपयोग करना संभव है (उदाहरण के लिए इसे सेट करके /<prefix>), और फिर इस उपसर्ग को उन कार्यों में संसाधित करें जिन्हें आप अपने साथ सजाते हैं @app.route(...)। यदि आप ऐसा करते हैं, तो आपको स्पष्ट रूप prefixसे अपने सजाए गए फ़ंक्शन में पैरामीटर घोषित करना होगा । इसके अलावा, आप कुछ नियमों के खिलाफ प्रस्तुत उपसर्ग की जांच करना चाहते हैं, और यदि चेक विफल हो जाता है तो 404 लौटा सकते हैं। 404 कस्टम री-इम्प्लीमेंटेशन से बचने के लिए, कृपया from werkzeug.exceptions import NotFoundऔर raise NotFound()यदि चेक विफल हो जाता है।
Blueprint। साझा करने के लिए धन्यवाद!
इसलिए, मेरा मानना है कि इसका एक मान्य उत्तर यह है: उपसर्ग को वास्तविक सर्वर अनुप्रयोग में कॉन्फ़िगर किया जाना चाहिए जिसका उपयोग आप विकास पूरा होने पर करते हैं। अपाचे, नग्नेक्स, आदि।
हालांकि, अगर आप विकास के दौरान काम करने के लिए इस चाहते हैं डिबग में बोतल एप्लिकेशन चलाते समय पर एक नज़र डालें इस सार ।
DispatcherMiddlewareबचाव लिए !मैं यहाँ कोड के लिए कोड कॉपी करूँगा:
"Serve a Flask app on a sub-url during localhost development."
from flask import Flask
APPLICATION_ROOT = '/spam'
app = Flask(__name__)
app.config.from_object(__name__) # I think this adds APPLICATION_ROOT
# to the config - I'm not exactly sure how!
# alternatively:
# app.config['APPLICATION_ROOT'] = APPLICATION_ROOT
@app.route('/')
def index():
return 'Hello, world!'
if __name__ == '__main__':
# Relevant documents:
# http://werkzeug.pocoo.org/docs/middlewares/
# http://flask.pocoo.org/docs/patterns/appdispatch/
from werkzeug.serving import run_simple
from werkzeug.wsgi import DispatcherMiddleware
app.config['DEBUG'] = True
# Load a dummy app at the root URL to give 404 errors.
# Serve app at APPLICATION_ROOT for localhost development.
application = DispatcherMiddleware(Flask('dummy_app'), {
app.config['APPLICATION_ROOT']: app,
})
run_simple('localhost', 5000, application, use_reloader=True)अब, एक स्वसंपूर्ण फ्लास्क ऐप के रूप में उपरोक्त कोड चलाते समय, http://localhost:5000/spam/प्रदर्शित करेगाHello, world! ।
एक अन्य उत्तर पर एक टिप्पणी में, मैंने व्यक्त किया कि मैं इस तरह से कुछ करना चाहता हूं:
from flask import Flask, Blueprint
# Let's pretend module_blueprint defines a route, '/record/<id>/'
from some_submodule.flask import module_blueprint
app = Flask(__name__)
app.config['APPLICATION_ROOT'] = '/api'
app.register_blueprint(module_blueprint, url_prefix='/some_submodule')
app.run()
# I now would like to be able to get to my route via this url:
# http://host:8080/api/some_submodule/record/1/DispatcherMiddlewareमेरे आकस्मिक उदाहरण पर लागू :
from flask import Flask, Blueprint
from flask.serving import run_simple
from flask.wsgi import DispatcherMiddleware
# Let's pretend module_blueprint defines a route, '/record/<id>/'
from some_submodule.flask import module_blueprint
app = Flask(__name__)
app.config['APPLICATION_ROOT'] = '/api'
app.register_blueprint(module_blueprint, url_prefix='/some_submodule')
application = DispatcherMiddleware(Flask('dummy_app'), {
app.config['APPLICATION_ROOT']: app
})
run_simple('localhost', 5000, application, use_reloader=True)
# Now, this url works!
# http://host:8080/api/some_submodule/record/1/एक और पूरी तरह से अलग तरीका माउंटपॉइंट्स के साथ है uwsgi।
एक ही प्रक्रिया ( पर्मलिंक ) में कई ऐप्स को होस्ट करने के बारे में डॉक्टर से ।
अपने uwsgi.iniआप में जोड़ें
[uwsgi]
mount = /foo=main.py
manage-script-name = true
# also stuff which is not relevant for this, but included for completeness sake:
module = main
callable = app
socket = /tmp/uwsgi.sockयदि आप अपनी फ़ाइल को कॉल नहीं करते हैं main.py, तो आपको mountऔर और दोनों को बदलने की आवश्यकता हैmodule
आप main.pyइस तरह दिख सकते हैं:
from flask import Flask, url_for
app = Flask(__name__)
@app.route('/bar')
def bar():
return "The URL for this page is {}".format(url_for('bar'))
# end defऔर एक nginx विन्यास (पूर्णता के लिए फिर से):
server {
listen 80;
server_name example.com
location /foo {
include uwsgi_params;
uwsgi_pass unix:///temp/uwsgi.sock;
}
}अब कॉलिंग फ्लास्क द्वारा लौटाए जाने पर example.com/foo/barप्रदर्शित होगी , क्योंकि यह स्वचालित रूप से एडाप्ट करता है। इस तरह आपके लिंक उपसर्ग समस्याओं के बिना काम करेंगे।/foo/barurl_for('bar')
from flask import Flask
app = Flask(__name__)
app.register_blueprint(bp, url_prefix='/abc/123')
if __name__ == "__main__":
app.run(debug='True', port=4444)
bp = Blueprint('burritos', __name__,
template_folder='templates')
@bp.route('/')
def test():
return "success"मुझे ऐसे ही "संदर्भ-मूल" की आवश्यकता थी। मैंने इसे WSGIScriptAlias का उपयोग करके /etc/httpd/conf.d/ के तहत गोपनीय फ़ाइल में किया:
<VirtualHost *:80>
WSGIScriptAlias /myapp /home/<myid>/myapp/wsgi.py
<Directory /home/<myid>/myapp>
Order deny,allow
Allow from all
</Directory>
</VirtualHost>इसलिए अब मैं अपने ऐप को इस प्रकार एक्सेस कर सकता हूं: http: // localhost: 5000 / myapp
गाइड देखें - http://modwsgi.readthedocs.io/en/develop/user-guides/quick-configuration-guide.html
मेरा समाधान जहां फ्लास्क और PHP एप्स नेक्स्टजिन नेग्नेक्स और PHP5.6
KEEP फ्लास्क रूट और PHP में उपनिर्देशिकाओं में
sudo vi /etc/php/5.6/fpm/php.ini1 पंक्ति जोड़ें
cgi.fix_pathinfo=0sudo vi /etc/php/5.6/fpm/pool.d/www.conf
listen = /run/php/php5.6-fpm.sock
uwsgi
sudo vi /etc/nginx/sites-available/defaultPHP के लिए NESTED LOCATIONS का उपयोग करें और FLASK को जड़ में रहने दें
server {
listen 80 default_server;
listen [::]:80 default_server;
# SSL configuration
#
# listen 443 ssl default_server;
# listen [::]:443 ssl default_server;
#
# Note: You should disable gzip for SSL traffic.
# See: https://bugs.debian.org/773332
#
# Read up on ssl_ciphers to ensure a secure configuration.
# See: https://bugs.debian.org/765782
#
# Self signed certs generated by the ssl-cert package
# Don't use them in a production server!
#
# include snippets/snakeoil.conf;
root /var/www/html;
# Add index.php to the list if you are using PHP
index index.html index.htm index.php index.nginx-debian.html;
server_name _;
# Serve a static file (ex. favico) outside static dir.
location = /favico.ico {
root /var/www/html/favico.ico;
}
# Proxying connections to application servers
location / {
include uwsgi_params;
uwsgi_pass 127.0.0.1:5000;
}
location /pcdp {
location ~* \.php$ {
try_files $uri =404;
fastcgi_split_path_info ^(.+\.php)(/.+)$;
fastcgi_pass unix:/var/run/php/php5.6-fpm.sock;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
include fastcgi_params;
}
}
location /phpmyadmin {
location ~* \.php$ {
try_files $uri =404;
fastcgi_split_path_info ^(.+\.php)(/.+)$;
fastcgi_pass unix:/var/run/php/php5.6-fpm.sock;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
include fastcgi_params;
}
}
# pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
#
#location ~ \.php$ {
# include snippets/fastcgi-php.conf;
#
# # With php7.0-cgi alone:
# fastcgi_pass 127.0.0.1:9000;
# # With php7.0-fpm:
# fastcgi_pass unix:/run/php/php7.0-fpm.sock;
#}
# deny access to .htaccess files, if Apache's document root
# concurs with nginx's one
#
#location ~ /\.ht {
# deny all;
#}
}READ सावधानी से https://www.digitalocean.com/community/tutorials/understanding-nginx-server-and-location-block-selection-algorithms
हमें स्थान मिलान (कोई नहीं) समझने की आवश्यकता है: यदि कोई संशोधक मौजूद नहीं है, तो स्थान की व्याख्या उपसर्ग मैच के रूप में की जाती है। इसका मतलब है कि दिए गए स्थान का मिलान मैच की शुरुआत के लिए अनुरोध URI की शुरुआत के खिलाफ किया जाएगा। =: यदि समान चिह्न का उपयोग किया जाता है, तो यह ब्लॉक मैच माना जाएगा यदि अनुरोध URI द्वारा दिए गए स्थान से बिल्कुल मेल खाता है। ~: यदि एक टिल्ड संशोधक मौजूद है, तो इस स्थान को केस-सेंसिटिव रेगुलर एक्सप्रेशन मैच के रूप में समझा जाएगा। ~ *: यदि एक टिल्ड और तारांकन संशोधक का उपयोग किया जाता है, तो स्थान ब्लॉक को केस-इन्सेंसिव रेगुलर एक्सप्रेशन मैच के रूप में व्याख्यायित किया जाएगा। ^ ~: यदि एक कैरेट और टिल्ड संशोधक मौजूद है, और यदि इस ब्लॉक को सर्वश्रेष्ठ गैर-नियमित अभिव्यक्ति मैच के रूप में चुना जाता है, तो नियमित अभिव्यक्ति मिलान नहीं होगा।
ऑर्डर महत्वपूर्ण है, नंगेक्स के "स्थान" विवरण से:
दिए गए अनुरोध के मिलान वाले स्थान को खोजने के लिए, nginx पहले उपसर्ग स्ट्रिंग्स (उपसर्ग स्थानों) का उपयोग करके परिभाषित स्थानों की जांच करता है। उनमें से, सबसे लंबे मिलान वाले उपसर्ग के साथ स्थान का चयन और याद किया जाता है। फिर कॉन्फ़िगरेशन फ़ाइल में उनकी उपस्थिति के क्रम में नियमित अभिव्यक्ति की जांच की जाती है। नियमित अभिव्यक्तियों की खोज पहले मैच पर समाप्त होती है, और संबंधित कॉन्फ़िगरेशन का उपयोग किया जाता है। यदि नियमित अभिव्यक्ति के साथ कोई मेल नहीं मिलता है, तो पहले याद किए गए उपसर्ग स्थान के कॉन्फ़िगरेशन का उपयोग किया जाता है।
इसका मतलब:
First =. ("longest matching prefix" match)
Then implicit ones. ("longest matching prefix" match)
Then regex. (first match)अभी भी इससे जूझ रहे लोगों के लिए, पहला उदाहरण काम करता है, लेकिन पूर्ण उदाहरण यहाँ है यदि आपके पास एक फ्लास्क ऐप है जो आपके नियंत्रण में नहीं है:
from os import getenv
from werkzeug.middleware.dispatcher import DispatcherMiddleware
from werkzeug.serving import run_simple
from custom_app import app
application = DispatcherMiddleware(
app, {getenv("REBROW_BASEURL", "/rebrow"): app}
)
if __name__ == "__main__":
run_simple(
"0.0.0.0",
int(getenv("REBROW_PORT", "5001")),
application,
use_debugger=False,
threaded=True,
)
flask.Flask#create_url_adapterऔरwerkzeug.routing.Map#bind_to_environऐसा लगता है कि यह काम करना चाहिए - आप कोड कैसे चला रहे थे? (url_forअपेक्षित मूल्य को वापस करने के लिए ऐप को वास्तव में एक WSGI वातावरण में उप-पथ पर रखा जाना चाहिए ।)