Get started with Function Compute using the console - Function Compute: Central de Documentação do Alibaba Cloud

Uma função de evento pode responder a diversos eventos de serviços de cloud, como o upload de um arquivo no Object Storage Service (OSS) ou um alerta disparado por um serviço de monitoramento. Ao utilizar uma função de evento, basta escrever a sua lógica de processamento. Você não precisa gerenciar a integração de eventos nem os recursos de computação subjacentes. O Function Compute executa uma instância apenas sob demanda, realiza o dimensionamento automático e encerra a instância assim que o evento é processado. A cobrança ocorre somente pelos recursos efetivamente consumidos.

Caso de uso

Suponha que você precise armazenar arquivos no OSS. Para acelerar os uploads, você primeiro compacta os arquivos no formato ZIP. Contudo, o objetivo é utilizar os arquivos diretamente, e não os pacotes ZIP. Esse cenário exige um processo automatizado para descompactar os arquivos e salvá-los novamente no OSS.

Uma abordagem tradicional exige a criação e integração de múltiplos programas para monitorar e tratar alterações de arquivos no OSS, além da implantação e manutenção contínua dessas aplicações. Com uma função de evento, o foco fica exclusivamente na lógica de processamento dos arquivos. Sempre que um arquivo é enviado para o OSS, um evento é gerado. Caso esse evento atenda às condições definidas, a função é acionada automaticamente para executar o seu handler. Ao final da tarefa, o Function Compute libera os recursos de computação de forma automática, garantindo economia de custos.

Considerando que você pode não ter um bucket do OSS disponível, este tutorial apresenta um exemplo prático para orientar a implementação de uma função de evento.

Você criará um evento simulado de upload de arquivo no OSS. Esse evento invocará uma função de evento para processar o arquivo e exibir informações no console, como o nome do arquivo e o nome do bucket.

Neste tutorial, você aprenderá a:

Use o console para criar uma função de evento, escrever um handler e testar a função de ponta a ponta.
Compreenda conceitos-chave, como o runtime do Function Compute e o runtime integrado.
Compreenda os parâmetros do handler event e context.

Pré-requisitos

Registrar uma conta Alibaba Cloud

Registre uma conta Alibaba Cloud e conclua a autenticação de nome real.

Ativar o Function Compute

Se a sua conta Alibaba Cloud foi registrada e verificada em ou após 27 de agosto de 2024, você pode usar o Function Compute diretamente, sem necessidade de ativação. Ao fazer login no console do Function Compute pela primeira vez, você também pode solicitar uma avaliação gratuita seguindo as instruções na tela. Para obter mais informações, consulte Avaliação gratuita.

Caso a sua conta Alibaba Cloud tenha sido registrada antes de 27 de agosto de 2024, siga estas etapas para ativar o serviço.

Acesse a página do produto Function Compute.
Clique em Console para abrir a página de ativação. Clique em Buy Now para ativar o serviço e acesse o console do Function Compute.
Nota
- Recomendamos ativar o serviço com a sua conta Alibaba Cloud e usar um usuário RAM para gerenciar funções e aplicativos relacionados. Conceda ao usuário RAM apenas as permissões necessárias para o seu negócio. Para obter mais informações, consulte Políticas de permissão e exemplos.
(Opcional) Ao fazer login no console do Function Compute pela primeira vez, clique em OK na caixa de diálogo Alibaba Cloud Service Authorization para criar uma função vinculada ao serviço. Isso permite que o Function Compute acesse outros serviços de cloud.

Após a criação da função, o Function Compute poderá acessar seus recursos de cloud, como VPC, ECS, Simple Log Service (SLS) e Container Registry. Para obter mais informações sobre a função vinculada ao serviço, consulte Função vinculada ao serviço.

Procedimento

Etapa 1: Selecionar o tipo de função

Acesse o Function Compute console. No painel de navegação à esquerda, escolha Function Management > Functions. Na barra de navegação superior, selecione a região onde deseja criar a função, clique em Create Function e, em seguida, selecione e crie uma Event Function conforme as instruções na tela.

