TOC

Comment installer et sécuriser OpenFaaS avec Docker Swarm sur Ubuntu 16.04

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

introduction

L'architecture sans serveur masque les instances de serveur au développeur et expose généralement une API permettant 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 confier 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éesserverless functions. 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, ce qui permet 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 deDocker Swarm etKubernetes, 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 parPrometheus 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 configurantTraefik avecLet’s Encypt. Cela garantit une communication sécurisée entre les nœuds du cluster, ainsi qu'OpenFaaS et ses opérateurs.

Conditions préalables

Pour suivre ce tutoriel, vous aurez besoin de:

  • Ubuntu 16.04 fonctionnant 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 installez toutes les dépendances répertoriées dans ces prérequis.

  • git,curl etjq installés sur votre ordinateur local. Vous utiliserezgit pour cloner le référentiel OpenFaaS,curl pour tester l'API etjq pour transformer les réponses brutesJSON de l'API en JSON lisible par l'homme. 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 deHow To Install and Use Docker on Ubuntu 16.04.

  • Un compteDocker Hub. Pour déployer des fonctions sur OpenFaaS, elles doivent ê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 avec Docker sur votre machine locale en utilisant la commandedocker login.

  • Docker Machine installé, aprèsHow To Provision and Manage Remote Docker Hosts with Docker Machine on Ubuntu 16.04.

  • Un jeton d'accès personnel DigitalOcean. Pour créer un jeton, suivezthese instructions.

  • Un cluster Docker Swarm de 3 nœuds, provisionné par lesHow to Create a Cluster of Docker Containers with Docker Swarm and DigitalOcean on Ubuntu 16.04 suivants.

  • 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 verrezexample.com comme exemple de domaine. Vous devriez le remplacer par votre propre domaine, que vous pouvez soit acheter surNamecheap, soit obtenir gratuitement surFreenom. Vous pouvez également utiliser un registraire de domaine différent de votre choix.

[[step-1 -—- download-openfaas-and-Installing-the-openfaas-cli]] == Étape 1 - Téléchargement d'OpenFaaS et installation de l'interface de ligne de commande OpenFaaS

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

Outre le clonage du référentiel, vous allez également installer 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. DansStep 7, vous l'utiliserez pour créer une fonctionPython et la déployer sur OpenFaaS.

Pour ce didacticiel, vous déploierez OpenFaaS v0.8.9. Bien que les étapes de déploiement d'autres versions doivent être similaires, assurez-vous de vérifier lesproject changelog pour vous assurer qu'il n'y a pas de modifications importantes.

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 obtiendrez des fichiers de la branche principale contenant les dernières modifications. Étant donné que les changements importants peuvent entrer dans la branche principale, son utilisation en production n’est pas recommandée. Voyons plutôt le tag0.8.9: 

git checkout 0.8.9

La sortie contient un message concernant l'extraction réussie et un avertissement concernant 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 

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é, ainsi que les fichiers de manifeste nécessaires, passons à l’installation de la CLI de FaaS.

Le moyen le plus simple d'installer l'interface de ligne de commande FaaS consiste à 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 scriptfaas-cli.sh dans votre répertoire personnel. Avant d’exécuter le script, il est conseillé de vérifier le contenu: 

less faas-cli.sh

Vous pouvez quitter l'aperçu en appuyant surq. Une fois que vous avez vérifié le contenu du script, vous pouvez poursuivre l'installation en attribuant des autorisations exécutables au script et en l'exécutant. Exécutez le script en tant que root pour qu'il se copie automatiquement sur vosPATH: 

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, vous avez installé la CLI de FaaS. 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 indicateurs 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 les manifestes OpenFaaS et installé la CLI de FaaS, que vous pouvez utiliser pour gérer votre instance OpenFaaS à partir de votre terminal.

Le répertoire~/faas contient des fichiers de la version0.8.9, ce qui signifie que vous pouvez maintenant déployer OpenFaaS sur votre Docker Swarm. Avant de le faire, modifions le fichier de manifeste de déploiement pour y inclure Traefik, qui sécurisera votre configuration OpenFaaS en configurant Let’s Encrypt.

[[step-2 -—- configuring-traefik]] == Étape 2 - Configuration de Traefik

Traefik est un proxy inverse compatible avec Docker fourni avec la prise en charge de SSL fournie par Let’s Encrypt. Le protocole SSL garantit que vous communiquez en toute sécurité avec le cluster Swarm 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 afin d'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

