Function Compute:Configure um gatilho OSS do EventBridge

Observações

Observe as diferenças entre os gatilhos OSS baseados no EventBridge e os gatilhos OSS nativos:

• É possível associar no máximo 10 gatilhos OSS nativos a um bucket. Para associar mais gatilhos OSS a um bucket, utilize gatilhos OSS baseados no EventBridge.

  Nota

  Recomendamos não associar mais de 10 gatilhos a um único bucket. Se precisar de mais gatilhos, crie um novo bucket e configure-os nele.

• Você pode criar até 50 gatilhos OSS baseados no EventBridge, conforme os limites de recursos do EventBridge. Para mais informações, consulte Limites.

• Em gatilhos OSS baseados no EventBridge, a combinação de Event Type, Object Prefix e Object Suffix não precisa ser única.

• Você pode configurar múltiplos valores para Object Prefix e Object Suffix. No entanto, não há suporte para correspondência difusa (fuzzy matching) nem expressões regulares em Object Prefix e Object Suffix.

• Um gatilho OSS baseado no EventBridge não fica ativo imediatamente. Após a criação, leva cerca de 30 segundos para começar a acionar a função associada.

Exemplo

Configure um gatilho OSS com uma regra que especifique os prefixos source e test e os sufixos .rar e .zip. Quando um arquivo compactado com sufixo .rar ou .zip for carregado no diretório source ou test de um bucket OSS especificado, uma função será acionada automaticamente. Após a execução da função, o arquivo descompactado será armazenado em outro diretório no mesmo bucket.

Pré-requisitos

• EventBridge

  • Ativar o EventBridge e conceder permissões

• Function Compute

  • Criar uma função

• Object Storage Service (OSS)

  • Criar buckets

Etapa 1: Criar um gatilho OSS do EventBridge

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 em na função desejada.

3. Na página de detalhes da função, clique em na aba Trigger e, em seguida, clique em Create Trigger.

4. No painel Trigger Type, defina Event triggers for Alibaba Cloud services como Object Storage Service (OSS) em OK, configure os demais parâmetros e clique em OK.

   Parâmetro	Ações	Exemplo
   Name	Insira um nome personalizado para o gatilho.	oss-trigger
   Version or Alias	O valor padrão é LATEST. Para criar um gatilho para uma versão ou alias diferente, primeiro selecione a versão ou alias na lista suspensa Version or Alias na página de detalhes da função. Para mais informações sobre versões e aliases, consulte Gerenciar versões e Gerenciar aliases.	LATEST
   Bucket Name	Selecione o bucket OSS criado.	bucket-zh****
   Object Prefix	Insira os prefixos dos nomes de objeto que deseja corresponder. O Function Compute recomenda configurar prefixos e sufixos para evitar invocações circulares e cobranças inesperadas. Clique em + Add Object Prefix para adicionar múltiplos valores para Object Prefix. Importante Um prefixo de objeto não pode começar com barra (/); caso contrário, o gatilho não será acionado.	source test
   Object Suffix	Insira os sufixos dos nomes de objeto que deseja corresponder. O Function Compute recomenda configurar prefixos e sufixos para evitar invocações circulares e cobranças inesperadas. Clique em + Add Object Suffix para adicionar múltiplos valores para Object Suffix.	png
   Event Type	Selecione um ou mais eventos de gatilho. Para mais informações sobre os tipos de evento do Function Compute, consulte Definições de eventos do OSS.	oss:ObjectCreated:PutObject, oss:ObjectCreated:PostObject, oss:ObjectCreated:CompleteMultipartUpload
   Event Pattern Content	Após configurar Object Prefix, Object Suffix e Event Type, o sistema preenche este parâmetro automaticamente. Importante Modifique o Event Pattern Content com cautela. Uma modificação incorreta pode causar falha no gatilho. Antes de alterar um padrão de evento, certifique-se de compreender as regras. Para mais informações, consulte Padrões de evento.	{ "source":[ "acs.oss" ] }
   Invocation Method	Selecione o método para invocar a função. O método padrão é invocação síncrona. Sync Invocation: O Function Compute aciona a função e aguarda a conclusão da execução antes de retornar o resultado. Este método é adequado para uma ampla variedade de casos de uso. Para mais informações, consulte Invocação síncrona. Async Invocation: O Function Compute aciona a função e retorna uma resposta imediatamente. O serviço garante que a função seja executada pelo menos uma vez, mas não retorna o resultado da execução. Recomendado para funções com tempos de execução longos. Para mais informações, consulte Invocação assíncrona.	Sync Invocation
   Trigger State	Define se o gatilho deve ser ativado imediatamente após a criação. Por padrão, Enable Trigger está selecionado, o que significa que o gatilho é ativado logo após a criação.	N/A
   Push Format	Especifica o formato de dados para o parâmetro de entrada de evento da função. CloudEvents: Especificação para descrever dados de eventos em um formato comum. Inclui uma descrição do evento e sua carga útil, simplificando a declaração e entrega de eventos entre serviços e plataformas. RawData: Entrega apenas a carga útil do evento, sem os outros metadados do formato CloudEvents. Nota Os gatilhos OSS nativos diferem dos gatilhos OSS baseados no EventBridge. O parâmetro de evento de um gatilho OSS nativo suporta apenas o modelo OSSEvents, que é o formato de evento gerado pelo OSS.	CloudEvents

   Para informações sobre parâmetros avançados, como configurações de nova tentativa e fila de mensagens mortas (dead letter), consulte Recursos avançados de gatilho.

   Após a criação, o gatilho aparece na lista Trigger Name. Para modificar ou excluir o gatilho, consulte Gerenciar gatilhos.

