codificação Base64

A codificação Base64 é usada para elementos no parâmetro de entrada ' args que podem quebrar a estrutura de dados interna do parâmetro ' args. Codificá-lo como Base64 ajuda a garantir que o valor inteiro consista apenas em caracteres legíveis em um alfabeto de 64 caracteres.

Por exemplo:

"eyAicGxhbmV0MSI6Ik1hcnMiLCAicGxhbmV0MiI6Ikp1cGl0ZXIiIH0="

Codificação de porcentagem ( URL-encoding)

A porcentagem de codificação é amplamente utilizada na tecnologia da Web Todos os caracteres de 8 bits são escritos como valores hexadecimais precedidos por um sinal de porcentagem (%). Esse tipo de codificação também é conhecido como URL-encoding. A função recebe os dados do tipo ' form-urlencoded em formato bruto no parâmetro ' __ce_body.

O serviço de funções Code Engine passa os parâmetros de consulta como estão (o ' ? inicial não faz parte deles) para o campo ' __ce_query do parâmetro ' args. Dessa forma, o código de função recebe esse parâmetro no formato codificado em URL; por exemplo:

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

conjunto de parâmetros args para argumentos de entrada internos (__ce_*)

O serviço de funções Code Engine injeta argumentos de entrada reservados nos dados de entrada ' args.

Os seguintes parâmetros podem aparecer no argumento ' args, dependendo de como o chamador fornece os dados da solicitação:

Os parâmetros internos do __ce_* não podem ser substituídos por dados de solicitação fornecidos na solicitação HTTP. HTTP as chamadas que tentam substituir falham com o código de status 400 (Bad Request).

Conteúdo do parâmetro " args se um chamador fornecer dados de solicitação por meio de parâmetros de consulta

Uma função recebe dados de parâmetros de consulta como pares de valores-chave no parâmetro __ce_query e é codificada em porcentagem ( URL-encoded). Além disso, cada parâmetro de consulta individual é um par de valores-chave no formato decodificado:

Exemplo Python de acesso a parâmetros de consulta:

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

Exemplo de acesso a parâmetros de consulta Node.js:

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;

Conteúdo do parâmetro " args se um chamador fornecer dados de solicitação por meio de dados de cabeçalho

Uma função recebe dados de cabeçalho de solicitação como pares de valores chave no parâmetro ' __ce_headers. O par chave-valor é convertido em um formato canônico, independentemente do formato em que a chave é definida na interface de dados externos. Por exemplo, tanto o " mykey quanto o " MYKEY são convertidos em " Mykey:

Exemplo Python de acesso a dados de cabeçalho:

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

Exemplo do Node.js de acesso a dados de cabeçalho:

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;

parâmetro args dos dados da solicitação do tipo de conteúdo ' application/json

Uma função recebe as chaves e os valores do documento JSON como parâmetros de propriedade de nível superior dedicados.

Quando nenhum valor é definido para Content-type na solicitação HTTP, a função Code Engine usa application/json como padrão.

Além disso, a carga útil JSON é disponibilizada para a função como está (como matriz de bytes) no formato Base64-encoded no parâmetro ' __ce_body.

Exemplo Python de acesso aos dados de entrada " 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,
  }

Exemplo do Node.js de acesso aos dados de entrada " 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;

parâmetro args dos dados da solicitação do tipo de conteúdo ' application/octet-stream

Uma função recebe dados binários no formato Base64-encoded para os dados binários ' __ce_body no parâmetro ' __ce_body:

Exemplo Python de acesso aos dados de entrada " 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,
  }

Exemplo do Node.js de acesso aos dados de entrada " 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;

parâmetro args dos dados da solicitação do tipo de conteúdo ' text/plain

Uma função recebe dados do tipo texto no formato Base64-encoded no parâmetro ' __ce_body:

A lógica de programa da função pode precisar de um unescape para recriar os dados originais.

Exemplo Python de acesso aos dados de entrada " 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,
  }

Exemplo do Node.js de acesso aos dados de entrada " 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;

