Kit di sviluppo delle funzioni (FDK)

Scopri i Function Development Kits (FDK) utilizzati da OCI Functions per supportare diversi linguaggi.

OCI Functions utilizza Fn Project Function Development Kits (FDK) per supportare i linguaggi più diffusi: Java, Node.js, Python, Go, Ruby e C#. Un FDK è un set di librerie di supporto che gestiscono gli interni di sistema (come protocolli, analisi di input e output e logica per i contenitori di funzioni). Ogni lingua FDK è composta da tre componenti:

Immagine di base build-time, contenente librerie e strumenti specifici della lingua per creare funzioni eseguibili.
Immagine di base runtime, per fornire un ambiente runtime specifico della lingua in cui eseguire le funzioni eseguibili.
Una libreria FDK (nel caso di Java, la libreria FDK è inclusa nelle immagini di base di build-time e runtime).

I FDK sono specifici di particolari versioni di una determinata lingua. Oracle pubblica regolarmente nuove immagini di base FDK in fase di build e runtime per le lingue supportate (ad esempio, per emettere una patch o per supportare una nuova versione rilasciata della lingua). Nel caso di Java, un aggiornamento FDK include sempre tutti e tre i componenti (le immagini di base builld-time e runtime, nonché la libreria FDK). Nel caso di altre lingue, un aggiornamento FDK potrebbe includere uno o più componenti.

Quando si crea una funzione per la prima volta utilizzando il comando fn init della CLI di Fn Project, è possibile specificare la lingua in cui il codice sorgente della funzione viene scritto utilizzando l'opzione di comando --runtime. Oltre a specificare una lingua, è possibile specificare facoltativamente una versione della lingua. Se non si specifica la versione della lingua, l'interfaccia CLI di Fn Project presuppone che si desideri utilizzare la versione più recente del linguaggio FDK disponibile. L'interfaccia CLI di Fn Project registra il valore dell'opzione di comando --runtime come valore del parametro runtime: nell'func.yaml della funzione. L'interfaccia CLI di Fn Project aggiunge inoltre i valori per i parametri build_image: e run_image: nel file func.yaml in base all'opzione di comando --runtime specificata, come indicato di seguito.

Se si specifica semplicemente una lingua come valore dell'opzione di comando --runtime, l'interfaccia CLI di Fn Project aggiunge le versioni più recenti delle immagini FDK di build-time e runtime di base di tale lingua come valori per i parametri build_image: e run_image:. Ad esempio, se si immette fn init --runtime python helloworld-func e Python 3.11 è la versione più recente disponibile, l'interfaccia CLI di Fn Project aggiunge quanto segue:
```
runtime: python
build_image: fnproject/python:3.11-dev
run_image: fnproject/python:3.11
```
Se si specificano sia una lingua che una versione come valore dell'opzione di comando --runtime, l'interfaccia CLI di Fn Project aggiunge la versione corrispondente delle immagini di build-time e runtime FDK della lingua come valori per i parametri build_image: e run_image:. Ad esempio, se si immette fn init --runtime python3.9 helloworld-func, l'interfaccia CLI di Fn Project aggiunge quanto segue:
```
runtime: python3.9
build_image: fnproject/python:3.9-dev
run_image: fnproject/python:3.9
```