[.note] #Note: Le fichier manifeste de Docker Compose utiliseYAML formatting, ce qui interdit strictement les tabulations et nécessite deux espaces pour l'indentation. Le manifeste échouera à se déployer si le fichier n'est pas formaté correctement.
#

Le déploiement d'OpenFaaS est composé de plusieurs services, définis sous la directiveservices, 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 sectionservices, ajoutez un nouveau service appelétraefik, qui utilise l'imagetraefik:v1.6 pour le déploiement:

~/faas/docker-compose.yml

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

L'image Traefik provient duTraefik Docker Hub repository, où vous pouvez trouver une liste de toutes les images disponibles.

Ensuite, demandons à Docker d'exécuter Traefik à l'aide de la directivecommand. Ceci exécutera Traefik, le configurera pour fonctionner avec Docker Swarm et fournira le protocole SSL à l’aide de Let’s Encrypt. Les drapeaux suivants vont configurer Traefik:

  • --docker.*: ces indicateurs indiquent à Traefik d'utiliser Docker et spécifient 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 indicateurs définissent les points d'entrée et les protocoles à utiliser. Dans notre cas, cela inclut HTTP sur le port80 et HTTPS sur le port443.

  • --acme.*: ces indicateurs indiquent à Traefik d’utiliserACME 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 du domaineexample.com dans les indicateurs--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 afin que vous puissiez ignorer les alertes d'expiration.

Ajoutez le bloc de code suivant sous la directiveimage et au-dessus degateway:

~/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 directivecommand en place, disons à Traefik quels ports exposer à Internet. Traefik utilise le port8080 pour ses opérations, tandis qu'OpenFaaS utilisera le port80 pour les communications non sécurisées et le port443 pour les communications sécurisées.

Ajoutez la directiveports suivante sous la directivecommand. La notationport-internet:port-docker garantit que le port du 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 directivevolumes, 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 loin dans cette étape.

La directivenetworks indique à Traefik d'utiliser le réseaufunctions, 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 directivedeploy demande à Docker d'exécuter Traefik uniquement sur le nœud du gestionnaire Docker Swarm.

Ajoutez les directives suivantes sous la directiveports:

~/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 servicetraefik 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 fonctionner avec Traefik. Par défaut, le servicegateway est configuré pour s'exécuter sur le port8080, qui chevauche Traefik.

Le servicegateway 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 servicegateway en utilisant Traefik au lieu de l'exposer directement à Internet.

Localisez le servicegateway, 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 directiveports du service pour éviter d'exposer directement le servicegateway.

Ensuite, ajoutez la directivelables suivante à la sectiondeploy du servicegateway. Cette directive expose les points de terminaison/ui,/system et/function sur le port8080 via 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 traitée dans lesStep 6 de ce didacticiel. Le point de terminaison/system est le point de terminaison d'API utilisé pour gérer OpenFaaS, tandis que le point de terminaison/function expose les points de terminaison d'API pour la gestion et l'exécution des fonctions. Step 5 de ce didacticiel couvre en détail l'API OpenFaaS.

Après modifications, votre servicegateway 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 volumeacme utilisé pour stocker les certificats Let’s Encrypt. Nous pouvons définir un volume vide, ce qui signifie que les données ne seront pas persistantes si vous détruisez le conteneur. Si vous détruisez le conteneur, les certificats seront régénérés lors du prochain démarrage de Traefik.

Ajoutez la directivevolumes 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.

[[step-3 -—- deploying-openfaas]] == É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 scriptdeploy_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 pourWindows etARM systems.

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 didacticiel, utilisons lesSwarm manager.

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

docker-machine use node-1

Sinon, utilisez la commande suivante: 

eval $(docker-machine env node-1)

Le scriptdeploy_stack.sh déploie toutes les ressources requises 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, ce qui prendra plusieurs minutes pour terminer le déploiement: 

~/faas/deploy_stack.sh

La sortie affiche une liste des ressources 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 de 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 surlocalhost: 

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 de FaaS configurée pour utiliser votre serveur nouvellement déployé. Avant de tester comment utiliser OpenFaaS, commençons par déployer quelques exemples de fonctions.

[[step-4 -—- deploying-openfaas-sample-functions]] == Étape 4 - Déploiement des exemples de fonctions OpenFaaS

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

Le projet OpenFaaS héberge quelques exemples de fonctions, et vous pouvez trouver une liste deavailable functions along with their deployment manifests in the OpenFaaS repository. Certaines des fonctions exemples incluentnodeinfo, pour afficher des informations sur le nœud sur lequel une fonction est exécutée,wordcount, pour compter le nombre de mots dans une requête passée, etmarkdown, pour la conversion passé l'entrée markdown à la sortie HTML.

