Codage Base64

Le codage Base64 est utilisé pour les éléments du paramètre d'entrée " args qui peuvent rompre la structure de données interne du paramètre " args. L'encodage en Base64 permet de s'assurer que la valeur entière est constituée uniquement de caractères lisibles dans un alphabet de 64 caractères.

Exemple :

"eyAicGxhbmV0MSI6Ik1hcnMiLCAicGxhbmV0MiI6Ikp1cGl0ZXIiIH0="

Codage en pourcentage (codage « URL »)

Le codage en pourcentage est largement utilisé dans la technologie Web. Tous les caractères 8 bits sont écrits sous forme de valeur hexadécimale précédée d'un signe de pourcentage (%). Ce type de codage est également connu sous le nom de codage ASCII ( URL ). La fonction reçoit les données de type " form-urlencoded en format brut dans le paramètre " __ce_body

Le service de fonctions Code Engine transmet les paramètres de la requête tels quels (le premier " ? n'en fait pas partie) dans le champ " __ce_query du paramètre " args. Ainsi, le code de fonction reçoit ce paramètre au format encodé en URL, par exemple :

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

paramètre args défini pour les arguments d'entrée internes (__ce_*)

Le service de fonctions Code Engine injecte des arguments d'entrée réservés dans les données d'entrée " args

Les paramètres suivants peuvent apparaître dans l'argument " args en fonction de la manière dont l'appelant fournit les données de la demande :

Les paramètres d' __ce_* s internes ne peuvent pas être écrasés par les données de requête fournies dans la requête d' HTTP. HTTP les appels qui tentent d'écraser échouent avec le code d'état « 400 » (mauvaise requête).

Contenu du paramètre " args si l'appelant fournit les données de la demande au moyen de paramètres de requête

Une fonction reçoit des données de paramètres de requête sous forme de paires clé-valeur dans le paramètre " __ce_query ", et est encodée en pourcentage (encodage " URL "). En outre, chaque paramètre de la requête est une paire clé-valeur dans le format décodé :

Exemple Python d'accès aux paramètres de requête :

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,
  }

Exemple Node.js d'accès aux paramètres de requête :

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;

Contenu du paramètre " args si l'appelant fournit les données de la demande par des données d'en-tête

Une fonction reçoit les données d'en-tête de la demande sous forme de paires clé-valeur dans le paramètre " __ce_headers. La paire clé-valeur est convertie dans un format canonique, quel que soit le format dans lequel la clé est définie sur l'interface de données externe. Par exemple, les deux mykey ou MYKEY sont convertis en Mykey:

Exemple Python d'accès aux données d'en-tête :

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,
  }

Exemple Node.js d'accès aux données d'en-tête :

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;

paramètre args des données de la demande du type de contenu " application/json

Une fonction reçoit les clés et les valeurs du document JSON en tant que paramètres de propriété de premier niveau dédiés.

Lorsque la valeur Content-type n'est pas définie dans la requête HTTP, la fonction Code Engine utilise la valeur application/json par défaut.

En outre, la charge utile JSON est mise à la disposition de la fonction telle quelle (sous la forme d'un tableau d'octets) au format Base64-encoded dans le paramètre " __ce_body.

Exemple Python d'accès aux données d'entrée " 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,
  }

Exemple Node.js d'accès aux données d'entrée " 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;

paramètre args des données de la demande du type de contenu " application/octet-stream

Une fonction reçoit des données binaires au format Base64-encoded pour les données binaires " __ce_body dans le paramètre " __ce_body:

Exemple Python d'accès aux données d'entrée " 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,
  }

Exemple Node.js d'accès aux données d'entrée " 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;

paramètre args des données de la demande du type de contenu " text/plain

Une fonction reçoit des données de type texte au format Base64-encoded dans le paramètre " __ce_body:

La logique du programme de la fonction peut avoir besoin de les désencapsuler pour recréer les données d'origine.

Exemple Python d'accès aux données d'entrée " 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,
  }

Exemple Node.js d'accès aux données d'entrée " 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;

