Simple Log Service:Use o Function Compute para consumir dados de log

Pré-requisitos

• Autorize o SLS a acionar a execução de funções por meio da Autorização de Acesso a Recursos.

• Function Compute

  • Criar uma função orientada a eventos

• Simple Log Service (SLS)

  • Criar um projeto e Logstores

    Crie um projeto e dois Logstores: um para armazenar os logs coletados (garanta a ingestão contínua, pois o Function Compute é acionado por dados incrementais) e outro para armazenar os logs de gatilho do SLS.

  Importante

  O projeto e o serviço Function Compute devem estar na mesma região.

Cenários

• Limpeza e transformação de dados

  Colete, transforme, consulte e analise logs com o SLS.

• Transferência de dados

  Envie dados para vários destinos e crie pipelines de dados entre produtos de big data na nuvem.

Funções de transformação de dados

• Tipos de função

  • Funções de modelo

    Modelos disponíveis: aliyun-log-fc-functions.

  • Funções definidas pelo usuário

    O formato de configuração varia conforme a implementação. Consulte o Guia de desenvolvimento de funções ETL.

• Mecanismo de gatilho do Function Compute

  Cada tarefa de gatilho corresponde a um gatilho do Function Compute. O SLS inicia um temporizador que consulta as informações de shard no Logstore. Quando novos dados chegam, o SLS gera uma tríade <shard_id,begin_cursor,end_cursor> como evento da função e aciona a execução.

  Nota

  Atualizações de armazenamento podem alterar os cursores sem novos dados e causar uma invocação vazia extra por shard. Para lidar com isso, busque os dados usando o cursor em sua função. Se nenhum dado for retornado, ignore a invocação. Consulte o Guia de desenvolvimento de funções definidas pelo usuário.

  Os gatilhos são baseados em tempo. Por exemplo, com um intervalo de 60 segundos e gravações contínuas no Shard 0, a função é acionada a cada 60 segundos para esse shard. Shards sem novos dados são ignorados. A função recebe o intervalo de cursores dos últimos 60 segundos e o utiliza para ler e processar os dados do shard.

Etapa 1: Criar um gatilho SLS

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

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

3. Na página de detalhes da função, clique na aba Trigger e em Create Trigger. No painel Create Trigger, defina Trigger Type como Log Service, configure os parâmetros a seguir e clique em OK.

Após a criação, o gatilho aparece na aba Triggers. Para modificar ou excluir um gatilho, consulte Gerenciamento de Gatilhos.

Etapa 2: Configurar permissões

1. Na página de detalhes da função, selecione a aba Configuration. Na seção Advanced Settings, clique em Modify.

2. No painel Advanced Settings, selecione uma Function Role:

   • Função padrão — AliyunFCServerlessDevsRole concede acesso somente leitura ao SLS e atende à maioria dos casos de uso.

   • Função RAM personalizada — se sua função grava no SLS ou acessa outros serviços, crie uma função RAM com:

     1. Trusted entity: Cloud Service → Function Compute. Consulte Criar uma função RAM para um serviço confiável da Alibaba Cloud.

     2. Permissões: as permissões SLS necessárias para sua função. Consulte Exemplos de políticas RAM personalizadas.

3. Clique em Deploy.

Etapa 3: Implantar e visualizar logs