Etapa 2: Selecionar um runtime

Python

Para Runtime, selecione Built-in Runtimes > Python > Python 3.10.

Recomendamos o uso de um runtime integrado para funções de evento. Isso ocorre porque os runtimes integrados incluem as dependências necessárias para responder a eventos de outros serviços de nuvem (por exemplo, o módulo oss2 do Python). Para mais informações, consulte Visão geral do ambiente . Caso utilize um runtime personalizado ou um runtime de Custom Container , você precisará instalar as dependências por conta própria. Para uma comparação detalhada dos runtimes, consulte Selecionar um runtime .

Node.js

Para Runtime, selecione Built-in Runtimes > Node.js > Node.js 20.

Recomendamos o uso de um built-in runtime para funções de evento. Isso ocorre porque os built-in runtimes incluem as dependências necessárias para responder a eventos de outros serviços de cloud (por exemplo, o módulo Node.js ali-oss ). Para mais informações, consulte Visão geral do ambiente . Se você utilizar um custom runtime ou um Custom Container runtime , será necessário instalar as dependências por conta própria. Para uma comparação detalhada dos runtimes, consulte Selecionar um runtime .

Etapa 3: Criar a função

Selecione o exemplo Hello, world! para criar a função. Mantenha os valores padrão para Advanced Settings e clique em Create.

Após criar a função, visualize o código de exemplo gerado no WebIDE, na guia Code. O trecho a seguir mostra o código de exemplo em Python.

# -*- coding: utf-8 -*-
import logging
import json

# To enable the initializer feature (https://www.alibabacloud.com/help/document_detail/2513452.html)
# please implement the initializer function as below:
# def initializer(context):
#   logger = logging.getLogger()
#   logger.info('initializing')

def handler(event, context):
    # evt = json.loads(event)
    logger = logging.getLogger()
    logger.info('hello world')
    return 'hello world'

O código de exemplo Hello, world! gera automaticamente um modelo de função com um ponto de entrada. Nas etapas seguintes, você poderá desenvolver o código da sua aplicação com base nesse modelo.

Etapa 4: Modifique e implante o código de exemplo

Linguagens compiladas, como Java, não oferecem suporte ao WebIDE; elas exigem compilação local e upload do pacote de código.

Python

No WebIDE do console, abra o arquivo index.py, substitua o código existente pelo código a seguir e, em seguida, clique em Deploy.

index.py

# -*- coding: utf-8 -*-
import logging
import json
# import oss2  # Uncomment this line if you need to create an OSS client.
logger = logging.getLogger()

def handler(event, context):  # The handler is the entry point for code execution.
    logger.info("Parsing event information...")
    input_events = json.loads(event)
    if not input_events.get('events'):  # Check the format of the input event.
        raise Exception("Invalid event format: The events array does not exist or is empty.")
    event_obj = input_events['events'][0]
    bucket_name = event_obj['oss']['bucket']['name']  # Parse the OSS bucket name.
    object_name = event_obj['oss']['object']['key']  # Parse the file name.
    region = context.region  # Parse the function region.
    logger.info(f"OSS bucket name: {bucket_name}, File name: {object_name}, Region: {region}")
    # If you have an OSS bucket, you can uncomment the following line to create an OSS client instance.
    # bucket = get_bucket(region, bucket_name, context)
    bucket = None
    result = process_event(bucket, object_name)  # Call a helper function to execute the event processing logic.
    return result

def process_event(bucket, object_name):
    logger.info("Starting event processing...")
    # You can write your event processing logic here.
    # zip_file = download_file(bucket, object_name)
    # result = extract_and_upload(bucket, zip_file)
    logger.info("Event processing completed.")
    result = 0
    return result  # A return value of 0 indicates that the event is successfully processed.

