Function Compute:Handler

O que é um handler?

O handler de uma função do FC é o método no código da função que processa requisições. Quando você invoca sua função FC, o Function Compute executa o handler configurado para processar a requisição. Configure o handler no console do Function Compute usando o parâmetro Handler.

Para uma função FC em Node.js, o formato do handler é filename.methodName. Por exemplo, se o arquivo for nomeado index.js ou index.mjs e o método for nomeado handler, o handler será index.handler.

Para obter mais informações sobre funções do FC e operações relacionadas, consulte Criar uma função acionada por evento.

As configurações de handler devem obedecer às especificações de configuração do Function Compute. Essas especificações variam conforme o tipo de handler.

Assinatura do handler

Um handler de evento simples tem a seguinte assinatura:

// index.mjs
export const handler = async (event, context) => {
  console.log("receive event: \n" + event);
  return "Hello World!";
};

// index.js
exports.handler = async function(event, context) {
  console.log("receive event: \n" + event);
  return "Hello World!";
};

// index.js
exports.handler = async function(event, context, callback) {
  console.log("event: \n" + event);
  callback(null, 'hello world');
};

O código de exemplo acima funciona da seguinte forma:

handler é o nome do método, correspondente ao Handler configurado no console do Function Compute. Por exemplo, se você definir index.handler como o Handler ao criar uma função, o Function Compute carrega a função handler definida em index.js e inicia a execução.

O runtime do Function Compute passa os parâmetros da requisição para o handler de requisição. O primeiro parâmetro é o objeto event, que contém o payload da requisição. O objeto event é do tipo Buffer; converta-o para o tipo de objeto necessário. O segundo parâmetro é o objeto context, que fornece informações de contexto do runtime para a invocação. Para mais informações, consulte Contexto.

Nota

• Ao usar o runtime Node.js 18 ou posterior, use o recurso Async/Await em vez de callback.

• O Function Compute converte o resultado retornado com base no seu tipo.

• Tipo Buffer: retornado sem alterações.

• Tipo Object: convertido para o formato JSON e retornado.

• Outros tipos: convertidos para string e retornados.

Async/Await

Ao usar o ambiente de runtime Node.js 18 ou posterior, recomendamos a abordagem Async/Await. Essa técnica permite escrever código assíncrono em Node.js de forma concisa e legível, evitando callbacks aninhados ou chamadas encadeadas.

A abordagem Async/Await oferece as seguintes vantagens em comparação às funções de callback callback:

• Maior legibilidade: o código com async/await segue um fluxo mais linear e síncrono, facilitando o entendimento e a manutenção. Isso evita callbacks profundamente aninhados, resultando em uma estrutura de código mais clara.

• Depuração e tratamento de erros simplificados: blocos try-catch capturam e tratam erros em operações assíncronas com mais facilidade. A pilha de erros torna-se mais clara, permitindo rastrear a origem do erro com maior precisão.

• Eficiência aprimorada: callbacks frequentemente exigem alternância entre diferentes partes do código. A abordagem async/await reduz o número de trocas de contexto, melhorando a eficiência do código.

Exemplo 1: Analisar parâmetros formatados em JSON

Código de exemplo

O Function Compute passa parâmetros formatados em JSON diretamente para sua função. Analise esses parâmetros no seu código. O código a seguir mostra como analisar um evento formatado em JSON.

export const handler = async (event, context) => {
  var eventObj = JSON.parse(event.toString());
  return eventObj['key'];
};

exports.handler = function(event, context, callback) {
  var eventObj = JSON.parse(event.toString());
  callback(null, eventObj['key']);
};

Pré-requisitos

Crie uma função Node.js. Para mais informações, consulte Criar uma função acionada por evento. Se desejar especificar seu código como um módulo ES, selecione Node.js 18 ou Node.js 20 como runtime durante a criação da função.

Procedimento

1. Faça login no console do Function Compute. No painel de navegação à esquerda, escolha Function Management > Functions.

2. Na barra de navegação superior, selecione uma região. Na página Functions, clique na função de destino.

