lid's Wiki

title: OpenFaaS: Speed Setup
description: Initiation rapide à OpenFaaS: mise en place
published: true
date: 2025-04-21T21:07:19.615Z
tags: kubernetes, openfaas
editor: markdown
dateCreated: 2025-04-21T18:53:23.772Z

I2 OpenFaaS

Note Importante

Attention, ici, le but est de rapidement pouvoir mettre en place, sur un petit cluster kubernetes, OpenFaaS.

Il est important de prendre en considération que les règles de sécurité ne sont pas, ici, respectées!!! N'UTILISEZ PAS CE SETUP EN PRODUCTION MAIS UNIQUEMENT DANS UN ENVIRONNEMENT ISOLÉ!!

Notamment, ici, les mauvaises pratiques à ne pas reproduire:

Dans un environnement de production, on voudra, à minima:

Installation k3s:

2 VMs, 2 coeurs/6Go RAM. Une control-plane, une autre worker.

Convention de nommage: i2-groupeX-role. Ex: i2-groupe2-control, i2-groupe2-worker, etc

Adresses IP: 172.16.150-159.0-255/16, GW 172.16.255.254

control-plane:

sudo apt install curl git # et autres utilitaires
curl -sfL https://get.k3s.io | sh -
mkdir .kube
sudo cp /etc/rancher/k3s/k3s.yaml .kube/config
chown -R 1000:1000 .kube/config
echo "export KUBECONFIG=${HOME}/.kube/config" >> .bashrc
source .bashrc
kubectl get nodes
sudo cat /var/lib/rancher/k3s/node-token
K1048c23b.....  << copiez cette ligne

worker

sudo apt install curl git
curl -sfL https://get.k3s.io | K3S_URL=https://IP-CONTROLPLANE:6443 K3S_TOKEN=K1048c23b... sh -
et voilà, fini!

retour au controlplane:

kubectl get nodes
NAME          STATUS   ROLES                  AGE     VERSION
k3s-master1   Ready    control-plane,master   7h12m   v1.32.3+k3s1
k3s-worker1   Ready    <none>                 7h11m   v1.32.3+k3s1

Installation de Helm et d'OpenFaaS

Controlplane

curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3
chmod 700 get_helm.sh
./get_helm.sh
helm repo add openfaas https://openfaas.github.io/faas-netes
helm repo update
kubectl create ns openfaas-fn
cd
mkdir helm
cd helm
helm fetch openfaas/openfaas
ls
tar xvzf openfaas...tar.gz
cd openfaas
nano values.yaml
# ligne 33:
serviceType: LoadBalancer
# sauvegarder/quitter
helm install -n openfaas --create-namespace openfaas openfaas/openfaas -f values.yaml
# RECUPEREZ ET NOTEZ LE MOT DE PASSE ADMIN
echo $(kubectl -n openfaas get secret basic-auth -o jsonpath="{.data.basic-auth-password}" | base64 -d)

Installation de k9s

controlplane

cd
wget https://github.com/derailed/k9s/releases/download/v0.50.4/k9s_Linux_amd64.tar.gz
tar xvzf k9s...tar.gz
sudo mv k9s /usr/local/bin/k9s

Déploiement d'un Statefulset PostgreSQL

controlplane, toujours

cd
mkdir postgres
cd postgres
vim postgres.yaml

puis copier/coller:

apiVersion: v1
kind: Service
metadata:
  name: postgres-svc
  namespace: postgres
  labels:
    app: postgresdb-test
spec:
  ports:
  - port: 5432
    name: postgresdb
    protocol: TCP
  clusterIP: None
  selector:
    app: postgresdb-test
---
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: postgresdb-test
  namespace: postgres
spec:
  selector:
    matchLabels:
      app: postgresdb-test
  serviceName: "postgres-svc"
  replicas: 1
  template:
    metadata:
      labels:
        app: postgresdb-test
    spec:
      terminationGracePeriodSeconds: 10
      containers:
      - name: postgresdb
        image: postgres:17
        env:
        - name: "POSTGRES_USER"
          value: "openfaas"
        - name: "POSTGRES_PASSWORD"
          value: "epsiepsi"
        ports:
        - containerPort: 5432
          name: postgresdb
          protocol: TCP
        volumeMounts:
        - name: postgres
          mountPath: /var/lib/postgresql/data
  volumeClaimTemplates:
  - metadata:
      name: postgres
    spec:
      accessModes: [ "ReadWriteOnce" ]
      resources:
        requests:
          storage: 4Gi

Créez vous des comptes dockerhub, si vous n'en avez pas déjà 😃

Les images seront publiques, osef, c'est pas de la prod 🫥

Créez vous une VM debian/ubuntu/whatever+docker (idéalement sur votre poste de travail) avec GUI

