Creazione di carichi di lavoro di funzione dal codice sorgente locale

È possibile creare la funzione " Code Engine " direttamente dal codice sorgente sulla propria workstation locale utilizzando la CLI di IBM Cloud® Code Engine. Utilizzare il comando function create (o fn create) per creare un bundle di codice dall'origine locale e distribuire la funzione per fare riferimento a questo bundle di codice creato.

Un bundle di codici è una raccolta di file che rappresenta il codice della funzione. Questo bundle di codice viene inserito nel contenitore di runtime. Il tuo bundle di codice è creato da Code Engine ed è memorizzato nel registro del contenitore o in linea con la funzione. Un bundle di codice non è un'immagine contenitore standard OCI (Open Container Initiative).

Quando si inoltra una build che estrae codice da una directory locale, il codice sorgente viene compresso in un file di archivio. Code Engine carica automaticamente il pacchetto di codice in un namespace IBM Cloud® Container Registry nel tuo account e crea e distribuisce la tua funzione per fare riferimento a questo bundle di codice creato. Nota che puoi indicare come destinazione solo IBM Cloud Container Registry per le tue build locali. Per questo scenario, è necessario fornire solo un nome per la funzione e il percorso dell'origine locale. Per un elenco completo delle opzioni, consultare il comando ibmcloud ce fn create.

Per informazioni sulle autorizzazioni richieste per accedere ai registri delle immagini, consultare Impostazione delle autorizzazioni per i registri delle immagini.

È possibile scegliere di ignorare alcuni pattern di file dall'interno del codice sorgente utilizzando il file .ceignore, che si comporta in modo simile a un file .gitignore. Ad esempio, le voci per un file .ceignore per una funzione Node.js potrebbero includere node_modules e .npm. Per ulteriori modelli di file di esempio da ignorare, vedi GitHub.gitignore repository.

IBM Cloud® Container Registry è necessario per questo scenario.

Prima di iniziare

Imposta il tuo ambiente CLICode Engine.
Creare e utilizzare un progetto.

Prima di lavorare con l'origine locale, assicurarsi che l'origine si trovi in un'ubicazione accessibile sulla workstation locale.

Creazione di una funzione dal codice sorgente locale con CLI

Questo esempio utilizza il seguente codice Node.js, salvato come un file main.js. È possibile sostituire il proprio codice.