3. Na página de configuração da função, selecione a aba Code. No editor de código, insira o código de exemplo anterior e clique em Deploy.

   Nota

   No código de exemplo acima, o handler da função corresponde ao método handler em index.js. Se o handler da sua função tiver uma configuração diferente, atualize o arquivo e o método correspondentes.

4. Na aba Code, clique no ícone à direita de Test Function. Na lista suspensa, selecione Configure Test Parameters. Insira os seguintes parâmetros de teste de exemplo e clique em OK.

   {
     "key": "value"
   }

5. Clique em Test Function.

   Após a execução bem-sucedida da função, verifique a resposta. A resposta é value.

Exemplo 2: Ler e gravar recursos OSS com segurança usando um par AccessKey temporário

Código de exemplo

Use o par AccessKey temporário fornecido pelo Function Compute para acessar o Object Storage Service (OSS). O código a seguir serve como exemplo.

// index.mjs
import OSSClient from 'ali-oss';

export const handler = async (event, context) => {
    console.log(event.toString());

    var ossClient = new OSSClient({
        accessKeyId: context.credentials.accessKeyId,
        accessKeySecret: context.credentials.accessKeySecret,
        stsToken: context.credentials.securityToken,
        region: 'oss-cn-shenzhen',
        bucket: 'my-bucket',
    });

    try {
      const uploadResult = await ossClient.put('myObj', Buffer.from('hello, fc', "utf-8"));
      console.log('upload success, ', uploadResult);
      return "put object"
    } catch (error) {
      throw error
    }
};

var OSSClient = require('ali-oss');

exports.handler = function (event, context, callback) {
    console.log(event.toString());

    var ossClient = new OSSClient({
        accessKeyId: context.credentials.accessKeyId,
        accessKeySecret: context.credentials.accessKeySecret,
        stsToken: context.credentials.securityToken,
        region: `oss-${context.region}`,
    		bucket: process.env.BUCKET_NAME,
    });

    ossClient.put('myObj', Buffer.from('hello, fc', "utf-8")).then(function (res) {
        callback(null, 'put object');
    }).catch(function (err) {
        callback(err);
    });  
};

Pré-requisitos

• Configure uma função para o serviço com permissões de acesso ao OSS. Para mais detalhes, consulte Conceder permissões ao Function Compute para acessar outros serviços em nuvem usando funções de função.

• Crie uma função que utilize o runtime Node.js. Para mais informações, consulte Criar uma função acionada por evento. Para especificar o código como módulo ES, defina o runtime como Node.js 18 ou Node.js 20 ao criar a função.

Procedimento

1. Faça login no console do Function Compute. No painel de navegação à esquerda, escolha Function Management > Functions.

2. Na barra de navegação superior, selecione uma região. Na página Functions, clique na função de destino.

3. (Opcional) Na aba Function Details da função, clique na aba Code. Na seção WebIDE, escolha para abrir um terminal. Em seguida, execute o comando abaixo para instalar a dependência ali-oss.

   npm install ali-oss --save

   Após a conclusão da instalação, a pasta node_modules é gerada no diretório de código à esquerda do WebIDE. Essa pasta contém o diretório ali-oss e outras bibliotecas dependentes.

4. Na aba Function Details da função, clique na aba Code. No editor de código, insira o código de exemplo fornecido acima. Salve o código e clique em Deploy.

   Nota

   • No código de exemplo, o handler da função é o método handler no arquivo index.js ou index.mjs. Se sua função utilizar um handler diferente, atualize o arquivo e o método adequadamente.

   • No código de exemplo, defina region e bucket conforme suas necessidades.

5. Clique em Test Function.

   Após a execução da função, visualize o resultado retornado. O resultado é put object.

Exemplo 3: Chamar um comando externo

Um programa Node.js também pode criar um processo fork para chamar comandos externos. Por exemplo, use o módulo child_process para executar o comando Linux ls -l e listar os arquivos no diretório atual. O código a seguir fornece um exemplo.