sudo apt install docker.io docker-compose
sudo usermod -aG docker votreutilisateur
sudo reboot
docker login

installez faas-cli dessus:

curl -sSL https://cli.openfaas.com | sudo sh
faas login --gateway http://IP_NODE_KUBE:8080 -u admin -p PASSWORD --tls-no-verify
faas up

Découverte d'OpenFaaS (enfin!)

Un générateur de mot de passe via dockerfile

Sur notre VM docker+faas-cli:

mkdir -p dockerfiles/pwgen
cd dockerfiles/pwgen
vim Dockerfile

Dans le dockerfile en question:

FROM --platform=${TARGETPLATFORM:-linux/amd64} ghcr.io/openfaas/classic-watchdog:0.3.3 as watchdog

FROM --platform=${TARGETPLATFORM:-linux/amd64} alpine:3.21.3

RUN apk update
RUN apk add pwgen
RUN mkdir -p /home/app

COPY --from=watchdog /fwatchdog /usr/bin/fwatchdog
RUN chmod +x /usr/bin/fwatchdog

# Add non root user
RUN addgroup -S app && adduser app -S -G app
RUN chown app /home/app

WORKDIR /home/app

USER app

ENV fprocess="pwgen -B -y -1 -c -n -s 24"

ENV write_debug="false"

EXPOSE 8080

HEALTHCHECK --interval=3s CMD [ -e /tmp/.lock ] || exit 1

CMD ["fwatchdog"]

On builde notre image, on la pushe:

docker build .
# récupérer l'id de l'image: 123456abcdef dans l'exemple ci-dessous:
docker tag 123456abcdef username/pwgenerator:latest
docker push username/pwgenerator:latest

le tag "latest" est un anti-pattern kubernetes, mais dans notre cas ça fera l'affaire.

On peut ensuite déployer notre fonction dans OpenFaaS.

utilisation de faas-cli pour créer un template python, et requêter notre BDD

Avec k9s, on va se connecter en shell à notre pod de base de données:

psql -U votreutilisateur
CREATE DATABASE userlist;
\c userlist
CREATE TABLE users ( name TEXT, pass TEXT, totp TEXT );
INSERT INTO users (name, pass, totp) VALUES ('test user', '1234', 'abcd');
\q
exit # on sort du pod et on retourne à la TUI k9s

note: ne faites pas ce genre de truc en prod, c'est pour la démo! Là rien n'est chiffré, c'est moche!

Ensuite, sur notre VM de travail (faas-cli et docker):

cd
mkdir -p faas/python
cd faas/python
faas new --lang python3-http pg-list-user
ls
build  pg-list-user  stack.yaml  template
# on édite notre fichier stack.yaml:
nano stack.yaml
# pour les vrais:
vim stack.yaml

version: 1.0
provider:
  name: openfaas
  gateway: http://IP_OPENFAAS:8080
functions:
  pg-list-user:
    lang: python3-http-debian
    handler: ./pg-list-user
    image: votreutilisateurdockerhub/pg-list-user:latest
    build_options:
      - libpq

On va ensuite éditer le fichier pg-list-user/requirements.txt et y ajouter:

psycopg2==2.9.10

puis le fichier pg-list-user/handler.py:

import psycopg2

def handle(event, context):
    try:
        conn = psycopg2.connect("dbname='userlist' user='openfaas' port=5432 host='postgres-svc.postgres.svc.cluster.local' password='epsiepsi'")
    except Exception as e:
        print("DB connection error {}".format(e))
        return {
                "statusCode": 500,
                "body": e
        }

    cur = conn.cursor()
    username = bytes.decode(event.body)
    cur.execute("""SELECT * FROM users where name=%s;""", [username])
    rows = cur.fetchall()

    return {
        "statusCode": 200,
        "body": rows
    }

Là aussi, on préferera utiliser des secrets OpenFaaS pour stocker nos identifiants, malheureusement, ce n'est dispo que dans la version Pro (payante, donc 😉)

Enfin, il nous reste à build notre conteneur, le push et enfin le déployer sur notre instance OpenFaaS:

faas build -f stack.yaml
faas push -f stack.yaml
faas deploy -f stack.yaml

On peut bien sûr utiliser plein d'autres langages, dont nodeJS, Go, ruby, dotnet8/C#, php8, rust, Bash, powershell, Java et même… Cobol.

Maintenant, le "Read-Eval-Print-Loop" à la sauce OpenFaaS/Kubernetes va consister à itérer sur le code de votre fonction pour l'étoffer au fur et à mesure, puis à build cette image, la push sur votre dépôt de conteneurs et enfin déployer votre nouvelle image sur OpenFaaS:

comme les itérations sont minimes, le temps de build/push/deploy est lui aussi très minime, vu qu'on ne "pushera" et "pullera" que les artefacts différents de l'image de base.