/**
 * 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;

Passare alla directory che contiene il file main.js o registrare il relativo percorso.

Creare una funzione denominata myfun-local che utilizza un file main.js come origine. Questo comando crea e invia automaticamente il bundle di codici a uno spazio dei nomi Container Registry nel tuo account. Se non hai uno spazio dei nomi Container Registry esistente, Code Engine ne crea automaticamente uno per te.

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

Output di esempio

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

L'output del comando function create fornisce informazioni sull'avanzamento dell'esecuzione della generazione prima della creazione della funzione.

In questo esempio, il bundle di codici creato viene caricato nello spazio dei nomi ce--abcde-glxo4kabcde in Container Registry.

La seguente tabella riepiloga le opzioni utilizzate con il comando fn create in questo esempio. Per ulteriori informazioni sul comando e sulle sue opzioni, consultare il comando ibmcloud ce function create. Poiché queste opzioni variano in base alla posizione del codice sorgente, assicuratevi che il vostro codice sorgente si trovi nella posizione corrispondente all'esempio.

Descrizione del comando
Opzione	Descrizione
`--name`	Il nome della funzione. Utilizzare un nome univoco all'interno del progetto. Questo valore è obbligatorio. Il nome deve iniziare con una lettera minuscola. Il nome deve terminare con un carattere alfanumerico minuscolo. Il nome deve essere di 63 caratteri o meno e può contenere lettere, numeri e trattini (-).
`--build-source`	Il percorso verso la fonte locale. Questo valore è obbligatorio.
`--runtime`	Il runtime da utilizzare per questa funzione. Questo valore è obbligatorio.

Utilizza il comando function get per visualizzare le informazioni sulla tua applicazione, incluse le informazioni sulla build.

ibmcloud ce function get --name myfun-local

Output di esempio

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()

Inclusione delle dipendenze per la funzione

È possibile creare funzioni in diversi linguaggi di programmazione. Quando il codice della funzione diventa complesso, è possibile aggiungere moduli di codice come dipendenze per la funzione. Ogni lingua ha i propri moduli da utilizzare con il codice funzione. Ad esempio, le dipendenze Node.js sono di solito moduli npm esistenti, mentre Python utilizza i pacchetti Python. Queste dipendenze devono essere dichiarate e create in un file con il proprio codice sorgente

Inclusione di moduli per una funzione Node.js

Crea una funzione che include una dipendenza per un modulo Node.js specifico creando un file package.json. In questo caso, sia il codice sorgente che il pacchetto si trovano nella stessa cartella.

Crea il codice di origine scrivendo il tuo codice in un file main.js. Ad esempio, copiare il seguente codice di esempio in un file denominato 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;

Creare un file package.json che contenga le dipendenze richieste per la funzione. Per l'esempio di codice precedente, utilizzare il seguente contenuto per il file package.json.
```
{
  "name": "function",
  "version": "1.0.0",
  "main": "main.js",
  "dependencies" : {
		    "lorem-ipsum" : "2.0.8"
 	}
}
```
Crea i tuoi file come funzione in Code Engine. In questo caso, ci si trova nella directory in cui si trovano i file locali in modo da poter utilizzare . come origine di build.
```
ibmcloud ce fn create --name nodelorem --runtime nodejs --build-source .
```
Eseguire il comando fn get fornito per trovare i dettagli sulla funzione.
Richiama la funzione incollando l' URL e in un browser web. Il browser visualizza un passaggio di lorem ipsum.

Per ulteriori informazioni sul comando fn create e le sue opzioni, consultare Creazione di una funzione.

Inclusione di moduli per una funzione Python

Creare una funzione che includa una dipendenza per uno specifico modulo Python creando un file requirements.txt. In tal caso, sia il codice sorgente che il file dei requisiti si trovano nella stessa cartella.

Creare la funzione salvando il codice in un file __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),
      }

Crea un requirements.txt contenente le tue dipendenze richieste per la tua funzione
```
lorem-text
```
Crea i tuoi file come funzione in Code Engine. In questo caso, ci si trova nella directory in cui si trovano i file locali in modo da poter utilizzare . come origine di build.
```
ibmcloud ce fn create --name pylorem --runtime python --build-source .
```
Eseguire il comando fn get fornito per trovare i dettagli sulla funzione.
Richiama la funzione incollando l' URL e in un browser web. Il browser visualizza un passaggio di lorem ipsum.

Per ulteriori informazioni sul comando fn create e le sue opzioni, consultare Creazione di una funzione.

Passi successivi

Ora che la tua funzione viene creata e distribuita dal codice sorgente locale, puoi aggiornare la funzione per soddisfare le esigenze utilizzando il comando ibmcloud ce function update. Se si desidera aggiornare l'origine da utilizzare con la propria funzione, è necessario fornire l'opzione --build-source nel comando function update.

Quando la tua funzione viene distribuita dall'origine locale o dal codice sorgente del repository dalla CLI, l'esecuzione della build risultante non si basa su una configurazione di build. Le esecuzioni di build completate vengono eliminate automaticamente. Le esecuzioni di build che non si basano su una configurazione di build vengono eliminate dopo 1 ora se l'esecuzione della build ha esito positivo. Se l'esecuzione della build non ha esito positivo, questa esecuzione della build viene eliminata dopo 24 ore. È possibile visualizzare solo le informazioni su questa esecuzione di build con la CLI. Non è possibile visualizzare l'esecuzione della build nella console.

Cerchi altri esempi di codice? Dai un'occhiata agli esempi disponibili nel repository " IBM Cloud Code Engine " su GitHub.