Etapa 2: Configurar parâmetros de entrada da função

Um gatilho OSS baseado no EventBridge passa o evento para a função como um parâmetro de entrada no formato CloudEvents. Você pode passar manualmente um evento para a função a fim de simular um gatilho.

1. Na aba Code da página de detalhes da função, clique em no ícone ao lado de Test Function e selecione Configure Test Parameters na lista suspensa.

2. No painel Configure Test Parameters, selecione Create New Test Event ou Modify Existing Test Event. Insira um nome de evento e o conteúdo do evento e clique em OK.

   O evento corresponde ao parâmetro de entrada do Function Compute. Quando um evento especificado ocorre no bucket OSS de destino, o sistema envia os dados do evento para a função vinculada no formato JSON. O código abaixo fornece um exemplo:

   {
       "datacontenttype": "application/json;charset=utf-8",
       "aliyunaccountid": "143199913****",
       "data": {
           "eventVersion": "1.0",
           "responseElements": {
               "requestId": "6364D216511B143733C5A67B"
           },
           "eventSource": "acs:oss",
           "eventTime": "2023-11-04T08:49:26.000Z",
           "requestParameters": {
               "sourceIPAddress": "140.205.XX.XX"
           },
           "eventName": "ObjectCreated:PutObject",
           "userIdentity": {
               "principalId": "143199913****"
           },
           "region": "cn-hangzhou",
           "oss": {
               "bucket": {
                   "name": "bucket-zh***",
                   "arn": "acs:oss:cn-hangzhou:143199913****:bucket-zh***",
                   "virtualBucket": "",
                   "ownerIdentity": "143199913****"
               },
               "ossSchemaVersion": "1.0",
               "object": {
                   "size": 13,
                   "objectMeta": {
                       "mimeType": "text/plain"
                   },
                   "deltaSize": 13,
                   "eTag": "59CA0EFA9F5633CB0371BBC0355478D8",
                   "key": "source/a.png"
               }
           }
       },
       "subject": "acs:oss:cn-hangzhou:143199913****:bucket-zh***/source/a.png",
       "aliyunoriginalaccountid": "143199913****",
       "source": "acs.oss",
       "type": "oss:ObjectCreated:PutObject",
       "aliyunpublishtime": "203-11-04T08:49:26.745Z",
       "specversion": "1.0",
       "aliyuneventbusname": "default",
       "id": "6364D216511B143733C5A67B",
       "time": "2023-11-04T08:49:26Z",
       "aliyunregionid": "cn-hangzhou"
   }

   A tabela a seguir descreve os campos no parâmetro de evento.

   Parâmetro	Tipo	Exemplo	Descrição
   datacontenttype	string	application/json;charset=utf-8	Tipo de conteúdo do parâmetro data. O parâmetro datacontenttype suporta apenas application/json;charset=utf-8.
   aliyunaccountid	string	143199913****	ID da sua conta Alibaba Cloud. Encontre-o na seção References da página Overview no console do Function Compute.
   data	struct	{}	Conteúdo do evento OSS, representado como um objeto JSON. Os CloudEvents contêm o contexto definido pelo OSS quando o evento ocorre, encapsulado neste parâmetro data.
   subject	string	acs:oss:cn-hangzhou:143199913**:bucket-zh**/source/a.png	Assunto do evento. O formato é acs:oss:<region>:<your_account_id>:<your_bucket>, onde <region> é a região da função, <your_account_id> é o ID da sua conta Alibaba Cloud e <your_bucket> é o nome do seu bucket.
   aliyunoriginalaccountid	string	143199913****	ID da conta Alibaba Cloud que originou o evento.
   source	string	acs.oss	Origem do evento. Para gatilhos OSS, o valor é fixo em acs.oss.
   type	string	oss:ObjectCreated:PutObject	Tipo do evento.
   aliyunpublishtime	timestamp	2023-11-04T08:49:26.745Z	Horário em que o evento foi recebido.
   specversion	string	1.0	Versão do protocolo CloudEvents.
   aliyuneventbusname	string	default	Nome do barramento de eventos que recebe o evento.
   id	string	6364D216511B143733C5A67B	ID do evento.
   time	timestamp	2023-11-04T08:49:26Z	Horário em que o evento ocorreu.
   aliyunregionid	string	cn-hangzhou	Região onde o evento foi recebido.
   aliyunpublishaddr	string	140.205.XX.XX	Endereço IP do servidor que recebe o evento.

   Atualize os seguintes campos no parâmetro data para corresponder à sua configuração:

   • userIdentity.principalId: Substitua pelo ID da sua conta Alibaba Cloud.

   • region: Substitua pela região onde você criou a função.

   • oss.bucket.name: Substitua pelo nome do seu bucket, que deve estar na mesma região da função.

   • oss.bucket.arn: O formato é acs:oss:<region>:<your_account_id>:<your_bucket>, onde <region> é a região da função, <your_account_id> é o ID da sua conta Alibaba Cloud e <your_bucket> é o nome do seu bucket na mesma região.

   • oss.bucket.ownerIdentity: Substitua pelo ID da sua conta Alibaba Cloud.

   • object.key: Substitua pelo objeto que você carregou no bucket de destino.

   Importante

   Ao simular um gatilho configurando o parâmetro de evento, certifique-se de que o objeto especificado, como source/a.png neste tutorial, exista no bucket configurado. Caso contrário, a função não será acionada ou sua execução falhará.

