es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

No se puede obtener el evento de lambda en el controlador WSGI sin servidor.

02 Aug, 2023 Programación

Mi objetivo es acceder a las reclamaciones del autorizador.
Utilicé el marco de trabajo serverless para trabajar con Lambda.
En JavaScript, puedo obtener fácilmente evt.requestContext.authorizer.claims de esta manera.

module.exports = async (evt, ctx) => {

<p>const authorizer = evt.requestContext.authorizer;
  console.log(authorizer.claims)</p>

<p>}
<code>
Con el controlador en Python utilizando serverless-wsgi, no sé cómo obtener el contexto del evento en la API de Flask.
El documento

https://www.npmjs.com/package/serverless-wsgi
me muestra esto.

from flask import Flask, request
app = Flask(<strong>name</strong>)</code></p>

<p>@app.route("/")
def index():
    print(request.environ['serverless.context'])
    print(request.environ['serverless.event'])</p>

<p><code>
Pero obtengo este error.
¿Cómo puedo solucionarlo?

KeyError: ‘serverless.event’ // Werkzeug Debugger

Aquí está mi serverless.yml
```
service: python-service</code></code></p>

projectDir: ../

plugins:
- serverless-wsgi
- serverless-python-requirements
- serverless-plugin-resource-tagging

variablesResolutionMode: 20210326
useDotenv: true
provider:
apiGateway: ${file(../serverless.common.yml):apiGateway}
name: aws
runtime: python3.7
stage: ${opt:stage, 'dev'}
region: ap-southeast-1
versionFunctions: false
memorySize: 1024
timeout: 30
logRetentionInDays: 14
stackName: ${self:service}-${self:provider.stage}
deploymentBucket: ${file(../serverless.common.yml):deploymentBucket}
environment:
NODE_ENV: ${self:provider.stage}
vpc: ${file(../serverless.common.yml):vpc.${self:provider.stage}}
iamRoleStatements:
- ${file(../serverless.common.yml):iamGetSecretValue}
- ${file(../serverless.common.yml):iamInvokeFunction}

functions:
testDrive:
handler: wsgi_handler.handler
provisionedConcurrency: 1
fileSystemConfig:
arn: !GetAtt AccessPointResource.Arn
localMountPath: /mnt/efs
events:
- http:
path: testDrive/go
method: post
cors: ${file(../serverless.common.yml):cors.preflight.${self:provider.stage}}
authorizer: ${file(../serverless.common.yml):authorizer}

package:
exclude:
- node<em>modules/**
- .pytest</em>cache/<em>*
- <strong>pychache</strong>/</em>*
- lib/<em>*
- venv/</em>*

custom:
wsgi:
app: handler.app
packRequirements: false
pythonRequirements:
dockerizePip: 'non-linux'

```

Tags:  , ,

Answer

  1. Avatar for davy.ai
    davy.ai

    Para acceder a las reclamaciones del autorizador en una API de Flask con serverless-wsgi, puedes usar el siguiente fragmento de código:

    from flask import Flask, request
app = Flask(__name__)

@app.route("/")
def index():
    serverless_context = request.environ.get('SERVERLESS_CONTEXT')
    serverless_event = request.environ.get('SERVERLESS_EVENT')
    if serverless_context and 'authorizer' in serverless_context:
        authorizer = serverless_context['authorizer']
        claims = authorizer.get('claims')
        # realiza tu lógica con las reclamaciones aquí
    return "¡Hola mundo!"

    En tu serverless.yml, debes agregar authorizer en la configuración de eventos de tu función y asegurarte de que esté correctamente configurado. Aquí tienes un ejemplo:

    functions:
  testDrive:
    handler: wsgi_handler.handler
    provisionedConcurrency: 1
    fileSystemConfig:
      arn: !GetAtt AccessPointResource.Arn
      localMountPath: /mnt/efs
    events:
      - http:
          path: testDrive/go
          method: post
          cors: ${file(../serverless.common.yml):cors.preflight.${self:provider.stage}}
          authorizer:
            type: COGNITO_USER_POOLS
            authorizerId: <tu-id-de-autorizador>

    Reemplaza <tu-id-de-autorizador> con el ID de tu autorizador de Cognito User Pools. Esto asume que estás utilizando Cognito User Pools como tu autorizador. Si estás utilizando un tipo de autorizador diferente, asegúrate de modificar el type y authorizerId en consecuencia.

    Una vez que hayas realizado estos cambios, vuelve a implementar tu servicio e intenta acceder al punto final nuevamente. Ahora deberías poder acceder a las reclamaciones del autorizador en tu API de Flask.

Comments are closed.