Tutorial

Comment exécuter des fonctions sans serveur en utilisant OpenFaaS sur DigitalOcean Kubernetes

KubernetesDigitalOcean Managed Kubernetes

L'auteur a choisi le Free and Open Source Fund pour recevoir un don dans le cadre du programme Write for Donations.

Introduction

En général, l'hébergement d'une application logicielle sur Internet nécessite la gestion, la planification et la surveillance de l'infrastructure pour un système monolithique. Contrairement à cette approche traditionnelle, l'architecture sans serveur (également appelée function as a service ou FaaS) décompose votre application en fonctions. Ces fonctions sont des entités apatrides, autonomes, déclenchées par des événements, fonctionnellement complètes, qui communiquent via des API que vous gérez, au lieu du matériel sous-jacent et du provisionnement explicite de l'infrastructure. Les fonctions sont évolutives de par leur conception, portables, plus rapides à mettre en place et plus faciles à tester que les apps ordinaires. Pour que l'architecture sans serveur fonctionne en principe, il faut une façon agnostique d'empaqueter et d'orchestrer les fonctions.

OpenFaaS est un framework open-source permettant d'implémenter l'architecture sans serveur sur Kubernetes, en utilisant des conteneurs Docker pour le stockage et l'exécution des fonctions. Il permet à tout programme d'être présenté comme un conteneur et géré comme une fonction via la ligne de commande ou l'interface utilisateur Web intégrée. OpenFaaS dispose d'un excellent support pour les mesures et fournit une mise à l'échelle automatique des fonctions lorsque la demande augmente.

Dans ce tutoriel, vous allez déployer OpenFaaS dans votre cluster DigitalOcean Kubernetes sur votre domaine et le sécuriser en utilisant les certificats gratuits Let’s Encrypt TLS. Vous explorerez également son interface web et déploierez les fonctions existantes et nouvelles en utilisant le faas-cli, l'outil officiel de la ligne de commande. À la fin de ce tutoriel, vous disposerez d'un système flexible pour déployer des fonctions sans serveur.

