Immer json-body in der aws Lambda-via API-gateway

Ich bin derzeit mit NodeJS zu bauen, die einen bot auf AWS lambda-über die AWS-Api-Gateway, und ich bin in ein Problem mit POST-requests und JSON-Daten. Mein api verwendet "Verwenden von Lambda-Proxy-integration" und auch wenn ich zum testen den proxy sendet einen content-type Application/json und einige json in dem Körper e.g {"foo":"bar"} ich kann nicht auf das Objekt zugreifen, ohne Analyse die ersten, die es

e.g

  var json = JSON.parse(event.body);
  console.log(json.foo);

Ich jetzt weiß, scheint das keine große Sache, nur läuft es über JSON.analysieren, aber ich habe gesehen, eine Reihe anderer Beispiele, in denen dies nicht der Fall. hier sehen https://github.com/pinzler/fb-messenger-bot-aws-lambda/blob/master/index.js

Muss ich noch etwas hinzufügen zu meinem API-gateway zu handhaben, richtig? mein 'Wunsch-Körper' Schritt in die "post-Methode Anforderung" hat einen content-type application/json set-up für den request-body.

Die readme-Datei für das obige Beispiel scheint nicht, die Verwendung von proxy-integration so weit wie ich kann sagen, also ich bin mir nicht sicher, was ich tun sollte, hier

InformationsquelleAutor der Frage TommyBs | 2017-01-14

aws-api-gateway aws-lambda

Gibt es zwei verschiedene Lambda-Integrationen, die Sie konfigurieren können, in der API-Gateway, wie Lambda-integration und Lambda-proxy-integration. Für Lambda-integrationdie Sie anpassen können, was Sie gehen, um pass zu Lambda in der Nutzlast, die Sie nicht brauchen, um zu analysieren den Körper, aber wenn Sie mit Lambda-Proxy-integration in der API-Gateway-API-Gateway-proxy alles auf Lambda in der Nutzlast, wie diese,

{
    "message": "Hello me!",
    "input": {
        "path": "/test/hello",
        "headers": {
            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
            "Accept-Encoding": "gzip, deflate, lzma, sdch, br",
            "Accept-Language": "en-US,en;q=0.8",
            "CloudFront-Forwarded-Proto": "https",
            "CloudFront-Is-Desktop-Viewer": "true",
            "CloudFront-Is-Mobile-Viewer": "false",
            "CloudFront-Is-SmartTV-Viewer": "false",
            "CloudFront-Is-Tablet-Viewer": "false",
            "CloudFront-Viewer-Country": "US",
            "Host": "wt6mne2s9k.execute-api.us-west-2.amazonaws.com",
            "Upgrade-Insecure-Requests": "1",
            "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.82 Safari/537.36 OPR/39.0.2256.48",
            "Via": "1.1 fb7cca60f0ecd82ce07790c9c5eef16c.cloudfront.net (CloudFront)",
            "X-Amz-Cf-Id": "nBsWBOrSHMgnaROZJK1wGCZ9PcRcSpq_oSXZNQwQ10OTZL4cimZo3g==",
            "X-Forwarded-For": "192.168.100.1, 192.168.1.1",
            "X-Forwarded-Port": "443",
            "X-Forwarded-Proto": "https"
        },
        "pathParameters": {"proxy": "hello"},
        "requestContext": {
            "accountId": "123456789012",
            "resourceId": "us4z18",
            "stage": "test",
            "requestId": "41b45ea3-70b5-11e6-b7bd-69b5aaebc7d9",
            "identity": {
                "cognitoIdentityPoolId": "",
                "accountId": "",
                "cognitoIdentityId": "",
                "caller": "",
                "apiKey": "",
                "sourceIp": "192.168.100.1",
                "cognitoAuthenticationType": "",
                "cognitoAuthenticationProvider": "",
                "userArn": "",
                "userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.82 Safari/537.36 OPR/39.0.2256.48",
                "user": ""
            },
            "resourcePath": "/{proxy+}",
            "httpMethod": "GET",
            "apiId": "wt6mne2s9k"
        },
        "resource": "/{proxy+}",
        "httpMethod": "GET",
        "queryStringParameters": {"name": "me"},
        "stageVariables": {"stageVarName": "stageVarValue"},
        "body": "{\"foo\":\"bar\"}",
        "isBase64Encoded": false
    }
}

Für das Beispiel, das Sie verweisen, ist es nicht immer der Körper aus der ursprünglichen Anfrage. Es ist die Konstruktion des response-body zurück zu API-Gateway. Es sollte in diesem format,

