Datenaustausch mit Funktionen

Base64-Codierung

Base64 wird für Elemente im Eingabeparameter " args verwendet, die die interne Datenstruktur des Parameters " args aufbrechen können. Durch die Base64 wird sichergestellt, dass der gesamte Wert nur aus lesbaren Zeichen in einem 64-Zeichen-Alphabet besteht.

Zum Beispiel:

"eyAicGxhbmV0MSI6Ik1hcnMiLCAicGxhbmV0MiI6Ikp1cGl0ZXIiIH0="

Prozentkodierung ( URL-Kodierung)

Prozentkodierung wird in der Webtechnologie häufig verwendet. Alle 8-Bit-Zeichen werden als Hexadezimalwert geschrieben, dem ein Prozentzeichen (%) vorangestellt wird. Diese Art der Codierung wird auch als URL-Codierung bezeichnet. Die Funktion empfängt die Daten vom Typ " form-urlencoded im Rohformat im Parameter " __ce_body.

Der Funktionsdienst Code Engine übergibt die Abfrageparameter unverändert (das führende " ? ist nicht Teil davon) in das Feld " __ce_query des Parameters " args. Auf diese Weise erhält der Funktionscode diesen Parameter im URL-codierten Format; zum Beispiel:

"x%5cb=1%22f4%20and%20"

parameter args für interne Eingabeargumente gesetzt (__ce_*)

Der Funktionsdienst Code Engine injiziert reservierte Eingabeargumente in die Eingabedaten " args.

Die folgenden Parameter können im Argument " args erscheinen, je nachdem, wie der Aufrufer die Anfragedaten bereitstellt:

Die internen __ce_*-Parameter können nicht mit Anfragedaten überschrieben werden, die in der HTTP-Anfrage bereitgestellt werden. HTTP aufrufe, die versuchen, zu überschreiben, schlagen fehl mit dem Statuscode 400 (Bad Request).

Inhalt des ' args-Parameters, wenn ein Aufrufer die Anfragedaten über Abfrageparameter bereitstellt

Eine Funktion empfängt Abfrageparameterdaten als Schlüssel-Wert-Paare im __ce_query-Parameter und ist prozentcodiert ( URL-codiert). Außerdem ist jeder einzelne Abfrageparameter ein Schlüssel-Wert-Paar im entschlüsselten Format:

Python für den Zugriff auf Abfrageparameter:

import os
def main(args):
  query_parm_1 = args.get("key", "default_value") # get the value of one query parameter

  try:
    query = args["__ce_query"]  # get all query parms
  except:
    query= "not part of request"

  return {
    "statusCode": 200,
    "body": query,
  }

Node.js für den Zugriff auf Abfrageparameter:

function main(args) {
  var query_parm_1 = args.key     // get the value of one query parameter
  var query = args.__ce_query     // get all query parameters

  return {
    statusCode: 200,
    "body" : query,
  };
}

module.exports.main = main;

Inhalt des Parameters ' args, wenn ein Aufrufer Anfragedaten durch Kopfdaten bereitstellt

Eine Funktion erhält Anforderungskopfdaten als Schlüssel-Wert-Paare im Parameter " __ce_headers. Das Schlüssel-Wert-Paar wird in ein kanonisches Format konvertiert, unabhängig davon, in welchem Format der Schlüssel an der externen Datenschnittstelle eingestellt ist. Zum Beispiel werden sowohl " mykey als auch " MYKEY in " Mykey" umgewandelt:

Python für den Zugriff auf Kopfdaten:

import os
def main(args):

  try:
    header = args["__ce_headers"]  # get complete header
    # value_1 = args["__ce_headers"]["Key_1"]  # get value of the Header parm with "Key_1"
  except:
    header = "not part of request"

  return {
    "statusCode": 200,
    "body": header,
  }

Node.js für den Zugriff auf Kopfdaten:

function main(args) {
  // var header_parm_1 = args.__ce_headers.Key_1  //get the value of one header parameter
  var header = args.__ce_headers  // get all header parameters

  return {
    statusCode: 200,
    "body" : header,
  };
}

module.exports.main = main;

parameter args aus Anfragedaten des Inhaltstyps ' application/json

Eine Funktion empfängt die Schlüssel und Werte des JSON-Dokuments als dedizierte Eigenschaftsparameter der obersten Ebene.

Wenn in der HTTP-Anfrage kein Wert für Content-type festgelegt ist, verwendet die Code Engine-Funktion standardmäßig application/json.

Darüber hinaus wird der Funktion die JSON-Nutzlast im Parameter " __ce_body " in Base64-encoded Format zur Verfügung gestellt (als Byte-Array).

Python für den Zugriff auf die Eingabedaten von " application/json:

import os
def main(args):
  try:
    body_encoded = args["__ce_body"]  # get complete header (base64 encoded)
    value_1 = args["key_1"]           # get value of the Header parm with "key_1"
  except:
    value_1 = "not part of request"

  return {
    "statusCode": 200,
    "body": value_1,
  }

Node.js für den Zugriff auf " application/json:

function main(args) {
  var body  = args.__ce_body  // get complete request body (base64 encoded)
  var value_1 = args.key_1    // get value of one single key

  return {
    statusCode: 200,
    "body" : value_1,
  };
}

module.exports.main = main;

parameter args aus Anfragedaten des Inhaltstyps ' application/octet-stream

Eine Funktion empfängt Binärdaten im Base64-encoded Format für die Binärdaten " __ce_body im Parameter " __ce_body:

Python für den Zugriff auf die Eingabedaten von " application/octet-stream:

import os
import base64

def main(args):
  try:
    body = base64.b64decode(args['__ce_body']).decode("utf-8")   # read binary data into the body variable
  except:
    body = "not binary data found"

  return {
    "headers": { "Content-Type": "text/plain" },  # text/plain, if ensured binary data do not conain backslash and double quotes
    "statusCode": 200,
    "body": body,
  }

Node.js für den Zugriff auf " application/octet-stream:

function main(args) {
  var base64EncodedBody = args.__ce_body   // get complete request body (base64 encoded)
  var body = Buffer.from(args.__ce_body, 'base64').toString('utf-8') //  read binary data into the body variable

  return {
    statusCode: 200,
    "body" : body,
  };
}

module.exports.main = main;

parameter args aus Anfragedaten des Inhaltstyps ' text/plain

Eine Funktion empfängt Daten vom Typ Text im Base64-encoded Format im Parameter " __ce_body:

Die Programmlogik der Funktion muss diese möglicherweise entschlüsseln, um die ursprünglichen Daten wiederherzustellen.

Python für den Zugriff auf die Eingabedaten von " text/plain:

import os
def main(args):
  body = args['__ce_body']  # get request body, is text encoded (escaped)

  return {
    "headers": { "Content-Type": "text/plain" },
    "statusCode": 200,
    "body": body,
  }

Node.js für den Zugriff auf " text/plain:

function main(args) {
  var body  = args.__ce_body  // get complete request body (text encoded)

  return {
    statusCode: 200,
    "body" : body,
  };
}

module.exports.main = main;

parameter args aus Anfragedaten des Inhaltstyps ' application/x-www-form-urlencoded

Eine Funktion empfängt die vollständigen Körperdaten in textkodiertem Format im Parameter " __ce_body:

Python für den Zugriff auf die Eingabedaten von " application/x-www-form-urlencoded:

import os
def main(args):
  body = args['__ce_body']  # get request body, is url-encoded (%)

  return {
    "headers": { "Content-Type": "text/plain" },
    "statusCode": 200,
    "body": body,
  }

Node.js für den Zugriff auf " application/x-www-form-urlencoded:

function main(args) {
  var body  = args.__ce_body  //get request body, is url-encoded (%)

  return {
    statusCode: 200,
    "body" : body,
  };
}

module.exports.main = main;

parameter args aus Anfragedaten des Inhaltstyps ' application/x-www-form-urlencoded und Abfrageparametern

Alle Kombinationen gemischter Datentypen sind möglich, aber beachten Sie, dass bei HTTP-Anfragen mit URL-Abfrageparametern und Textparametern die Textparameter Vorrang vor den Abfrageparametern haben.

Körperwert des Inhaltstyps ' application/json

Der Funktionscode muss den Wert des Elements " body als gültige DatenstrukturNodeJs-JSON oder Python) liefern. Die Schlüssel und Werte der Datenstruktur müssen den Syntaxregeln von JSON entsprechen, damit der Code Engine-Dienst die Antwortdaten im application/json HTTP-Antwortdatenabschnitt bereitstellen kann.

Backslashes (\) und doppelte Anführungszeichen (") in der Datenstruktur werden im Antwortdatenabschnitt von HTTP in einem textcodierten Format übermittelt.

Python für eine ' application/json:

  import os
  def main(args):
    # python dictionary
    result_body = { "key_1" : "myfolder\myFile" }

    return {
      "headers": {
        "Content-Type": "application/json",
      },
      "statusCode": 200,
      "body": result_body,
    }

Node.js für eine ' application/json:

function main(args) {
  // JSON data structure
  // Note: Backslash must be text encoded
  result_body =  { "key1" : "myfolder\\myFile"}

  return {
	  statusCode: 200,
	  headers: {
	    'Content-Type': "application/json",
	  },
	  "body" : result_body ,
  };
}
module.exports.main = main;

Körperwert des Inhaltstyps ' application/octet-stream

Die Ergebnisdaten für den Funktionscode müssen Base64-encoded sein, bevor Sie sie der Ergebnisstruktur hinzufügen.

Python für eine ' application/octet-stream:

import os
import base64

def main(args):
  result_body = "myfolder_myFile"
  enc_result_body=base64.encodebytes(result_body.encode()).decode("utf-8").strip()

  return {
    "headers": {
      "Content-Type": "application/octet-stream",
    },
    "statusCode": 200,
    "body": enc_result_body,
  }

Node.js für eine ' application/octet-stream:

function main(args) {
  var result_body = "###\unreturned body###\n"
  var buff = new Buffer(result_body , 'utf8');

  return {
    statusCode: 200,
    headers: {
      'Content-Type': "application/octet-stream",
    },
    "body" : buff.toString('base64') ,
  };
}

module.exports.main = main;

Körperwert des Inhaltstyps ' text/plain

Der Funktionscode muss die gesamte Antwort in einer einzigen Zeichenfolge enthalten. Der Funktionsdienst Code Engine prüft die Antwortdaten nicht; die Daten werden wie vorgesehen an den Aufrufer übermittelt.

Python für eine ' text/plain:

def main(args):
  result_body = "myfolder_myFile"

  return {
    "headers": {
      "Content-Type": "text/plain;charset=utf-8",
    },
    "statusCode": 200,
    "body": result_body,
  }

Body-Wert des Content-Typs ' application/x-www-form-urlencoded (prozentual verschlüsselter Inhalt)

Der Funktionscode muss sicherstellen, dass die Antwortdaten vor dem Hinzufügen zur Ergebnisdatenstruktur URL-codiert werden. Der Code Engine-Funktionsdienst überprüft die Antwortdaten nicht auf korrekte Syntax. Die Daten werden wie vorgesehen an den Anrufer übermittelt.

Python für eine ' application/x-www-form-urlencoded:

import os
def main(args):
  result_body = "myfolder%20myFile"

  return {
    "headers": {
    "Content-Type": "application/x-www-form-urlencoded",
    },
    "statusCode": 200,
    "body": result_body,
  }

HTTP-Header-Felder

Der Header von HTTP enthält alle Schlüssel-Wert-Paare, die der Funktionscode zur Ergebnisdatenstruktur hinzugefügt hat.

Der Funktionsdienst Code Engine fügt die folgenden Schlüssel-Wert-Paare hinzu:

Die Namen der Kopfzeilenschlüssel werden immer in Kleinbuchstaben wiedergegeben.

HTTP-Statuscode

Der Ursprung des Statuscodes HTTP kann der Funktionsdienst Code Engine selbst oder der durch den Funktionscode festgelegte Statuscode sein. Das Vorhandensein des Header-Feldes " x-faas-statuscode ist der Indikator für den Ursprung.

Die Bedeutung des HTTP-Statuscodes kann in der Code Engine-Funktionsdokumentation nachgelesen werden, wenn das x-faas-actionstatus-Header-Feld nicht gesetzt ist. Wenn das Header-Feld jedoch festgelegt ist, definiert die Logik der Funktion die Bedeutung des HTTP-Statuscodes.

Code Engine die Funktion "service runs" führt eine eingeschränkte Gültigkeitsprüfung der Antwortdaten und des Inhaltstyps durch und gibt einen HTTP-Statuscode von 400 zurück, wenn das Datenformat oder die Codierung (generiert durch den Funktionscode) ungültig ist.

HTTP antwortdaten

Die Antwortdaten von HTTP auf der externen Datenschnittstelle sind identisch mit den in der Ergebnisdatenstruktur vom Funktionscode gelieferten Daten. Nur wenn " MIME-Type " application/json ist, werden der Schlüssel und die Werte in der bereitgestellten JSON-Antwort geändert. Alle Backslashes und doppelten Anführungszeichen werden escaped.

Der Anrufer erhält zum Beispiel die Antwortdaten " application/json. Der Funktionscode, der die Antwortdaten liefert, lautet wie folgt:

import os
def main(args):
  # python dictionary
  result_body = { "key_1" : "myfolder\myFile" }

  return {
    "headers": {
      "Content-Type": "application/json",
      "key" : "sample",
    },
    "statusCode": 200,
    "body": result_body,
  }

Der " curl-Mandant, der die Antwort " statusCcode, die " header-Felder und die Antwortdaten verwendet, sieht folgendermaßen aus:

  curl -v -i  https://sample.1kweru2e873.eu-gb.codeengine.appdomain.cloud/
	 -> Response:
	stdout>
   * Host default-encoded-response.1lpigeajq5fg.us-east.codeengine.appdomain.cloud:443 was resolved.
   * IPv6: 2606:4700:90:0:7554:9304:2cbe:8cbf
   * IPv4: 172.65.197.223
   * using HTTP/1.x
   > GET / HTTP/1.1
   > Host: default-encoded-response.1lpigeajq5fg.us-east.codeengine.appdomain.cloud
   > User-Agent: curl/8.8.0
   > Accept: *//*

   * Request completely sent off
   < HTTP/1.1 200 OK
   < content-type: application/json
   < key: sample
   < x-faas-actionstatus: 200
   < x-faas-activation-id: 5cbab12c-5c6e-4000-96cf-0f7fcb42a979
   < x-request-id: e7098271-4780-4893-bbd4-64d4c8d7605e
   < content-length: 13
   { "key_1" : "myfolder\\myFile }* Connection