Conditions préalables

  • Un cluster DigitalOcean Kubernetes avec votre connexion configurée comme kubectl par défaut. Le cluster doit avoir au moins 8 Go de RAM et 4 cœurs de CPU disponibles pour OpenFaaS (davantage sera nécessaire en cas d'utilisation plus intensive). Les instructions sur la façon de configurer kubectl sont indiquées dans l'étape Se connecter à votre cluster lorsque vous créez votre cluster. Pour créer un cluster Kubernetes sur DigitalOcean, voir notre Kubernetes Quickstart.
  • Docker installé sur votre machine locale. En suivant les étapes 1 et 2 pour votre distribution, voir Comment installer Docker.
  • Un compte sur Docker Hub pour stocker les images Docker que vous allez créer pendant ce tutoriel.
  • faas-cli, l'outil CLI officiel pour la gestion d'OpenFaaS, installé sur votre machine locale. Pour connaître les instructions concernant les plateformes multiples, consultez les documents officiels.
  • Le gestionnaire de paquets Helm installé sur votre machine locale. Pour ce faire, complétez l'étape 1 et ajoutez le dépôt stable de l'étape 2 du tutoriel Comment installer un logiciel sur les clusters Kubernetes avec le gestionnaire de paquets Helm 3.
  • Le Nginx Ingress Controller et Cert Manager installés sur votre cluster en utilisant Helm afin d'exposer OpenFaaS en utilisant Ingress Resources. Pour ce faire, suivez Comment configurer une entrée Nginx sur DigitalOcean Kubernetes en utilisant Helm.
  • Un nom de domaine entièrement enregistré pour héberger OpenFaaS, pointé vers le Load Balancer utilisé par l'Ingress Nginx. Ce tutoriel utilisera openfaas.your_domain tout au long du cours. Vous pouvez acheter un nom de domaine sur Namecheap, en obtenir un gratuitement sur Freenom, ou utiliser le registraire de domaine de votre choix.

Remarque : le nom de domaine que vous utilisez dans ce tutoriel doit être différent de celui utilisé dans le tutoriel préalable Comment configurer une entrée Nginx sur DigitalOcean Kubernetes.

Étape 1 - Installation d'OpenFaaS en utilisant Helm

Dans cette étape, vous allez installer OpenFaaS sur votre cluster Kubernetes en utilisant Helm et l'exposer sur votre domaine.

Dans le cadre du prérequis Nginx Ingress Controller, vous avez créé des exemples de services et une entrée. Vous n'en aurez pas besoin dans ce tutoriel, vous pouvez donc les supprimer en exécutant les commandes suivantes :

  • kubectl delete -f hello-kubernetes-first.yaml
  • kubectl delete -f hello-kubernetes-second.yaml
  • kubectl delete -f hello-kubernetes-ingress.yaml

Comme vous allez déployer des fonctions sous forme d'objets Kubernetes, il est utile de les stocker, ainsi qu'OpenFaaS lui-même, dans des espaces de noms distincts de votre cluster. L'espace de nom OpenFaaS sera appelé openfaas, et l'espace de nom des fonctions sera openfaas-fn. Créez-les dans votre cluster en exécutant la commande suivante :

  • kubectl apply -f https://raw.githubusercontent.com/openfaas/faas-netes/master/namespaces.yml

Vous verrez la sortie suivante :

Output
namespace/openfaas created namespace/openfaas-fn created

Ensuite, vous devrez ajouter le dépôt OpenFaaS Helm, qui héberge la carte OpenFaaS. Pour ce faire, exécutez la commande suivante :

  • helm repo add openfaas https://openfaas.github.io/faas-netes/

Helm affichera la sortie suivante :

Output
"openfaas" has been added to your repositories

Actualisez le cache de la carte Helm :

  • helm repo update

Vous verrez la sortie suivante :

Output
Hang tight while we grab the latest from your chart repositories... ...Successfully got an update from the "openfaas" chart repository ...Successfully got an update from the "jetstack" chart repository ...Successfully got an update from the "stable" chart repository Update Complete. ⎈ Happy Helming!⎈

Avant d'installer OpenFaaS, vous devrez personnaliser certains paramètres de la carte. Vous les stockerez sur votre machine locale, dans un fichier nommé values.yaml. Créez et ouvrez le fichier avec votre éditeur de texte :

  • nano values.yaml

Ajoutez les lignes suivantes :

values.yaml
functionNamespace: openfaas-fn
generateBasicAuth: true

ingress:
  enabled: true
  annotations:
    kubernetes.io/ingress.class: "nginx"
  hosts:
    - host: openfaas.your_domain
      serviceName: gateway
      servicePort: 8080
      path: /

Tout d'abord, vous spécifiez l'espace de nom où les fonctions seront stockées en attribuant openfaas-fn à la variable functionNamespace. En réglant generateBasicAuth sur true, vous ordonnez à Helm de mettre en place une authentification obligatoire lors de l'accès à l'interface web OpenFaaS et de générer pour vous une combinaison de nom d'utilisateur et de mot de passe de connexion.

Ensuite, vous activez la création d'Ingress et vous la configurez pour utiliser le contrôleur d'Ingress Nginx et servir le service OpenFaaS de la passerelle sur votre domaine.

N'oubliez pas de remplacer openfaas.your_domain par le domaine souhaité dans les conditions préalables. Lorsque vous avez terminé, enregistrez et fermez le fichier.

Enfin, installez OpenFaaS dans l'espace de nom openfaas avec les valeurs personnalisées :

  • helm upgrade openfaas --install openfaas/openfaas --namespace openfaas -f values.yaml

Vous verrez le résultat suivant :

Output
Release "openfaas" does not exist. Installing it now. NAME: openfaas LAST DEPLOYED: ... NAMESPACE: openfaas STATUS: deployed REVISION: 1 TEST SUITE: None NOTES: To verify that openfaas has started, run: kubectl -n openfaas get deployments -l "release=openfaas, app=openfaas" To retrieve the admin password, run: echo $(kubectl -n openfaas get secret basic-auth -o jsonpath="{.data.basic-auth-password}" | base64 --decode)

La sortie montre que l'installation a réussi. Exécutez la commande suivante afin de révéler le mot de passe pour le compte admin :

  • echo $(kubectl -n openfaas get secret basic-auth -o jsonpath="{.data.basic-auth-password}" | base64 --decode) | tee openfaas-password.txt

Le mot de passe décodé est écrit sur la sortie et dans un fichier appelé openfaas-password.txt en utilisant en même temps tee. Notez la sortie, qui est votre mot de passe OpenFaaS pour le compte admin.

Vous pouvez regarder les conteneurs OpenFaaS devenir disponibles en exécutant la commande suivante :

  • kubectl -n openfaas get deployments -l "release=openfaas, app=openfaas"

Lorsque tous les déploiements énumérés sont ready, tapez CTRL + C pour quitter.

Vous pouvez maintenant naviguer vers le domaine spécifié dans votre navigateur web. Saisissez admin comme nom d'utilisateur et le mot de passe qui l'accompagne lorsque vous y êtes invité. Vous verrez l'interface web OpenFaaS :

OpenFaaS - Panneau de contrôle vide

Vous avez installé avec succès OpenFaaS et exposé son panneau de contrôle sur votre domaine. Ensuite, vous allez le sécuriser en utilisant les certificats TLS gratuits de Let’s Encrypt.

Étape 2 - Activation des TLS pour votre domaine

Au cours de cette étape, vous allez sécuriser votre domaine exposé en utilisant les certificats Let’s Encrypt, fournis par cert-manager.

Pour ce faire, vous devrez modifier la configuration d'entrée dans values.yaml. Ouvrez-le pour le modifier :

  • nano values.yaml

Ajoutez les lignes surlignées suivantes :

values.yaml
generateBasicAuth: true

ingress:
  enabled: true
  annotations:
    kubernetes.io/ingress.class: "nginx"
    cert-manager.io/cluster-issuer: letsencrypt-prod
  tls:
    - hosts:
        - openfaas.your_domain
      secretName: openfaas-crt
  hosts:
    - host: openfaas.your_domain
      serviceName: gateway
      servicePort: 8080
      path: /

Le bloc tls définit dans quel Secret les certificats de vos sites (listés sous hosts) vont stocker leurs certificats, que le ClusterIssuer letsencrypt-prod émet. En général, le Secret spécifié doit être différent pour chaque entrée dans votre cluster.

N'oubliez pas de remplacer openfaas.your_domain par le domaine que vous souhaitez, puis de sauvegarder et de fermer le fichier.

Appliquez les changements à votre cluster en exécutant la commande suivante :

  • helm upgrade openfaas --install openfaas/openfaas --namespace openfaas -f values.yaml

Vous verrez la sortie suivante :

Output
Release "openfaas" has been upgraded. Happy Helming! NAME: openfaas LAST DEPLOYED: ... NAMESPACE: openfaas STATUS: deployed REVISION: 2 TEST SUITE: None NOTES: To verify that openfaas has started, run: kubectl -n openfaas get deployments -l "release=openfaas, app=openfaas" To retrieve the admin password, run: echo $(kubectl -n openfaas get secret basic-auth -o jsonpath="{.data.basic-auth-password}" | base64 --decode)

Vous devrez attendre quelques minutes que les serveurs Let’s Encrypt délivrent un certificat pour votre domaine. En attendant, vous pouvez suivre sa progression en inspectant le résultat de la commande suivante :

  • kubectl describe certificate openfaas-crt -n openfaas

La fin de la sortie ressemblera à cela :

Output
Events: Type Reason Age From Message ---- ------ ---- ---- ------- Normal GeneratedKey 24m cert-manager Generated a new private key Normal Requested 16m cert-manager Created new CertificateRequest resource "openfaas-crt-1017759607" Normal Issued 16m cert-manager Certificate issued successfully

Lorsque la dernière ligne de la sortie indique Certificate issued successfully, vous pouvez quitter en appuyant sur CTRL + C. Rafraîchissez votre domaine dans votre navigateur pour le tester. Vous verrez le cadenas à gauche de la barre d'adresse dans votre navigateur, ce qui signifie que votre connexion est sécurisée.

Vous avez sécurisé votre domaine OpenFaaS en utilisant les certificats TLS gratuits de Let’s Encrypt. Vous allez maintenant utiliser l'interface utilisateur web et gérer les fonctions à partir de celle-ci.

Étape 3 - Déploiement de fonctions via l'interface utilisateur web

Dans cette section, vous explorerez l'interface utilisateur web OpenFaaS, puis vous déploierez, gérerez et invoquerez des fonctions à partir de celle-ci.

L'interface utilisateur web OpenFaaS se compose de deux parties principales : à gauche, une colonne où les fonctions déployées seront répertoriées, et le panneau central, où vous verrez des informations détaillées sur une fonction sélectionnée et pourrez interagir avec elle.

Pour déployer une nouvelle fonction, cliquez sur le bouton Deploy New Function sous le logo OpenFaaS, en haut à gauche. Vous verrez un dialogue vous demandant de choisir une fonction :

OpenFaaS - Deploy a New Function dialog

L'onglet FROM STORE répertorie les fonctions prédéfinies de l'OpenFaaS function store que vous pouvez déployer immédiatement. Chaque fonction est présentée avec une brève description, et vous pouvez sélectionner l'icône de lien à droite d'une fonction pour consulter son code source. Pour déployer une fonction stockée à partir de cette liste, sélectionnez-la, puis cliquez sur le bouton DEPLOY.

Vous pouvez également fournir votre propre fonction en passant à l'onglet CUSTOM :

OpenFaaS - Deploy a Custom Function

Ici, vous devez spécifier une image Docker de votre fonction qui est configurée spécifiquement pour OpenFaaS et disponible dans un registre Docker (tel que Docker Hub). Dans cette étape, vous déploierez une fonction prédéfinie à partir du magasin OpenFaaS, puis dans les étapes suivantes, vous créerez et déploierez des fonctions personnalisées dans Docker Hub.

Vous déploierez la fonction NodeInfo, qui renvoie des informations à propos de la machine sur laquelle elle est déployée, telles que l'architecture du processeur, le nombre de cœurs, la mémoire RAM totale disponible et le temps de fonctionnement (en secondes).

Dans la liste des fonctions du magasin, sélectionnez NodeInfo et cliquez sur DEPLOY. Elle apparaîtra bientôt dans la liste des fonctions déployées.

OpenFaaS - NodeInfo Deployed

Sélectionnez-la. Dans la partie centrale de l'écran, vous verrez des informations de base sur la fonction déployée.

OpenFaaS - Deployed Function Info

L'état de la fonction se met à jour en temps réel, et devrait rapidement passer à Ready. Si elle reste sur Not Ready pendant longtemps, il est fort probable que votre cluster ne dispose pas des ressources nécessaires pour accepter un nouveau pod. Vous pouvez consulter Comment redimensionner les Droplets pour obtenir des informations sur la manière de régler ce problème.

Une fois qu'elle est sur Ready, la fonction déployée est accessible à l'URL indiquée. Pour la tester, vous pouvez naviguer jusqu'à l'URL dans votre navigateur ou l'appeler depuis le panneau Invoke function situé sous l'info-fonction.

OpenFaaS - Invoke Deployed Function

Vous pouvez choisir entre Text, JSON et Download pour indiquer le type de réponse que vous attendez. Si vous souhaitez que la requête soit POST au lieu de GET, vous pouvez fournir des données de requête dans le champ Request body.

Pour appeler la fonction nodeinfo, cliquez sur le bouton INVOKE. OpenFaaS élaborera et exécutera une requête HTTP en fonction des options sélectionnées et remplira les champs de réponse avec les données reçues.

OpenFaaS - nodeinfo Function Response

Le statut de la réponse est HTTP 200 OK, ce qui signifie que la requête a été exécutée avec succès. L'organisme de réponse contient des informations système que la fonction NodeInfo collecte, ce qui signifie qu'elle est correctement accessible et fonctionne correctement.

Pour supprimer une fonction, sélectionnez-la dans la liste et cliquez sur l'icône de la poubelle, située dans le coin supérieur droit de la page. Lorsque vous y êtes invité, cliquez sur OK pour confirmer. Le statut de la fonction passera à Not Ready (ce qui signifie qu'elle est retirée du cluster) et la fonction disparaîtra bientôt complètement de l'interface utilisateur.

