Kits de développement de fonctions (FDK)

Découvrez les kits de développement de fonctions (FDK) utilisés par OCI Functions pour prendre en charge différents langages.

OCI Functions utilise des kits de développement de fonctions de projet Fn pour prendre en charge les langages populaires tels que Java, Node.js, Python, Go, Ruby et C#. Un FDK est un ensemble de bibliothèques auxiliaires qui gèrent les éléments internes du système (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 build contenant des bibliothèques et des outils propres à la langue pour créer des fonctions exécutables.
Image de base d'exécution, pour fournir un environnement d'exécution propre à la langue 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 build 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 build et d'exécution FDK pour les langages pris en charge (par exemple, pour émettre un patch ou pour prendre en charge une nouvelle version du langage). Dans le cas de Java, une mise à jour FDK inclut toujours les trois composants (les images de base de temps et d'exécution, ainsi que la bibliothèque FDK). Dans le cas d'autres langues, une mise à jour de clé étrangère peut inclure un ou plusieurs composants.

Lorsque vous créez une fonction pour la première fois à l'aide de la commande fn init de l'interface de ligne de commande du projet Fn, vous indiquez 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 n'indiquez pas la version de langue, l'interface de ligne de commande du projet Fn suppose que vous souhaitez utiliser la version la plus récente de la clé étrangère de langue disponible. L'interface de ligne de commande du projet Fn 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 du projet Fn 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 indiquez, comme suit :

Si vous indiquez simplement une langue comme valeur de l'option de commande --runtime, l'interface de ligne de commande du projet Fn ajoute les versions les plus récentes des images de base de build 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 du projet Fn ajoute ce qui suit :
```
runtime: python
build_image: fnproject/python:3.11-dev
run_image: fnproject/python:3.11
```
Si vous indiquez à la fois une langue et une version en tant que valeur de l'option de commande --runtime, l'interface de ligne de commande du projet Fn ajoute la version correspondante des images de base de build 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 du projet Fn ajoute ce qui suit :
```
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 de fn deploy, l'interface de ligne de commande du projet Fn crée une image Docker (et, dans le cas de fn deploy, propage 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 du projet Fn :

Utilise l'image de base de build indiqué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 indiquée par le paramètre run_image: dans l'image Docker, afin de fournir l'environnement d'exécution dans lequel exécuter la fonction exécutable.

L'interface de ligne de commande du projet Fn utilise les versions mises en cache des images de base de build et d'exécution du kit FDK, si elles sont disponibles. Si les versions mises en cache des images de base ne sont pas disponibles, l'interface de ligne de commande du projet Fn extrait de Docker Hub les images de base de build et d'exécution du kit FDK de langue.

Si une nouvelle version d'une clé étrangère 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 automatiquement mises à jour. Les versions initiales des images de base de build et d'exécution de la clé étrangère de langage 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 build et d'exécution de la clé étrangère de langage.

Si vous voulez recréer une fonction existante avec une version de langue différente et inclure une exécution différente 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 clé étrangère de langage. Pour assurer la cohérence et éviter toute confusion, mettez à jour la valeur du paramètre runtime: afin qu'elle corresponde à l'option de commande --runtime pour la version de la clé étrangère de langage. Dans le cas des fonctions Java, vous devez également modifier la version de clé étrangère dans le fichier pom.xml de la fonction.

Exemples

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

Exemple 1 : Créer une fonction avec Python 3.11

Si vous voulez créer une 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 du projet Fn 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 build et d'exécution du kit 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 du projet Fn 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 build 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 du projet Fn continue d'utiliser les versions initiales des images de base de build 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 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 du projet Fn 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 build et d'exécution de la clé étrangère Python qui sont appropriées pour Python 3.9 en tant que valeurs pour les paramètres build_image: et run_image:, comme indiqué ci-dessous :

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 du projet Fn continue d'utiliser les versions Python 3.9 initiales des images de base de build et d'exécution pour créer l'exécutable de la fonction et fournir l'environnement d'exécution.

Exemple 3 : reconstruction d'une fonction existante avec Python 3.8

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

fn build helloworld-func

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

Exemple 4 : reconstruction d'une fonction Python 3.8 existante avec Python 3.11

Si vous voulez reconstruire une fonction existante qui a été initialement construite 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 afin de référencer la dernière version de FDK pour Python 3.11 (reportez-vous à Découverte des dernières versions d'image de base de build et d'exécution de FDK pour une version de langage prise en charge spécifique) :
```
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: afin 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 du projet Fn utilise les versions des images de base de build et d'exécution de la clé étrangère Python indiquées par les paramètres build_image: et run_image: dans le fichier func.yaml pour créer l'exécutable de la fonction et fournir l'environnement d'exécution. Désormais, lorsque vous créez la fonction, l'interface de ligne de commande du projet Fn utilise ces versions des images de base de build et d'exécution.

Comportement dans les versions antérieures de la CLI du projet Fn (avant la version 0.6.7)

