Comment installer et sécuriser OpenFaaS à l'aide de Docker Swarm sur Ubuntu 16.04

De Get Docs
Aller à :navigation, rechercher

L'auteur a sélectionné le Diversity in Tech Fund pour recevoir un don dans le cadre du programme Write for DOnations.

Introduction

L'architecture sans serveur cache les instances de serveur au développeur et expose généralement une API qui permet aux développeurs d'exécuter leurs applications dans le cloud. Cette approche aide les développeurs à déployer rapidement des applications, car ils peuvent laisser le provisionnement et la maintenance des instances aux équipes DevOps appropriées. Cela réduit également les coûts d'infrastructure, car avec les outils appropriés, vous pouvez faire évoluer vos instances à la demande.

Les applications qui s'exécutent sur des plates-formes sans serveur sont appelées fonctions sans serveur. Une fonction est un code exécutable conteneurisé utilisé pour effectuer des opérations spécifiques. La conteneurisation des applications garantit que vous pouvez reproduire un environnement cohérent sur de nombreuses machines, permettant la mise à jour et la mise à l'échelle.

OpenFaaS est un framework gratuit et open source pour créer et héberger des fonctions sans serveur. Avec la prise en charge officielle de Docker Swarm et Kubernetes, il vous permet de déployer vos applications à l'aide de la puissante API, de l'interface de ligne de commande ou de l'interface utilisateur Web. Il est livré avec des métriques intégrées fournies par Prometheus et prend en charge la mise à l'échelle automatique à la demande, ainsi que la mise à l'échelle à partir de zéro.

Dans ce didacticiel, vous allez configurer et utiliser OpenFaaS avec Docker Swarm exécuté sur Ubuntu 16.04, et sécuriser son interface utilisateur Web et son API en configurant Traefik avec Let's Encypt. Cela garantit une communication sécurisée entre les nœuds du cluster, ainsi qu'entre OpenFaaS et ses opérateurs.

Conditions préalables

Pour suivre ce tutoriel, vous aurez besoin de :

  • Ubuntu 16.04 s'exécutant sur votre ordinateur local. Vous pouvez utiliser d'autres distributions et systèmes d'exploitation, mais assurez-vous d'utiliser les scripts OpenFaaS appropriés pour votre système d'exploitation et d'installer toutes les dépendances répertoriées dans ces prérequis.
  • git, curl et jq installés sur votre ordinateur local. Vous utiliserez git pour cloner le référentiel OpenFaaS, curl pour tester l'API et jq pour transformer les réponses brutes JSON de l'API en réponses humaines. -JSON lisible. Pour installer les dépendances requises pour cette configuration, utilisez les commandes suivantes : sudo apt-get update && sudo apt-get install git curl jq
  • Docker installé, en suivant les étapes 1 et 2 de Comment installer et utiliser Docker sur Ubuntu 16.04.
  • Un compte Docker Hub. Pour déployer des fonctions sur OpenFaaS, elles devront être publiées sur un registre de conteneurs public. Nous utiliserons Docker Hub pour ce didacticiel, car il est à la fois gratuit et largement utilisé. Assurez-vous de vous authentifier auprès de Docker sur votre ordinateur local à l'aide de la commande docker login.
  • Docker Machine installé, suivant Comment provisionner et gérer des hôtes Docker distants avec Docker Machine sur Ubuntu 16.04.
  • Un jeton d'accès personnel DigitalOcean. Pour créer un jeton, suivez ces instructions.
  • Un cluster Docker Swarm de 3 nœuds, provisionné en suivant Comment créer un cluster de conteneurs Docker avec Docker Swarm et DigitalOcean sur Ubuntu 16.04.
  • Un nom de domaine entièrement enregistré avec un enregistrement A pointant vers l'une des instances de Docker Swarm. Tout au long du didacticiel, vous verrez example.com comme exemple de domaine. Vous devez le remplacer par votre propre domaine, que vous pouvez soit acheter sur Namecheap, soit obtenir gratuitement sur Freenom. Vous pouvez également utiliser un autre bureau d'enregistrement de domaine de votre choix.

Étape 1 - Téléchargement d'OpenFaaS et installation de la CLI d'OpenFaaS

Pour déployer OpenFaaS sur votre Docker Swarm, vous devrez télécharger les manifestes et les scripts de déploiement. Le moyen le plus simple de les obtenir est de cloner le référentiel officiel OpenFaas et de vérifier la balise appropriée, qui représente une version OpenFaaS.

En plus de cloner le référentiel, vous installerez également le FaaS CLI, un puissant utilitaire de ligne de commande que vous pouvez utiliser pour gérer et déployer de nouvelles fonctions à partir de votre terminal. Il fournit des modèles pour créer vos propres fonctions dans la plupart des principaux langages de programmation. Dans Étape 7, vous l'utiliserez pour créer une fonction Python et la déployer sur OpenFaaS.

Pour ce didacticiel, vous allez déployer OpenFaaS v0.8.9. Bien que les étapes de déploiement d'autres versions soient similaires, assurez-vous de consulter le Journal des modifications du projet pour vous assurer qu'il n'y a pas de modifications majeures.

Tout d'abord, accédez à votre répertoire personnel et exécutez la commande suivante pour cloner le référentiel dans le répertoire ~/faas :

cd ~
git clone https://github.com/openfaas/faas.git

Accédez au répertoire ~/faas nouvellement créé :

cd ~/faas

Lorsque vous clonez le référentiel, vous obtenez des fichiers de la branche principale contenant les dernières modifications. Étant donné que les changements avec rupture peuvent pénétrer dans la branche master, il n'est pas recommandé de les utiliser en production. À la place, examinons la balise 0.8.9 :

git checkout 0.8.9

La sortie contient un message sur la réussite de l'extraction et un avertissement sur la validation des modifications apportées à cette branche :

OutputNote: checking out '0.8.9'.

You are in 'detached HEAD' state. You can look around, make experimental
changes and commit them, and you can discard any commits you make in this
state without impacting any branches by performing another checkout.

If you want to create a new branch to retain commits you create, you may
do so (now or later) by using -b with the checkout command again. Example:

  git checkout -b <new-branch-name>

HEAD is now at 8f0d2d1 Expose scale-function endpoint

Si vous voyez des erreurs, assurez-vous de les résoudre en suivant les instructions à l'écran avant de continuer.

Une fois le référentiel OpenFaaS téléchargé, avec les fichiers manifestes nécessaires, procédons à l'installation de la CLI FaaS.

