Este conteúdo foi traduzido por máquina para sua conveniência e a Huawei Cloud não pode garantir que o conteúdo foi traduzido com precisão. Para exibir o conteúdo original, use o link no canto superior direito para mudar para a página em inglês.
Central de ajuda/ FunctionGraph/ Primeiros passos/ Implementação de uma função usando uma imagem de contêiner/ Desenvolvimento de uma função de evento
Atualizado em 2023-09-28 GMT+08:00
Ver PDF
Compartilhar

Desenvolvimento de uma função de evento

Introdução

Ao desenvolver uma função de evento usando uma imagem personalizada, implemente um servidor HTTP na imagem e ouça a porta 8000 para solicitações. Por padrão, o caminho de solicitação /init é a entrada de inicialização da função. Implemente-o conforme necessário. Para obter detalhes sobre a inicialização da função, consulte Inicializador. O caminho de solicitação /invoke é a entrada de execução da função onde os eventos de gatilho são processados. Para obter detalhes sobre os parâmetros de solicitação, consulte Fontes de eventos suportadas.

Passo 1: preparar o ambiente

Para executar as operações descritas nesta seção, verifique se você tem as permissões de FunctionGraph Administrator, ou seja, as permissões completas para o FunctionGraph. Para obter mais informações, consulte Gerenciamento de permissões.

Passo 2: criar uma imagem

Tome o sistema operacional Linux x86 de 64 bits como exemplo.

  1. Crie uma pasta. 
    mkdir custom_container_event_example && cd custom_container_event_example
  1. Implemente um servidor HTTP para processar init e invoke solicitações e dar uma resposta. Node.js é usado como exemplo.

    Crie o arquivo main.js para introduzir o framework Express e implementar um manipulador de função (método POST e caminho /invoke e um inicializador (método POST e caminho /init).

    const express = require('express'); 
 
const PORT = 8000; 
 
const app = express(); 
app.use(express.json());
 
app.post('/init', (req, res) => { 
  console.log('receive', req.body);
  res.send('Hello init\n'); 
}); 
 
app.post('/invoke', (req, res) => { 
  console.log('receive', req.body);
  res.send('Hello invoke\n'); 
}); 
 
app.listen(PORT, () => { 
  console.log(`Listening on http://localhost:${PORT}`); 
});
  1. Crie o arquivo package.json para npm para que ele possa identificar as dependências do projeto e do projeto de processo. 
    {
  "name": "custom-container-event-example",
  "version": "1.0.0",
  "description": "An example of a custom container event function",
  "main": "main.js",
  "scripts": {},
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
      "express": "^4.17.1"
  }
}
    • name: nome do projeto
    • version: versão do projeto
    • main: arquivo de entrada da aplicação
    • dependencies: todas as dependências disponíveis do projeto em npm
  2. Crie um Dockerfile. 
    FROM node:12.10.0

ENV HOME=/home/custom_container
ENV GROUP_ID=1003
ENV GROUP_NAME=custom_container
ENV USER_ID=1003
ENV USER_NAME=custom_container

RUN mkdir -m 550 ${HOME} && groupadd -g ${GROUP_ID} ${GROUP_NAME} && useradd -u ${USER_ID} -g ${GROUP_ID} ${USER_NAME}

COPY --chown=${USER_ID}:${GROUP_ID} main.js ${HOME}
COPY --chown=${USER_ID}:${GROUP_ID} package.json ${HOME}

RUN cd ${HOME} && npm install

RUN chown -R ${USER_ID}:${GROUP_ID} ${HOME}

RUN find ${HOME} -type d | xargs chmod 500
RUN find ${HOME} -type f | xargs chmod 500

USER ${USER_NAME}
WORKDIR ${HOME}

