Para el siguiente ajax solicitud post para Flask (¿cómo puedo utilizar los datos publicados a partir de ajax en el frasco?):

$.ajax({
    url: "http://127.0.0.1:5000/foo", 
    type: "POST",
    contentType: "application/json",
    data: JSON.stringify({'inputVar': 1}),
    success: function( data ) { 
        alert( "success" + data );
    }   
});

Tengo un Origen de la Cruz de Compartir Recursos (CORS) de error:

No 'Access-Control-Allow-Origin' header is present on the requested resource. 
Origin 'null' is therefore not allowed access. 
The response had HTTP status code 500.

Traté de resolverlo en los dos siguientes maneras, pero ninguno parece funcionar.

  1. Mediante Termo-CORS

Este es un Flask de extensión para el manejo de CORS que debe hacer cross-origen AJAX posible.

Mi pythonServer.py el uso de esta solución:

from flask import Flask
from flask.ext.cors import CORS, cross_origin

app = Flask(__name__)
cors = CORS(app, resources={r"/foo": {"origins": "*"}})
app.config['CORS_HEADERS'] = 'Content-Type'

@app.route('/foo', methods=['POST','OPTIONS'])
@cross_origin(origin='*',headers=['Content-Type','Authorization'])
def foo():
    return request.json['inputVar']

if __name__ == '__main__':
    app.run()
  1. El uso específico de Matraz Decorador

Este es un oficial Matraz fragmento de código de la definición de un decorador, que debe permitir CORS en las funciones que la decora.

Mi pythonServer.py el uso de esta solución:

from flask import Flask, make_response, request, current_app
from datetime import timedelta
from functools import update_wrapper

app = Flask(__name__)

def crossdomain(origin=None, methods=None, headers=None,
                max_age=21600, attach_to_all=True,
                automatic_options=True):
    if methods is not None:
        methods = ', '.join(sorted(x.upper() for x in methods))
    if headers is not None and not isinstance(headers, basestring):
        headers = ', '.join(x.upper() for x in headers)
    if not isinstance(origin, basestring):
        origin = ', '.join(origin)
    if isinstance(max_age, timedelta):
        max_age = max_age.total_seconds()

    def get_methods():
        if methods is not None:
            return methods

        options_resp = current_app.make_default_options_response()
        return options_resp.headers['allow']

    def decorator(f):
        def wrapped_function(*args, **kwargs):
            if automatic_options and request.method == 'OPTIONS':
                resp = current_app.make_default_options_response()
            else:
                resp = make_response(f(*args, **kwargs))
            if not attach_to_all and request.method != 'OPTIONS':
                return resp

            h = resp.headers

            h['Access-Control-Allow-Origin'] = origin
            h['Access-Control-Allow-Methods'] = get_methods()
            h['Access-Control-Max-Age'] = str(max_age)
            if headers is not None:
                h['Access-Control-Allow-Headers'] = headers
            return resp

        f.provide_automatic_options = False
        return update_wrapper(wrapped_function, f)
    return decorator

@app.route('/foo', methods=['GET','POST','OPTIONS'])
@crossdomain(origin="*")
def foo():
    return request.json['inputVar']

if __name__ == '__main__':
    app.run()

Por favor puede dar algunos indicios de por qué es eso?

  • ¿a averiguar? Me encuentro con el mismo problema 🙁
  • Esta es una vieja cuestión, pero sólo para estar seguro de que: ¿de reiniciar el Matraz servidor? También me pregunto por qué tengo el mismo error, incluso pensé que todo era exactamente como deberían. Resulta, usted tiene que reiniciar el servidor para que realmente surta efecto
InformationsquelleAutor Matteo | 2014-11-17