paramètre args des données de la demande du type de contenu " application/x-www-form-urlencoded

Une fonction reçoit les données complètes du corps en format texte dans le paramètre " __ce_body:

Exemple Python d'accès aux données d'entrée " 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,
  }

Exemple Node.js d'accès aux données d'entrée " 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;

paramètre args à partir des données de la demande de type de contenu " application/x-www-form-urlencoded et des paramètres de la requête

Toutes les combinaisons de types de données mixtes sont possibles, mais il faut tenir compte du fait que pour les requêtes d' HTTP, avec des paramètres de requête ( URL ) et des paramètres de corps (body parameters), les paramètres de corps ont priorité sur les paramètres de requête.

Valeur du corps du type de contenu " application/json

Le code de la fonction doit fournir la valeur de l'élément " body sous la forme d'une structure de données valideNodeJs-JSON ou Python). Les clés et les valeurs de la structure de données doivent respecter les règles de syntaxe JSON afin que le service Code Engine puisse fournir les données de réponse dans la section de données de réponse application/json HTTP.

Les barres obliques inversées (\) et les guillemets doubles (") de la structure de données sont fournis sous forme de texte codé dans la section des données de réponse HTTP.

Exemple Python d'une réponse " 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,
    }

Exemple Node.js d'une réponse " 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;

Valeur du corps du type de contenu " application/octet-stream

Les données de résultat du code de fonction doivent être Base64-encoded avant d'être ajoutées à la structure de résultat.

Exemple Python d'une réponse " 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,
  }

Exemple Node.js d'une réponse " 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;

Valeur du corps du type de contenu " text/plain

Le code de la fonction doit fournir l'ensemble de la réponse en une seule chaîne. Le service de fonctions Code Engine ne vérifie pas les données de réponse ; les données sont transférées à l'appelant comme prévu.

Exemple Python d'une réponse " text/plain

def main(args):
  result_body = "myfolder_myFile"

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

Valeur du corps du type de contenu " application/x-www-form-urlencoded (contenu codé en pourcentage)

URL Le code de fonction doit permettre de s'assurer que les données de réponse sont encodées en UTF-8 avant d'être ajoutées à la structure de données de résultat. Le service des fonctions d' Code Engine s ne vérifie pas la syntaxe des données de réponse. Les données sont transférées à l'appelant comme prévu.

Exemple Python d'une réponse " 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,
  }

zones d'en-tête HTTP

L'en-tête d' HTTP s contient toutes les paires clé-valeur que le code de fonction a ajoutées à la structure de données de résultat.

Le service de fonctions Code Engine ajoute les paires clé-valeur suivantes :

Les noms des clés d'en-tête sont toujours indiqués en minuscules.

Codes de statut HTTP

L'origine du code d'état d' HTTP peut être le service des fonctions d' Code Engine lui-même ou le code d'état défini par le code de fonction. La présence du champ d'en-tête " x-faas-statuscode est l'indicateur de l'origine.

La signification du code d'état d' HTTP peut être lue dans la documentation des fonctions d' Code Engine, si le champ d'en-tête d' x-faas-actionstatus n'est pas défini. Cependant, si le champ d'en-tête est défini, la logique de la fonction définit la signification du code d'état d' HTTP.

Code Engine exécute un contrôle de validité limité sur les données de la réponse et le type de contenu, et renvoie un code d'état HTTP ( 400 ) si le format ou le codage des données (généré par le code de fonction) n'est pas valide.

HTTP données de réponse

Les données de réponse d' HTTP s sur l'interface de données externe sont identiques à celles fournies dans la structure de données de résultat par le code de fonction. Ce n'est que si le " MIME-Type est le " application/json que la clé et les valeurs de la réponse JSON fournie sont modifiées. Toutes les barres obliques inverses et tous les guillemets doubles sont échappés.

Par exemple, l'appelant obtient des données de réponse de type " application/json Le code de fonction qui fournit les données de réponse est le suivant :

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,
  }

Le client " curl qui utilise la réponse " statusCcode, les champs " header et les données de la réponse est le suivant :

  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