# def get_bucket(region, bucket_name, context):
#     # Create an OSS bucket client instance here. The required identity authentication information can be obtained from the context.
#     creds = context.credentials  # Obtain the temporary key.
#     auth = oss2.StsAuth(
#         creds.access_key_id,
#         creds.access_key_secret,
#         creds.security_token)
#     endpoint = f'oss-{region}-internal.aliyuncs.com'
#     bucket = oss2.Bucket(auth, endpoint, bucket_name)
#     return bucket

# def download_file(bucket, object_name):
#     # This is the sample code for downloading a file from OSS.
#     try:
#         file_obj = bucket.get_object(object_name)
#         return file_obj
#     except oss2.exceptions.OssError as e:
#         logger.error(f"Failed to download the file: {e}")

# def extract_and_upload(bucket, file_obj):
#     # You can define the logic for decompressing and uploading files to OSS here.
#     return 0;

Detalhes do código

def handler(event, context):
- handler: Esta função Python é o handler. Seu código pode incluir várias funções Python, mas o handler é sempre o ponto de entrada. Mantenha o nome do handler inalterado para que o Function Compute possa encontrá-lo corretamente. Para mais informações, consulte O que é um handler?.
  
  No console do Function Compute, na página de detalhes da função, clique na aba Function Details, selecione a subaba Configuration para visualizar ou editar o campo Request Handler. O formato do campo é [filename].[function_name], por exemplo, index.handler.
- event: Quando um evento aciona a função, as informações sobre o evento, como o nome do bucket e o nome do arquivo para um evento de upload de arquivo do OSS, são passadas por meio do parâmetro event. Esse parâmetro é um objeto JSON. Para mais informações sobre o conteúdo do parâmetro event para diferentes tipos de gatilho, consulte Formato de evento de gatilho.
- context: O objeto context é passado para a sua função por meio do parâmetro context. Ele contém informações sobre a invocação, a configuração da função e a autenticação. As informações de autenticação são derivadas das permissões da role configurada para a função. Após configurar uma role, o Function Compute (FC) obtém uma chave temporária (token STS) chamando a operação AssumeRole e passa a chave para a sua função no campo credentials do objeto context. Para mais informações, consulte Conceder permissões ao Function Compute para acessar outros serviços de cloud usando uma função. Para saber mais sobre as informações contidas no objeto de contexto, consulte Contexto.
logger.info(): Você pode usar os recursos padrão de log de uma linguagem de programação para gerar logs. Por exemplo, em Python, é possível usar métodos do módulo logging para gravar informações nos logs. Este exemplo usa uma instrução para imprimir o nome do Bucket, o nome do arquivo e o nome da região. Após a chamada da função, você pode visualizar a saída do log no console. Para mais informações, consulte Logs.

Node.js

No WebIDE do console, abra o arquivo index.mjs, substitua o código existente pelo código a seguir e clique em Deploy.

index.mjs

'use strict';
// import OSSClient from 'ali-oss'; // Uncomment this line if you need to create an OSS client.

export const handler = async (event, context) => { // The handler is the entry point for code execution.
  console.log("Parsing event information...");
  const inputEvents = JSON.parse(event);
  if (!Array.isArray(inputEvents.events) || inputEvents.events.length === 0) { // Check the format of the input event.
    throw new Error("Invalid event format: The events array does not exist or is empty.");
  }
  const eventObj = inputEvents.events[0];
  const bucketName = eventObj.oss.bucket.name; // Parse the OSS bucket name.
  const objectName = eventObj.oss.object.key; // Parse the file name.
  const region = context.region;  // Parse the function region.
  console.log(`OSS bucket name: ${bucketName}, File name: ${objectName}, Region: ${region}`);
  // If you have an OSS bucket, you can uncomment the following line to create an OSS client instance.
  // const bucket = getBucket(region, context)
  const bucket = null;
  const result = processEvent(bucket, objectName); // Call a helper function to execute the event processing logic.
  return result;
};