Le manifestestack.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 de FaaS.

Exécutez la commandefaas-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éplicas et un nombre d'appels: 

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 commandefaas-cli deploy a été exécutée avec succès.

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

[[step-5 -—- using-the-openfaas-api]] == Étape 5 - Utilisation de l'API OpenFaaS

OpenFaaS est livré avec une puissante API que vous pouvez utiliser pour gérer et exécuter vos fonctions sans serveur. UtilisonsSwagger, 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 les utiliser. Dans le référentiel OpenFaaS, vous pouvez trouver lesSwagger API specification, qui peuvent être utilisés avec l'éditeur Swagger pour convertir la spécification en une forme lisible par l'homme.

Accédez à votre navigateur Web vershttp://editor.swagger.io/. Vous devriez être accueilli avec l'écran suivant:

Swagger Editor Welcome page

Vous trouverez ici un éditeur de texte contenant le code source de la spécification Swagger, ainsi que la documentation de l’API lisible par l’homme à droite.

Importons la spécification OpenFaaS Swagger. Dans le menu du haut, cliquez sur le boutonFile, puis surImport URL:

Swagger Editor Import URL

Une fenêtre contextuelle apparaît dans laquelle vous devez 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, entrez le lien vers la spécification de l'API Swagger OpenFaaS:https://raw.githubusercontent.com/openfaas/faas/master/api-docs/swagger.yml

Swagger Editor Input URL

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

Swagger Editor OpenFaaS API specification

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 courtes descriptions. En cliquant sur un noeud final, vous obtiendrez plus de détails à ce sujet, notamment ses paramètres, sa méthode et les réponses possibles:

Swagger Editor Endpoint details

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

Ensuite, vous utiliserez une commandecurl pour communiquer avec l'API. Revenez donc à votre terminal. Avec l'indicateur-u, vous pourrez passer la paireadmin:your_openfaas_password que vous avez obtenue à l'étape 3, tandis que l'indicateur-X définira la méthode de requête. Vous passerez également votre URL de 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 noeud final dans la documentation de l'API.

A 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 un résultat ressemblant à 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 terminal en utilisant la méthode recommandée et les bonnes informations d’identité. Vous pouvez également vérifier les journaux du servicegateway à l'aide de la commande suivante: 

docker service logs func_gateway

Par défaut, la réponse de l'API à l'appelcurl renvoie du JSON brut sans nouvelles lignes, ce qui n'est pas lisible par l'homme. Pour l'analyser, envoyez la réponse decurl à l'utilitairejq, 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 forme lisible par l'homme. Vous pouvez voir le nom de la fonction que vous pouvez utiliser pour gérer et appeler des fonctions avec l'API, le nombre d'appels, ainsi que des informations telles que les étiquettes et le nombre de réplicas, 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 de l'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 commandecurl suivante pour exécuter la fonctionechoit, qui est livrée avec OpenFaaS et renvoie la chaîne que vous avez envoyée sous forme de 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 montreraSammy 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 servicegateway.

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

[[step-6 -—- using-the-openfaas-web-ui]] == Étape 6 - Utilisation de l'interface 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 permettant de générer des codes QR à partir du magasin FaaS et de générer un exemple de code.

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

Dans la boîte de dialogue 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 boutonDeploy New Functions utilisé pour installer de nouvelles fonctions.

Cliquez surDeploy 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:

OpenFaaS Functions store

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

Pour ce tutoriel, vous déploierez la fonctionQR Code Generator depuis le FaaS Store. Localisez l'élémentQR Code Generator - Go dans la liste, cliquez dessus, puis cliquez sur le boutonDeploy en bas de la fenêtre:

OpenFaaS QR Code Generator function

Après avoir cliqué surDeploy, la fenêtreDeploy A New Function 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 fonctionqrcode-go. Cliquez sur cette entrée pour la sélectionner. La fenêtre de la fonction principale affiche le nom de la fonction, le nombre de répliques, le nombre d'appels et l'image, ainsi que l'option permettant d'appeler la fonction:

OpenFaaS QR Code Function

Générons un code QR contenant l’URL de votre domaine. Dans le champRequest body, saisissez le contenu du code QR que vous souhaitez générer; dans notre cas, ce sera“example.com”. Une fois que vous avez terminé, cliquez sur le boutonInvoke.