Dans cette étape, vous avez utilisé l'interface utilisateur web OpenFaaS, et déployé et géré des fonctions à partir de celle-ci. Vous allez maintenant voir comment vous pouvez déployer et gérer les fonctions OpenFaaS en utilisant la ligne de commande.

Étape 4 - Gestion des fonctions à l'aide de faas-cli

Dans cette section, vous allez configurer le faas-cli pour qu'il fonctionne avec votre cluster. Ensuite, vous déploierez et gérerez vos fonctions existantes par le biais de la ligne de commande.

Pour éviter de devoir spécifier votre domaine OpenFaaS chaque fois que vous exécutez le faas-cli, vous le stockerez dans une variable d'environnement appelée OPENFAAS_URL, dont la valeur sera automatiquement récupérée et utilisée par le faas-cli pendant l'exécution.

Ouvrez .bash_profile dans votre répertoire de base pour le modifier :

  • nano ~/.bash_profile

Ajoutez la ligne suivante :

~/.bash_profile
. . .
export OPENFAAS_URL=https://openfaas.your_domain

N'oubliez pas de remplacer openfaas.your_domain par le domaine que vous souhaitez, puis de sauvegarder et de fermer le fichier.

Pour éviter d'avoir à vous connecter à nouveau, évaluez manuellement le fichier :

  • . ~/.bash_profile

