Création de charges de travail de fonction à partir du code source local

Vous pouvez créer votre fonction « Code Engine » directement à partir du code source sur votre poste de travail local à l'aide de l'interface de ligne de commande (CLI) d' IBM Cloud® Code Engine. Utilisez la commande function create (ou fn create) pour générer un bundle de code à partir de votre source locale et déployer votre fonction pour référencer ce bundle de code généré.

Un bundle de code est une collection de fichiers qui représente votre code de fonction. Ce bundle de code est injecté dans le conteneur d'exécution. Votre bundle de code est créé par Code Engine et est stocké dans le registre de conteneur ou en ligne avec la fonction. Un bundle de code n'est pas une image de conteneur standard OCI (Open Container Initiative).

Lorsque vous soumettez une compilation qui récupère du code à partir d'un répertoire local, votre code source est compressé dans un fichier d'archive. Code Engine télécharge automatiquement ce paquet de code vers un espace de noms IBM Cloud® Container Registry de votre compte, puis crée et déploie votre fonction afin qu'elle fasse référence à ce paquet de code compilé. Notez que vous ne pouvez cibler IBM Cloud Container Registry que pour vos générations locales. Dans ce cas de figure, il vous suffit d'indiquer le nom de la fonction et le chemin d'accès à la source locale. Pour obtenir la liste complète des options, consultez la ibmcloud ce fn create commande.

Pour plus d'informations sur les droits requis pour l'accès aux registres d'images, voir Configuration des droits pour les registres d'images.

Vous pouvez choisir d'ignorer certains modèles de fichier à partir de votre code source à l'aide du fichier .ceignore, qui se comporte de la même manière qu'un fichier .gitignore. Par exemple, les entrées d'un fichier « .ceignore » correspondant à la fonction « Node.js » peuvent inclure node_modules et .npm. Pour découvrir d'autres exemples de types de fichiers à ignorer, consultez le dépôt.gitignore de GitHub.

IBM Cloud® Container Registry est nécessaire dans ce cas de figure.

Avant de commencer

Configurez votre environnement d'interface de ligne de commande Code Engine.
Créez et utilisez un projet.

Avant de travailler avec la source locale, assurez-vous que votre source se trouve dans un emplacement accessible sur votre poste de travail en local.

Création d'une fonction à partir d'un code source local via l'interface de ligne de commande (CLI)

Cet exemple utilise le code Node.js suivant, sauvegardé en tant que fichier main.js. Vous pouvez remplacer votre propre code.

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

Accédez au répertoire qui contient le fichier main.js ou enregistrez le chemin d'accès à ce fichier.

Créez une fonction appelée myfun-local qui utilise le fichier main.js comme source. Cette commande compile automatiquement le bundle de code et le publie dans un espace de noms « Container Registry » de votre compte. Si vous ne disposez pas d'un espace-noms Container Registry existant, Code Engine en crée automatiquement un pour vous.

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

Exemple de sortie

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

Notez que la sortie de la commande function create fournit des informations sur la progression de l'exécution de la génération avant la création de la fonction.

Dans cet exemple, le bundle de code généré est mis en ligne dans l'espace de noms « ce--abcde-glxo4kabcde » sur Container Registry.

Le tableau suivant récapitule les options utilisées avec la fn create commande dans cet exemple. Pour plus d'informations sur cette commande et ses options, consultez la ibmcloud ce function create commande. Comme ces options varient en fonction de l'emplacement du code source, assurez-vous que votre code source se trouve à l'emplacement correspondant à l'exemple.

Description de la commande
Option	Description
`--name`	Nom de la fonction. Utilisez un nom unique dans le projet. Cette valeur est requise. Le nom doit commencer par une lettre minuscule. Le nom doit se terminer par un caractère alphanumérique en minuscules. Le nom doit contenir 63 caractères ou moins et peut contenir des lettres, des nombres et des traits d'union (-).
`--build-source`	Le chemin d'accès à la source locale. Cette valeur est obligatoire.
`--runtime`	Environnement d'exécution à utiliser pour cette fonction. Cette valeur est obligatoire.

