Trousses de développement de fonction (FDK)

Découvrez les trousses FDK utilisées par le service des fonctions pour OCI prises en charge dans différentes langues.

Le service des fonctions pour OCI utilise les trousses FN Project Function Development Kits (FDK) pour prendre en charge les langages populaires : Java, Node.js, Python, Go, Ruby et C#. Un FDK est un ensemble de bibliothèques d'aide qui gèrent les systèmes internes (tels que les protocoles, l'analyse des entrées et des sorties et la logique des conteneurs de fonction). Chaque langue FDK se compose de trois composants :

Image de base de compilation, contenant des bibliothèques et des outils propres au langage pour créer des fonctions exécutables.
Image de base d'exécution, pour fournir un environnement d'exécution propre au langage dans lequel exécuter des fonctions exécutables.
Une bibliothèque FDK (dans le cas de Java, la bibliothèque FDK est incluse dans les images de base de compilation et d'exécution).

Les FDK sont spécifiques à des versions particulières d'une langue donnée. Oracle publie régulièrement de nouvelles images de base de compilation et d'exécution FDK pour les langues prises en charge (par exemple, pour l'émission d'un correctif ou pour la prise en charge d'une nouvelle version du langage). Dans le cas de Java, une mise à jour FDK inclut toujours les trois composants (les images de base de builld-time et d'exécution, ainsi que la bibliothèque FDK). Dans le cas d'autres langues, une mise à jour FDK peut inclure un ou plusieurs composants.

Lorsque vous créez pour la première fois une fonction à l'aide de la commande fn init de l'interface de ligne de commande Fn Project, vous spécifiez la langue dans laquelle le code source de la fonction est écrit à l'aide de l'option de commande --runtime. En plus de spécifier une langue, vous pouvez éventuellement spécifier une version de la langue. Si vous ne spécifiez pas la version de la langue, l'interface de ligne de commande Fn Project suppose que vous voulez utiliser la version la plus récente du FDK de langue disponible. L'interface de ligne de commande Fn Project enregistre la valeur de l'option de commande --runtime en tant que valeur du paramètre runtime: dans func.yaml de la fonction. L'interface de ligne de commande Fn Project ajoute également des valeurs pour les paramètres build_image: et run_image: dans le fichier func.yaml en fonction de l'option de commande --runtime que vous spécifiez, comme suit :

Si vous spécifiez simplement une langue comme valeur de l'option de commande --runtime, l'interface de ligne de commande Fn Project ajoute les versions les plus récentes des images de base de compilation et d'exécution FDK de cette langue en tant que valeurs pour les paramètres build_image: et run_image:. Par exemple, si vous entrez fn init --runtime python helloworld-func et que Python 3.11 est la version la plus récente disponible, l'interface de ligne de commande Fn Project ajoute ce qui suit :
```
runtime: python
build_image: fnproject/python:3.11-dev
run_image: fnproject/python:3.11
```
Si vous spécifiez à la fois une langue et une version en tant que valeur de l'option de commande --runtime, l'interface de ligne de commande Fn Project ajoute la version correspondante des images de base de compilation et d'exécution FDK de la langue en tant que valeurs pour les paramètres build_image: et run_image:. Par exemple, si vous entrez fn init --runtime python3.9 helloworld-func, l'interface de ligne de commande Fn Project ajoute les éléments suivants :
```
runtime: python3.9
build_image: fnproject/python:3.9-dev
run_image: fnproject/python:3.9
```

Lorsque vous créez une fonction à l'aide de fn build ou fn deploy, l'interface de ligne de commande Fn Project crée une image Docker (et, dans le cas de fn deploy, pousse l'image vers un registre Docker). L'image Docker contient les dépendances d'exécution de la fonction. Si la fonction est écrite dans une langue pour laquelle un FDK est disponible, l'interface de ligne de commande Fn Project :

Utilise l'image de base de temps de compilation spécifiée par le paramètre build_image: pour créer une version exécutable de la fonction et inclut la fonction exécutable dans l'image Docker.
Inclut l'image de base d'exécution spécifiée par le paramètre run_image: dans l'image Docker, pour fournir l'environnement d'exécution dans lequel exécuter la fonction exécutable.

L'interface de ligne de commande Fn Project utilise des versions en mémoire cache des images de base de compilation et d'exécution de FDK, si celles-ci sont disponibles. Si les versions en mémoire cache des images de base ne sont pas disponibles, l'interface de ligne de commande Fn Project extrait les images de base de compilation et d'exécution de la trousse FDK du langage à partir de Docker Hub.

Notez que si une nouvelle version d'un FDK de langue est publiée, les valeurs des paramètres build_image: et run_image: dans le fichier func.yaml d'une fonction existante ne sont pas mises à jour automatiquement. Les versions initiales des images de base de compilation et d'exécution de la trousse FDK du langage qui étaient précédemment spécifiées en tant que valeurs pour les paramètres build_image: et run_image: lors de la création de la fonction sont toujours utilisées pour créer l'exécutable de la fonction et pour fournir l'environnement d'exécution. L'utilisation des valeurs initiales des paramètres build_image: et run_image: permet de s'assurer que le code de fonction reste compatible avec les images de base de compilation et d'exécution de la trousse FDK de langue.

Si vous voulez reconstruire une fonction existante avec une version de langue différente et inclure une autre exécution dans l'image Docker de la fonction, modifiez les valeurs des paramètres build_image: et run_image: dans le fichier func.yaml de la fonction pour référencer une version différente de la trousse FDK de langue. Pour assurer la cohérence et éviter toute confusion, mettez à jour la valeur du paramètre runtime: pour qu'elle corresponde à l'option de commande --runtime pour la version de la trousse FDK de langue. Dans le cas des fonctions Java, vous devez également modifier la version de FDK dans le fichier pom.xml de la fonction.

Exemples

Les exemples de cette section supposent que vous utilisez l'interface de ligne de commande Fn Project version 0.6.7 (ou ultérieure) et que Python 3.11 est la version la plus récente de Python prise en charge par le FDK Python.

Exemple 1 : Créer une nouvelle fonction avec Python 3.11

Si vous voulez créer une nouvelle fonction avec Python 3.11, exécutez l'une des commandes suivantes :

fn init --runtime python helloworld-func

fn init --runtime python3.11 helloworld-func

Dans le cas de fn init --runtime python helloworld-func, l'interface de ligne de commande Fn Project enregistre la valeur de l'option de commande --runtime en tant que valeur du paramètre runtime: dans func.yaml de la fonction et ajoute les numéros de version les plus récents des images de base de compilation et d'exécution de la trousse FDK Python en tant que valeurs pour les paramètres build_image: et run_image: :

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

Dans le cas de fn init --runtime python3.11 helloworld-func, l'interface de ligne de commande Fn Project enregistre la valeur de l'option de commande --runtime en tant que valeur du paramètre runtime: dans func.yaml de la fonction et ajoute les images de base de compilation et d'exécution de Python 3.11 FDK en tant que valeurs pour les paramètres build_image: et run_image: :

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

Désormais, lorsque vous créez la fonction, l'interface de ligne de commande Fn Project continue d'utiliser les versions initiales des images de base de compilation et d'exécution pour créer l'exécutable de la fonction et fournir l'environnement d'exécution.

Exemple 2 : Créer une nouvelle fonction avec Python 3.9

Si vous voulez créer une nouvelle fonction avec Python 3.9, exécutez la commande suivante :

fn init --runtime python3.9 helloworld-func

L'interface de ligne de commande Fn Project enregistre la valeur de l'option de commande --runtime en tant que valeur du paramètre runtime: dans func.yaml de la fonction et ajoute la version des images de base de temps de compilation et d'exécution de la trousse FDK Python appropriées pour Python 3.9 en tant que valeurs pour les paramètres build_image: et run_image:, comme indiqué :

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

Désormais, lorsque vous créez la fonction, l'interface de ligne de commande Fn Project continue d'utiliser les versions Python 3.9 initiales des images de base de compilation et d'exécution pour créer l'exécutable de fonction et fournir l'environnement d'exécution.

Exemple 3 : Recréer une fonction existante avec Python 3.8

Si vous voulez reconstruire une fonction existante qui a été initialement créée avec Python 3.8, et que vous voulez continuer à la créer avec Python 3.8, exécutez la commande suivante :

fn build helloworld-func

Les paramètres build_image: et run_image: dans le fichier func.yaml étaient initialement réglés aux versions des images de base de compilation et d'exécution du trousseau FDK Python appropriées pour Python 3.8. Lorsque vous créez la fonction, l'interface de ligne de commande Fn Project continue d'utiliser les mêmes images de base de compilation et d'exécution Python 3.8 pour créer l'exécutable de fonction et fournir l'environnement d'exécution.

Exemple 4 : Recréer une fonction Python 3.8 existante avec Python 3.11

Si vous voulez reconstruire une fonction existante qui a été initialement créée avec Python 3.8, et que vous voulez maintenant la construire avec Python 3.11 :

Modifiez les valeurs des paramètres build_image: et run_image: dans func.yaml de la fonction pour référencer la dernière version de trousse FDK pour Python 3.11 (voir Comment trouver les dernières versions d'image de base de temps de compilation et d'exécution de trousse FDK pour une version de langage prise en charge particulière) :
```
runtime: python3.8
build_image: fnproject/python:3.11-dev
run_image: fnproject/python:3.11
```
Pour assurer la cohérence et éviter toute confusion, mettez à jour la valeur du paramètre runtime: pour qu'elle corresponde à l'option de commande --runtime pour Python 3.11.
```
runtime: python3.11
build_image: fnproject/python:3.11-dev
run_image: fnproject/python:3.11
```
Exécutez la commande suivante :
```
fn build helloworld-func
```

L'interface de ligne de commande Fn Project utilise les versions des images de base de compilation et d'exécution de la trousse FDK Python spécifiées par les paramètres build_image: et run_image: dans le fichier func.yaml pour créer l'exécutable de fonction et pour fournir l'environnement d'exécution. Désormais, lorsque vous créez la fonction, l'interface de ligne de commande Fn Project utilise ces versions des images de base de compilation et d'exécution.

Comportement dans les versions antérieures de l'interface de ligne de commande Fn Project (avant la version 0.6.7)

À l'aide des versions de l'interface de ligne de commande Fn Project antérieures à la version 0.6.7, chaque fois que vous avez créé ou recréé une fonction écrite dans un langage pris en charge par un FDK (à l'exception de Java, voir ci-dessous), l'interface de ligne de commande Fn Project utilisait des versions en mémoire cache des images de base de compilation et d'exécution du FDK du langage, si elles étaient disponibles. Si les versions en mémoire cache des images de base n'étaient pas disponibles, l'interface de ligne de commande Fn Project a extrait les versions les plus récentes des images de base de Docker Hub. Par conséquent, vous ne pouviez pas être certain que le code de fonction était compatible avec l'image de base de compilation du langage FDK utilisée pour créer l'exécutable de fonction, ou avec l'image de base d'exécution utilisée pour fournir l'environnement d'exécution.

Vous pouvez continuer à créer des fonctions existantes exactement comme précédemment, en ne spécifiant pas explicitement la version du FDK de langue lorsque vous créez une fonction. L'interface de ligne de commande Fn Project continuera d'utiliser les versions en mémoire cache des images de base de compilation et d'exécution de la trousse FDK (le cas échéant), ou d'extraire les versions les plus récentes des images de base de Docker Hub (si les images en mémoire cache ne sont pas disponibles).

À partir de la version 0.6.7 de l'interface de ligne de commande Fn Project :

Si vous spécifiez explicitement la version de la trousse FDK de langue lorsque vous créez une fonction, l'interface de ligne de commande Fn Project ajoute cette version en tant que valeur des paramètres build_image: et run_image: dans le fichier func.yaml de la fonction.
Si vous créez ou déployez une fonction et que le fichier func.yaml de la fonction ne contient pas déjà les paramètres build_image: et run_image:, car elle a été créée avec une version antérieure de l'interface de ligne de commande Fn Project, l'interface de ligne de commande Fn Project ajoute les paramètres au fichier func.yaml. Les valeurs des paramètres build_image: et run_image: enregistrent les versions des images de base de compilation et d'exécution FDK que l'interface de ligne de commande Fn Project utilise actuellement.

Sauf si vous spécifiez explicitement une version différente lorsque vous reconstruisez la fonction plus tard, l'interface de ligne de commande Fn Project continue d'utiliser la version FDK spécifiée par les paramètres build_image: et run_image:.

Notez que dans le cas des fonctions Java, les versions précédentes de l'interface de ligne de commande Fn Project ont ajouté les paramètres runtime:, build_image: et run_image: aux fichiers func.yaml, pour garantir que le code de fonction reste compatible avec les images de base de compilation et d'exécution de la trousse FDK Java.

Comment connaître les versions linguistiques prises en charge par les FDK

Pour connaître les versions des langages pris en charge par les trousses FDK (Java, Node.js, Python, Go, Ruby et C#) :

S'il n'a pas encore été mis à niveau, mettez à niveau l'interface de ligne de commande Fn Project vers la version la plus récente. Voir Mise à niveau de l'interface de ligne de commande Fn Project.
Dans une fenêtre de terminal, entrez :
```
fn init --help | grep runtime
```
Par exemple :
```
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
```
Dans l'exemple ci-dessus, vous pouvez voir que différents trousses FDK prennent en charge :
- trois versions de dotnet (pour C#), Java, Python et Node.js
- deux versions de Go, et Ruby
- Une version de Kotlin
Pour plus de détails sur les versions prises en charge, voir Langues prises en charge par le service des fonctions pour OCI.

Comment connaître la version des images de base de compilation et d'exécution FDK utilisées pour une fonction existante

Pour connaître la version des images de base de compilation et d'exécution FDK que l'interface de ligne de commande Fn Project utilise actuellement pour créer l'exécutable de fonction et pour fournir l'environnement d'exécution :

S'il n'a pas encore été mis à niveau, mettez à niveau l'interface de ligne de commande Fn Project vers la version la plus récente. Voir Mise à niveau de l'interface de ligne de commande Fn Project.
Dans une fenêtre de terminal, accédez au répertoire contenant le code de fonction.
Utilisez les commandes fn build ou fn deploy pour créer ou déployer la fonction.
Les paramètres build_image: et run_image: sont ajoutés au fichier func.yaml de la fonction, s'ils ne sont pas déjà présents. Les valeurs de paramètre affichent la version des images de base de compilation et d'exécution FDK que l'interface de ligne de commande Fn Project utilise actuellement pour créer l'exécutable de fonction et pour fournir l'environnement d'exécution.

Comment trouver les versions d'image de base de compilation et d'exécution de trousses FDK par défaut pour un langage donné

Pour connaître les versions d'image de base de compilation et d'exécution par défaut de FDK que l'interface de ligne de commande Fn Project utilise actuellement pour créer des exécutables de fonction et pour fournir l'environnement d'exécution, pour les fonctions écrites dans un langage donné :

S'il n'a pas encore été mis à niveau, mettez à niveau l'interface de ligne de commande Fn Project vers la version la plus récente. Voir Mise à niveau de l'interface de ligne de commande Fn Project.
Dans une fenêtre de terminal, créez une fonction helloworld en entrant :
```
fn init --runtime <language> hello-func
```
où <language> est la langue qui vous intéresse (l'une des langues suivantes : java, python, node, ruby, go, kotlin ou dotnet (pour C#).
Par exemple :
```
fn init --runtime java hello-func
```
Accédez au répertoire /hello-func créé pour la nouvelle fonction et ouvrez le fichier func.yaml dans un éditeur de texte.
Les versions d'image de base de compilation et d'exécution par défaut de FDK pour la langue que vous avez spécifiée sont affichées en tant que valeurs des paramètres build_image: et run_image:.

Comment trouver les dernières versions d'image de base de compilation et d'exécution de trousses FDK pour une version de langue prise en charge particulière

Pour connaître les dernières versions d'image de base de compilation et d'exécution de FDK que l'interface de ligne de commande Fn Project utilise actuellement pour créer des exécutables et fournir l'environnement d'exécution pour les fonctions d'une version particulière d'un langage donné.

S'il n'a pas encore été mis à niveau, mettez à niveau l'interface de ligne de commande Fn Project vers la version la plus récente. Voir Mise à niveau de l'interface de ligne de commande Fn Project.
Pour voir les versions de langue prises en charge disponibles, exécutez :
```
fn init --help | grep runtime
```
Par exemple :
```
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
```
Notez les valeurs valides de l'option de commande --runtime pour la langue qui vous intéresse, qui incluent les numéros des versions prises en charge. Par exemple :
- 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 (pour C#)
Dans une fenêtre de terminal, créez une fonction helloworld en entrant :
```
fn init --runtime <language-version> hello-func
```
où <language-version> est la langue et la version qui vous intéressent.
Par exemple :
```
fn init --runtime java17 hello-func
```
Accédez au répertoire /hello-func créé pour la nouvelle fonction et ouvrez le fichier func.yaml dans un éditeur de texte.
Les dernières versions d'image de base de compilation et d'exécution de trousses FDK prises en charge pour la version de langue que vous avez spécifiée sont affichées en tant que valeurs des paramètres build_image: et run_image:.

Comment mettre à niveau une fonction existante pour utiliser la dernière version de l'image de base de compilation et d'exécution FDK pour un langage pris en charge

Pour mettre à niveau une fonction existante afin que l'interface de ligne de commande Fn Project utilise les dernières versions d'image de base de compilation et d'exécution FDK pour un langage pris en charge afin de créer l'exécutable de la fonction et de fournir l'environnement d'exécution :

S'il n'a pas encore été mis à niveau, mettez à niveau l'interface de ligne de commande Fn Project vers la version la plus récente. Voir Mise à niveau de l'interface de ligne de commande Fn Project.
Dans une fenêtre de terminal, accédez au répertoire contenant le code de fonction et ouvrez le fichier func.yaml dans un éditeur de texte.
Les paramètres build_image: et run_image: affichent les versions d'image de base de compilation et d'exécution FDK actuellement utilisées par l'interface de ligne de commande Fn Project pour créer l'exécutable de fonction et fournir l'environnement d'exécution. Par exemple :
```
build_image: fnproject/fn-java-fdk-build:jdk11-1.0.105
run_image: fnproject/fn-java-fdk:jre11-1.0.105
```
Si les paramètres build_image: et run_image: ne sont pas présents dans le fichier func.yaml, utilisez les commandes fn build ou fn deploy pour créer la fonction. Cela ajoutera les paramètres build_image: et run_image: au fichier func.yaml, réglé aux versions d'image de compilation FDK et d'image d'exécution actuellement utilisées par l'interface de ligne de commande Fn Project.
Découvrez les versions d'image de compilation et d'image de base d'exécution de FDK pour la version de la langue que l'interface de ligne de commande Fn Project doit utiliser (voir Comment trouver les dernières versions d'image de base de compilation et d'exécution de FDK pour une version de langue prise en charge particulière).
Ouvrez le fichier func.yaml dans un éditeur de texte (s'il n'est pas déjà ouvert) et mettez-le à jour comme suit :
1. Remplacez les valeurs des paramètres build_image: et run_image: par les versions d'image de base de compilation et d'exécution FDK que vous avez identifiées à l'étape précédente.
  Par exemple, vous pouvez modifier :
```
build_image: fnproject/fn-java-fdk-build:jdk11-1.0.105
run_image: fnproject/fn-java-fdk:jre11-1.0.105
```
  jusqu'à
```
build_image: fnproject/fn-java-fdk-build:jdk11-1.0.130
run_image: fnproject/fn-java-fdk:jre11-1.0.130
```
2. Pour assurer la cohérence et éviter toute confusion, modifiez la valeur du paramètre runtime: pour qu'elle corresponde à l'option de commande --runtime pour la version de la langue. Par exemple :
```
runtime: java11
```
Pour les fonctions Java uniquement, ouvrez le fichier pom.xml dans un éditeur de texte et mettez à jour l'élément <fdk.version> pour qu'il corresponde à la version spécifiée dans func.yaml.
Par exemple, vous pouvez remplacer <fdk.version>1.0.105</fdk.version> par <fdk.version>1.0.130</fdk.version>.
Déployez à nouveau la fonction et testez-la pour confirmer que le code de fonction est compatible avec les nouvelles versions d'image de base de compilation et d'exécution de FDK que l'interface de ligne de commande Fn Project utilise maintenant pour créer l'exécutable de fonction et pour fournir l'environnement d'exécution.

Documentation sur Oracle Cloud Infrastructure