async function processEvent (bucket, objectName) {
  console.log("Starting event processing...");
  // You can write your event processing logic here.
  // const zipFile = downloadFile(bucket, objectName);
  // const result = extractAndUpload(bucket, zipFile);
  console.log("Event processing completed.");
  const result = 0;
  return result;
}

// function getBucket (region, context) {
//   // Create an OSS bucket client instance here. The required identity authentication information can be obtained from the context.
//   const bucket = new OSSClient({
//     region: region,
//     accessKeyId: context.credentials.accessKeyId,
//     accessKeySecret: context.credentials.accessKeySecret,
//     securityToken: context.credentials.securityToken
//   });
//   return bucket;
// }

// async function downloadFile (bucket, objectName) {
//   try {
//     // This is the sample code for downloading a file from OSS.
//     const result = await bucket.get(objectName, objectName);
//     console.log(result);
//     return result;
//   } catch (e) {
//     console.log(e);
//   }
// }

// async function extractAndUpload (bucket, zipFile) {
//     // You can define the logic for decompressing and uploading files to OSS here.
//     return 0;
// }

Detalhes do código

export const handler = async (event, context)
- handler: esta função Node.js é o handler. Seu código pode incluir várias funções Node.js, mas o handler é sempre o ponto de entrada. Mantenha o nome do handler inalterado para que o Function Compute possa encontrá-lo corretamente. Para mais informações, consulte O que é um handler?.
- event: quando um evento aciona uma função, o parâmetro event transmite informações sobre o evento, como o nome do bucket e o nome do arquivo para um evento de upload de arquivo do OSS. Esse parâmetro é um objeto JSON. Para saber quais informações estão incluídas no event para diferentes tipos de eventos, consulte Formato de evento de gatilho.
- context: o objeto de contexto de tempo de execução de uma função. Ele é passado para a sua função por meio do parâmetro context e contém informações como a invocação, a configuração da função e a autenticação de identidade. As informações de autenticação de identidade derivam das permissões da função configurada para a função. Após configurar uma função para a função, o FC obtém uma chave temporária (STS Token) chamando a operação AssumeRole. Em seguida, o FC passa a chave temporária para a sua função por meio do campo credentials no objeto context. Para mais informações, consulte Usar uma função para conceder permissões ao Function Compute para acessar outros serviços de cloud. Para saber quais informações o objeto de contexto contém, consulte Contexto.
console.log(): você pode usar os recursos padrão de log de uma linguagem de programação, como o módulo console no Node.js, para imprimir informações em um log. O exemplo neste tópico usa uma instrução para imprimir o nome do bucket, o nome do arquivo e o nome da região. Após a invocação da função, você pode visualizar a saída do log no console. Para mais informações, consulte Logs.

Etapa 5: Teste a função

Para simular o acionamento de uma função por meio do upload de um arquivo no OSS, definiremos um evento simulado e o utilizaremos para disparar a execução.

Além de utilizar um evento simulado, você também pode usar um evento real do OSS para acionar a função e testá-la. Para mais informações, consulte Próximas etapas .

Crie um evento simulado: Na página Function Details, clique na aba Code. Clique na seta suspensa à direita de Test Function e selecione Configure Test Parameters. Na lista Event Template, selecione OSS. O console gera automaticamente um evento simulado com o mesmo formato de um evento real do OSS.

Você pode personalizar o Event Name e os valores dos parâmetros no objeto do evento, como o nome do bucket do OSS e o nome do arquivo. Ao terminar, clique em OK.

Exemplo de evento simulado do OSS

Cole o conteúdo do evento de exemplo a seguir na caixa de texto de parâmetros de teste e prossiga com as próximas etapas.