Quando si crea una funzione utilizzando fn build o fn deploy, l'interfaccia CLI di Fn Project crea un'immagine Docker (e, nel caso di fn deploy, esegue il push dell'immagine in un registro Docker). L'immagine Docker contiene le dipendenze di runtime della funzione. Se la funzione è scritta in una lingua per la quale è disponibile un FDK, l'interfaccia CLI di Fn Project:

Utilizza l'immagine di base della fase di build specificata dal parametro build_image: per creare una versione eseguibile della funzione e include la funzione eseguibile nell'immagine Docker.
Include l'immagine di base runtime specificata dal parametro run_image: nell'immagine Docker per fornire l'ambiente di runtime in cui eseguire la funzione eseguibile.

L'interfaccia CLI di Fn Project utilizza le versioni memorizzate nella cache delle immagini di base in fase di creazione e runtime del FDK, se disponibili. Se le versioni inserite nella cache delle immagini di base non sono disponibili, l'interfaccia CLI di Fn Project estrae le immagini di base in fase di creazione e runtime del linguaggio FDK da Docker Hub.

Si noti che se viene rilasciata una nuova versione di un FDK di lingua, i valori per i parametri build_image: e run_image: nel file func.yaml di una funzione esistente non vengono aggiornati automaticamente. Le versioni iniziali delle immagini di build-time e runtime di base del linguaggio FDK specificate in precedenza come valori per i parametri build_image: e run_image: quando la funzione è stata creata vengono ancora utilizzate per creare l'eseguibile della funzione e per fornire l'ambiente runtime. L'utilizzo dei valori iniziali dei parametri build_image: e run_image: consente di garantire che il codice funzione rimanga compatibile con le immagini di base in fase di creazione e runtime del linguaggio FDK.

Se si desidera ricreare una funzione esistente con una versione di lingua diversa e includere un runtime diverso nell'immagine Docker della funzione, modificare i valori dei parametri build_image: e run_image: nel file func.yaml della funzione per fare riferimento a una versione diversa del file FDK della lingua. Per coerenza ed evitare confusione, aggiornare il valore del parametro runtime: in modo che corrisponda all'opzione di comando --runtime per la versione del linguaggio FDK. Nel caso delle funzioni Java, è inoltre necessario modificare la versione FDK nel file pom.xml della funzione.

Esempi

Gli esempi in questa sezione presuppongono che si stia utilizzando l'interfaccia CLI di Fn Project versione 0.6.7 (o successiva) e che Python 3.11 sia la versione più recente di Python supportata dal FDK Python.

Esempio 1: creare una nuova funzione con Python 3.11

Se si desidera creare una nuova funzione con Python 3.11, eseguire uno dei seguenti comandi:

fn init --runtime python helloworld-func

fn init --runtime python3.11 helloworld-func

Nel caso di fn init --runtime python helloworld-func, l'interfaccia CLI di Fn Project registra il valore dell'opzione di comando --runtime come valore del parametro runtime: nella funzione func.yaml e aggiunge i numeri di versione più recenti delle immagini di build-time e base runtime di Python FDK come valori per i parametri build_image: e run_image::

runtime: python
build_image: fnproject/python:3.11-dev
run_image: fnproject/python:3.11

Nel caso di fn init --runtime python3.11 helloworld-func, l'interfaccia CLI di Fn Project registra il valore dell'opzione di comando --runtime come valore del parametro runtime: nella funzione func.yaml e aggiunge le immagini di build-time e runtime di Python 3.11 FDK come valori per i parametri build_image: e run_image::

runtime: python3.11
build_image: fnproject/python:3.11-dev
run_image: fnproject/python:3.11

D'ora in poi, quando si crea la funzione, l'interfaccia CLI di Fn Project continua a utilizzare le versioni iniziali delle immagini di base build-time e runtime per creare l'eseguibile della funzione e fornire l'ambiente runtime.

Esempio 2: creare una nuova funzione con Python 3.9

Per creare una nuova funzione con Python 3.9, eseguire il comando seguente:

fn init --runtime python3.9 helloworld-func

L'interfaccia CLI di Fn Project registra il valore dell'opzione di comando --runtime come valore del parametro runtime: nella funzione func.yaml e aggiunge la versione delle immagini di base di build-time e runtime di Python FDK appropriate per Python 3.9 come valori per i parametri build_image: e run_image:, come mostrato di seguito.

runtime: python3.9
build_image: fnproject/python:3.9-dev
run_image: fnproject/python:3.9

D'ora in poi, quando si crea la funzione, l'interfaccia CLI di Fn Project continua a utilizzare le versioni Python 3.9 iniziali delle immagini di build-time e runtime di base per creare l'eseguibile della funzione e fornire l'ambiente di runtime.

Esempio 3: Ricreare una funzione esistente con Python 3.8

Se si desidera ricreare una funzione esistente creata inizialmente con Python 3.8 e si desidera continuare a crearla con Python 3.8, eseguire il comando seguente:

fn build helloworld-func

I parametri build_image: e run_image: nel file func.yaml erano originariamente impostati sulle versioni delle immagini di base di build-time e runtime di Python FDK appropriate per Python 3.8. Quando si crea la funzione, l'interfaccia CLI di Fn Project continua a utilizzare le stesse immagini di build-time e runtime di Python 3.8 per creare l'eseguibile della funzione e per fornire l'ambiente runtime.

Esempio 4: Ricreare una funzione Python 3.8 esistente con Python 3.11

Se si desidera ricreare una funzione esistente creata inizialmente con Python 3.8 e ora si desidera crearla con Python 3.11:

Modificare i valori dei parametri build_image: e run_image: nel file func.yaml della funzione per fare riferimento alla versione FDK più recente per Python 3.11 (vedere Come scoprire le versioni più recenti delle immagini di base di build e runtime FDK per una determinata versione di lingua supportata):
```
runtime: python3.8
build_image: fnproject/python:3.11-dev
run_image: fnproject/python:3.11
```
Per coerenza ed evitare confusione, aggiornare il valore del parametro runtime: in modo che corrisponda all'opzione del comando --runtime per Python 3.11.
```
runtime: python3.11
build_image: fnproject/python:3.11-dev
run_image: fnproject/python:3.11
```
Eseguire il comando riportato di seguito:
```
fn build helloworld-func
```

L'interfaccia CLI di Fn Project utilizza le versioni delle immagini di build-time e di base runtime di Python FDK specificate dai parametri build_image: e run_image: nel file func.yaml per creare l'eseguibile della funzione e fornire l'ambiente runtime. D'ora in poi, quando si crea la funzione, l'interfaccia CLI di Fn Project utilizza quelle versioni delle immagini di base di build-time e runtime.

Comportamento in versioni precedenti dell'interfaccia CLI di Fn Project (prima della versione 0.6.7)

Utilizzando le versioni dell'interfaccia CLI di Fn Project precedenti alla versione 0.6.7, ogni volta che hai creato o ricostruito una funzione scritta in una lingua supportata da un FDK (ad eccezione di Java, vedi sotto), l'interfaccia CLI di Fn Project ha utilizzato le versioni memorizzate nella cache delle immagini di base di build-time e runtime di FDK del linguaggio, se disponibili. Se le versioni delle immagini di base inserite nella cache non erano disponibili, l'interfaccia CLI di Fn Project ha estratto le versioni più recenti delle immagini di base da Docker Hub. Di conseguenza, non è stato possibile essere certi che il codice funzione fosse compatibile con l'immagine di base del tempo di build di FDK del linguaggio utilizzata per creare l'eseguibile della funzione o con l'immagine di base del runtime utilizzata per fornire l'ambiente runtime.

È possibile continuare a creare funzioni esistenti esattamente come prima, non specificando esplicitamente la versione del linguaggio FDK quando si crea una funzione. L'interfaccia CLI di Fn Project continuerà a utilizzare le versioni memorizzate nella cache delle immagini di base in fase di creazione e runtime del FDK (se disponibili) o a estrarre le versioni più recenti delle immagini di base da Docker Hub (se le immagini inserite nella cache non sono disponibili).

A partire da Fn Project CLI versione 0.6.7:

Se si specifica esplicitamente la versione del linguaggio FDK quando si crea una funzione, l'interfaccia CLI di Fn Project aggiunge tale versione come valore dei parametri build_image: e run_image: nel file func.yaml della funzione.
Se si crea o distribuisce una funzione e il file func.yaml della funzione non contiene già i parametri build_image: e run_image: perché è stato creato con una versione precedente dell'interfaccia CLI di Fn Project, l'interfaccia CLI di Fn Project aggiunge i parametri al file func.yaml. I valori dei parametri build_image: e run_image: registrano le versioni delle immagini di build-time e base runtime FDK attualmente utilizzate dall'interfaccia CLI di Fn Project.

A meno che non si specifichi esplicitamente una versione diversa quando si ricostruisce la funzione in un secondo momento, l'interfaccia CLI di Fn Project continua a utilizzare la versione FDK specificata dai parametri build_image: e run_image:.

Nel caso delle funzioni Java, le versioni precedenti dell'interfaccia CLI di Fn Project hanno aggiunto i parametri runtime:, build_image: e run_image: ai file func.yaml, per garantire che il codice della funzione rimanesse compatibile con le immagini di base di build-time e runtime di Java FDK.

Come scoprire le versioni linguistiche supportate dai FDK

Per scoprire le versioni dei linguaggi supportati da FDK (Java, Node.js, Python, Go, Ruby e C#):

Se non è stato ancora aggiornato, aggiornare l'interfaccia CLI di Fn Project alla versione più recente. Vedere Upgrading the Fn Project CLI.
In una finestra del terminale, immettere:
```
fn init --help | grep runtime
```
Ad esempio:
```
fn init --help | grep runtime

--runtime value Choose an existing runtime - dotnet, dotnet3.1, dotnet6.0, dotnet8.0, go, go1.18, go1.19, java, java11, java17, java8, kotlin, node, node14, node16, node18, python, python3.11, python3.8, python3.9, ruby, ruby2.7, ruby3.1
```
Nell'esempio precedente, è possibile vedere che diversi FDK supportano:
- tre versioni di dotnet (per C#), Java, Python e Node.js
- Due versioni di Go e Ruby
- Una versione di Kotlin
Per ulteriori dettagli sulle versioni supportate, vedere Lingue supportate dalle funzioni OCI.

Come scoprire la versione delle immagini FDK build-time e runtime base utilizzate per una funzione esistente

Per scoprire la versione delle immagini FDK build-time e runtime base che l'interfaccia CLI di Fn Project sta attualmente utilizzando per creare l'eseguibile della funzione e per fornire l'ambiente runtime:

Se non è stato ancora aggiornato, aggiornare l'interfaccia CLI di Fn Project alla versione più recente. Vedere Upgrading the Fn Project CLI.
In una finestra di terminale, passare alla directory che contiene il codice funzione.
Utilizzare i comandi fn build o fn deploy per creare o distribuire la funzione.
I parametri build_image: e run_image: vengono aggiunti al file func.yaml della funzione, se non sono già presenti. I valori dei parametri mostrano la versione delle immagini FDK build-time e runtime base che l'interfaccia CLI di Fn Project sta attualmente utilizzando per creare l'eseguibile della funzione e per fornire l'ambiente runtime.

Come scoprire le versioni predefinite dell'immagine di base FDK e runtime per una determinata lingua

Per scoprire le versioni predefinite dell'immagine di base FDK e runtime attualmente utilizzate dall'interfaccia CLI di Fn Project per creare eseguibili di funzioni e per fornire l'ambiente runtime per le funzioni scritte in una determinata lingua:

Se non è stato ancora aggiornato, aggiornare l'interfaccia CLI di Fn Project alla versione più recente. Vedere Upgrading the Fn Project CLI.
In una finestra del terminale, creare una nuova funzione helloworld immettendo:
```
fn init --runtime <language> hello-func
```
dove <language> è la lingua specifica a cui si è interessati (una delle seguenti: java, python, node, ruby, go, kotlin o dotnet (per C#)).
Ad esempio:
```
fn init --runtime java hello-func
```
Passare alla directory /hello-func creata per la nuova funzione e aprire il file func.yaml in un editor di testo.
Le versioni predefinite dell'immagine di base del tempo di creazione e del runtime FDK per la lingua specificata vengono visualizzate come valori dei parametri build_image: e run_image:.

Come scoprire le versioni più recenti delle immagini di base FDK in fase di build e runtime per una determinata versione di lingua supportata

Per scoprire le versioni più recenti dell'immagine di base FDK in fase di build e runtime attualmente utilizzate dall'interfaccia CLI di Fn Project per creare eseguibili e fornire l'ambiente runtime per le funzioni in una determinata versione di una determinata lingua.

Se non è stato ancora aggiornato, aggiornare l'interfaccia CLI di Fn Project alla versione più recente. Vedere Upgrading the Fn Project CLI.
Per visualizzare le versioni di lingua supportate disponibili, eseguire le operazioni riportate di seguito.
```
fn init --help | grep runtime
```
Ad esempio:
```
fn init --help | grep runtime

--runtime value Choose an existing runtime - dotnet, dotnet3.1, dotnet6.0, dotnet8.0, go, go1.18, go1.19, java, java11, java17, java8, kotlin, node, node14, node16, node18, python, python3.11, python3.8, python3.9, ruby, ruby2.7, ruby3.1
```
Prendere nota dei valori validi dell'opzione di comando --runtime per la lingua specifica a cui si è interessati, che includono i numeri delle versioni supportate. Ad esempio:
- java17, java11, java8
- python3.11, python3.9, python3.8
- node18, node16, node14
- ruby2.7, ruby3.1
- go1.19, go1.18
- dotnet3.1, dotnet6.0, dotnet8.0 (per C#)
In una finestra del terminale, creare una nuova funzione helloworld immettendo:
```
fn init --runtime <language-version> hello-func
```
dove <language-version> è la lingua e la versione particolare a cui sei interessato.
Ad esempio:
```
fn init --runtime java17 hello-func
```
Passare alla directory /hello-func creata per la nuova funzione e aprire il file func.yaml in un editor di testo.
Le versioni più recenti supportate delle immagini di base FDK e runtime per la versione della lingua specificata vengono visualizzate come valori dei parametri build_image: e run_image:.

Come aggiornare una funzione esistente per utilizzare la build-time FDK più recente e la versione di immagine di base runtime per una lingua supportata

Per aggiornare una funzione esistente in modo che l'interfaccia CLI di Fn Project utilizzi la build-time FDK più recente e le versioni di immagine di base runtime per un linguaggio supportato per creare l'eseguibile della funzione e per fornire l'ambiente runtime:

Se non è stato ancora aggiornato, aggiornare l'interfaccia CLI di Fn Project alla versione più recente. Vedere Upgrading the Fn Project CLI.
In una finestra di terminale, passare alla directory che contiene il codice funzione e aprire il file func.yaml in un editor di testo.
I parametri build_image: e run_image: mostrano il tempo di generazione FDK e le versioni dell'immagine di base runtime attualmente utilizzate dall'interfaccia CLI di Fn Project per creare l'eseguibile della funzione e per fornire l'ambiente runtime. Ad esempio:
```
build_image: fnproject/fn-java-fdk-build:jdk11-1.0.105
run_image: fnproject/fn-java-fdk:jre11-1.0.105
```
Se i parametri build_image: e run_image: non sono presenti nel file func.yaml, utilizzare i comandi fn build o fn deploy per creare la funzione. In questo modo verranno aggiunti i parametri build_image: e run_image: al file func.yaml, impostati sulle versioni dell'immagine di build FDK e dell'immagine runtime attualmente utilizzate dall'interfaccia CLI di Fn Project.
Individuare le versioni dell'immagine FDK in fase di creazione e dell'immagine di base in fase di esecuzione per la versione della lingua che si desidera venga utilizzata dall'interfaccia CLI di Fn Project (vedere Come scoprire le versioni più recenti dell'immagine di base in fase di creazione e runtime FDK per una determinata versione della lingua supportata).
Aprire il file func.yaml in un editor di testo (se non è già aperto) e aggiornarlo come indicato di seguito.
1. Modificare i valori dei parametri build_image: e run_image: impostandoli sulle versioni dell'immagine di base di runtime e build FDK identificate nel passo precedente.
  Ad esempio, è possibile modificare:
```
build_image: fnproject/fn-java-fdk-build:jdk11-1.0.105
run_image: fnproject/fn-java-fdk:jre11-1.0.105
```
  to
```
build_image: fnproject/fn-java-fdk-build:jdk11-1.0.130
run_image: fnproject/fn-java-fdk:jre11-1.0.130
```
2. Per coerenza ed evitare confusione, modificare il valore del parametro runtime: in modo che corrisponda all'opzione di comando --runtime per la versione della lingua. Ad esempio:
```
runtime: java11
```
Solo per le funzioni Java, aprire il file pom.xml in un editor di testo e aggiornare l'elemento <fdk.version> in modo che corrisponda alla versione specificata in func.yaml.
Ad esempio, è possibile modificare <fdk.version>1.0.105</fdk.version> in <fdk.version>1.0.130</fdk.version>.
Distribuire nuovamente la funzione e testarla per confermare che il codice funzione è compatibile con le nuove versioni di immagine FDK build-time e runtime base che l'interfaccia CLI di Fn Project sta ora utilizzando per creare l'eseguibile della funzione e per fornire l'ambiente runtime.

Documentazione di Oracle Cloud Infrastructure