Criando cargas de trabalho de função a partir do código-fonte local

Você pode criar sua função do Code Engine diretamente a partir do código-fonte em sua estação de trabalho local usando a CLI do IBM Cloud® Code Engine. Use o comando function create (ou fn create) para construir um pacote configurável de códigos de sua origem local e implementar sua função para referenciar esse pacote configurável de códigos construído.

Um pacote configurável de código é uma coleção de arquivos que representa seu código de função. Este pacote configurável de códigos é injetado no contêiner de tempo de execução Seu pacote configurável de códigos é criado pelo Code Engine e armazenado no registro do contêiner ou sequencial com a função. Um pacote configurável de código não é uma imagem de contêiner padrão do Open Container Initiative (OCI)

Quando você envia uma compilação que obtém o código de um diretório local, seu código-fonte é compactado em um arquivo de compactação. O Code Engine envia automaticamente o pacote de código para um namespace IBM Cloud® Container Registry na sua conta e, em seguida, cria e implanta sua função para que ela faça referência a esse pacote de código compilado. Note que você só pode destinar o IBM Cloud Container Registry para suas construções locais. Nesse cenário, basta fornecer apenas um nome para a função e o caminho para a fonte local. Para obter uma lista completa das opções, consulte o ibmcloud ce fn create comando.

Para obter informações sobre permissões necessárias para acessar registros de imagens, consulte Configurando autoridades para registros de imagens.

É possível optar por ignorar certos padrões de arquivo de dentro do seu código-fonte usando o arquivo .ceignore, que se comporta de forma semelhante a um arquivo .gitignore. Por exemplo, as entradas de um arquivo .ceignore para uma função Node.js podem incluir node_modules e .npm``. Para ver mais exemplos de padrões de arquivos a serem ignorados, consulte o repositório .gitignore do GitHub.

IBM Cloud® Container Registry é necessário para esse cenário.

Antes de Iniciar

Configure o seu ambiente da CLI do Code Engine.
Criar e trabalhar com um projeto.

Antes de trabalhar com a origem local, certifique-se de que sua origem esteja em um local acessível em sua estação de trabalho local.

Criação de uma função a partir de código-fonte local usando a CLI

Este exemplo usa o seguinte código Node.js, salvo como um arquivo main.js. É possível substituir seu próprio código.

/**
 * The `main` function is the entry-point into the function.
 * It has one optional argument, which carries all the
 * parameters the function was invoked with.
*/
async function main(params) {
  // log environment variables available to the function
  console.log(process.env);
  // log Code Engine system headers available to the function
  console.log(params.__ce_headers);
  // log all parameters for debugging purposes
  console.log("params: "+params);
  // since functions are invoked through http(s), we return an HTTP response
  return {
      statusCode: 200,
      headers: { 'Content-Type': 'application/json' },
      body: params };
}
// this step is necessary, if you gave your main function a different name
// we include it here for documentation purposes only
module.exports.main = main;

Altere para o diretório que contém o arquivo main.js ou registre o caminho para ele.

Crie uma função chamada myfun-local que use um arquivo main.js como origem.. Este comando compila e envia automaticamente o pacote de código para um namespace do Container Registry na sua conta. Se você não tiver um namespace do Container Registry, o Code Engine criará automaticamente um para você.

ibmcloud ce fn create --name myfun-local --runtime nodejs --build-source main.js

Saída de exemplo

Preparing function 'myfun-local' for build push...
Creating function 'myfun-local'...
Packaging files to upload from source path 'main.js'...
Submitting build run 'myfun-local-run-230123-111011111'...
Creating image 'icr.io/ce--abcde-glxo4kabcde/function-myfun-local:230123-1650-yrj86'...
Waiting for build run to complete...
Build run status: 'Running'
Build run completed successfully.
Run 'ibmcloud ce buildrun get -n myfun-local-run-230626-115011911' to check the build run status.
Waiting for function 'myfun-local' to become ready...
Function 'myfun-local' is ready.
OK
Run 'ibmcloud ce function get -n myfun-local' to see more details.
https://myfun-local.glxo4kabcde.us-south.codeengine.test.appdomain.cloud

Observe que a saída do comando function create fornece informações sobre a progressão da execução da construção antes que a função seja criada.

Neste exemplo, o pacote de código compilado é enviado para o namespace ce--abcde-glxo4kabcde em Container Registry.

A tabela a seguir resume as opções utilizadas com o fn create comando neste exemplo. Para obter mais informações sobre o comando e suas opções, consulte o ibmcloud ce function create comando. Como essas opções variam de acordo com a localização do código-fonte, certifique-se de que seu código-fonte esteja no local correspondente ao exemplo.

Descrição do comando
Opção	Descrição
`--name`	O nome da função. Use um nome que seja exclusivo dentro do projeto. Esse valor é necessário. O nome deve começar com uma letra minúscula. O nome deve terminar com um caractere alfanumérico minúscula. O nome deve ter 63 caracteres ou menos e pode conter letras, números e hifens (-).
`--build-source`	O caminho para a origem local. Este valor é necessário.
`--runtime`	O tempo de execução a ser usado para esta função Este valor é necessário.

Use o comando function get para exibir informações sobre o seu app, incluindo informações sobre a construção.

ibmcloud ce function get --name myfun-local

Saída de exemplo

Getting function 'myfun-local'...
OK
Name:          myfun-local
Project Name:  sample
Project ID:    abcdefgh-abcd-abcd-abcd-1a2b3c4d5e6f
Age:           5m41s
Created:       2023-06-26T16:50:14Z
URL:           https://myfun-local.glxo4kabcde.us-south.codeengine.test.appdomain.cloud
Status:        Ready
Resources:
  CPU:                 0.25
  Memory:              500M
  Max Execution Time:  60 seconds
