Aller au contenu
mofcloud

Déployer MOF sur Kubernetes

Dernière mise à jour :

MOF, Dash et MCP dans un seul Pod.

Linux amd64 · kubectl · PostgreSQL externe · 1 Pod · 3 conteneurs

Réseau privé · droit CREATEDB requis · PostgreSQL en TLS uniquement non pris en charge.

Source des images

Télécharger mof.yaml

Docker Hub · MOF v2.0.15 · Dash v2.0.17 · MCP v2.0.3

Télécharger mof.yaml ↓
Voir le fichier
mof.yaml
# MOF v2.0.15 + Dash v2.0.17 + MCP v2.0.3
# Edit database address, user and password before applying. Keep this file private.
# Keep the Service names mof, mof-mcp and dash, all in one namespace: the components find each
# other by them (mof:8080, mof-mcp:8001). Renamed Services can't connect.
# Private-network PostgreSQL without TLS. TLS-only databases are not supported by this release.
apiVersion: v1
kind: Namespace
metadata:
  name: mof
---
apiVersion: v1
kind: Secret
metadata:
  name: mof-database
  namespace: mof
type: Opaque
stringData:
  password: "REPLACE_WITH_YOUR_DATABASE_PASSWORD"
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: mof-config
  namespace: mof
data:
  RK_POSTGRES_0_ADDR: "db.example.com:5432"
  RK_POSTGRES_0_USER: "mof"
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: mof
  namespace: mof
spec:
  replicas: 1
  # First-release template: stop the old Pod before starting the new version.
  strategy:
    type: Recreate
  selector:
    matchLabels:
      app: mof
  template:
    metadata:
      labels:
        app: mof
      # Prometheus discovery by annotation; see the monitoring guide for a PodMonitor
      annotations:
        prometheus.io/scrape: "true"
        prometheus.io/port: "8080"
        prometheus.io/path: /internal/v1/mof/metrics
    spec:
      enableServiceLinks: false
      nodeSelector:
        kubernetes.io/arch: amd64
      terminationGracePeriodSeconds: 120
      containers:
        - name: mof
          image: mofcloud/mof:v2.0.15
          envFrom:
            - configMapRef:
                name: mof-config
          env:
            - name: RK_POSTGRES_0_PASS
              valueFrom:
                secretKeyRef:
                  name: mof-database
                  key: password
          ports:
            - name: api
              containerPort: 8080
          startupProbe:
            httpGet:
              path: /v1/mof/site-info
              port: api
            periodSeconds: 10
            failureThreshold: 60
          readinessProbe:
            httpGet:
              path: /v1/mof/site-info
              port: api
            periodSeconds: 10
            timeoutSeconds: 5
          resources:
            requests:
              cpu: "500m"
              memory: "1Gi"
          volumeMounts:
            - name: offer-cache
              mountPath: /usr/src/mof/offer-cache
      volumes:
        - name: offer-cache
          emptyDir: {}
---
apiVersion: v1
kind: Service
metadata:
  name: mof
  namespace: mof
spec:
  selector:
    app: mof
  ports:
    - name: api
      port: 8080
      targetPort: api
  type: ClusterIP
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: mof-mcp
  namespace: mof
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mof-mcp
  template:
    metadata:
      labels:
        app: mof-mcp
    spec:
      enableServiceLinks: false
      nodeSelector:
        kubernetes.io/arch: amd64
      containers:
        - name: mof-mcp
          image: mofcloud/mof-mcp:v2.0.3
          ports:
            - name: mcp
              containerPort: 8001
          readinessProbe:
            exec:
              command: ["node", "/app/build/healthcheck.js"]
            periodSeconds: 10
            timeoutSeconds: 5
          resources:
            requests:
              cpu: "100m"
              memory: "128Mi"
---
apiVersion: v1
kind: Service
metadata:
  name: mof-mcp
  namespace: mof
spec:
  selector:
    app: mof-mcp
  ports:
    - name: mcp
      port: 8001
      targetPort: mcp
  type: ClusterIP
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: dash
  namespace: mof
spec:
  replicas: 1
  selector:
    matchLabels:
      app: dash
  template:
    metadata:
      labels:
        app: dash
    spec:
      enableServiceLinks: false
      nodeSelector:
        kubernetes.io/arch: amd64
      containers:
        - name: dash
          image: mofcloud/dash:v2.0.17
          ports:
            - name: web
              containerPort: 80
          readinessProbe:
            httpGet:
              path: /
              port: web
            periodSeconds: 10
          resources:
            requests:
              cpu: "100m"
              memory: "64Mi"
---
apiVersion: v1
kind: Service
metadata:
  name: dash
  namespace: mof
spec:
  selector:
    app: dash
  ports:
    - name: web
      port: 80
      targetPort: web
  type: ClusterIP