Le moyen le plus simple d'installer la CLI FaaS est d'utiliser le script officiel. Dans votre terminal, accédez à votre répertoire personnel et téléchargez le script à l'aide de la commande suivante :

cd ~
curl -sSL -o faas-cli.sh https://cli.openfaas.com

Cela téléchargera le script faas-cli.sh dans votre répertoire personnel. Avant d'exécuter le script, c'est une bonne idée de vérifier le contenu :

less faas-cli.sh

Vous pouvez quitter l'aperçu en appuyant sur q. Une fois que vous avez vérifié le contenu du script, vous pouvez procéder à l'installation en accordant des autorisations exécutables au script et en l'exécutant. Exécutez le script en tant que root afin qu'il soit automatiquement copié sur votre PATH :

chmod +x faas-cli.sh
sudo ./faas-cli.sh

La sortie contient des informations sur la progression de l'installation et la version de la CLI que vous avez installée :

Outputx86_64
Downloading package https://github.com/openfaas/faas-cli/releases/download/0.6.17/faas-cli as /tmp/faas-cli
Download complete.

Running as root - Attempting to move faas-cli to /usr/local/bin
New version of faas-cli installed to /usr/local/bin
Creating alias 'faas' for 'faas-cli'.
  ___                   _____           ____
 / _ \ _ __   ___ _ __ |  ___|_ _  __ _/ ___|