{
    "events": [
        {
            "eventName": "ObjectCreated:PutObject",
            "eventSource": "acs:oss",
            "eventTime": "2024-08-13T06:45:43.000Z",
            "eventVersion": "1.0",
            "oss": {
                "bucket": {
                    "arn": "acs:oss:cn-hangzhou:164901546557****:test-bucket",
                    "name": "test-bucket",
                    "ownerIdentity": "164901546557****"
                },
                "object": {
                    "deltaSize": 122539,
                    "eTag": "688A7BF4F233DC9C88A80BF985AB****",
                    "key": "source/example.zip",
                    "size": 122539
                },
                "ossSchemaVersion": "1.0",
                "ruleId": "9adac8e253828f4f7c0466d941fa3db81161****"
            },
            "region": "cn-hangzhou",
            "requestParameters": {
                "sourceIPAddress": "140.205.XX.XX"
            },
            "responseElements": {
                "requestId": "58F9FF2D3DF792092E12044C"
            },
            "userIdentity": {
                "principalId": "164901546557****"
            }
        }
    ]
}

Na aba Code, clique em Test Function para acionar a função. Após a execução bem-sucedida, visualize a Response. Um valor de retorno 0 indica que o evento foi processado com sucesso. Clique em Log Output para visualizar os logs gerados durante a execução da função.

Ao testar uma função, o Function Compute transmite o conteúdo do evento simulado para o manipulador handler por meio do parâmetro event e executa o código definido na etapa anterior para analisar o parâmetro event e processar o arquivo.

A saída de log exibe as seguintes informações principais: FunctionCompute python3 runtime inited, seguida por quatro entradas de log de nível [INFO]: Parsing event information..., OSS bucket name is test-bucket, file name is source/example.zip, Region is cn-hangzhou, Starting event processing..., Event processing completed..., indicando que a função analisou com sucesso as informações do evento simulado do OSS e concluiu o processamento do arquivo.

Etapa 6: (Opcional) Limpar recursos

O Function Compute cobra com base no uso real de recursos. Funções não invocadas não geram custos. Contudo, fique atento a outros produtos ou recursos de cloud associados à função, como os dados armazenados no OSS e no File Storage NAS (NAS).

Para excluir uma função, acesse o console do Function Compute, escolha Function Management > Functions e selecione uma região. Na coluna Actions da função de destino, clique em Delete. Na caixa de diálogo, confirme se a função não possui recursos associados, como gatilhos, e então confirme a exclusão.

Próximas etapas

Você já criou uma função de evento no console, modificou o handler e testou a função com um event simulado. Consulte as seguintes operações avançadas de acordo com as necessidades do seu negócio:

Adicione um gatilho:
- Como talvez você não tenha um bucket do OSS, este exemplo utiliza um evento simulado de upload do OSS para testes. Em cargas de trabalho reais, adicione um gatilho do OSS à função. Para mais informações, consulte Configurar um gatilho nativo do OSS.
- Além do armazenamento de objetos, eventos de diversos serviços da Alibaba Cloud (como várias filas de mensagens, Tablestore e SLS) também podem acionar o Function Compute. Para ver a lista de gatilhos compatíveis, consulte Visão geral dos gatilhos.
Adicione dependências: Os runtimes integrados incluem dependências comuns para o processamento de eventos, mas podem não atender às suas necessidades em produção. A abordagem mais simples é empacotar seu código e as dependências em um arquivo ZIP (um pacote de código) e fazer o deploy no Function Compute. Para mais informações, consulte Implantar um pacote de código. Para reduzir o tamanho do pacote de código e acelerar o cold start da função, utilize uma camada (layer) para gerenciar as dependências. Para mais informações, consulte Criar uma camada personalizada.
Configure logs: Para facilitar a depuração, a resolução de problemas ou a auditoria de segurança, recomendamos a configuração de logs para as suas funções. Para mais informações, consulte Configurar o recurso de log.

Referências

Além do console, é possível utilizar a ferramenta de linha de comando Serverless Devs para executar as operações mencionadas. Para mais informações, consulte Início rápido.
Recomendamos os tutoriais a seguir para aprofundar seus conhecimentos sobre funções de evento:
- Higienizar dados de mensagens do RocketMQ usando o Function Compute
- Usar o Function Compute para descompactar automaticamente arquivos compactados no OSS