Etapa 3: Escrever e testar o código da função

Após criar o gatilho OSS, escreva e teste o código da função para verificar sua correção. A função será então acionada automaticamente por eventos reais do OSS.

1. Na aba Code da página de detalhes da função, insira seu código no editor e clique em Deploy.

   A seção a seguir descreve os preparativos e fornece códigos de exemplo.

   Nota

   Se precisar ler ou gravar recursos do OSS na sua função, recomendamos usar um endpoint interno do OSS para evitar tráfego de internet e taxas associadas. Para mais informações sobre endpoints internos do OSS, consulte Regiões e endpoints.

   /* Preparations:
   1. Run the following commands in a terminal to create the package.json file and install the jimp module.
     a. Run npm init to create the package.json file.
     b. Run npm install jimp to install the jimp module.
   2. Make sure that the function handler is index.handler.
   */
   
   'use strict';
    console.log('Loading function ...');
    var oss = require('ali-oss');
    var fs = require('fs');
    var jimp = require("jimp");
    module.exports.handler = function (eventBuf, ctx, callback) {
        console.log('Received event:', eventBuf.toString());
        var event = JSON.parse(eventBuf);
   
        var ossEvent = event.data;
   
        // OSS regions are prefixed with "oss-". Example: oss-cn-shanghai.
        var ossRegion = "oss-" + ossEvent.region;
        // Create an OSS client.
        var client = new oss({
            region: ossRegion,
            /*
            An Alibaba Cloud account's AccessKey pair grants full API access. For security, use a RAM user for API calls and routine O&M.
            Do not hard-code your AccessKey ID and secret in your code, as this can lead to leaks and compromise your account's security.
            This example retrieves credentials from the context.
            */
            accessKeyId: ctx.credentials.accessKeyId,
            accessKeySecret: ctx.credentials.accessKeySecret,
            stsToken: ctx.credentials.securityToken
        });
        // Obtain the bucket name from the event.
        client.useBucket(ossEvent.oss.bucket.name);
        // The processed image is saved to the processed/ directory.
        var newKey = ossEvent.oss.object.key.replace("source/", "processed/");
        var tmpFile = "/tmp/processed.png";
        // Obtain the OSS object.
        console.log('Getting object: ', ossEvent.oss.object.key)
        client.get(ossEvent.oss.object.key).then(function (val) {
            // Read the content of the OSS object from the cache.
            jimp.read(val.content, function (err, image) {
                if (err) {
                    console.error("Failed to read image");
                    callback(err);
                    return;
                }
                // Resize the image and save it to the tmp file.
                image.resize(128, 128).write(tmpFile, function (err) {
                    if (err) {
                        console.error("Failed to write image locally");
                        callback(err);
                        return;
                    }
                    // Upload the read OSS object to the OSS bucket and rename the object.
                    console.log('Putting object: ', newKey);
                    client.put(newKey, tmpFile).then(function (val) {
                        console.log('Put object:', val);
                        callback(null, val);
                        return;
                    }).catch(function (err) {
                        console.error('Failed to put object: %j', err);
                        callback(err);
                        return
                    });
                });
            });
        }).catch(function (err) {
            console.error('Failed to get object: %j', err);
            callback(err);
            return
        });
    };

   # Preparations:
   # 1. Make sure that the role configured for the function has permissions to access OSS. You can log on to the RAM console to grant the required permissions to the role.
   # 2. Make sure that the function's request handler is index.handler.
   
   # -*- coding: utf-8 -*-
   import oss2, json
   from wand.image import Image
   def handler(event, context):
       evt = json.loads(event)
       creds = context.credentials
       # Required by OSS SDK
       # An Alibaba Cloud account's AccessKey pair grants full API access. For security, use a RAM user for API calls and routine O&M.
       # Do not hard-code your AccessKey ID and secret in your code, as this can lead to leaks and compromise your account's security.
       # This example retrieves credentials from the context.
       auth=oss2.StsAuth(
           creds.access_key_id,
           creds.access_key_secret,
           creds.security_token)
       evt = evt['data']
       bucket_name = evt['oss']['bucket']['name']
       endpoint = 'oss-' +  evt['region'] + '-internal.aliyuncs.com'
       bucket = oss2.Bucket(auth, endpoint, bucket_name)
       objectName = evt['oss']['object']['key']
       # Processed images will be saved to processed/
       newKey = objectName.replace("source/", "processed/")
       remote_stream = bucket.get_object(objectName)
       if not remote_stream:
           return
       remote_stream = remote_stream.read()
       with Image(blob=remote_stream)  as img:
           with img.clone() as i:
               i.resize(128, 128)
               new_blob = i.make_blob()
               bucket.put_object(newKey, new_blob)

   /* Preparations:
   1. Make sure that the role configured for the function has permissions to access OSS. You can log on to the RAM console and grant the role permissions to access OSS.
   2. Make sure that the function's request handler is index.handler.
   */
   
   <?php
     use OSS\OssClient;
   function handler($event, $context) {
     $event           = json_decode($event, $assoc = true);
     /*
       An Alibaba Cloud account's AccessKey pair grants full API access. For security, use a RAM user for API calls and routine O&M.
       Do not hard-code your AccessKey ID and secret in your code, as this can lead to leaks and compromise your account's security.
       This example retrieves credentials from the context.
     */
     $accessKeyId     = $context["credentials"]["accessKeyId"];
     $accessKeySecret = $context["credentials"]["accessKeySecret"];
     $securityToken   = $context["credentials"]["securityToken"];
     $evt        = $event['data'];
     $bucketName = $evt['oss']['bucket']['name'];
     $endpoint   = 'oss-' . $evt['region'] . '-internal.aliyuncs.com';
     $objectName = $evt['oss']['object']['key'];
     $newKey = str_replace("source/", "processed/", $objectName);
     try {
       $ossClient = new OssClient($accessKeyId, $accessKeySecret, $endpoint, false, $securityToken);
       $content = $ossClient->getObject($bucketName , $objectName);
       if ($content == null || $content == "") {
         return;
       }
       $imagick = new Imagick();
       $imagick->readImageBlob($content);
       $imagick->resizeImage(128, 128, Imagick::FILTER_LANCZOS, 1);
       $ossClient->putObject($bucketName, $newKey, $imagick->getImageBlob());
     } catch (OssException $e) {
       print($e->getMessage());
     }
   }

   /* Preparations:
   1. Add the following dependencies to pom.xml.
   <dependencies>
       <dependency>
         <groupId>com.aliyun.fc.runtime</groupId>
         <artifactId>fc-java-core</artifactId>
         <version>1.4.1</version>
       </dependency>
       <dependency>
         <groupId>com.aliyun.fc.runtime</groupId>
         <artifactId>fc-java-event</artifactId>
         <version>1.2.0</version>
       </dependency>
   </dependencies>
   2. Make sure that the function handler is example.App::handleRequest.
   */
   
   package example;
   
   import java.io.*;
   import java.util.Map;
   
   import com.aliyun.fc.runtime.Context;
   import com.aliyun.fc.runtime.StreamRequestHandler;
   import com.aliyun.fc.runtime.event.OSSEvent.Event;
   
   import com.fasterxml.jackson.annotation.JsonCreator;
   import com.fasterxml.jackson.annotation.JsonProperty;
   import com.fasterxml.jackson.core.type.TypeReference;
   import com.fasterxml.jackson.databind.DeserializationFeature;
   import com.fasterxml.jackson.databind.ObjectMapper;
   
   public class App implements StreamRequestHandler {
   
       private static final ObjectMapper mapper = new ObjectMapper().configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
       public static final class CloudEvent {
           public final String id;
   
           public final String source;
           public final String specversion;
   
           public final String type;
           public final String datacontenttype;
   
           public final String dataschema;
   
           public final String subject;
   
           public final String time;
   
           public final Map<String, ?> extensions;
   
           public final Event data;
   
           @JsonCreator
           public CloudEvent(@JsonProperty("id") String id, @JsonProperty("source") String source, @JsonProperty("specversion") String specversion, @JsonProperty("type") String type, @JsonProperty("datacontenttype") String datacontenttype, @JsonProperty("dataschema") String dataschema, @JsonProperty("subject") String subject, @JsonProperty("time") String time, @JsonProperty("extensions") Map<String, ?> extensions, @JsonProperty("data") Event data) {
               this.id = id;
               this.source = source;
               this.specversion = specversion;
               this.type = type;
               this.datacontenttype = datacontenttype;
               this.dataschema = dataschema;
               this.subject = subject;
               this.time = time;
               this.extensions = extensions;
               this.data = data;
           }
   
           public String getId() {
               return this.id;
           }
   
           public String getSource() {
               return this.source;
           }
   
           public String getSpecversion() {
               return this.specversion;
           }
   
           public String getType() {
               return this.type;
           }
   
           public String getDatacontenttype() {
               return this.datacontenttype;
           }
   
           public String getDataschema() {
               return this.dataschema;
           }
   
           public String getSubject() {
               return this.subject;
           }
   
           public String getTime() {
               return this.time;
           }
   
           public Map<String, ?> getExtensions() {
               return this.extensions;
           }
   
           public Event getData() {
               return this.data;
           }
       }
       @Override
       public void handleRequest(
               InputStream inputStream, OutputStream outputStream, Context context) throws IOException {
           CloudEvent cloudEvents = mapper.readValue(inputStream, new TypeReference<CloudEvent>() {});
           Event ossEvent = cloudEvents.getData();
           context.getLogger().info(String.format("received %s from %s @ %s", ossEvent.eventName, ossEvent.eventSource, ossEvent.region));
           outputStream.write(String.format("received %s from %s @ %s", ossEvent.eventName, ossEvent.eventSource, ossEvent.region).getBytes());
           outputStream.write(String.format("received bucket %s", ossEvent.oss.bucket.arn).getBytes());
           outputStream.write(String.format("received object %s and it's size is %s", ossEvent.oss.object.key, ossEvent.oss.object.size).getBytes());
       }
   }

2. Clique em Test Function.

   Após a conclusão da execução, visualize o resultado acima da aba Code.

Perguntas frequentes

• O que fazer se um gatilho falhar ao invocar a função?

• O que fazer se uma função for acionada várias vezes quando um objeto é carregado no OSS?

Tópicos relacionados

• Para conhecer os tipos de eventos OSS configuráveis, consulte Definições de eventos do OSS.

• Para modificar ou excluir um gatilho existente, consulte Atualizar um gatilho.

• Problemas relacionados a gatilhos:

  • Para verificar qual evento invocou sua função, registre o tipo de evento no seu código. Para mais informações, consulte Gerenciamento de logs.

  • Para chamar uma função a partir de outra, faça uma chamada direta de API ou use o CloudFlow para orquestrá-las. Se invocar assincronamente uma função que executa uma tarefa de longa duração, configure um destino para lidar com o resultado da invocação. Para mais informações, consulte Funções podem invocar umas às outras? e Configurar um destino para uma invocação assíncrona.