Creazione di carichi di lavoro funzionali con il codice sorgente del repository

È possibile creare la funzione direttamente dal codice sorgente che si trova in un repository Git dalla console IBM Cloud® Code Engine o con la CLI.

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

In questo scenario, Code Engine costruisce un bundle di codice dal sorgente del repository Git, carica automaticamente il bundle di codice nel registro del contenitore e quindi crea la funzione per fare riferimento al bundle di codice costruito. È necessario fornire solo un nome per la funzione, l'indirizzo URL al repository Git e il tempo di esecuzione della funzione. In questo caso, Code Engine gestisce lo spazio dei nomi per voi. Tuttavia, se si vuole usare un registro di contenitori diverso, è necessario specificare il bundle di codice e un segreto di registro per quel registro di contenitori.

Per informazioni sulle autorizzazioni necessarie per accedere ai registri immagini, vedere Impostazione delle autorità per i registri immagini.

Creazione di carichi di lavoro funzionali con il codice sorgente del repository dalla console

Creare una funzione con codice sorgente dalla console.

Aprire la Code Engine console.
Seleziona " Inizia a creare ".
Seleziona un progetto dall'elenco dei progetti disponibili. È anche possibile crearne uno nuovo. Per creare una funzione è necessario selezionare un progetto.
Seleziona " Funzione ".
Inserisci un nome per la funzione; ad esempio, myfunction. Assegna alla tua funzione un nome che sia univoco all'interno del progetto.
Selezionare un' immagine Runtime per il codice funzione. Per ulteriori informazioni, vedere Runtime.
Selezionare questa opzione per compilare il pacchetto di codice partendo dal codice sorgente. Selezionando questa opzione, la funzione viene creata dal codice sorgente e memorizzata nel registro del contenitore.
Selezionare un repository di origine, ad esempio https://github.com/IBM/CodeEngine. Se si sceglie di usare il sorgente di esempio, non è necessario richiedere le credenziali, quindi si può selezionare None per l'accesso al repo del codice. È possibile fornire facoltativamente il nome di una filiale. Se non si fornisce un nome di ramo e si lascia il campo vuoto, Code Engine utilizza automaticamente il ramo predefinito del repository specificato. Fai clic su Next.
Selezionare una strategia per la costruzione e le risorse per la costruzione. Per ulteriori informazioni sulle opzioni di creazione, vedere Pianificazione della creazione. Fai clic su Next.
Selezionare un percorso del registro del contenitore, come IBM Registry Dallas, per specificare dove memorizzare l'immagine dell'output della compilazione. Se il registro è privato, è necessario impostarne l'accesso.
Fornisce le informazioni del registro su dove memorizzare l'immagine dell'output della compilazione. Seleziona un segreto del Registro esistente oppure creane uno nuovo. Se si sta creando la propria immagine su un'istanza di Container Registry presente nel proprio account, è possibile selezionare Code Engine managed secret e lasciare che Code Engine crei e gestisca il segreto per l'utente.
Selezionare uno spazio dei nomi, un nome e un tag per l'immagine. Se state creando la vostra immagine su un'istanza di IBM Cloud Container Registry presente nel vostro account, potete selezionare uno spazio dei nomi esistente o lasciare che Code Engine crei e gestisca lo spazio dei nomi per voi. Per ulteriore assistenza, fare clic su Aiutami a specificare il bundle di codice. Per ulteriori informazioni, vedere Accesso ai registri dei contenitori.
Specificare le informazioni sulle risorse, comprese le combinazioni di CPU e memoria e il ritardo di riduzione della scala.
Opzionalmente, specificare un dominio personalizzato o variabili d'ambiente. È possibile aggiungere queste opzioni in un secondo momento.
Fai clic su Crea.
Dopo che lo stato della funzione è passato a Pronto, è possibile testare la funzione. Fare clic sulla funzione Test e poi su Invia richiesta. Per aprire la funzione in una pagina web, fare clic sulla funzione URL.
È possibile modificare il codice della funzione anche nella finestra Editor. Quando si distribuisce nuovamente la funzione, il codice viene memorizzato in linea.

È possibile richiamare la funzione facendo clic su Prova funzione e poi su Invia richiesta.

Creazione di carichi di lavoro funzionali con il codice sorgente del repository con la CLI

Usare il comando function create per creare un bundle di codice dal sorgente del repository Git e per creare una funzione che faccia riferimento al bundle costruito. Per un elenco completo delle opzioni, vedere il comando ibmcloud ce function create.

Prima di iniziare

Configurare l'ambiente Code Engine CLI.
Creare e lavorare con un progetto.

Il seguente esempio function create crea la funzione myfun, che fa riferimento al codice che si trova in https://github.com/IBM/CodeEngine. Questo comando costruisce automaticamente il bundle di codice e lo carica in uno spazio dei nomi IBM Cloud® Container Registry nel proprio account. La funzione fa riferimento a questo pacchetto di codice costruito. Specificando l'opzione --build-context-dir, la compilazione utilizza i sorgenti della cartella helloworld-samples/function-codebundle-nodejs.