Maintenant, assurez-vous que faas-cli est installé sur votre machine locale. Si vous ne l'avez pas encore installé, faites-le en suivant les instructions décrites dans les documents officiels.

Ensuite, configurez vos identifiants de connexion en exécutant la commande suivante :

  • cat ~/openfaas-password.txt | faas-cli login --username admin --password-stdin

La sortie ressemblera à :

Output
Calling the OpenFaaS server to validate the credentials... credentials saved for admin https://openfaas.your_domain

Pour déployer une fonction depuis le magasin, exécutez la commande suivante :

  • faas store deploy function_name

Vous pouvez essayer de déployer nodeinfo en exécutant :

  • faas store deploy nodeinfo

Vous verrez une sortie comme celle-ci :

Output
Deployed. 202 Accepted. URL: https://openfaas.your_domain/function/nodeinfo

Pour lister les fonctions déployées, exécutez faas list :

  • faas list

Vous verrez apparaître vos fonctions existantes :

Output
Function Invocations Replicas nodeinfo 0 1

Pour obtenir des informations détaillées sur une fonction déployée, utilisez faas describe :

  • faas describe nodeinfo

Votre sortie sera semblable à :

Name:                nodeinfo
Status:              Ready
Replicas:            1
Available replicas:  1
Invocations:         0
Image:               functions/nodeinfo-http:latest
Function process:
URL:                 https://openfaas.your_domain/function/nodeinfo
Async URL:           https://openfaas.your_domain/async-function/nodeinfo
Labels:              faas_function : nodeinfo
                     uid : 514253614