Conservez les noms de Service mof, mof-mcp et dash, tous dans un même namespace. Les composants se trouvent par ces noms (mof:8080, mof-mcp:8001), rien d’autre n’est donc à configurer ; des Services renommés ne peuvent pas se connecter.

Connexion à la base de données

Renseignez votre PostgreSQL existant dans mof.yaml :

RK_POSTGRES_0_ADDR
Adresse:port
RK_POSTGRES_0_USER
Nom d’utilisateur
stringData.password
Mot de passe de la base existante

Gardez les mots de passe entre guillemets et ce fichier privé.

Déployer

Terminal
kubectl apply -f mof.yaml
kubectl -n mof rollout status deployment/mof --timeout=10m
kubectl -n mof rollout status deployment/mof-mcp deployment/dash

Une fois les trois déployés, récupérez le mot de passe Admin :

Terminal
kubectl -n mof logs deployment/mof | grep "Admin password"

Ouvrir MOF

Terminal
kubectl -n mof port-forward service/dash 8000:80

Laissez ce terminal ouvert.

Adminhttp://127.0.0.1:8000/admin

Installez votre licence et créez des utilisateurs.

MOF Webhttp://127.0.0.1:8000

Connectez-vous avec votre compte MOF.

Configuration avancée

Compatibilité TLS de PostgreSQL

MOF applique les paramètres TLS à Mof et AsyncJobMof, mais pas aux bases des fournisseurs. Ce modèle exige un réseau privé de confiance et ne peut pas utiliser PostgreSQL en TLS uniquement.

Domaine, HTTPS et OAuth facultatif

Utilisez un contrôleur Ingress existant et faites pointer votre domaine dessus. Définissez la classe, le nom d’hôte et un Secret TLS existant dans le namespace mof.

Télécharger ingress.yaml ↓
ingress.yaml
# Requires an installed Ingress controller and an existing TLS Secret.
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: mof
  namespace: mof
spec:
  ingressClassName: nginx
  tls:
    - hosts: [mof.example.com]
      secretName: mof-web-tls
  rules:
    - host: mof.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: dash
                port:
                  number: 80
Terminal
kubectl apply -f ingress.yaml
kubectl -n mof get ingress

Activez MCP dans Admin → Paramètres → MCP. Endpoint : /v1/mof/remote-mcp. Les jetons n’ont pas besoin d’OAuth ; l’OAuth par navigateur nécessite HTTPS, MOF_PUBLIC_URL et MOF_MCP_OAUTH_SECRET.

Health checks et dépannage
Terminal
kubectl -n mof get pods
kubectl -n mof logs deployment/mof --tail=100
kubectl -n mof logs deployment/mof-mcp --tail=60
kubectl -n mof logs deployment/dash --tail=60
kubectl -n mof exec deployment/mof -- wget -q -O - http://mof-mcp:8001/health

Attendu : mof, mof-mcp et dash Running et Ready ; MCP ready: true. En cas d’échec au démarrage, vérifiez le pull des images, l’architecture des nœuds et l’accès à la base.

Paramètres du modèle
RK_POSTGRES_0_ADDRhostname:port du PostgreSQL externe, joignable depuis le Pod.
RK_POSTGRES_0_USERRôle de base existant autorisé à créer les bases MOF et fournisseurs.
mof-database / passwordMot de passe de la base stocké dans un Secret ; injecté uniquement dans MOF.
Services mof / mof-mcp / dashUn Deployment et un Service chacun. Ils se trouvent par nom de Service ; rien à définir.
replicas / strategy1 / Recreate. Les mises à niveau interrompent brièvement le service ; la HA multi-réplicas sort du cadre de ce modèle.
resources.requestsRéservations de planification, pas des limites de mémoire. Dimensionnez MOF selon votre volume de factures et surveillez l’utilisation réelle.
offer-cache / emptyDirCache public des prix reconstructible. Perdu lorsque le Pod est remplacé ; les données de facturation restent dans PostgreSQL.
ingressClassName / host / tlsÀ adapter à votre contrôleur installé, votre domaine public et votre Secret TLS. Facultatif pour des vérifications locales par port-forward.
Mises à jour, données et mise à l’échelle

Sauvegardez PostgreSQL, mettez à jour les versions d’images et appliquez mof.yaml. Redémarrez après une modification de ConfigMap ou de Secret. Les mises à niveau Recreate interrompent le service.

Terminal
kubectl -n mof rollout restart deployment/mof
kubectl -n mof rollout status deployment/mof --timeout=10m

Un seul réplica ; les Jobs Kubernetes à la demande ne sont pas implémentés. Les données applicatives restent dans le PostgreSQL externe ; le cache des prix peut être reconstruit.