ibmcloud ce function create --name myfun --runtime nodejs --build-source https://github.com/IBM/CodeEngine --build-context-dir /helloworld-samples/function-codebundle-nodejs

Output di esempio

Preparing function 'myfun' for build push...
Creating function 'myfun'...
Submitting build run 'myfun-run-230111-111212718'...
Creating image 'icr.io/ce--abcde-glxo4kabcde/function-myfun:230111-1532-vwo4o'...
Waiting for build run to complete...
Build run status: 'Running'
Build run completed successfully.
Run 'ibmcloud ce buildrun get -n myfun-run-230111-111212718' to check the build run status.
Waiting for function 'myfun' to become ready...
Function 'myfun' is ready.
OK                                                
Run 'ibmcloud ce function get -n myfun' to see more details.
https://myfun.11a66hbi3rhz.us-south.codeengine.appdomain.cloud

Si noti che l'output del comando function create fornisce informazioni sulla progressione dell'esecuzione della compilazione prima della creazione della funzione.

In questo esempio, il bundle di codice costruito viene caricato nello spazio dei nomi ce--abcde-4svg40kna19 in Container Registry.

La tabella seguente riassume le opzioni utilizzate con il comando function create in questo esempio. Per ulteriori informazioni sul comando e le sue opzioni, vedere il comando ibmcloud ce function create comando.

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 composto da un massimo di 63 caratteri e può contenere lettere, numeri e trattini (-).
`--build-source`	URL del repository Git che contiene il codice sorgente; ad esempio, `https://github.com/IBM/CodeEngine`.
`--build-context-dir`	La directory del repository che contiene il codice. Questo valore è facoltativo.
`--runtime`	Il tempo di esecuzione della funzione.

Il seguente output mostra il risultato del comando function get per questo esempio, comprese le informazioni sulla compilazione.

Output di esempio

Getting function 'myfun'
'...
OK
Name:          myfun  
Project Name:  sample  
Project ID:    abcdefgh-abcd-abcd-abcd-1a2b3c4d5e6f
Age:           27m  
Created:       2023-06-27T21:07:26Z  
Visibility:    public  
URL:           https://myfun.13c66hbi3rhz.us-south.codeengine.appdomain.cloud  
Internal URL:  http://myfun.13c66hbi3rhz.function.cluster.local  
Resources:    
  CPU:               0.25  
  Memory:            500M  
  Timeout:           60 seconds  
  Scale Down Delay:  1 seconds  
  Trusted profiles:  disabled  
Environment Variables:    
  Type     Name             Value  
  Literal  CE_API_BASE_URL  https://api.us-south.codeengine.cloud.ibm.com  
  Literal  CE_DOMAIN        us-south.codeengine.appdomain.cloud  
  Literal  CE_FUNCTION      myfun  
  Literal  CE_REGION        us-south  
  Literal  CE_SUBDOMAIN     13c66hbi3rhz  
  Literal  CE_PROJECT_ID    abcdefgh-abcd-abcd-abcd-1a2b3c4d5e6f
Build Information:    
  Build Run Name:     myfun-run-230111-111212718  
  Build Type:         git  
  Build Strategy:     codebundle-nodejs-22
  Timeout:            600  
  Source:             https://github.com/IBM/CodeEngine  
  Context Directory:  /helloworld-samples/function-codebundle-nodejs    
                      
  Build Run Status:   Succeeded  
  Build Run Reason:   All Steps have completed executing  
  Run 'ibmcloud ce buildrun get -n myfun-run-230111-111212718' for details.  
Function Code:    
  Runtime:        nodejs-22
  Bundle Secret:  ce-auto-icr-us-south  
  Code Bundle:    cr://icr.io/ce--abcde-glxo4kabcde/function-myfun:230111-1532-vwo4o
  Main:           main
Status:  Ready  
URL:     https://myfun.13c66hbi3rhz.us-south.codeengine.appdomain.cloud

Ora che la funzione è stata creata dal codice sorgente del repository, è possibile aggiornarla per soddisfare le proprie esigenze utilizzando il comando ibmcloud ce function update. Se si desidera aggiornare il sorgente da utilizzare con la propria funzione, è necessario fornire l'opzione --build-source al comando function update del comando.

Quando la funzione viene creata dal codice sorgente del repository o da quello locale con la CLI, l'esecuzione del build risultante non si basa su una configurazione di build. Le esecuzioni completate vengono cancellate automaticamente. Le esecuzioni di build non basate su una configurazione di build vengono eliminate dopo 1 ora se l'esecuzione di build ha successo. Se l'esecuzione della build non ha successo, questa viene cancellata dopo 24 ore. È possibile visualizzare le informazioni relative all'esecuzione della build solo con la CLI. Non è possibile visualizzare l'esecuzione della build nella console.

Includere le dipendenze per la propria funzione

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

Includere moduli per una funzione di Node.js

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

