Pular para o conteúdo
mofcloud

Implantar o MOF no Kubernetes

Última atualização:

MOF, Dash e MCP em um Pod.

Linux amd64 · kubectl · PostgreSQL externo · 1 Pod · 3 contêineres

Rede privada · permissão CREATEDB obrigatória · PostgreSQL somente com TLS não suportado.

Origem da imagem

Baixar mof.yaml

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

Download mof.yaml ↓
Ver arquivo
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

Mantenha os nomes de Service mof, mof-mcp e dash, todos no mesmo namespace. Os componentes se encontram por esses nomes (mof:8080, mof-mcp:8001), então não é preciso configurar mais nada; Services renomeados não conseguem se conectar.

Conexão com o banco de dados

Preencha seu PostgreSQL existente no mof.yaml:

RK_POSTGRES_0_ADDR
Endereço:porta
RK_POSTGRES_0_USER
Usuário
stringData.password
Senha do banco de dados existente

Mantenha as senhas entre aspas e este arquivo privado.

Implantar

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

Quando os três estiverem implantados, obtenha a senha do Admin:

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

Abrir o MOF

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

Mantenha este terminal em execução.

Adminhttp://127.0.0.1:8000/admin

Instale sua licença e crie usuários.

MOF Webhttp://127.0.0.1:8000

Entre com sua conta do MOF.

Configuração avançada

Compatibilidade de TLS do PostgreSQL

O MOF aplica as configurações de TLS ao Mof e ao AsyncJobMof, mas não aos bancos de dados dos provedores. Este modelo exige uma rede privada confiável e não pode usar PostgreSQL somente com TLS.

Domínio, HTTPS e OAuth opcional

Use um Ingress controller existente e aponte seu domínio para ele. Defina a classe, o hostname e um Secret de TLS existente no namespace mof.

Download 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

Habilite o MCP em Admin → Configurações → MCP. Endpoint: /v1/mof/remote-mcp. Tokens não precisam de OAuth; OAuth pelo navegador exige HTTPS, MOF_PUBLIC_URL e MOF_MCP_OAUTH_SECRET.

Health checks e solução de problemas
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

Esperado: mof, mof-mcp e dash Running e Ready; MCP ready: true. Se a inicialização falhar, verifique o pull das imagens, a arquitetura do nó e o acesso ao banco de dados.

Parâmetros do modelo
RK_POSTGRES_0_ADDRhostname:porta do PostgreSQL externo, acessível a partir do Pod.
RK_POSTGRES_0_USERRole de banco de dados existente com permissão para criar os bancos de dados do MOF e dos provedores.
mof-database / passwordSenha do banco de dados armazenada em um Secret; injetada apenas no MOF.
Services mof / mof-mcp / dashUm Deployment e um Service para cada. Eles se encontram pelo nome do Service; nada a configurar.
replicas / strategy1 / Recreate. As atualizações interrompem o serviço brevemente; HA com várias réplicas está fora deste modelo.
resources.requestsReservas de agendamento, não limites de memória. Dimensione o MOF conforme o volume de faturas e monitore o uso real.
offer-cache / emptyDirCache de preços públicos reconstruível. É perdido quando o Pod é substituído; os dados de faturamento permanecem no PostgreSQL.
ingressClassName / host / tlsAjuste ao seu controller instalado, domínio público e Secret de TLS. Opcional para verificações locais com port-forward.
Atualizações, dados e escalabilidade

Faça backup do PostgreSQL, atualize as versões das imagens e aplique o mof.yaml. Reinicie após alterar ConfigMap ou Secret. Atualizações com Recreate interrompem o serviço.

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

Apenas uma réplica; Jobs do Kubernetes sob demanda não estão implementados. Os dados da aplicação ficam no PostgreSQL externo; o cache de preços pode ser reconstruído.