'use strict';

import { exec } from 'child_process';
import { promisify } from 'util';

const execPromisify = promisify(exec);
export const handler = async (event, context) => {
  try {
    const { stdout, stderr } = await execPromisify("ls -l");
    console.log(`stdout: ${stdout}`);
    if (stderr !== "") {
      console.error(`stderr: ${stderr}`);
    }
    return stdout;
  } catch (error) {
    console.error(`exec error: ${error}`);
    return error;
  }
}

'use strict';

var exec = require('child_process').exec;
exports.handler = (event, context, callback) => {
  console.log('start to execute a command');
  exec("ls -l", function(error, stdout, stderr){
    callback(null, stdout);
});
}

Exemplo 4: Chamar uma função usando um gatilho HTTP

Código de exemplo

Use a URL fornecida pelo gatilho HTTP para chamar a função. O código a seguir serve como exemplo.

• Se o Authentication Method do gatilho HTTP estiver definido como No Authentication, use o Postman ou um comando curl para chamar a função. Para mais informações, consulte Procedimento.

• Se o Authentication Method do gatilho HTTP estiver configurado como Signature Authentication, JWT authentication or Bearer authentication, use o método de autenticação correspondente para chamar a função. Para mais informações, consulte Autenticação.

Para informações sobre os formatos de payload de requisição e resposta em chamadas feitas por gatilhos HTTP, consulte Chamar uma função usando um gatilho HTTP.

'use strict';

export const handler = async (event, context) => {
  const eventObj = JSON.parse(event);
  console.log(`receive event: ${JSON.stringify(eventObj)}`);

  let body = 'Hello World!';
  // get http request body
  if ("body" in eventObj) {
    body = eventObj.body;
    if (eventObj.isBase64Encoded) {
      body = Buffer.from(body, 'base64').toString('utf-8');
    }
  }
  console.log(`receive http body: ${body}`);

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

'use strict';
exports.handler = (event, context, callback) => {
  const eventObj = JSON.parse(event);
  console.log(`receive event: ${JSON.stringify(eventObj)}`);

  let body = 'Hello World!';
  // get http request body
  if ("body" in eventObj) {
    body = eventObj.body;
    if (eventObj.isBase64Encoded) {
      body = Buffer.from(body, 'base64').toString('utf-8');
    }
  }
  console.log(`receive http body: ${body}`);

  callback(null, {
    'statusCode': 200,
    'body': body
  });
}

Pré-requisitos

Crie uma função com runtime Node.js e um gatilho HTTP conforme os exemplos anteriores. Para mais informações, consulte Criar uma função acionada por evento e Configurar um gatilho HTTP. Para especificar o código como módulo ES, selecione Node.js 18 ou Node.js 20 como runtime ao criar a função.

Procedimento

1. Faça login no console do Function Compute. No painel de navegação à esquerda, escolha Function Management > Functions.

2. Na barra de navegação superior, selecione uma região. Na página Functions, clique na função de destino.

3. Na página de detalhes da função, clique na aba Triggers. Na página Triggers, obtenha o endpoint público do gatilho HTTP.

4. Execute o seguinte comando em uma ferramenta curl para chamar a função.

   curl -i "https://test-nodejs-dlgxxr****.cn-shanghai.fcapp.run" -d 'Hello World!'

   No comando acima, https://test-nodejs-dlgxxr****.cn-shanghai.fcapp.run é o endpoint público do gatilho HTTP.

   A seguinte resposta é retornada.

   HTTP/1.1 200 OK
   Access-Control-Expose-Headers: Date,x-fc-request-id
   Content-Disposition: attachment
   Content-Length: 12
   Content-Type: text/html; charset=utf-8
   Etag: W/"c-Lve95gjOVATpfV8EL5X4nxwjKHE"
   X-Fc-Request-Id: 1-65d866a8-15d8796a-cb9b4feb69ca
   X-Powered-By: Express
   Date: Fri, 23 Feb 2024 09:34:34 GMT
   
   Hello World!