1. Na aba Code, cole o código da função no editor e clique em Deploy. O exemplo Python a seguir lê dados de log do Logstore de origem usando o intervalo de cursores do evento de gatilho. Ele usa credenciais temporárias de context.credentials para inicializar o cliente SLS, sem necessidade de chaves codificadas.

   """
   Reads log data from an SLS Logstore within the cursor range
   provided by the trigger event.
   """
   import logging
   import json
   from aliyun.log import LogClient
   
   logger = logging.getLogger()
   
   def handler(event, context):
       # Get temporary credentials from the function's execution role.
       creds = context.credentials
       access_key_id = creds.access_key_id
       access_key_secret = creds.access_key_secret
       security_token = creds.security_token
   
       # Parse the trigger event.
       event_obj = json.loads(event.decode())
       source = event_obj['source']
       endpoint = source['endpoint']
       log_project = source['projectName']
       log_store = source['logstoreName']
       shard_id = source['shardId']
       begin_cursor = source['beginCursor']
       end_cursor = source['endCursor']
   
       # Initialize the SLS client with temporary credentials.
       client = LogClient(
           endpoint=endpoint,
           accessKeyId=access_key_id,
           accessKey=access_key_secret,
           securityToken=security_token
       )
   
       # Pull all log groups in the range [begin_cursor, end_cursor).
       while True:
           response = client.pull_logs(
               project_name=log_project,
               logstore_name=log_store,
               shard_id=shard_id,
               cursor=begin_cursor,
               count=100,
               end_cursor=end_cursor,
               compress=False
           )
           log_group_cnt = response.get_loggroup_count()
           if log_group_cnt == 0:
               break
           logger.info("Got %d log group(s) from %s", log_group_cnt, log_store)
           logger.info(response.get_loggroup_list())
           begin_cursor = response.get_next_cursor()
   
       return 'success'

2. Na página de detalhes da função, acesse Logs > Function Logs para verificar se a função está recebendo e processando dados. Se a mensagem "The logging feature is not enabled for the current function." aparecer, clique em Enable.

(Opcional) Etapa 4: Testar com um evento simulado

1. Na aba Code, clique no ícone ao lado de Test Function e selecione Configure Test Parameters.

2. No painel Configure Test Parameters, selecione Create New Test Event ou Modify Existing Test Event. Selecione o modelo Log Service, insira um nome de evento e clique em OK.

3. Clique em Test Function. Após a conclusão da execução, visualize o resultado acima da aba Code.

Parâmetro event

Quando o gatilho é acionado, o SLS passa o seguinte objeto JSON para o parâmetro event da função:

{
    "parameter": {},
    "source": {
        "endpoint": "http://cn-hangzhou-intranet.log.aliyuncs.com",
        "projectName": "fc-test-project",
        "logstoreName": "fc-test-logstore",
        "shardId": 0,
        "beginCursor": "MTUyOTQ4MDIwOTY1NTk3ODQ2Mw==",
        "endCursor": "MTUyOTQ4MDIwOTY1NTk3ODQ2NA=="
    },
    "jobName": "1f7043ced683de1a4e3d8d70b5a412843d81****",
    "taskId": "c2691505-38da-4d1b-998a-f1d4bb8c****",
    "cursorTime": 1529486425
}

Campos configuráveis pelo usuário

Campos de origem (o bloco de log que sua função lê)

Campos gerados pelo sistema (preenchidos automaticamente pelo Function Compute, sem necessidade de configuração)

Operações relacionadas

• Consultar logs de gatilho

  Para visualizar estatísticas de execução do gatilho, crie um índice no Logstore de logs do gatilho. Criar um índice.

• Visualizar logs de execução da função

  Use a CLI para inspecionar detalhes da execução da função. Visualizar logs de invocação.

Perguntas frequentes

O gatilho SLS não invoca a função

Verifique se novos dados estão sendo gravados no Logstore configurado. O gatilho só é acionado quando os dados do shard mudam. Se houver fluxo de dados, verifique os logs do gatilho e os logs de execução da função em busca de mensagens de erro.

Por que a contagem de invocações está alta?

Cada shard dispara independentemente. Um Logstore com 10 shards produz 10 invocações por intervalo durante a operação normal. Se o gatilho estiver recuperando atrasos (quando o processamento fica mais de 10 segundos atrás), ele acelera para aproximadamente uma invocação a cada 2 segundos por shard até recuperar o atraso.

Erro: "denied by sts or ram"

A função RAM está sem as permissões SLS necessárias. Revise e atualize a função conforme descrito na Etapa 2: Configurar permissões.