Function Compute:Gatilhos do Tablestore

Pré-requisitos

Antes de começar, verifique se você tem:

• Uma função no Function Compute. Consulte Criar uma função.

• Uma instância do Tablestore. Consulte Criar instâncias.

• Uma tabela nessa instância. Consulte Criar tabelas.

Limitações

• Os gatilhos do Tablestore têm suporte nas seguintes regiões: China (Pequim), China (Hangzhou), China (Xangai), China (Shenzhen), Japão (Tóquio), Singapura, Alemanha (Frankfurt) e China (Hong Kong).

• A tabela do Tablestore deve estar na mesma região da função.

• A execução da função invocada por um gatilho do Tablestore não pode exceder 1 minuto.

• Para acessar o Tablestore pela rede interna, use um endpoint de Virtual Private Cloud (VPC) no formato: {instance}.{region}.vpc.tablestore.aliyuncs.com.

Observações de uso

Evite loops de invocação. Se uma função gravar de volta na mesma tabela que a acionou — por exemplo, a Tabela A aciona a Função B e a Função B atualiza a Tabela A — o gatilho dispara novamente, criando um loop infinito. Projete seu fluxo de dados para direcionar a saída da função a uma tabela diferente.

Comportamento de nova tentativa em caso de falha. Se a execução da função falhar, o gatilho tentará novamente até que os dados de log no Tablestore expirem.

Etapa 1: Ativar o recurso Stream na tabela de dados

O recurso Stream do Tablestore captura alterações incrementais de dados e as entrega à sua função. Ative-o na tabela de dados antes de criar o gatilho.

1. Faça login no console do Tablestore.

2. Na barra de navegação superior, selecione uma região.

3. Na página Overview, clique em no alias da instância ou em Manage Instance na coluna Actions.

4. Na aba Instance Details, clique em na aba Data Tables. Em seguida, clique em no nome da tabela e selecione a aba Stream ou clique em em e selecione Stream.

5. Na aba Stream, clique em em Enable ao lado de Stream Information.

6. Na caixa de diálogo Enable Stream, defina o parâmetro Log Expiration Time e clique em em Enable. O valor deve ser um número inteiro diferente de zero, em horas. Máximo: 168 horas.

Etapa 2: Criar um gatilho do Tablestore

1. Faça login no console do Function Compute. No painel de navegação à esquerda, clique em em 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 Configurations. No painel de navegação à esquerda, clique em em Triggers e, em seguida, em Create Trigger.

4. No painel Create Trigger, configure os seguintes parâmetros e clique em em OK.

Após a criação, o gatilho aparece na aba Triggers. Para modifique ou exclua um gatilho, consulte Gerenciamento de gatilhos.

Etapa 3: Configurar parâmetros de teste

Para testar a função antes que os dados cheguem do Tablestore, configure um evento de teste correspondente ao formato de payload do gatilho do Tablestore.

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.

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

O gatilho do Tablestore codifica dados incrementais no formato Concise Binary Object Representation (CBOR) e os passa para sua função como um evento. O exemplo a seguir mostra um payload com três tipos de registro — PutRow, UpdateRow e DeleteRow — para demonstrar como a estrutura varia conforme a operação:

{
    "Version": "Sync-v1",
    "Records": [
        {
            "Type": "PutRow",
            "Info": {
                "Timestamp": 1506416585740836
            },
            "PrimaryKey": [
                {
                    "ColumnName": "pk_0",
                    "Value": 1506416585881590900
                },
                {
                    "ColumnName": "pk_1",
                    "Value": "2017-09-26 17:03:05.8815909 +0800 CST"
                },
                {
                    "ColumnName": "pk_2",
                    "Value": 1506416585741000
                }
            ],
            "Columns": [
                {
                    "Type": "Put",
                    "ColumnName": "attr_0",
                    "Value": "hello_table_store",
                    "Timestamp": 1506416585741
                },
                {
                    "Type": "Put",
                    "ColumnName": "attr_1",
                    "Value": 1506416585881590900,
                    "Timestamp": 1506416585741
                }
            ]
        },
        {
            "Type": "UpdateRow",
            "Info": {
                "Timestamp": 1506416600000000
            },
            "PrimaryKey": [
                {
                    "ColumnName": "pk_0",
                    "Value": 1506416585881590900
                }
            ],
            "Columns": [
                {
                    "Type": "Put",
                    "ColumnName": "attr_0",
                    "Value": "updated_value",
                    "Timestamp": 1506416600000
                },
                {
                    "Type": "DeleteOneVersion",
                    "ColumnName": "attr_1",
                    "Timestamp": 1506416585741
                }
            ]
        },
        {
            "Type": "DeleteRow",
            "Info": {
                "Timestamp": 1506416700000000
            },
            "PrimaryKey": [
                {
                    "ColumnName": "pk_0",
                    "Value": 1506416585881590900
                }
            ],
            "Columns": []
        }
    ]
}

A tabela a seguir descreve os campos do evento.

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

Após criar o gatilho, escreva o código da função para processar o payload de eventos do Tablestore. A função é invocada automaticamente quando os dados na tabela são alterados.

1. Na página de detalhes da função, clique em na aba Code, insira o código da função e clique em em Deploy. O exemplo Python a seguir lê registros de eventos do Tablestore e extrai valores de chave primária e colunas de atributo:

   import logging
   import cbor
   import json
   
   def get_attribute_value(record, column):
       attrs = record[u'Columns']
       for x in attrs:
           if x[u'ColumnName'] == column:
               return x['Value']
   
   def get_pk_value(record, column):
       attrs = record[u'PrimaryKey']
       for x in attrs:
           if x['ColumnName'] == column:
               return x['Value']
   
   def handler(event, context):
       logger = logging.getLogger()
       logger.info("Begin to handle event")
       #records = cbor.loads(event)
       records = json.loads(event)
       for record in records['Records']:
           logger.info("Handle record: %s", record)
           pk_0 = get_pk_value(record, "pk_0")
           attr_0 = get_attribute_value(record, "attr_0")
       return 'OK'

   Para exemplos nos runtimes Node.js, PHP, Java e C#, consulte Usar o Tablestore para acionar o Function Compute nos runtimes Node.js, PHP, Java e C#.

2. Clique em em Test Function.

Após a execução, visualize os resultados na aba Code.

Perguntas frequentes

Por que a criação do gatilho falha em uma região específica?

Os gatilhos do Tablestore estão disponíveis apenas em determinadas regiões. Verifique a seção Limitações para confirme se há suporte à sua região.

Por que não consigo encontrar minha tabela do Tablestore ao criar um gatilho?

A tabela do Tablestore deve estar na mesma região da função. Se a tabela estiver em uma região diferente, ela não aparecerá na configuração do gatilho.

Por que continuo vendo erros "Invocation canceled by client"?

Esse erro geralmente indica que o tempo limite do lado do cliente é menor que a duração real da execução da função. Aumente o período de tempo limite do cliente. Para mais detalhes, consulte O que devo fazer se o cliente for desconectado e a mensagem "Invocation canceled by client" for relatada?

Por que meu gatilho do Tablestore não dispara após a gravação de dados na tabela?

Verifique o seguinte:

1. Confirme se o recurso Stream está ativado na tabela. Consulte Etapa 1: Ativar o recurso Stream na tabela de dados.

2. Confirme se a função correta (AliyunTableStoreStreamNotificationRole) foi configurada ao criar o gatilho. Consulte Etapa 2: Criar um gatilho do Tablestore.

3. Verifique os logs de execução da função para identificar possíveis falhas. Se a função falhar repetidamente, novas tentativas ocorrerão até que os dados de log expirem. Consulte O que devo fazer se um gatilho não conseguir acionar a execução da função?