Creare il codice sorgente scrivendo il codice in un file main.js. Ad esempio, copiare il seguente esempio di codice in un file chiamato 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 necessarie per la funzione. Per l'esempio di codice precedente, utilizzare i seguenti contenuti per il file package.json.
```
{
  "name": "function",
  "version": "1.0.0",
  "main": "main.js",
  "dependencies" : {
		    "lorem-ipsum" : "2.0.8"
 	}
}
```
Create i vostri file come funzione in Code Engine. Entrambi i file precedenti devono essere accessibili nel repository. Se si trovano in un repository privato, creare l'accesso al repository di codice privato e quindi fornire questo valore con l'opzione --build-git-repo-secret. Se i file si trovano in una directory diversa da main, fornire il percorso della directory con l'opzione --build-context-dir. L'esempio seguente estrae i file dal repository pubblico https://github.com/IBM/CodeEngine.
```
ibmcloud ce fn create -n nodelorem -runtime nodejs --build-source https://github.com/IBM/CodeEngine --build-context-dir /helloworld-samples/function-codebundle-nodejs/
```
Eseguite il comando fn get per trovare i dettagli della vostra funzione.
Invocate la vostra funzione incollando il sito URL in un browser web. Il browser visualizza un passaggio di lorem ipsum.

Per ulteriori informazioni sul comando fn create e sulle sue opzioni, vedere Creare una funzione.

Includere moduli per una funzione di Python

Creare una funzione che includa una dipendenza per uno specifico modulo Python creando un file requirements.txt. In questo 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),
      }

Creare un requirements.txt contenente le dipendenze necessarie per la propria funzione
```
lorem-text
```
Create i vostri file come funzione in Code Engine. Entrambi i file precedenti devono essere accessibili nel repository. Se si trovano in un repository privato, creare l'accesso al repository di codice privato e quindi fornire questo valore con l'opzione --build-git-repo-secret. Se i file si trovano in una directory diversa da main, fornire il percorso della directory con l'opzione --build-context-dir. L'esempio seguente estrae i file dal repository pubblico https://github.com/IBM/CodeEngine.
```
ibmcloud ce fn create -n pylorem -runtime python --build-source https://github.com/IBM/CodeEngine --build-context-dir /helloworld-samples/function-codebundle-python/
```
Eseguite il comando fn get per trovare i dettagli della vostra funzione.
Invocate la vostra funzione incollando il sito URL in un browser web. Il browser visualizza un passaggio di lorem ipsum.

Per ulteriori informazioni sul comando fn create e sulle sue opzioni, vedere Creare una funzione.

Passi successivi

Dopo aver creato la funzione, è possibile accedervi facendo clic su Test function nella console o trovando il sito URL per la funzione con il comando function get con il comando
È possibile creare una mappatura del dominio personalizzata e assegnarla alla funzione.
Dopo che la funzione è stata creata e distribuita, è possibile aggiornarla per soddisfare le proprie esigenze dalla console o utilizzando il comando ibmcloud ce function update. Se si desidera aggiornare il sorgente da utilizzare con la propria funzione, è necessario fornire l'opzione --build-source al comando function update del comando.

Dopo la creazione della funzione, è possibile aggiornare la funzione e il suo codice di riferimento utilizzando uno dei seguenti modi, indipendentemente dal modo in cui è stata creata o aggiornata la funzione:

Se si dispone di un bundle di codice esistente, è necessario fornire solo un riferimento all'immagine, che punta alla posizione del registro del contenitore quando si distribuisce l'applicazione. Per ulteriori informazioni, vedere Creazione di carichi di lavoro di funzioni da pacchetti di codice esistenti.

Se si è creata una funzione con il comando function create e si è specificata l'opzione --build-source per costruire il bundle di codice dal sorgente locale o dal repository e si vuole cambiare la funzione per puntare a un bundle di codice diverso, bisogna prima rimuovere l'associazione della compilazione dalla funzione. Ad esempio, eseguire ibmcloud ce function update -n FUN_NAME --build-clear. Dopo aver rimosso l'associazione della build dalla funzione, è possibile aggiornare la funzione per fare riferimento a un'immagine diversa.
Se si parte da un codice sorgente che risiede in un repository Git, si può scegliere di lasciare che Code Engine costruisca il bundle di codice dal sorgente e crei la funzione con una sola operazione. In questo scenario, Code Engine carica il proprio bundle di codice su IBM Cloud® Container Registry. Per saperne di più, vedere Creazione della funzione dal codice sorgente del repository.
Se si parte da un codice sorgente che risiede su una workstation locale, si può scegliere Code Engine per costruire il bundle di codice dal sorgente e creare la funzione con un unico comando CLI. In questo scenario, Code Engine carica il codice sorgente e il bundle di codice su IBM Cloud® Container Registry.

Ad esempio, si può scegliere che Code Engine costruisca il sorgente locale mentre si evolve lo sviluppo del sorgente per la funzione. Quindi, dopo che il bundle di codice è maturato, si può aggiornare la funzione per fare riferimento al bundle di codice specifico che si desidera. È possibile ripetere questo processo secondo le necessità.

Cercate altri esempi di codice? Consultate la repo Samples for IBM Cloud Code Engine GitHub.