Lorsque vous sélectionnez l’option de sortieText ouJSON, la fonction affiche le contenu du fichier, qui n’est pas utilisable ou lisible par l’homme:

OpenFaaS generated QR code

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'optionDownload, puis cliquez à nouveau surInvoke. Peu de temps après, vous devriez télécharger le code QR que vous pourrez ouvrir avec la visionneuse d'images de votre choix:

Generated QR code

En plus de déployer des fonctions à partir du magasin FaaS ou d'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.

[[step-7 -—- creation-functions-with-the-faas-cli]] == Étape 7 - Création de fonctions avec la CLI FaaS

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

Comparée à l'interface Web ou à l'API, la CLI de FaaS contient 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 les envoyer dans un registre d'images, tel que Docker Hub.

Au cours de 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éfautechoit, qui renvoie une entrée passée sous forme de requête.

Nous allons utiliser Python pour écrire notre fonction. Si vous souhaitez en savoir plus sur Python, vous pouvez consulter nosHow To Code in Python 3 tutorial series et nosHow To Code in Python eBook.

Avant de créer la nouvelle fonction, créons un répertoire dans lequel stocker les fonctions FaaS et naviguez jusqu’au: 

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

Exécutez la commande suivante pour créer une nouvelle fonction Python appeléeecho-input. Assurez-vous de remplaceryour-docker-hub-username par votre nom d'utilisateur Docker Hub, car vous transférerez 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 une confirmation de la création réussie de la fonction. Si vous n'avez pas de modèles téléchargés, la CLI les téléchargera 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 commandefaas-cli new est un répertoire~/faas-fucntions/echo-input nouvellement créé contenant le code de la fonction et le fichierecho-input.yml. Ce fichier contient des informations sur votre fonction: sa langue, son nom et le serveur sur lequel vous allez le 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, etrequirements.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 fichierrequirements.txt est vide. Vous pouvez vérifier cela en utilisant la commandecat: 

cat requirements.txt

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

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

nano handler.py

La fonction par défaut est appeléehandle et prend un seul paramètre,req, qui contient une requête transmise à la fonction lorsqu'elle est appelée. La fonction ne fait qu'une chose, renvoyant la requête passée en tant que 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 directivereturn 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épertoirefaas-functions où se trouve le fichierecho-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 construction: 

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 pour 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, en tant que solution gratuite, mais vous pouvez utiliser n’importe quel registre de conteneurs, y compris votre propre registre privé.

Exécutez la commande suivante pour envoyer l'image que vous avez construite vers votre référentiel spécifié sur Docker Hub: 

faas-cli push -f echo-input.yml

Pousser prendra plusieurs minutes, en fonction de 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 transmise à Docker Hub, vous pouvez l’utiliser pour déployer une fonction sur votre serveur OpenFaaS.

Pour déployer votre fonction, exécutez la commandedeploy, qui prend le chemin vers le manifeste qui décrit votre fonction, ainsi que l'adresse de votre serveur OpenFaaS: 

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

La sortie affiche l’état du déploiement, ainsi que le nom de la fonction que vous déployez et le code de l’état de 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'état200. 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 vérifier qu'il fonctionne comme prévu en l'invoquant.

Pour appeler une fonction avec l'interface de ligne de commande FaaS, utilisez la commandeinvoke en lui passant le nom de la fonction et l'adresse OpenFaaS. Une fois la commande exécutée, il vous sera demandé de saisir la demande que vous souhaitez envoyer à la fonction.

Exécutez la commande suivante pour appeler la fonctionecho-input: 

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

Vous serez invité à saisir la demande que vous souhaitez envoyer à la fonction: 

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

Entrez le texte que vous souhaitez envoyer à la fonction, tel que: 

Sammy The Shark!

Une fois que vous avez terminé, appuyez surENTER puis surCTRL + D pour terminer la demande. Le raccourciCTRL + D dans le terminal est utilisé pour enregistrer une fin de fichier (EOF). La CLI OpenFaaS arrête la lecture à partir du terminal une fois que EOF est 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 le résultat ou si vous obtenez une erreur, revenez aux é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 l'interface de ligne de commande. Etre capable d'exécuter vos fonctions avec l'une de ces méthodes vous offre la flexibilité 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, de l’UI Web et de la CLI OpenFaaS. Vous avez également sécurisé votre infrastructure en utilisant Traefik pour fournir le protocole SSL à l’aide de Let’s Encrypt.

Si vous voulez en savoir plus sur le projet OpenFaaS, vous pouvez consulter leurswebsite et lesproject’s official documentation.

Related