Build Information:
  Build Run Name:     myfun-local-run-230123-111011111
  Build Type:         local
  Build Strategy:     codebundle-nodejs-22
  Timeout:            600
  Source:             main.js
  Build Run Summary:  Succeeded
  Build Run Status:   Succeeded
  Build Run Reason:   All Steps have completed executing
  Run 'ibmcloud ce buildrun get -n myfun-local-run-230123-111011111' for details.
Function Code:
  Runtime:        nodejs-22 (managed)
  Bundle Secret:  ce-auto-icr-us-south
  Code Bundle:    cr://icr.io/ce--abcde-glxo4kabcde/function-myfun-local:230123-1650-yrj86
  Main:           main()

Incluindo dependências para sua função

Você pode criar funções em muitas linguagens de programação diferentes. Quando seu código de função cresce complexo, é possível incluir módulos de código como dependências para sua função. Cada idioma tem seus próprios módulos para usar com seu código de função. Por exemplo, as dependências Node.js geralmente são módulos npm existentes, enquanto o Python usa pacotes Python. Essas dependências devem ser declaradas e criadas em um arquivo com seu código de origem

Incluindo módulos para uma função Node.js

Crie uma função que inclua uma dependência para um módulo Node.js específico criando um arquivo package.json. Nesse caso, o código-fonte e o arquivo de pacote estão localizados na mesma pasta..

Crie seu código-fonte gravando seu código em um arquivo main.js. Por exemplo, copie o exemplo de código a seguir em um arquivo chamado main.js

/**
* The `main` function is the entry-point into the function.
* It has one optional argument, which carries all the
* parameters the function was invoked with.
*/
function main(params /* optional */) {
  // use third-party 'lorem-ipsum' package to generate random words
  const LoremIpsum = require("lorem-ipsum").LoremIpsum;
  const lorem = new LoremIpsum();
  // since functions are invoked through http(s), we return an HTTP response
  return {
    headers: { "Content-Type": "text/plain;charset=utf-8" },
    body: lorem.generateWords(10),
  };
}
// this step is necessary, if you gave your main function a different name
// we include it here for documentation purposes only
module.exports.main = main;

Crie um arquivo package.json que contenha as dependências necessárias para sua função. Para o exemplo de código anterior, use o seguinte conteúdo para seu arquivo package.json.
```
{
  "name": "function",
  "version": "1.0.0",
  "main": "main.js",
  "dependencies" : {
		    "lorem-ipsum" : "2.0.8"
 	}
}
```
Crie seus arquivos como uma função no Code Engine. Nesse caso, você está no diretório no qual os arquivos locais existem, portanto, é possível usar . como a origem da construção
```
ibmcloud ce fn create --name nodelorem --runtime nodejs --build-source .
```
Execute o comando fn get fornecido para localizar detalhes sobre sua função.
Invoque sua função colando o endereço URL em um navegador da Web. Seu navegador exibe uma passagem de lorem ipsum..

Para obter mais informações sobre o comando fn create e suas opções, consulte Criar uma Função.

Incluindo módulos para uma função Python

Crie uma função que inclua uma dependência para um módulo Python específico, criando um arquivo requirements.txt Nesse caso, tanto o código de origem quanto o arquivo de requisitos estão localizados na mesma pasta

Crie sua função salvando seu código em um arquivo __main__.py

# use third-party 'lorem-ipsum' package to generate random words
from lorem_text import lorem
# The `main` function is the entry-point into the function.
# It has one optional argument, which carries all the
# parameters the function was invoked with.
def main(params):
    words = 10
    # since functions are invoked through http(s), we return an HTTP response
    return {
      "headers": {
        "Content-Type": "text/plain;charset=utf-8",
    },
    "body": lorem.words(words),
}
def main(params):
     words = 10
     return {
          "headers": {
              "Content-Type": "text/plain;charset=utf-8",
          },
          "body": lorem.words(words),
      }

Crie um requirements.txt contendo suas dependências necessárias para sua função
```
lorem-text
```
Crie seus arquivos como uma função no Code Engine. Nesse caso, você está no diretório no qual os arquivos locais existem, portanto, é possível usar . como a origem da construção
```
ibmcloud ce fn create --name pylorem --runtime python --build-source .
```
Execute o comando fn get fornecido para localizar detalhes sobre sua função.
Invoque sua função colando o endereço URL em um navegador da Web. Seu navegador exibe uma passagem de lorem ipsum..

Para obter mais informações sobre o comando fn create e suas opções, consulte Criar uma Função.

Próximas etapas

Agora que sua função foi criada e implementada a partir do código-fonte local, é possível atualizar a função para atender às suas necessidades usando o comando ibmcloud ce function update Se você quiser atualizar seu código-fonte para usá-lo com sua função, é necessário especificar a opção “ --build-source ” no function update comando.

Quando sua função é implementada a partir da origem local ou do código-fonte do repositório da CLI, a execução de construção resultante não é baseada em uma configuração de construção. As execuções de construção que são concluídas são excluídas automaticamente. As execuções de construção que não são baseadas em uma configuração de construção serão excluídas após uma hora se a execução de construção for bem-sucedida... Se a execução de construção não for bem-sucedida, essa execução de construção será excluída após 24 horas É possível exibir apenas informações sobre essa execução de construção com a CLI (interface da linha de comandos) Não é possível visualizar essa execução de compilação no console.

Procurando mais exemplos de código? Confira os exemplos no repositório “ IBM Cloud Code Engine ” GitHub.