{
    "statusCode": httpStatusCode,
    "headers": { "headerName": "headerValue", ... },
    "body": "...",
    "isBase64Encoded": false
}

InformationsquelleAutor der Antwort Ka Hou Ieong

3

Ich denke, es gibt ein paar Dinge zu verstehen, wenn die Arbeit mit API-Gateway-integration mit Lambda.

Lambda-Integration vs Lambda-Proxy-Integration

Früher gab es nur die Lambda-Integration erfordert mapping-Vorlagen. Ich vermute, das ist, warum immer noch sehen viele Beispiele mit.
- Gewusst wie: übergeben Sie ein querystring-Parameter oder die parameter der route zu AWS Lambda von Amazon API-Gateway
  
  Ab September 2017, müssen Sie nicht mehr zum konfigurieren von mappings, um Zugriff auf die request-body.
- Serverlose Architektur auf die AWS
  
  Lambda-Proxy-Integration, Wenn Sie es aktivieren, API-Gateway-Karte wird jede Anfrage nach JSON und übergeben es an der Lambda, da das event-Objekt. In der Lambda-Funktion können Sie abrufen query-string-Parameter, Header, stage-Variablen, die den Pfad-Parameter, request-context und der Körper aus.
  
  Ohne Aktivierung Lambda-Proxy-Integration, müssen Sie erstellen Sie eine mapping-Vorlage in der Integration Request-Sektion des API-Gateway und entscheiden, wie die Zuordnung der HTTP-request um JSON zu sich selbst. Und Sie würde wahrscheinlich zu erstellen, die eine Integration von Response-mapping wenn Sie die übergabe von Informationen an den client zurück.
  
  Vor der Lambda-Proxy-Integration wurde Hinzugefügt, waren die Benutzer gezwungen, um die anzeigen-Anforderungen und-Antworten manuell, das war eine Quelle der Bestürzung, vor allem bei komplexeren Zuordnungen.
Körper wird escaped string, nicht als JSON

Verwendung von Lambda-Proxy-Integration, den Körper im Falle von lambda-Ausdruck ist ein string mit backslash escaped, kein JSON.
```
"body": "{\"foo\":\"bar\"}" 
```
Wenn getestet in einem JSON-formatter.
```
Parse error on line 1:
{\"foo\":\"bar\"}
-^
Expecting 'STRING', '}', got 'undefined'
```
Dokument unten ist über die Antwort aber es sollte beantragen.
- Ich erhielt eine "fehlerhafte Lambda-proxy Reaktion" Fehler oder 502 status code mit der Amazon-API-Gateway. Wie kann ich dies beheben?
  
  Den Körper Feld, wenn Sie zurückkehren JSON, muss einen string umgewandelt oder es wird dazu führen, dass weitere Probleme mit der Antwort. Können Sie JSON verwenden.stringify zu handhaben, in Node.js Funktionen; andere Laufzeiten erfordern unterschiedliche Lösungen, aber das Konzept ist das gleiche.
JavaScript zugreifen, es als JSON-Objekt zu konvertieren müssen Sie es zurück in das JSON-Objekt mit json.analysieren in JapaScript, json.dumps in Python.
- Wie die Arbeit mit JSON in JavaScript
  
  Strings sind nützlich für den Transport, aber Sie werden in der Lage sein wollen konvertieren Sie Sie zurück in ein JSON-Objekt auf dem client und/oder server-Seite.
Den AWS-Dokumentation zeigt, was zu tun ist.
```
if (event.body !== null && event.body !== undefined) {
    let body = JSON.parse(event.body)
    if (body.time) 
        time = body.time;
}
...
var response = {
    statusCode: responseCode,
    headers: {
        "x-custom-header" : "my custom header value"
    },
    body: JSON.stringify(responseBody)
};
console.log("response: " + JSON.stringify(response))
callback(null, response);
```
InformationsquelleAutor der Antwort mon

Ich bin mit lambda mit Zappa;
Ich bin senden von Daten mit POST im json-format:

Mein code für basic_lambda_pure.py ist:

import time
import requests
import json
def my_handler(event, context):
    print("Received event: " + json.dumps(event, indent=2))
    print("Log stream name:", context.log_stream_name)
    print("Log group name:",  context.log_group_name)
    print("Request ID:", context.aws_request_id)
    print("Mem. limits(MB):", context.memory_limit_in_mb)
    # Code will execute quickly, so we add a 1 second intentional delay so you can see that in time remaining value.
    print("Time remaining (MS):", context.get_remaining_time_in_millis())

    if event["httpMethod"] == "GET":
        hub_mode = event["queryStringParameters"]["hub.mode"]
        hub_challenge = event["queryStringParameters"]["hub.challenge"]
        hub_verify_token = event["queryStringParameters"]["hub.verify_token"]
        return {'statusCode': '200', 'body': hub_challenge, 'headers': 'Content-Type': 'application/json'}}

    if event["httpMethod"] == "post":
        token = "xxxx"
    params = {
        "access_token": token
    }
    headers = {
        "Content-Type": "application/json"
    }
        _data = {"recipient": {"id": 1459299024159359}}
        _data.update({"message": {"text": "text"}})
        data = json.dumps(_data)
        r = requests.post("https://graph.facebook.com/v2.9/me/messages",params=params, headers=headers, data=data, timeout=2)
        return {'statusCode': '200', 'body': "ok", 'headers': {'Content-Type': 'application/json'}}

Bekam ich die nächste json-Antwort:

{
"resource": "/",
"path": "/",
"httpMethod": "POST",
"headers": {
"Accept": "*/*",
"Accept-Encoding": "deflate, gzip",
"CloudFront-Forwarded-Proto": "https",
"CloudFront-Is-Desktop-Viewer": "true",
"CloudFront-Is-Mobile-Viewer": "false",
"CloudFront-Is-SmartTV-Viewer": "false",
"CloudFront-Is-Tablet-Viewer": "false",
"CloudFront-Viewer-Country": "US",
"Content-Type": "application/json",
"Host": "ox53v9d8ug.execute-api.us-east-1.amazonaws.com",
"Via": "1.1 f1836a6a7245cc3f6e190d259a0d9273.cloudfront.net (CloudFront)",
"X-Amz-Cf-Id": "LVcBZU-YqklHty7Ii3NRFOqVXJJEr7xXQdxAtFP46tMewFpJsQlD2Q==",
"X-Amzn-Trace-Id": "Root=1-59ec25c6-1018575e4483a16666d6f5c5",
"X-Forwarded-For": "69.171.225.87, 52.46.17.84",
"X-Forwarded-Port": "443",
"X-Forwarded-Proto": "https",
"X-Hub-Signature": "sha1=10504e2878e56ea6776dfbeae807de263772e9f2"
},
"queryStringParameters": null,
"pathParameters": null,
"stageVariables": null,
"requestContext": {
"path": "/dev",
"accountId": "001513791584",
"resourceId": "i6d2tyihx7",
"stage": "dev",
"requestId": "d58c5804-b6e5-11e7-8761-a9efcf8a8121",
"identity": {
"cognitoIdentityPoolId": null,
"accountId": null,
"cognitoIdentityId": null,
"caller": null,
"apiKey": "",
"sourceIp": "69.171.225.87",
"accessKey": null,
"cognitoAuthenticationType": null,
"cognitoAuthenticationProvider": null,
"userArn": null,
"userAgent": null,
"user": null
},
"resourcePath": "/",
"httpMethod": "POST",
"apiId": "ox53v9d8ug"
},
"body": "eyJvYmplY3QiOiJwYWdlIiwiZW50cnkiOlt7ImlkIjoiMTA3OTk2NDk2NTUxMDM1IiwidGltZSI6MTUwODY0ODM5MDE5NCwibWVzc2FnaW5nIjpbeyJzZW5kZXIiOnsiaWQiOiIxNDAzMDY4MDI5ODExODY1In0sInJlY2lwaWVudCI6eyJpZCI6IjEwNzk5NjQ5NjU1MTAzNSJ9LCJ0aW1lc3RhbXAiOjE1MDg2NDgzODk1NTUsIm1lc3NhZ2UiOnsibWlkIjoibWlkLiRjQUFBNHo5RmFDckJsYzdqVHMxZlFuT1daNXFaQyIsInNlcSI6MTY0MDAsInRleHQiOiJob2xhIn19XX1dfQ==",
"isBase64Encoded": true
}

meine Daten auf Körper Schlüssel, aber ist code64 codiert, Wie kann ich das wissen? Ich sah den Schlüssel isBase64Encoded

Kopiere ich den Wert für Körper Schlüssel und entschlüsseln mit Dieses tool und "eureka", bekomme ich die Werte.

Ich hoffe, dies hilft Ihnen. 🙂

InformationsquelleAutor der Antwort Te ENe Te

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Lambda-Integration vs Lambda-Proxy-Integration

Körper wird escaped string, nicht als JSON