parâmetro args dos dados da solicitação do tipo de conteúdo ' application/x-www-form-urlencoded

Uma função recebe os dados completos do corpo em formato codificado por texto no parâmetro ' __ce_body:

Exemplo Python de acesso aos dados de entrada " 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,
  }

Exemplo do Node.js de acesso aos dados de entrada " 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;

parâmetro args dos dados da solicitação do tipo de conteúdo ' application/x-www-form-urlencoded e parâmetros de consulta

Todas as combinações de tipos de dados mistos são possíveis, mas considere que, para solicitações HTTP com parâmetros de consulta URL e parâmetros de corpo, os parâmetros de corpo têm precedência sobre os parâmetros de consulta.

Valor do corpo do tipo de conteúdo ' application/json

O código da função deve fornecer o valor do elemento ' body como uma estrutura de dados válidaNodeJs-JSON ou Python). As chaves e os valores da estrutura de dados devem seguir as regras de sintaxe JSON para que o serviço Code Engine possa fornecer os dados de resposta na seção de dados de resposta application/json HTTP.

As barras invertidas (\) e as aspas duplas (") na estrutura de dados são entregues em formato de texto codificado na seção de dados de resposta HTTP.

Exemplo Python de uma resposta " 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,
    }

Exemplo do Node.js de uma resposta " 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;

Valor do corpo do tipo de conteúdo ' application/octet-stream

Os dados de resultado do código de função devem ser Base64-encoded antes de serem adicionados à estrutura de resultados.

Exemplo Python de uma resposta " 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,
  }

Exemplo do Node.js de uma resposta " 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;

Valor do corpo do tipo de conteúdo ' text/plain

O código da função deve fornecer a resposta completa em uma única cadeia de caracteres. O serviço de funções Code Engine não verifica os dados de resposta; os dados são transferidos para o chamador conforme fornecido.

Exemplo Python de uma resposta " text/plain:

def main(args):
  result_body = "myfolder_myFile"

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

Valor do corpo do tipo de conteúdo ' application/x-www-form-urlencoded (conteúdo codificado por porcentagem)

O código da função deve ajudar a garantir que os dados da resposta sejam codificados em URL antes de serem adicionados à estrutura de dados do resultado. O serviço de funções Code Engine não verifica se a sintaxe dos dados de resposta está correta. Os dados são transferidos para o autor da chamada conforme fornecido.

Exemplo Python de uma resposta " 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 campos de cabeçalho

O cabeçalho HTTP contém todos os pares de valores-chave que o código de função adicionou à estrutura de dados do resultado.

O serviço de funções Code Engine adiciona os seguintes pares de valores-chave:

Os nomes das chaves de cabeçalho são sempre respondidos em letras minúsculas.

Código de status HTTP

A origem do código de status HTTP pode ser o próprio serviço de funções Code Engine ou o código de status definido pelo código de função. A presença do campo de cabeçalho " x-faas-statuscode é o indicador da origem.

O significado do código de status HTTP pode ser lido na documentação das funções Code Engine se o campo de cabeçalho x-faas-actionstatus não estiver definido. No entanto, se o campo de cabeçalho for definido, a lógica da função definirá o significado do código de status HTTP.

Code Engine o serviço de funções executa uma verificação de validade limitada nos dados de resposta e no tipo de conteúdo e retorna um código de status HTTP de 400 se o formato ou a codificação dos dados (gerados pelo código de função) for inválido.

HTTP dados de resposta

Os dados de resposta do site HTTP na interface de dados externa são idênticos aos fornecidos na estrutura de dados de resultado pelo código de função. Somente se o " MIME-Type for " application/json, a chave e os valores na resposta JSON fornecida serão modificados. Todas as barras invertidas e aspas duplas são escapadas.

Por exemplo, o chamador recebe os dados de resposta " application/json. O código de função que fornece os dados de resposta é o seguinte:

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

O cliente ' curl que usa a resposta ' statusCcode, os campos ' header e os dados da resposta é o seguinte:

  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