Annotations:         prometheus.io.scrape : false

Vous pouvez invoquer une fonction avec faas invoke :

  • faas invoke nodeinfo

Vous obtiendrez le message suivant :

Output
Reading from STDIN - hit (Control + D) to stop.

Vous pouvez ensuite fournir un corps de requête. Si vous le faites, la méthode sera POST au lieu de GET. Lorsque vous avez terminé avec la saisie de données, ou si vous souhaitez que la requête soit GET, appuyez sur CTRL + D. Le faas-cli exécutera alors la requête souscrite et affichera la réponse, de la même façon que l'interface utilisateur web.

Pour supprimer une fonction, exécutez faas remove :

  • faas remove nodeinfo

Vous obtiendrez la sortie suivante :

Output
Deleting: nodeinfo. Removing old function.

Exécutez une nouvelle fois faas list pour voir que nodeinfo a été supprimée :

Output
Function Invocations Replicas

Au cours de cette étape, vous avez déployé, listé, invoqué et retiré des fonctions de votre cluster à partir de la ligne de commande en utilisant le faas-cli. Au cours de la prochaine étape, vous allez créer votre propre fonction et la déployer sur votre cluster.

Étape 5 - Création et déploiement d'une nouvelle fonction

Vous allez maintenant créer un exemple de fonction Node.JS en utilisant le faas-cli et le déployer dans votre cluster.

La fonction que vous allez créer sera packagée dans un conteneur Docker et publiée sur Docker Hub. Pour pouvoir publier des conteneurs, vous devez vous connecter en exécutant la commande suivante :

  • docker login

Saisissez votre nom d'utilisateur et votre mot de passe Docker Hub lorsque vous êtes invité à terminer la procédure de connexion.

Vous stockerez l'exemple de fonction Node.JS dans un dossier appelé sample-js-function. Créez-le en utilisant la commande suivante :

  • mkdir sample-js-function

Naviguez jusqu'à lui :

  • cd sample-js-function

Remplissez le répertoire avec le modèle d'une fonction JS en exécutant la commande suivante :

  • faas new sample-js --lang node

La sortie finale ressemblera à ceci :