En utilisant des versions de l'interface de ligne de commande du projet Fn antérieures à la version 0.6.7, chaque fois que vous avez créé ou reconstruit 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 du projet Fn utilisait des versions mises en cache des images de base de compilation et d'exécution du langage FDK, si elles étaient disponibles. Si les versions mises en cache des images de base n'étaient pas disponibles, l'interface de ligne de commande du projet Fn 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 la fonction était compatible avec l'image de base de compilation du langage FDK utilisée pour construire l'exécutable de la 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 auparavant, en n'indiquant pas explicitement la version du langage FDK lorsque vous créez une fonction. L'interface de ligne de commande du projet Fn continuera à utiliser les versions en cache des images de base de build et d'exécution du kit FDK (si disponibles), ou extraira les versions les plus récentes des images de base de Docker Hub (si les images en cache ne sont pas disponibles).

A partir de la version 0.6.7 de la CLI du projet Fn :

Si vous indiquez explicitement la version de la clé étrangère de langue lors de la création d'une fonction, l'interface de ligne de commande du projet Fn 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 du projet Fn, l'interface de ligne de commande du projet Fn 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 build et d'exécution FDK actuellement utilisées par l'interface de ligne de commande du projet Fn.

Sauf si vous spécifiez explicitement une autre version lorsque vous recréez la fonction ultérieurement, l'interface de ligne de commande du projet Fn continue d'utiliser la version de clé étrangère indiquée par les paramètres build_image: et run_image:.

Dans le cas des fonctions Java, les versions précédentes de l'interface de ligne de commande du projet Fn ont ajouté les paramètres runtime:, build_image: et run_image: aux fichiers func.yaml, afin de garantir que le code de fonction reste compatible avec les images de base de build et d'exécution du kit Java FDK.

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

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

S'il n'a pas encore été mis à niveau, mettez à niveau l'interface de ligne de commande du projet Fn vers la version la plus récente. Reportez-vous à la section Upgrading the Fn Project CLI.
Dans une fenêtre de terminal, saisissez la commande suivante :
```
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 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, reportez-vous à Langues prises en charge par OCI Functions.

Comment trouver 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 build et d'exécution FDK que l'interface de ligne de commande du projet Fn 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 du projet Fn vers la version la plus récente. Reportez-vous à la section Upgrading the Fn Project CLI.
Dans une fenêtre de terminal, passez au répertoire contenant le code de la 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 indiquent la version des images de base de compilation et d'exécution FDK que l'interface de ligne de commande du projet Fn utilise actuellement pour créer l'exécutable de la fonction et pour fournir l'environnement d'exécution.

Comment trouver les versions d'image de base de build et d'exécution FDK par défaut pour une langue donnée

Pour connaître les versions d'image de base de build et d'exécution FDK par défaut que l'interface de ligne de commande du projet Fn utilise actuellement pour créer des exécutables de fonction et pour fournir l'environnement d'exécution pour les fonctions écrites dans une langue donnée, procédez comme suit :

S'il n'a pas encore été mis à niveau, mettez à niveau l'interface de ligne de commande du projet Fn vers la version la plus récente. Reportez-vous à la section Upgrading the Fn Project CLI.
Dans une fenêtre de terminal, créez une fonction helloworld en entrant la commande suivante :
```
fn init --runtime <language> hello-func
```
où <language> est la langue particulière qui vous intéresse (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 build et d'exécution de clé étrangère par défaut pour la langue indiquée sont affichées sous forme de valeurs des paramètres build_image: et run_image:.

Découvrez les dernières versions d'image de base de build et d'exécution FDK pour une version de langue prise en charge donnée

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

S'il n'a pas encore été mis à niveau, mettez à niveau l'interface de ligne de commande du projet Fn vers la version la plus récente. Reportez-vous à la section Upgrading the Fn Project CLI.
Pour afficher 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 particulière qui vous intéresse, notamment le nombre de 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 la commande suivante :
```
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 build et d'exécution FDK prises en charge pour la version de langue indiquée sont affichées en tant que valeurs des paramètres build_image: et run_image:.

Mise à niveau d'une fonction existante pour utiliser la dernière version d'image de base de build et d'exécution FDK pour une langue prise en charge

Pour mettre à niveau une fonction existante afin que l'interface de ligne de commande du projet Fn utilise les dernières versions d'image de base de build et d'exécution FDK pour un langage pris en charge afin de créer l'exécutable de 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 du projet Fn vers la version la plus récente. Reportez-vous à la section Upgrading the Fn Project CLI.
Dans une fenêtre de terminal, passez au répertoire contenant le code de la 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 build et d'exécution FDK actuellement utilisées par l'interface de ligne de commande du projet Fn 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, défini sur l'image de build FDK et les versions d'image d'exécution actuellement utilisées par l'interface de ligne de commande du projet Fn.
Découvrez les versions d'image de build et d'image de base d'exécution FDK correspondant à la version de la langue que l'interface de ligne de commande du projet Fn doit utiliser (reportez-vous à Découverte des dernières versions d'image de base de build et d'exécution FDK pour une version de langue prise en charge spécifique).
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 build et d'exécution de clé étrangère 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
```
  vers
```
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: afin 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 indiqué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 vérifier que le code de la fonction est compatible avec les nouvelles versions d'image de base de build et d'exécution FDK que l'interface de ligne de commande du projet Fn utilise maintenant pour créer l'exécutable de la fonction et pour fournir l'environnement d'exécution.

Documentation Oracle Cloud Infrastructure