8 Comentarios

  1. 31

    Funcionó como un campeón, después de que el bit de modificación a su código de

    # initialization
    app = Flask(__name__)
    app.config['SECRET_KEY'] = 'the quick brown fox jumps over the lazy   dog'
    app.config['CORS_HEADERS'] = 'Content-Type'
    
    cors = CORS(app, resources={r"/foo": {"origins": "http://localhost:port"}})
    
    @app.route('/foo', methods=['POST'])
    @cross_origin(origin='localhost',headers=['Content- Type','Authorization'])
    def foo():
        return request.json['inputVar']
    
    if __name__ == '__main__':
       app.run()

    He sustituido * por localhost. Ya que, como he leído en muchos blogs y posts, debe permitir el acceso para el dominio específico

  2. 51

    Usted puede obtener los resultados con un simple:

    @app.route('your route', methods=['GET'])
    def yourMethod(params):
        response = flask.jsonify({'some': 'data'})
        response.headers.add('Access-Control-Allow-Origin', '*')
        return response
    • Mejor que la adición de crossdomain aplicación!
    • Simple y eficaz
    • Genial! Estoy de acuerdo, simple y eficaz. La OMI Debería ser aceptado respuesta
    • Dali – ¿sabes lo que es apropiado de manera de permitir el origen de la cruz si estoy de representación de una plantilla en lugar de sólo un objeto json? es decir, la última línea de código en yourMethod es: return render_template('template.html',some_var = response)
    • esto de plano no funciona
    • Este podría ser utilizado en un método post? He intentado durante la carga de un archivo de método y he fracasado.

  3. 36

    Bueno, yo enfrentamos al mismo problema. Para los nuevos usuarios que podrán aterrizar en esta página.
    Simplemente siga su documentación oficial.

    Instalar termo-cors

    pip install -U flask-cors

    a continuación, después de la inicialización de la aplicación, inicializar flask-cors con argumentos predeterminados:

    from flask import Flask
    from flask_cors import CORS
    
    app = Flask(__name__)
    CORS(app)
    
    @app.route("/")
    def helloWorld():
       return "Hello, cross-origin-world!"
    • Esto da el siguiente error para que me de Acceso a XMLHttpRequest en ‘my_domain’ de origen ‘127.0.0.1:5000‘ ha sido bloqueado por CORS de la política: la Respuesta a la comprobación previa petición de no pasar el control de acceso de verificación: El ‘Access-Control-Allow-Origin’ encabezado contiene varios valores ‘127.0.0.1:5000, *’, pero sólo uno es permitido.
  4. 3

    Tenga en cuenta que la configuración de la Access-Control-Allow-Origin encabezado en el Matraz objeto de respuesta es buena en muchos casos (como este), pero no tiene ningún efecto cuando se sirven los recursos estáticos (en una producción de la instalación, al menos). Eso es debido a que la estática de los activos son atendidos directamente por la frontal del servidor web (generalmente Nginx o Apache). Así que, en ese caso, usted tiene que configurar el encabezado de respuesta en el nivel de servidor web, no en el Frasco.

    Para obtener más detalles, consulte este artículo que escribí hace un tiempo, explica cómo configurar los encabezados (en mi caso, yo estaba tratando de hacer cross-domain servir de Fuente Impresionante de activos).

    También, como @Satu dijo, usted puede necesitar para permitir el acceso sólo para un dominio específico, en el caso de JS peticiones AJAX. Para solicitar los recursos estáticos (como archivos de fuente), creo que las normas son menos estrictas, y permitiendo el acceso de cualquier dominio es más aceptado.

  5. 2

    Bien podría hacer de esta una respuesta. Yo tenía el mismo problema hoy en día y que no era más que un no-problema de lo esperado. Después de agregar el CORS funcionalidad, debe reiniciar el Matraz de servidor (ctrl + c -> python manage.py runserver, o cualquiera que sea el método que use)) para que el cambio surta efecto, incluso si el código es correcto. De lo contrario el CORS no funcionará en la instancia activa.

    Aquí se ve para mí y funciona (Python 3.6.1, Frasco 0.12):

    factory.py:

    from flask import Flask
    from flask_cors import CORS  # This is the magic
    
    
    def create_app(register_stuffs=True):
        """Configure the app and views"""
        app = Flask(__name__)
        CORS(app)  # This makes the CORS feature cover all routes in the app
    
        if register_stuffs:
            register_views(app)
        return app
    
    
    def register_views(app):
        """Setup the base routes for various features."""
        from backend.apps.api.views import ApiView
        ApiView.register(app, route_base="/api/v1.0/")

    views.py:

    from flask import jsonify
    from flask_classy import FlaskView, route
    
    
    class ApiView(FlaskView):
        @route("/", methods=["GET"])
        def index(self):
            return "API v1.0"
    
        @route("/stuff", methods=["GET", "POST"])
        def news(self):
            return jsonify({
                "stuff": "Here be stuff"
            })

    En mi Reaccionan de la aplicación de consola.registro:

    Sending request:
    GET /stuff
    With parameters:
    null
    bundle.js:17316 Received data from Api:
    {"stuff": "Here be stuff"}
  6. 2

    He utilizado decorador dada por Armin Ronacher con pequeñas modificaciones (debido a las diferentes cabeceras que son solicitados por el cliente).Y que trabajó para mí. (donde yo lo uso angular como el solicitante solicita application/json tipo).

    El código modificado ligeramente por debajo de los lugares,

    from flask import jsonify
    
    @app.route('/my_service', methods=['POST', 'GET','OPTIONS'])
    @crossdomain(origin='*',headers=['access-control-allow-origin','Content-Type'])
    def my_service():
        return jsonify(foo='cross domain ftw')

    jsonify enviará un application/json tipo, otra cosa que sea de texto/html.
    los encabezados se agregan como el cliente en mi caso petición de los encabezados de

     const httpOptions = {
          headers: new HttpHeaders({
            'Content-Type': 'application/json',
            'Access-Control-Allow-Origin':'*'
          })
        };
        return this.http.post<any>(url, item,httpOptions)
  7. 0

    He luchado mucho con algo similar. Intente lo siguiente:

    1. Utilizar algún tipo de plugin para el navegador que puede mostrar los encabezados de HTML.
    2. Introduzca la URL de su servicio, y ver la devuelve los valores de encabezado.
    3. Asegúrese de Access-Control-Allow-Origin se establece a uno y sólo un dominio, que debe ser la solicitud de origen. No establece Access-Control-Allow-Origin a *.

    Si esto no ayuda, echa un vistazo a este artículo. Es en PHP, pero describe exactamente lo que los encabezados se debe establecer para qué valores de CORS a trabajar.

    CORS Que Funciona En IE, Firefox, Chrome Y Safari

  8. 0

    Nota: La colocación de cross_origin debe estar derecha y dependencias se instalarán.
    En el lado del cliente, asegúrese de especificar el tipo de datos del servidor es mucho. Por ejemplo application/json o text/html

    Para mí el código escrito a continuación hizo magia

    from flask import Flask,request,jsonify
    from flask_cors import CORS,cross_origin
    app=Flask(__name__)
    CORS(app, support_credentials=True)
    @app.route('/api/test', methods=['POST', 'GET','OPTIONS'])
    @cross_origin(supports_credentials=True)
    def index():
        if(request.method=='POST'):
         some_json=request.get_json()
         return jsonify({"key":some_json})
        else:
            return jsonify({"GET":"GET"})
    
    
    if __name__=="__main__":
        app.run(host='0.0.0.0', port=5000)

Dejar respuesta

Please enter your comment!
Please enter your name here