| | | | '_ \ / _ \ '_ \| |_ / _` |/ _` \___ \
| |_| | |_) |  __/ | | |  _| (_| | (_| |___) |
 \___/| .__/ \___|_| |_|_|  \__,_|\__,_|____/
      |_|

CLI:
 commit:  b5597294da6dd98457434fafe39054c993a5f7e7
 version: 0.6.17

Si vous voyez une erreur, assurez-vous de la résoudre en suivant les instructions à l'écran avant de poursuivre le didacticiel.

À ce stade, la CLI FaaS est installée. Pour en savoir plus sur les commandes que vous pouvez utiliser, exécutez la CLI sans aucun argument :

faas-cli

La sortie affiche les commandes et les drapeaux disponibles :

Output  ___                   _____           ____
 / _ \ _ __   ___ _ __ |  ___|_ _  __ _/ ___|
| | | | '_ \ / _ \ '_ \| |_ / _` |/ _` \___ \
| |_| | |_) |  __/ | | |  _| (_| | (_| |___) |
 \___/| .__/ \___|_| |_|_|  \__,_|\__,_|____/
      |_|


Manage your OpenFaaS functions from the command line

Usage:
  faas-cli [flags]
  faas-cli [command]

Available Commands:
  build          Builds OpenFaaS function containers
  cloud          OpenFaaS Cloud commands
  deploy         Deploy OpenFaaS functions
  help           Help about any command
  invoke         Invoke an OpenFaaS function
  list           List OpenFaaS functions
  login          Log in to OpenFaaS gateway
  logout         Log out from OpenFaaS gateway
  new            Create a new template in the current folder with the name given as name
  push           Push OpenFaaS functions to remote registry (Docker Hub)
  remove         Remove deployed OpenFaaS functions
  store          OpenFaaS store commands
  template       Downloads templates from the specified github repo
  version        Display the clients version information

Flags:
      --filter string   Wildcard to match with function names in YAML file
  -h, --help            help for faas-cli
      --regex string    Regex to match with function names in YAML file
  -f, --yaml string     Path to YAML file describing function(s)

Use "faas-cli [command] --help" for more information about a command.

Vous avez maintenant obtenu avec succès les manifestes OpenFaaS et installé la CLI FaaS, que vous pouvez utiliser pour gérer votre instance OpenFaaS depuis votre terminal.

Le répertoire ~/faas contient les fichiers de la version 0.8.9, ce qui signifie que vous pouvez maintenant déployer OpenFaaS sur votre Docker Swarm. Avant cela, modifions le fichier manifeste de déploiement pour inclure Traefik, qui sécurisera votre configuration OpenFaaS en configurant Let's Encrypt.

Étape 2 - Configuration de Traefik

Traefik est un proxy inverse compatible Docker fourni avec le support SSL fourni par Let's Encrypt. Le protocole SSL garantit que vous communiquez avec le cluster Swarm en toute sécurité en cryptant les données que vous envoyez et recevez entre les nœuds.

Pour utiliser Traefik avec OpenFaaS, vous devez modifier le manifeste de déploiement OpenFaaS pour inclure Traefik et indiquer à OpenFaaS d'utiliser Traefik au lieu d'exposer directement ses services à Internet.

Revenez au répertoire ~/faas et ouvrez le manifeste de déploiement OpenFaaS dans un éditeur de texte :

cd ~/faas
nano ~/faas/docker-compose.yml

Remarque : Le fichier manifeste Docker Compose utilise le formatage YAML, qui interdit strictement les tabulations et nécessite deux espaces pour l'indentation. Le manifeste ne se déploiera pas si le fichier n'est pas correctement formaté.


Le déploiement OpenFaaS est composé de plusieurs services, définis sous la directive services, qui fournissent les dépendances nécessaires pour exécuter OpenFaaS, l'API OpenFaaS et l'interface utilisateur Web, ainsi que Prometheus et AlertManager (pour la gestion des métriques).

Au début de la section services, ajoutez un nouveau service appelé traefik, qui utilise l'image traefik:v1.6 pour le déploiement :

~/faas/docker-compose.yml

version: "3.3"
services:
    traefik:
        image: traefik:v1.6
    gateway:
         ...

L'image Traefik provient du référentiel Traefik Docker Hub , où vous pouvez trouver une liste de toutes les images disponibles.

Ensuite, demandons à Docker d'exécuter Traefik en utilisant la directive command. Cela exécutera Traefik, le configurera pour fonctionner avec Docker Swarm et fournira SSL à l'aide de Let's Encrypt. Les drapeaux suivants configureront Traefik :

  • --docker.* : ces indicateurs indiquent à Traefik d'utiliser Docker et précisent qu'il s'exécute dans un cluster Docker Swarm.
  • --web=true : cet indicateur active l'interface utilisateur Web de Traefik.
  • --defaultEntryPoints et --entryPoints : ces drapeaux définissent les points d'entrée et les protocoles à utiliser. Dans notre cas, cela inclut HTTP sur le port 80 et HTTPS sur le port 443.
  • --acme.* : Ces indicateurs indiquent à Traefik d'utiliser ACME pour générer des certificats Let's Encrypt afin de sécuriser votre cluster OpenFaaS avec SSL.

Assurez-vous de remplacer les espaces réservés de domaine example.com dans les drapeaux --acme.domains et --acme.email par le domaine que vous allez utiliser pour accéder à OpenFaaS. Vous pouvez spécifier plusieurs domaines en les séparant par une virgule et un espace. L'adresse e-mail est destinée aux notifications et alertes SSL, y compris les alertes d'expiration de certificat. Dans ce cas, Traefik gérera automatiquement le renouvellement des certificats, vous pouvez donc ignorer les alertes d'expiration.

Ajoutez le bloc de code suivant sous la directive image et au-dessus de gateway :

~/faas/docker-compose.yml

...
    traefik:
        image: traefik:v1.6
        command: -c --docker=true
            --docker.swarmmode=true
            --docker.domain=traefik
            --docker.watch=true
            --web=true
            --defaultEntryPoints='http,https'
            --entryPoints='Name:https Address::443 TLS'
            --entryPoints='Name:http Address::80'
            --acme=true
            --acme.entrypoint='https'
            --acme.httpchallenge=true
            --acme.httpchallenge.entrypoint='http'
            --acme.domains='example.com, www.example.com'
            --acme.email='[email protected]'
            --acme.ondemand=true
            --acme.onhostrule=true
            --acme.storage=/etc/traefik/acme/acme.json
...

Avec la directive command en place, indiquons à Traefik quels ports exposer à Internet. Traefik utilise le port 8080 pour ses opérations, tandis qu'OpenFaaS utilisera le port 80 pour les communications non sécurisées et le port 443 pour les communications sécurisées.

Ajoutez la directive ports suivante sous la directive command. La notation port-internet:port-docker garantit que le port sur le côté gauche est exposé par Traefik à Internet et correspond au port du conteneur sur le côté droit :

~/faas/docker-compose.yml

        ...
        command:
            ...
        ports:
            - 80:80
            - 8080:8080
            - 443:443
        ...

Ensuite, à l'aide de la directive volumes, montez le fichier de socket Docker de l'hôte exécutant Docker sur Traefik. Le fichier de socket Docker communique avec l'API Docker afin de gérer vos conteneurs et d'obtenir des détails à leur sujet, tels que le nombre de conteneurs et leurs adresses IP. Vous monterez également le volume appelé acme, que nous définirons plus tard dans cette étape.

La directive networks demande à Traefik d'utiliser le réseau functions, qui est déployé avec OpenFaaS. Ce réseau garantit que les fonctions peuvent communiquer avec d'autres parties du système, y compris l'API.

La directive deploy indique à Docker d'exécuter Traefik uniquement sur le nœud du gestionnaire Docker Swarm.

Ajoutez les directives suivantes sous la directive ports :

~/faas/docker-compose.yml

       ...
        volumes:
            - "/var/run/docker.sock:/var/run/docker.sock"
            - "acme:/etc/traefik/acme"
        networks:
            - functions
        deploy:
            placement:
                constraints: [node.role == manager]

À ce stade, le bloc de service traefik devrait ressembler à ceci :

~/faas/docker-compose.yml

version: "3.3"
services:
    traefik:
        image: traefik:v1.6
        command: -c --docker=true
            --docker.swarmmode=true
            --docker.domain=traefik
            --docker.watch=true
            --web=true
            --defaultEntryPoints='http,https'
            --entryPoints='Name:https Address::443 TLS'
            --entryPoints='Name:http Address::80'            
            --acme=true
            --acme.entrypoint='https'
            --acme.httpchallenge=true
            --acme.httpchallenge.entrypoint='http'
            --acme.domains='example.com, www.example.com'
            --acme.email='[email protected]'
            --acme.ondemand=true
            --acme.onhostrule=true
            --acme.storage=/etc/traefik/acme/acme.json
        ports:
            - 80:80
            - 8080:8080
            - 443:443
        volumes:
            - "/var/run/docker.sock:/var/run/docker.sock"
            - "acme:/etc/traefik/acme"
        networks:
          - functions
        deploy:
          placement:
            constraints: [node.role == manager]
    
    gateway:
        ...

Bien que cette configuration garantisse que Traefik sera déployé avec OpenFaaS, vous devez également configurer OpenFaaS pour qu'il fonctionne avec Traefik. Par défaut, le service gateway est configuré pour s'exécuter sur le port 8080, qui chevauche Traefik.

Le service gateway fournit la passerelle API que vous pouvez utiliser pour déployer, exécuter et gérer vos fonctions. Il gère les métriques (via Prometheus) et la mise à l'échelle automatique, et héberge l'interface utilisateur Web.

Notre objectif est d'exposer le service gateway en utilisant Traefik au lieu de l'exposer directement sur Internet.

Localisez le service gateway, qui devrait ressembler à ceci :

~/faas/docker-compose.yml

...
    gateway:
        ports:
            - 8080:8080
        image: openfaas/gateway:0.8.7
        networks:
            - functions
        environment:
            functions_provider_url: "http://faas-swarm:8080/"
            read_timeout:  "300s"        # Maximum time to read HTTP request
            write_timeout: "300s"        # Maximum time to write HTTP response
            upstream_timeout: "300s"     # Maximum duration of upstream function call - should be more than read_timeout and write_timeout
            dnsrr: "true"               # Temporarily use dnsrr in place of VIP while issue persists on PWD
            faas_nats_address: "nats"
            faas_nats_port: 4222
            direct_functions: "true"    # Functions are invoked directly over the overlay network
            direct_functions_suffix: ""
            basic_auth: "${BASIC_AUTH:-true}"
            secret_mount_path: "/run/secrets/"
            scale_from_zero: "false"
        deploy:
            resources:
                # limits:   # Enable if you want to limit memory usage
                #     memory: 200M
                reservations:
                    memory: 100M
            restart_policy:
                condition: on-failure
                delay: 5s
                max_attempts: 20
                window: 380s
            placement:
                constraints:
                    - 'node.platform.os == linux'
        secrets:
            - basic-auth-user
            - basic-auth-password
...

Supprimez la directive ports du service pour éviter d'exposer directement le service gateway.

Ensuite, ajoutez la directive lables suivante à la section deploy du service gateway. Cette directive expose les points de terminaison /ui, /system et /function sur le port 8080 sur Traefik :

~/faas/docker-compose.yml

       ...
        deploy:
            labels:
                - traefik.port=8080
                - traefik.frontend.rule=PathPrefix:/ui,/system,/function
            resources:
            ...            

Le point de terminaison /ui expose l'interface utilisateur Web OpenFaaS, qui est couverte dans l'Étape 6 de ce didacticiel. Le point de terminaison /system est le point de terminaison de l'API utilisé pour gérer OpenFaaS, tandis que le point de terminaison /function expose les points de terminaison de l'API pour la gestion et l'exécution des fonctions. L'étape 5 de ce tutoriel couvre l'API OpenFaaS en détail.

Après modifications, votre service gateway devrait ressembler à ceci :

~/faas/docker-compose.yml

...
    gateway:       
        image: openfaas/gateway:0.8.7
        networks:
            - functions
        environment:
            functions_provider_url: "http://faas-swarm:8080/"
            read_timeout:  "300s"        # Maximum time to read HTTP request
            write_timeout: "300s"        # Maximum time to write HTTP response
            upstream_timeout: "300s"     # Maximum duration of upstream function call - should be more than read_timeout and write_timeout
            dnsrr: "true"               # Temporarily use dnsrr in place of VIP while issue persists on PWD
            faas_nats_address: "nats"
            faas_nats_port: 4222
            direct_functions: "true"    # Functions are invoked directly over the overlay network
            direct_functions_suffix: ""
            basic_auth: "${BASIC_AUTH:-true}"
            secret_mount_path: "/run/secrets/"
            scale_from_zero: "false"
        deploy:
            labels:
                - traefik.port=8080
                - traefik.frontend.rule=PathPrefix:/ui,/system,/function
            resources:
                # limits:   # Enable if you want to limit memory usage
                #     memory: 200M
                reservations:
                    memory: 100M
            restart_policy:
                condition: on-failure
                delay: 5s
                max_attempts: 20
                window: 380s
            placement:
                constraints:
                    - 'node.platform.os == linux'
        secrets:
            - basic-auth-user
            - basic-auth-password
...

Enfin, définissons le volume acme utilisé pour stocker les certificats Let's Encrypt. Nous pouvons définir un volume vide, ce qui signifie que les données ne persisteront pas si vous détruisez le conteneur. Si vous détruisez le conteneur, les certificats seront régénérés au prochain démarrage de Traefik.

Ajoutez la directive volumes suivante sur la dernière ligne du fichier :

~/faas/docker-compose.yml

...
volumes:
    acme:

Une fois que vous avez terminé, enregistrez le fichier et fermez votre éditeur de texte. À ce stade, vous avez configuré Traefik pour protéger votre déploiement OpenFaaS et Docker Swarm. Vous êtes maintenant prêt à le déployer avec OpenFaaS sur votre cluster Swarm.

Étape 3 - Déploiement d'OpenFaaS

Maintenant que vous avez préparé le manifeste de déploiement OpenFaaS, vous êtes prêt à le déployer et à commencer à utiliser OpenFaaS. Pour déployer, vous utiliserez le script deploy_stack.sh. Ce script est destiné à être utilisé sur les systèmes d'exploitation Linux et macOS, mais dans le répertoire OpenFaaS, vous pouvez également trouver des scripts appropriés pour les systèmes Windows et ARM.

Avant de déployer OpenFaaS, vous devrez demander à docker-machine d'exécuter les commandes Docker à partir du script sur l'une des machines du Swarm. Pour ce tutoriel, utilisons le Swarm manager.

Si vous avez configuré la commande docker-machine use, vous pouvez l'utiliser :

docker-machine use node-1

Sinon, utilisez la commande suivante :

eval $(docker-machine env node-1)

Le script deploy_stack.sh déploie toutes les ressources nécessaires pour qu'OpenFaaS fonctionne comme prévu, y compris les fichiers de configuration, les paramètres réseau, les services et les informations d'identification pour l'autorisation avec le serveur OpenFaaS.

Exécutons le script, dont le déploiement prendra plusieurs minutes :

~/faas/deploy_stack.sh

La sortie affiche une liste des ressources qui sont créées dans le processus de déploiement, ainsi que les informations d'identification que vous utiliserez pour accéder au serveur OpenFaaS et à la commande FaaS CLI.

Notez ces informations d'identification, car vous en aurez besoin tout au long du didacticiel pour accéder à l'interface utilisateur Web et à l'API :

OutputAttempting to create credentials for gateway..
roozmk0y1jkn17372a8v9y63g
q1odtpij3pbqrmmf8msy3ampl
[Credentials]
 username: admin
 password: your_openfaas_password
 echo -n your_openfaas_password | faas-cli login --username=admin --password-stdin

Enabling basic authentication for gateway..

Deploying OpenFaaS core services
Creating network func_functions
Creating config func_alertmanager_config
Creating config func_prometheus_config
Creating config func_prometheus_rules
Creating service func_alertmanager
Creating service func_traefik
Creating service func_gateway
Creating service func_faas-swarm
Creating service func_nats
Creating service func_queue-worker
Creating service func_prometheus

Si vous voyez des erreurs, suivez les instructions à l'écran pour les résoudre avant de poursuivre le didacticiel.

Avant de continuer, authentifions la CLI FaaS auprès du serveur OpenFaaS à l'aide de la commande fournie par le script de déploiement.

Le script a généré les indicateurs que vous devez fournir à la commande, mais vous devrez ajouter un indicateur supplémentaire, --gateway, avec l'adresse de votre serveur OpenFaaS, car la CLI FaaS suppose que le serveur de passerelle s'exécute sur [ X222X] :

echo -n your_openfaas_password | faas-cli login --username=admin --password-stdin --gateway https://example.com

La sortie contient un message sur l'autorisation réussie :

OutputCalling the OpenFaaS server to validate the credentials...
credentials saved for admin https://example.com

À ce stade, vous disposez d'un serveur OpenFaaS entièrement fonctionnel déployé sur votre cluster Docker Swarm, ainsi que de la CLI FaaS configurée pour utiliser votre serveur nouvellement déployé. Avant de tester comment utiliser OpenFaaS, déployons quelques exemples de fonctions pour commencer.

Étape 4 - Déploiement des exemples de fonctions OpenFaaS

Initialement, OpenFaaS est livré sans aucune fonction déployée. Pour commencer à le tester et à l'utiliser, vous aurez besoin de certaines fonctions.

Le projet OpenFaaS héberge quelques exemples de fonctions, et vous pouvez trouver une liste des fonctions disponibles ainsi que leurs manifestes de déploiement dans le référentiel OpenFaaS. Certaines des fonctions d'exemple incluent nodeinfo, pour afficher des informations sur le nœud où une fonction est en cours d'exécution, wordcount, pour compter le nombre de mots dans une requête transmise, et markdown , pour convertir l'entrée Markdown transmise en sortie HTML.

Le manifeste stack.yml dans le répertoire ~/faas déploie plusieurs exemples de fonctions avec les fonctions mentionnées ci-dessus. Vous pouvez le déployer à l'aide de la CLI FaaS.

Exécutez la commande faas-cli suivante, qui prend le chemin vers le manifeste de la pile et l'adresse de votre serveur OpenFaaS :

faas-cli deploy -f ~/faas/stack.yml --gateway https://example.com

La sortie contient des codes d'état et des messages indiquant si le déploiement a réussi ou non :

OutputDeploying: wordcount.

Deployed. 200 OK.
URL: https://example.com/function/wordcount

Deploying: base64.

Deployed. 200 OK.
URL: https://example.com/function/base64

Deploying: markdown.

Deployed. 200 OK.
URL: https://example.com/function/markdown

Deploying: hubstats.

Deployed. 200 OK.
URL: https://example.com/function/hubstats

Deploying: nodeinfo.

Deployed. 200 OK.
URL: https://example.com/function/nodeinfo

Deploying: echoit.

Deployed. 200 OK.
URL: https://example.com/function/echoit

Si vous voyez des erreurs, assurez-vous de les résoudre en suivant les instructions à l'écran.

Une fois le déploiement de la pile terminé, répertoriez toutes les fonctions pour vous assurer qu'elles sont déployées et prêtes à être utilisées :

faas-cli list --gateway https://example.com

La sortie contient une liste de fonctions, ainsi que leurs numéros de réplique et un nombre d'invocations :

OutputFunction                        Invocations     Replicas
markdown                        0               1
wordcount                       0               1
base64                          0               1
nodeinfo                        0               1
hubstats                        0               1
echoit                          0               1

Si vous ne voyez pas vos fonctions ici, assurez-vous que la commande faas-cli deploy a été exécutée avec succès.

Vous pouvez maintenant utiliser les exemples de fonctions OpenFaaS pour tester et démontrer comment utiliser l'API, l'interface utilisateur Web et la CLI. À l'étape suivante, vous commencerez par utiliser l'API OpenFaaS pour répertorier et exécuter des fonctions.

Étape 5 - Utilisation de l'API OpenFaaS

OpenFaaS est livré avec une API puissante que vous pouvez utiliser pour gérer et exécuter vos fonctions sans serveur. Utilisons Swagger, un outil d'architecture, de test et de documentation des API, pour parcourir la documentation de l'API, puis utilisons l'API pour répertorier et exécuter des fonctions.

Avec Swagger, vous pouvez consulter la documentation de l'API pour savoir quels points de terminaison sont disponibles et comment vous pouvez les utiliser. Dans le référentiel OpenFaaS, vous pouvez trouver la spécification de l'API Swagger, qui peut être utilisée avec l'éditeur Swagger pour convertir la spécification sous une forme lisible par l'homme.

Naviguez dans votre navigateur Web jusqu'à http://editor.swagger.io/. Vous devriez être accueilli par l'écran suivant :

Vous trouverez ici un éditeur de texte contenant le code source de l'exemple de spécification Swagger et la documentation de l'API lisible par l'homme sur la droite.

Importons la spécification OpenFaaS Swagger. Dans le menu du haut, cliquez sur le bouton Fichier, puis sur Importer URL :

Vous verrez une fenêtre contextuelle dans laquelle vous devrez entrer l'adresse de la spécification de l'API Swagger. Si vous ne voyez pas la fenêtre contextuelle, assurez-vous que les fenêtres contextuelles sont activées pour votre navigateur Web.

Dans le champ, saisissez le lien vers la spécification de l'API Swagger OpenFaaS : https://raw.githubusercontent.com/openfaas/faas/master/api-docs/swagger.yml

Après avoir cliqué sur le bouton OK, l'éditeur Swagger vous montrera la référence API pour OpenFaaS, qui devrait ressembler à ceci :

Sur le côté gauche, vous pouvez voir la source du fichier de référence de l'API, tandis que sur le côté droit, vous pouvez voir une liste de points de terminaison, ainsi que de brèves descriptions. Cliquer sur un point de terminaison vous montre plus de détails à son sujet, y compris les paramètres qu'il prend, la méthode qu'il utilise et les réponses possibles :

Une fois que vous savez quels terminaux sont disponibles et quels paramètres ils attendent, vous pouvez les utiliser pour gérer vos fonctions.

Ensuite, vous utiliserez une commande curl pour communiquer avec l'API, revenez donc à votre terminal. Avec le drapeau -u, vous pourrez passer la paire admin:your_openfaas_password que vous avez obtenue à l'étape 3, tandis que le drapeau -X définira la méthode de requête. Vous transmettrez également l'URL de votre point de terminaison, https://example.com/system/functions :

curl -u admin:your_openfaas_password -X GET https://example.com/system/functions

Vous pouvez voir la méthode requise pour chaque point de terminaison dans la documentation de l'API.

À l'étape 4, vous avez déployé plusieurs exemples de fonctions, qui doivent apparaître dans le résultat :

Output[{"name":"base64","image":"functions/alpine:latest","invocationCount":0,"replicas":1,"envProcess":"base64","availableReplicas":0,"labels":{"com.openfaas.function":"base64","function":"true"}},{"name":"nodeinfo","image":"functions/nodeinfo:latest","invocationCount":0,"replicas":1,"envProcess":"","availableReplicas":0,"labels":{"com.openfaas.function":"nodeinfo","function":"true"}},{"name":"hubstats","image":"functions/hubstats:latest","invocationCount":0,"replicas":1,"envProcess":"","availableReplicas":0,"labels":{"com.openfaas.function":"hubstats","function":"true"}},{"name":"markdown","image":"functions/markdown-render:latest","invocationCount":0,"replicas":1,"envProcess":"","availableReplicas":0,"labels":{"com.openfaas.function":"markdown","function":"true"}},{"name":"echoit","image":"functions/alpine:latest","invocationCount":0,"replicas":1,"envProcess":"cat","availableReplicas":0,"labels":{"com.openfaas.function":"echoit","function":"true"}},{"name":"wordcount","image":"functions/alpine:latest","invocationCount":0,"replicas":1,"envProcess":"wc","availableReplicas":0,"labels":{"com.openfaas.function":"wordcount","function":"true"}}]

Si vous ne voyez pas de sortie qui ressemble à ceci, ou si vous voyez une erreur, suivez les instructions à l'écran pour résoudre le problème avant de poursuivre le didacticiel. Assurez-vous d'envoyer la demande au bon point de terminaison en utilisant la méthode recommandée et les bonnes informations d'identification. Vous pouvez également consulter les journaux du service gateway à l'aide de la commande suivante :

docker service logs func_gateway

Par défaut, la réponse de l'API à l'appel curl renvoie un JSON brut sans nouvelles lignes, qui n'est pas lisible par l'homme. Pour l'analyser, dirigez la réponse de curl vers l'utilitaire jq, qui convertira le JSON en une forme lisible par l'homme :

curl -u admin:your_openfaas_password -X GET https://example.com/system/functions | jq

La sortie est maintenant sous une forme lisible par l'homme. Vous pouvez voir le nom de la fonction, que vous pouvez utiliser pour gérer et invoquer des fonctions avec l'API, le nombre d'invocations, ainsi que des informations telles que les étiquettes et le nombre de répliques, pertinentes pour Docker :

Output[
  {
    "name": "base64",
    "image": "functions/alpine:latest",
    "invocationCount": 0,
    "replicas": 1,
    "envProcess": "base64",
    "availableReplicas": 0,
    "labels": {
      "com.openfaas.function": "base64",
      "function": "true"
    }
  },
  {
    "name": "nodeinfo",
    "image": "functions/nodeinfo:latest",
    "invocationCount": 0,
    "replicas": 1,
    "envProcess": "",
    "availableReplicas": 0,
    "labels": {
      "com.openfaas.function": "nodeinfo",
      "function": "true"
    }
  },
  {
    "name": "hubstats",
    "image": "functions/hubstats:latest",
    "invocationCount": 0,
    "replicas": 1,
    "envProcess": "",
    "availableReplicas": 0,
    "labels": {
      "com.openfaas.function": "hubstats",
      "function": "true"
    }
  },
  {
    "name": "markdown",
    "image": "functions/markdown-render:latest",
    "invocationCount": 0,
    "replicas": 1,
    "envProcess": "",
    "availableReplicas": 0,
    "labels": {
      "com.openfaas.function": "markdown",
      "function": "true"
    }
  },
  {
    "name": "echoit",
    "image": "functions/alpine:latest",
    "invocationCount": 0,
    "replicas": 1,
    "envProcess": "cat",
    "availableReplicas": 0,
    "labels": {
      "com.openfaas.function": "echoit",
      "function": "true"
    }
  },
  {
    "name": "wordcount",
    "image": "functions/alpine:latest",
    "invocationCount": 0,
    "replicas": 1,
    "envProcess": "wc",
    "availableReplicas": 0,
    "labels": {
      "com.openfaas.function": "wordcount",
      "function": "true"
    }
  }
]

Prenons l'une de ces fonctions et exécutons-la en utilisant le point de terminaison API /function/function-name. Ce point de terminaison est disponible via la méthode POST, où l'indicateur -d vous permet d'envoyer des données à la fonction.

Par exemple, exécutons la commande curl suivante pour exécuter la fonction echoit, qui est livrée avec OpenFaaS prête à l'emploi et génère la chaîne que vous lui avez envoyée en tant que requête. Vous pouvez utiliser la chaîne "Sammy The Shark" pour démontrer :

curl -u admin:your_openfaas_password -X POST https://example.com/function/func_echoit -d "Sammy The Shark"

La sortie vous montrera Sammy The Shark :

OutputSammy The Shark

Si vous voyez une erreur, suivez les journaux à l'écran pour résoudre le problème avant de poursuivre le didacticiel. Vous pouvez également consulter les journaux du service gateway.

À ce stade, vous avez utilisé l'API OpenFaaS pour gérer et exécuter vos fonctions. Jetons maintenant un coup d'œil à l'interface utilisateur Web d'OpenFaaS.

Étape 6 - Utilisation de l'interface utilisateur Web OpenFaaS

OpenFaaS est livré avec une interface utilisateur Web que vous pouvez utiliser pour ajouter de nouvelles fonctions et exécuter les fonctions installées. Dans cette étape, vous allez installer une fonction de génération de codes QR à partir du FaaS Store et générer un exemple de code.

Pour commencer, pointez votre navigateur Web sur https://example.com/ui/. Notez que la barre oblique finale est nécessaire pour éviter une erreur « introuvable ».

Dans la boîte de dialogue d'authentification HTTP, entrez le nom d'utilisateur et le mot de passe que vous avez obtenus lors du déploiement d'OpenFaaS à l'étape 3.

Une fois connecté, vous verrez les fonctions disponibles sur le côté gauche de l'écran, ainsi que le bouton Déployer de nouvelles fonctions utilisé pour installer de nouvelles fonctions.

Cliquez sur Deploy New Functions pour déployer une nouvelle fonction. Vous verrez la fenêtre FaaS Store, qui fournit des fonctions testées par la communauté que vous pouvez installer en un seul clic :

En plus de ces fonctions, vous pouvez également déployer des fonctions manuellement à partir d'une image Docker.

Pour ce tutoriel, vous allez déployer la fonction QR Code Generator depuis le FaaS Store. Localisez l'élément QR Code Generator - Go dans la liste, cliquez dessus, puis cliquez sur le bouton Deploy en bas de la fenêtre :

Après avoir cliqué sur Déployer, la fenêtre Déployer une nouvelle fonction se fermera et la fonction sera déployée. Dans la liste sur le côté gauche de la fenêtre, vous verrez une liste pour la fonction qrcode-go. Cliquez sur cette entrée pour la sélectionner. La fenêtre principale de la fonction affichera le nom de la fonction, le nombre de répliques, le nombre d'invocations et l'image, ainsi que l'option d'invoquer la fonction :

Générons un code QR contenant l'URL avec votre domaine. Dans le champ Request body, saisissez le contenu du QR code que vous souhaitez générer ; dans notre cas, ce sera "exemple.com". Une fois que vous avez terminé, cliquez sur le bouton Appeler.

Lorsque vous sélectionnez l'option de sortie Texte ou JSON, la fonction affichera le contenu du fichier, qui n'est pas utilisable ou lisible :

Vous pouvez télécharger une réponse. qui dans notre cas sera un fichier PNG avec le code QR. Pour ce faire, sélectionnez l'option Télécharger, puis cliquez à nouveau sur Appeler. Peu de temps après, vous devriez avoir téléchargé le QR code, que vous pourrez ouvrir avec la visionneuse d'images de votre choix :

En plus de déployer des fonctions depuis le magasin FaaS ou depuis des images Docker, vous pouvez également créer vos propres fonctions. Dans l'étape suivante, vous allez créer une fonction Python à l'aide de l'interface de ligne de commande FaaS.

Étape 7 - Création de fonctions avec la CLI FaaS

Dans les étapes précédentes, vous avez configuré la CLI FaaS pour qu'elle fonctionne avec votre serveur OpenFaaS. La CLI FaaS est une interface de ligne de commande que vous pouvez utiliser pour gérer OpenFaaS et installer et exécuter des fonctions, comme vous le feriez via l'API ou en utilisant l'interface utilisateur Web.

Par rapport à l'interface utilisateur Web ou à l'API, la CLI FaaS propose des modèles pour de nombreux langages de programmation que vous pouvez utiliser pour créer vos propres fonctions. Il peut également créer des images de conteneur basées sur votre code de fonction et envoyer des images vers un registre d'images, tel que Docker Hub.

Dans cette étape, vous allez créer une fonction, la publier sur Docker Hub, puis l'exécuter sur votre serveur OpenFaaS. Cette fonction sera similaire à la fonction par défaut echoit, qui renvoie l'entrée transmise en tant que requête.

Nous allons utiliser Python pour écrire notre fonction. Si vous souhaitez en savoir plus sur Python, vous pouvez consulter notre série de didacticiels Comment coder en Python 3 et notre Comment coder en Python eBook.

Avant de créer la nouvelle fonction, créons un répertoire pour stocker les fonctions FaaS et accédez-y :

mkdir ~/faas-functions
cd ~/faas-functions

Exécutez la commande suivante pour créer une nouvelle fonction Python appelée echo-input. Assurez-vous de remplacer your-docker-hub-username par votre nom d'utilisateur Docker Hub, car vous pousserez la fonction vers Docker Hub plus tard :

faas-cli new echo-input --lang python --prefix your-docker-hub-username --gateway https://example.com

La sortie contient la confirmation de la création réussie de la fonction. Si vous n'avez pas téléchargé de modèles, la CLI téléchargera les modèles dans votre répertoire actuel :

Output2018/05/13 12:13:06 No templates found in current directory.
2018/05/13 12:13:06 Attempting to expand templates from https://github.com/openfaas/templates.git
2018/05/13 12:13:11 Fetched 12 template(s) : [csharp dockerfile go go-armhf node node-arm64 node-armhf python python-armhf python3 python3-armhf ruby] from https://github.com/openfaas/templates.git
Folder: echo-input created.
  ___                   _____           ____
 / _ \ _ __   ___ _ __ |  ___|_ _  __ _/ ___|
| | | | '_ \ / _ \ '_ \| |_ / _` |/ _` \___ \
| |_| | |_) |  __/ | | |  _| (_| | (_| |___) |
 \___/| .__/ \___|_| |_|_|  \__,_|\__,_|____/
      |_|


Function created in folder: echo-input
Stack file written: echo-input.yml

Le résultat de la commande faas-cli new est un répertoire ~/faas-fucntions/echo-input nouvellement créé contenant le code de la fonction et le fichier echo-input.yml. Ce fichier contient des informations sur votre fonction : dans quelle langue elle se trouve, son nom et le serveur sur lequel vous allez la déployer.

Accédez au répertoire ~/faas-fucntions/echo-input :

cd ~/faas-fucntions/echo-input

Pour voir le contenu du répertoire, exécutez :

ls

Le répertoire contient deux fichiers : handler.py, qui contient le code de votre fonction, et requirements.txt, qui contient les modules Python requis par la fonction.

Étant donné que nous n'avons actuellement besoin d'aucun module Python autre que celui par défaut, le fichier requirements.txt est vide. Vous pouvez vérifier cela en utilisant la commande cat :

cat requirements.txt

Ensuite, écrivons une fonction qui renverra une requête sous forme de chaîne.

Le fichier handler.py contient déjà l'exemple de code de gestionnaire, qui renvoie une réponse reçue sous forme de chaîne. Jetons un œil au code :

nano handler.py

La fonction par défaut s'appelle handle et prend un seul paramètre, req, qui contient une requête transmise à la fonction lorsqu'elle est invoquée. La fonction ne fait qu'une chose, renvoyant la requête transmise comme réponse :

def handle(req):
    """handle a request to the function
    Args:
        req (str): request body
    """

    return req

Modifions-le pour inclure du texte supplémentaire, en remplaçant la chaîne dans la directive return comme suit :

    return "Received message: " + req

Une fois que vous avez terminé, enregistrez le fichier et fermez votre éditeur de texte.

Ensuite, construisons une image Docker à partir du code source de la fonction. Accédez au répertoire faas-functions où se trouve le fichier echo-input.yml :

cd ~/faas-functions

La commande suivante crée l'image Docker pour votre fonction :

faas-cli build -f echo-input.yml

La sortie contient des informations sur la progression de la compilation :

Output[0] > Building echo-input.
Clearing temporary build folder: ./build/echo-input/
Preparing ./echo-input/ ./build/echo-input/function
Building: sammy/echo-input with python template. Please wait..
Sending build context to Docker daemon  7.168kB
Step 1/16 : FROM python:2.7-alpine
 ---> 5fdd069daf25
Step 2/16 : RUN apk --no-cache add curl     && echo "Pulling watchdog binary from Github."     && curl -sSL https://github.com/openfaas/faas/releases/download/0.8.0/fwatchdog > /usr/bin/fwatchdog     && chmod +x /usr/bin/fwatchdog     && apk del curl --no-cache
 ---> Using cache
 ---> 247d4772623a
Step 3/16 : WORKDIR /root/
 ---> Using cache
 ---> 532cc683d67b
Step 4/16 : COPY index.py           .
 ---> Using cache
 ---> b4b512152257
Step 5/16 : COPY requirements.txt   .
 ---> Using cache
 ---> 3f9cbb311ab4
Step 6/16 : RUN pip install -r requirements.txt
 ---> Using cache
 ---> dd7415c792b1
Step 7/16 : RUN mkdir -p function
 ---> Using cache
 ---> 96c25051cefc
Step 8/16 : RUN touch ./function/__init__.py
 ---> Using cache
 ---> 77a9db274e32
Step 9/16 : WORKDIR /root/function/
 ---> Using cache
 ---> 88a876eca9e3
Step 10/16 : COPY function/requirements.txt .
 ---> Using cache
 ---> f9ba5effdc5a
Step 11/16 : RUN pip install -r requirements.txt
 ---> Using cache
 ---> 394a1dd9e4d7
Step 12/16 : WORKDIR /root/
 ---> Using cache
 ---> 5a5893c25b65
Step 13/16 : COPY function           function
 ---> eeddfa67018d
Step 14/16 : ENV fprocess="python index.py"
 ---> Running in 8e53df4583f2
Removing intermediate container 8e53df4583f2
 ---> fb5086bc7f6c
Step 15/16 : HEALTHCHECK --interval=1s CMD [ -e /tmp/.lock ] || exit 1
 ---> Running in b38681a71378
Removing intermediate container b38681a71378
 ---> b04c045b0994
Step 16/16 : CMD ["fwatchdog"]
 ---> Running in c5a11078df3d
Removing intermediate container c5a11078df3d
 ---> bc5f08157c5a
Successfully built bc5f08157c5a
Successfully tagged sammy/echo-input:latest
Image: your-docker-hub-username/echo-input built.
[0] < Building echo-input done.
[0] worker done.

Si vous obtenez une erreur, assurez-vous de la résoudre en suivant les instructions à l'écran avant de déployer la fonction.

Vous devrez conteneuriser votre fonction OpenFaaS afin de la déployer. La conteneurisation des applications garantit que l'environnement nécessaire à l'exécution de votre application peut être facilement reproduit et que votre application peut être facilement déployée, mise à l'échelle et mise à jour.

Pour ce didacticiel, nous utiliserons Docker Hub, car il s'agit d'une solution gratuite, mais vous pouvez utiliser n'importe quel registre de conteneurs, y compris votre propre registre privé.

Exécutez la commande suivante pour transférer l'image que vous avez créée vers votre dépôt spécifié sur Docker Hub :

faas-cli push -f echo-input.yml

Pousser prendra plusieurs minutes, selon la vitesse de votre connexion Internet. La sortie contient la progression du téléchargement de l'image :

Output[0] > Pushing echo-input.
The push refers to repository [docker.io/sammy/echo-input]
320ea573b385: Pushed 
9d87e56f5d0c: Pushed 
6f79b75e7434: Pushed 
23aac2d8ecf2: Pushed 
2bec17d09b7e: Pushed 
e5a0e5ab3be6: Pushed 
e9c8ca932f1b: Pushed 
beae1d55b4ce: Pushed 
2fcae03ed1f7: Pushed 
62103d5daa03: Mounted from library/python 
f6ac6def937b: Mounted from library/python 
55c108c7613c: Mounted from library/python 
e53f74215d12: Mounted from library/python 
latest: digest: sha256:794fa942c2f593286370bbab2b6c6b75b9c4dcde84f62f522e59fb0f52ba05c1 size: 3033
[0] < Pushing echo-input done.
[0] worker done.

Enfin, avec votre image poussée vers Docker Hub, vous pouvez l'utiliser pour déployer une fonction sur votre serveur OpenFaaS.

Pour déployer votre fonction, exécutez la commande deploy, qui reprend le chemin du manifeste décrivant votre fonction, ainsi que l'adresse de votre serveur OpenFaaS :

faas-cli deploy -f echo-input.yml --gateway https://example.com

Le résultat affiche l'état du déploiement, ainsi que le nom de la fonction que vous déployez et le code d'état du déploiement :

OutputDeploying: echo-input.

Deployed. 200 OK.
URL: https://example.com/function/echo-input

Si le déploiement réussit, vous verrez un code d'état 200. En cas d'erreur, suivez les instructions fournies pour résoudre le problème avant de continuer.

À ce stade, votre fonction est déployée et prête à être utilisée. Vous pouvez tester qu'il fonctionne comme prévu en l'appelant.

Pour invoquer une fonction avec la CLI FaaS, utilisez la commande invoke en lui transmettant le nom de la fonction et l'adresse OpenFaaS. Après avoir exécuté la commande, il vous sera demandé de saisir la requête que vous souhaitez envoyer à la fonction.

Exécutez la commande suivante pour appeler la fonction echo-input :

faas-cli invoke echo-input --gateway https://example.com

Il vous sera demandé de saisir la requête que vous souhaitez envoyer à la fonction :

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

Saisissez le texte que vous souhaitez envoyer à la fonction, par exemple :

Sammy The Shark!

Une fois que vous avez terminé, appuyez sur ENTER puis sur CTRL + D pour terminer la demande. Le raccourci CTRL + D dans le terminal est utilisé pour enregistrer une fin de fichier (EOF). La CLI OpenFaaS arrête de lire depuis le terminal une fois EOF reçu.

Après quelques secondes, la commande affichera la réponse de la fonction :

OutputReading from STDIN - hit (Control + D) to stop.
Sammy The Shark!
Received message: Sammy The Shark!

Si vous ne voyez pas la sortie ou si vous obtenez une erreur, revenez sur les étapes précédentes pour vous assurer que vous avez déployé la fonction comme expliqué et suivez les instructions à l'écran pour résoudre le problème.

À ce stade, vous avez interagi avec votre fonction à l'aide de trois méthodes : l'interface utilisateur Web, l'API et la CLI. La possibilité d'exécuter vos fonctions avec l'une de ces méthodes vous offre la possibilité de décider de la manière dont vous souhaitez intégrer les fonctions dans vos flux de travail existants.

Conclusion

Dans ce didacticiel, vous avez utilisé l'architecture sans serveur et OpenFaaS pour déployer et gérer vos applications à l'aide de l'API OpenFaaS, de l'interface utilisateur Web et de la CLI. Vous avez également sécurisé votre infrastructure en tirant parti de Traefik pour fournir SSL à l'aide de Let's Encrypt.

Si vous souhaitez en savoir plus sur le projet OpenFaaS, vous pouvez consulter leur site Web et la documentation officielle du projet [1].