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 HTTP
Atualizado em 2023-09-28 GMT+08:00
Ver PDF
Compartilhar

Desenvolvimento de uma função HTTP

Introdução

Ao desenvolver uma função HTTP usando uma imagem personalizada, implemente um servidor HTTP na imagem e ouça a porta 8000 para solicitações. As funções HTTP suportam apenas gatilhos de APIG.

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_http_example && cd custom_container_http_example
  1. Implemente um servidor HTTP. Node.js é usado como exemplo. Para obter detalhes sobre outras linguagens, consulteCriação de uma função HTTP.

    Crie o arquivo main.js para introduzir o framework Express, receber solicitações POST, imprimir o corpo da solicitação como saída padrão e retornar "Hello FunctionGraph, method POST" para o cliente.

    const express = require('express'); 
 
const PORT = 8000; 
 
const app = express(); 
app.use(express.json());
 
app.post('/*', (req, res) => { 
    console.log('receive', req.body); 
    res.send('Hello FunctionGraph, method POST');
});
 
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-http-example",
  "version": "1.0.0",
  "description": "An example of a custom container http 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 main.js para iniciar o contêiner. Não altere este parâmetro.
    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_http_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_http_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_http_example:latest
  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/helloworld
    As seguintes informações são retornadas com base no código do módulo: 
    Hello FunctionGraph, method POST
  1. Verifique se as seguintes informações são exibidas: 
    receive {"message":"HelloWorld"}

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

Passo 4: carregar a imagem

  1. Faça logon no console do SoftWare Repository for Container (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 Functiono no canto superior direito e escolha Select template.
  3. Defina as informações básicas.
    • Function Type: selecione HTTP Function.
    • Function Name: digite custom_container_http.
    • 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.

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 apig-event-template, defina o Event Name como helloworld, modifique o evento de teste da seguinte forma e clique em Create. 
    {
    "body": "{\"message\": \"helloworld\"}",
    "requestContext": {
        "requestId": "11cdcdcf33949dc6d722640a13091c77",
        "stage": "RELEASE"
    },
    "queryStringParameters": {
        "responseType": "html"
    },
    "httpMethod": "POST",
    "pathParameters": {},
    "headers": {
        "Content-Type": "application/json"
    },
    "path": "/helloworld",
    "isBase64Encoded": false
}

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 importantes 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.