EXPOSE 8000
ENTRYPOINT ["node", "main.js"]
    • FROM: especificar a imagem de base node:12.10.0. A imagem de base é obrigatória e seu valor pode ser alterado.
    • ENV: definir as variáveis de ambiente HOME (/home/custom_container), GROUP_NAME e USER_NAME (custom_container), USER_ID e GROUP_ID (1003). Essas variáveis de ambiente são obrigatórias e seus valores podem ser alterados.
    • RUN: usar o formato RUN<Command>. Por exemplo, RUN mkdir -m 550 ${HOME}, que significa criar o diretório home para o usuário ${USER_NAME} durante a construção do contêiner.
    • USER: alternar para o usuário ${USER_NAME}.
    • WORKDIR: alternar o diretório de trabalho para o diretório home do usuário ${USER_NAME}.
    • COPY: copiar main.js e package.json para o diretório home do usuário ${USER_NAME} no contêiner.
    • EXPOSE: expor a porta 8000 do contêiner. Não altere este parâmetro.
    • ENTRYPOINT: executar o comando node node /home/tester/main.js para iniciar o contêiner.
    1. Você pode usar qualquer imagem de base.
    2. No ambiente de nuvem, o UID 1003 e o GID 1003 são usados para iniciar o contêiner por padrão. Os dois IDs podem ser modificados escolhendo Configuration > Basic Settings > Container Image Override na página de detalhes da função. Eles não podem ser root ou um ID reservado.
  1. Crie uma imagem.

    No exemplo a seguir, o nome da imagem é custom_container_event_example, a tag é latest e o ponto (.) indica o diretório em que o Dockerfile está localizado. Execute o comando de criação de imagem para empacotar todos os arquivos no diretório e enviar o pacote para um mecanismo de contêiner para criar uma imagem.

    docker build -t custom_container_event_example:latest .

Passo 3: executar verificação local

  1. Inicie o contêiner do Docker. 
    docker run -u 1003:1003 -p 8000:8000 custom_container_event_example:latest
  1. Abra um novo prompt de comando e envie uma mensagem pela porta 8000 para acessar o diretório /init especificado no código do modelo. 
    curl -XPOST -H 'Content-Type: application/json' localhost:8000/init

    As seguintes informações são retornadas com base no código do módulo:

    Hello init
  1. Abra um novo prompt de comando e envie uma mensagem pela porta 8000 para acessar o diretório /invoke especificado no código do modelo. 
    curl -XPOST -H 'Content-Type: application/json' -d '{"message":"HelloWorld"}' localhost:8000/invoke

    As seguintes informações são retornadas com base no código do módulo:

    Hello invoke
  1. Verifique se as seguintes informações são exibidas: 
    Listening on http://localhost:8000
receive {}
receive { message: 'HelloWorld' }

    Como alternativa, execute o comando docker logs para obter logs de contêiner.

Passo 4: carregar a imagem

  1. Efetue logon no console do SWR. No painel de navegação, escolha My Images.
  2. Clique em Upload Through Client ou Upload Through SWR no canto superior direito.
  3. Carregue a imagem conforme solicitado.

  4. Veja a imagem na página My Images.

Passo 5: criar uma função

  1. Efetue logon no console do FunctionGraph. No painel de navegação, escolha Functions > Function List.
  2. Clique em Create Function no canto superior direito e escolha Select template.
  3. Defina as informações básicas.
    • Function Type: selecione Event Function.
    • Function Name: digite custom_container_event.
    • Use container image: selecione a imagem carregada para SWR. Exemplo: swr.{ID de região}.myhuaweicloud.com/{nome da organização}/{nome da imagem}:{tag da imagem}
    • Agency: selecione uma agência com a permissão SWR Admin. Se nenhuma agência estiver disponível, crie uma consultando Criação de uma agência.
  4. Após a conclusão da configuração, clique em Create Function.
  5. Na página de detalhes da função, escolha Configuration > Advanced Settings e ative Initialization. A API init será chamada para inicializar a função.

Passo 6: testar a função

  1. Na página de detalhes da função, clique em Test. Na caixa de diálogo exibida, crie um evento de teste.
  2. Selecione blank-template, defina o Event Name como helloworld, modifique o evento de teste da seguinte forma e clique em Create. 
    {
    "message": "HelloWorld"
}

Passo 7: ver o resultado da execução.

Clique em Test e visualize o resultado da execução à direita.

Figura 1 Resultado da execução
  • Function Output: exibe o resultado do retorno da função.
  • Log Output: exibe os logs de execução da função.
  • Summary: exibe informações-chave dos logs.

    Um máximo de 2 KB de logs podem ser exibidos. Para obter mais informações de log, consulte Consulta de logs de função.

Passo 8: exibir métricas de monitoramento

Na página de detalhes da função, clique na guia Monitoring.

  • Na página de guia Monitoring, escolha Metrics e selecione um intervalo de tempo (como 5 minutos, 15 minutos ou 1 hora) para consultar a função.
  • As seguintes métricas são exibidas: chamadas, erros, duração (incluindo as durações máxima, média e mínima) e aceleradores.

Passo 9: excluir a função

  1. Na página Detalhes da função, escolha Operation > Delete function no canto superior direito.
  2. Na caixa de diálogo exibida, clique em OK para liberar recursos.