Utilisez la commande **function get**pour afficher des informations sur votre application, y compris des informations sur la génération.

ibmcloud ce function get --name myfun-local

Exemple de sortie

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

Inclusion de dépendances pour votre fonction

Vous pouvez créer des fonctions dans de nombreux langages de programmation différents. Lorsque votre code de fonction devient complexe, vous pouvez ajouter des modules de code en tant que dépendances pour votre fonction. Chaque langue possède ses propres modules à utiliser avec votre code de fonction. Par exemple, les dépendances Node.js sont généralement des modules npm existants, alors que Python utilise des packages Python. Ces dépendances doivent être déclarées et créées dans un fichier avec votre code source

Inclusion de modules pour une fonction Node.js

Créez une fonction qui inclut une dépendance pour un module Node.js spécifique en créant un fichier package.json. Dans ce cas, le code source et le fichier de package se trouvent dans le même dossier.

Créez votre code source en l'écrivant dans un fichier main.js. Par exemple, copiez l'exemple de code suivant dans un fichier appelé 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;

Créez un fichier package.json contenant les dépendances requises pour votre fonction. Pour l'exemple de code précédent, utilisez le contenu suivant pour votre fichier package.json.
```
{
  "name": "function",
  "version": "1.0.0",
  "main": "main.js",
  "dependencies" : {
		    "lorem-ipsum" : "2.0.8"
 	}
}
```
Créez vos fichiers en tant que fonction dans Code Engine. Dans ce cas, vous vous trouvez dans le répertoire où se trouvent les fichiers locaux afin de pouvoir utiliser . comme source de génération.
```
ibmcloud ce fn create --name nodelorem --runtime nodejs --build-source .
```
Exécutez la commande fn get fournie pour trouver des détails sur votre fonction.
Invoquez votre fonction en collant l' URL dans un navigateur web. Votre navigateur affiche un passage de lorem ipsum.

Pour plus d'informations sur la commande fn create et ses options, voir Création d'une fonction.

Inclusion de modules pour une fonction Python

Créez une fonction qui inclut une dépendance pour un module Python spécifique en créant un fichier requirements.txt. Dans ce cas, le code source et le fichier d'exigences se trouvent dans le même dossier.

Créez votre fonction en sauvegardant votre code dans un fichier __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),
      }

Créez un requirements.txt contenant vos dépendances requises pour votre fonction
```
lorem-text
```
Créez vos fichiers en tant que fonction dans Code Engine. Dans ce cas, vous vous trouvez dans le répertoire où se trouvent les fichiers locaux afin de pouvoir utiliser . comme source de génération.
```
ibmcloud ce fn create --name pylorem --runtime python --build-source .
```
Exécutez la commande fn get fournie pour trouver des détails sur votre fonction.
Invoquez votre fonction en collant l' URL dans un navigateur web. Votre navigateur affiche un passage de lorem ipsum.

Pour plus d'informations sur la commande fn create et ses options, voir Création d'une fonction.

Etapes suivantes

Maintenant que votre fonction est créée et déployée à partir du code source local, vous pouvez la mettre à jour en fonction de vos besoins à l'aide de la commande ibmcloud ce function update. Si vous souhaitez mettre à jour votre source pour l'utiliser avec votre fonction, vous devez spécifier l'option « --build-source » dans la function update commande.

Lorsque votre fonction est déployée à partir de la source locale ou du code source du référentiel à partir de l'interface de ligne de commande, l'exécution de la génération résultante n'est pas basée sur une configuration de génération. Les exécutions de génération terminées sont automatiquement supprimées. Les exécutions de génération qui ne sont pas basées sur une configuration de génération sont supprimées après 1 heure si l'exécution de génération aboutit. Si l'exécution de la génération échoue, elle est supprimée au bout de 24 heures. Vous pouvez uniquement afficher des informations sur cette exécution de génération à l'aide de l'interface de ligne de commande. Vous ne pouvez pas visualiser cette exécution dans la console.

Vous recherchez d'autres exemples de code ? Découvrez le site Exemples pour le dépôt « IBM Cloud Code Engine GitHub ».