Output
2020/03/24 17:06:08 No templates found in current directory. 2020/03/24 17:06:08 Attempting to expand templates from https://github.com/openfaas/templates.git 2020/03/24 17:06:10 Fetched 19 template(s) : [csharp csharp-armhf dockerfile go go-armhf java11 java11-vert -x java8 node node-arm64 node-armhf node12 php7 python python-armhf python3 python3-armhf python3-debian ru by] from https://github.com/openfaas/templates.git Folder: sample-js created. ___ _____ ____ / _ \ _ __ ___ _ __ | ___|_ _ __ _/ ___| | | | | '_ \ / _ \ '_ \| |_ / _` |/ _` \___ \ | |_| | |_) | __/ | | | _| (_| | (_| |___) | \___/| .__/ \___|_| |_|_| \__,_|\__,_|____/ |_| Function created in folder: sample-js Stack file written: sample-js.yml ...

Comme indiqué dans la sortie, le code de la fonction elle-même se trouve dans le dossier sample-js, tandis que la configuration OpenFaaS de la fonction se trouve dans le fichier sample-js.yaml. Sous le répertoire sample-js (qui ressemble à un projet Node.JS normal) se trouvent deux fichiers, handler.js et package.json.

handler.js contient un véritable code JS qui renvoie une réponse lorsque la fonction est appelée. Le contenu du gestionnaire ressemble à ce qui suit :

sample-js-function/sample-js/handler.js
"use strict"

module.exports = async (context, callback) => {
    return {status: "done"}
}

Il exporte une fonction lambda avec deux paramètres, un context avec les données de la requête et un callback que vous pouvez utiliser pour transmettre les données de la réponse, au lieu de simplement les renvoyer.

Ouvrez ce fichier pour le modifier :

  • nano sample-js/handler.js

Modifiez la ligne surlignée comme suit :

sample-js-function/sample-js/handler.js
"use strict"

module.exports = async (context, callback) => {
    return {status: "<h1>Hello Sammy!</h1>"}
}

Lorsque vous avez terminé, enregistrez et fermez le fichier. Cette fonction OpenFaaS va, lorsqu'elle est appelée, écrire Hello Sammy ! à la réponse.

Ensuite, ouvrez le fichier de configuration pour le modifier :

  • nano sample-js.yml

Il ressemblera à ce qui suit :

sample-js-function/sample-js.yml
version: 1.0
provider:
  name: openfaas
  gateway: https://openfaas.your_domain
functions:
  sample-js:
    lang: node
    handler: ./sample-js
    image: sample-js:latest

Pour le provider, il spécifie openfaas et une passerelle par défaut. Ensuite, il définit la fonction sample-js, spécifie sa langue (node), son gestionnaire et le nom de l'image Docker, que vous devrez modifier pour inclure le nom d'utilisateur de votre compte Docker Hub, comme cela :

sample-js-function/sample-js.yml
version: 1.0
provider:
  name: openfaas
  gateway: http://127.0.0.1:8080
functions:
  sample-js:
    lang: node
    handler: ./sample-js
    image: your_docker_hub_username/sample-js:latest

Enregistrez et fermez le fichier.

Ensuite, construisez l'image Docker, poussez-la vers Docker Hub, et déployez-la sur votre cluster, tout cela en même temps en exécutant la commande suivante :

  • faas up -f sample-js.yml

Il y aura beaucoup de sorties (principalement de Docker), qui se termineront ainsi :

Output
. . . [0] < Pushing sample-js [your_docker_hub_username/sample-js:latest] done. [0] Worker done. Deploying: sample-js. Deployed. 202 Accepted. URL: https://openfaas.your_domain/function/sample-js

Invoquez votre fonction nouvellement déployée pour vous assurer qu'elle fonctionne :

  • faas invoke sample-js

Appuyez sur CTRL + D. Vous verrez la sortie suivante :

Output
<h1>Hello Sammy!</h1>

Cela signifie que la fonction a été packagée et déployée correctement.

Vous pouvez supprimer la fonction en exécutant :

  • faas remove sample-js

Vous avez maintenant créé et déployé avec succès une fonction Node.JS personnalisée sur votre instance OpenFaaS de votre cluster.

Conclusion

Vous avez déployé OpenFaaS sur votre cluster DigitalOcean Kubernetes et vous êtes prêt à le déployer et à accéder à des fonctions prédéfinies et personnalisées. Vous pouvez maintenant implémenter l'architecture Function as a Service, qui peut accroître l'utilisation des ressources et améliorer les performances de vos applications.

Si vous souhaitez en savoir plus sur les fonctionnalités avancées d'OpenFaaS (telles que la mise à l'échelle automatique de vos fonctions déployées et le suivi de leurs performances), consultez la documentation officielle.

0 Comments

Creative Commons License