Utilizzando l'API di AWS Gateway, posso accedere ai cookie?

Question

Utilizzo di un'integrazione proxy HTTP Desidero accedere ai cookie e aggiungerne uno alla risposta JSON. È possibile?

Answer 1

Per accedere ai cookie inviati dal client nel back-end, è necessario impostare un'associazione dall'intestazione della richiesta del metodo all'intestazione della richiesta di integrazione.

Queste istruzioni presuppongono che sia già stato impostato un semplice metodo in Gateway API.

cookie di accesso nel backend

1. Sotto metodo di richiesta, creano una richiesta HTTP Header con il nome di "Cookie"
2. Sotto l'integrazione richiesta, creare un header HTTP con il nome "Cookie" e Valore "mappato da" di method.request.header.Cookie.
3. Probabilmente sarà necessario impostare CORS per questo metodo. Vedi: http://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-cors.html
4. Distribuisci la tua API e fai una richiesta al tuo endpoint Gateway API con il tuo browser/client. Dovresti vedere le richieste che arrivano al tuo back-end HTTP con il valore dell'intestazione del cookie inviato dal browser.

Aggiungi biscotto alla risposta

È possibile impostare un colpo di testa Set-Cookie risposta in un modo analogo per il lato di risposta risposta integrazione/metodo della configurazione metodo.

1. In Metodo di risposta, creare un'intestazione di risposta con il nome Set-Cookie
2. Sotto l'installazione Integrazione di Risposta mapping di intestazione con l'intestazione di risposta Set-Cookie e il valore Mapping integration.response.header.Set-Cookie

prega di notare che in questo momento, gateway API supporta l'impostazione di una singola intestazione di risposta Set-Cookie. Se il tuo back-end tenta di impostare più intestazioni Set-Cookie, verrà impostato solo l'ultimo. Vedere questo post sul forum per ulteriori dettagli: https://forums.aws.amazon.com/thread.jspa?messageID=701434

Answer 2

Se si seleziona l'opzione "Usa integrazione proxy Lambda" nel metodo gateway API, le intestazioni delle richieste verranno passate alla funzione Lambda tramite la variabile event. Il gateway API si aspetta inoltre una risposta diversa dalla funzione di callback. Questo formato di risposta può essere utilizzato per dettare un'intestazione Set-Cookie. ad esempio:

Questo approccio ha il vantaggio di non richiedere alcuna modifica del metodo o della risposta del metodo.

Ecco una funzione Lambda di esempio che utilizza questa logica per ruotare un valore del cookie dopo ogni richiesta.

exports.handler = (event, context, callback) => { 

    var cookies = getCookiesFromHeader(event.headers); 

    var old_cookie = cookies.flavor; 
    var new_cookie = pickCookieFlavor(old_cookie); 

    return callback(null, { 
     statusCode: 200, 
     headers: { 
      'Set-Cookie': setCookieString('flavor', new_cookie), 
      'Content-Type': 'text/plain' 
     }, 
     body: 'Your cookie flavor was ' + old_cookie + '. Your new flavor is ' + new_cookie + '.' 
    }); 
}; 

/** 
* Rotate the cookie flavor 
*/ 
function pickCookieFlavor(cookie) { 
    switch (cookie) { 
     case 'peanut': 
      return 'chocolate'; 
     case 'chocolate': 
      return 'raisin and oat'; 
     default: 
      return 'peanut'; 
    } 
} 

/** 
* Receives an array of headers and extract the value from the cookie header 
* @param {String} errors List of errors 
* @return {Object} 
*/ 
function getCookiesFromHeader(headers) { 

    if (headers === null || headers === undefined || headers.Cookie === undefined) { 
     return {}; 
    } 

    // Split a cookie string in an array (Originally found http://stackoverflow.com/a/3409200/1427439) 
    var list = {}, 
     rc = headers.Cookie; 

    rc && rc.split(';').forEach(function(cookie) { 
     var parts = cookie.split('='); 
     var key = parts.shift().trim() 
     var value = decodeURI(parts.join('=')); 
     if (key != '') { 
      list[key] = value 
     } 
    }); 

    return list; 
}; 


/** 
* Build a string appropriate for a `Set-Cookie` header. 
* @param {string} key  Key-name for the cookie. 
* @param {string} value Value to assign to the cookie. 
* @param {object} options Optional parameter that can be use to define additional option for the cookie. 
* ``` 
* { 
*  secure: boolean // Watever to output the secure flag. Defaults to true. 
*  httpOnly: boolean // Watever to ouput the HttpOnly flag. Defaults to true. 
*  domain: string // Domain to which the limit the cookie. Default to not being outputted. 
*  path: string // Path to which to limit the cookie. Defaults to '/' 
*  expires: UTC string or Date // When this cookie should expire. Default to not being outputted. 
*  maxAge: integer // Max age of the cookie in seconds. For compatibility with IE, this will be converted to a 
*   `expires` flag. If both the expires and maxAge flags are set, maxAge will be ignores. Default to not being 
*   outputted. 
* } 
* ``` 
* @return string 
*/ 
function setCookieString(key, value, options) { 
    var defaults = { 
     secure: true, 
     httpOnly: true, 
     domain: false, 
     path: '/', 
     expires: false, 
     maxAge: false 
    } 
    if (typeof options == 'object') { 
     options = Object.assign({}, defaults, options); 
    } else { 
     options = defaults; 
    } 

    var cookie = key + '=' + value; 

    if (options.domain) { 
     cookie = cookie + '; domain=' + options.domain; 
    } 

    if (options.path) { 
     cookie = cookie + '; path=' + options.path; 
    } 

    if (!options.expires && options.maxAge) { 
     options.expires = new Date(new Date().getTime() + parseInt(options.maxAge) * 1000); // JS operate in Milli-seconds 
    } 

    if (typeof options.expires == "object" && typeof options.expires.toUTCString) { 
     options.expires = options.expires.toUTCString(); 
    } 

    if (options.expires) { 
     cookie = cookie + '; expires=' + options.expires.toString(); 
    } 

    if (options.secure) { 
     cookie = cookie + '; Secure'; 
    } 

    if (options.httpOnly) { 
     cookie = cookie + '; HttpOnly'; 
    } 

    return cookie; 
}