AnythingMCP auf Google Kubernetes Engine (GKE) bereitstellen

Überblick

Dies ist die fortgeschrittenste Bereitstellungsoption, gedacht für Teams, die Skalierbarkeit auf Enterprise-Niveau und verwaltete Infrastruktur benötigen. Sie erstellen Kubernetes-Manifeste und verwenden Cloud SQL oder ein clusterinternes PostgreSQL.

Voraussetzungen

• Ein GCP-Konto mit aktivierter Abrechnung
• gcloud und kubectl installiert
• Docker lokal installiert
• Ein Domainname

gcloud services enable container.googleapis.com \
  artifactregistry.googleapis.com \
  sqladmin.googleapis.com

Einen GKE-Cluster erstellen

gcloud container clusters create anythingmcp-cluster \
  --region us-central1 \
  --num-nodes 2 \
  --machine-type e2-standard-2 \
  --enable-autoscaling --min-nodes 1 --max-nodes 5

gcloud container clusters get-credentials anythingmcp-cluster \
  --region us-central1

Image erstellen und pushen

gcloud artifacts repositories create anythingmcp \
  --repository-format docker \
  --location us-central1

gcloud auth configure-docker us-central1-docker.pkg.dev

git clone https://github.com/HelpCode-ai/anythingmcp.git
cd anythingmcp

docker build -t us-central1-docker.pkg.dev/YOUR_PROJECT_ID/anythingmcp/app:latest .
docker push us-central1-docker.pkg.dev/YOUR_PROJECT_ID/anythingmcp/app:latest

Kubernetes Secrets erstellen

kubectl create secret generic anythingmcp-secrets \
  --from-literal=JWT_SECRET=$(openssl rand -hex 32) \
  --from-literal=ENCRYPTION_KEY=$(openssl rand -hex 16) \
  --from-literal=NEXTAUTH_SECRET=$(openssl rand -hex 32) \
  --from-literal=POSTGRES_PASSWORD=$(openssl rand -hex 16)

PostgreSQL bereitstellen

Einfaches clusterinternes StatefulSet (für Produktion empfiehlt sich stattdessen Cloud SQL):

# postgres.yaml
apiVersion: v1
kind: Service
metadata:
  name: postgres
spec:
  clusterIP: None
  selector:
    app: postgres
  ports:
    - port: 5432
---
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: postgres
spec:
  serviceName: postgres
  replicas: 1
  selector:
    matchLabels:
      app: postgres
  template:
    metadata:
      labels:
        app: postgres
    spec:
      containers:
        - name: postgres
          image: postgres:17-alpine
          ports:
            - containerPort: 5432
          env:
            - name: POSTGRES_DB
              value: anythingmcp
            - name: POSTGRES_USER
              value: amcp
            - name: POSTGRES_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: anythingmcp-secrets
                  key: POSTGRES_PASSWORD
          volumeMounts:
            - name: data
              mountPath: /var/lib/postgresql/data
  volumeClaimTemplates:
    - metadata:
        name: data
      spec:
        accessModes: ["ReadWriteOnce"]
        resources:
          requests:
            storage: 10Gi

kubectl apply -f postgres.yaml

AnythingMCP bereitstellen

# anythingmcp.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: anythingmcp
spec:
  replicas: 2
  selector:
    matchLabels:
      app: anythingmcp
  template:
    metadata:
      labels:
        app: anythingmcp
    spec:
      containers:
        - name: anythingmcp
          image: us-central1-docker.pkg.dev/YOUR_PROJECT_ID/anythingmcp/app:latest
          ports:
            - containerPort: 3000
            - containerPort: 4000
          env:
            - name: NODE_ENV
              value: production
            - name: PORT
              value: "4000"
            - name: MCP_AUTH_MODE
              value: oauth2
            - name: POSTGRES_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: anythingmcp-secrets
                  key: POSTGRES_PASSWORD
            - name: DATABASE_URL
              value: postgresql://amcp:$(POSTGRES_PASSWORD)@postgres:5432/anythingmcp
            - name: JWT_SECRET
              valueFrom:
                secretKeyRef:
                  name: anythingmcp-secrets
                  key: JWT_SECRET
            - name: ENCRYPTION_KEY
              valueFrom:
                secretKeyRef:
                  name: anythingmcp-secrets
                  key: ENCRYPTION_KEY
            - name: NEXTAUTH_SECRET
              valueFrom:
                secretKeyRef:
                  name: anythingmcp-secrets
                  key: NEXTAUTH_SECRET
          readinessProbe:
            httpGet:
              path: /health
              port: 4000
            initialDelaySeconds: 10
            periodSeconds: 5
          livenessProbe:
            httpGet:
              path: /health
              port: 4000
            initialDelaySeconds: 30
            periodSeconds: 10
          resources:
            requests:
              cpu: 250m
              memory: 256Mi
            limits:
              cpu: "1"
              memory: 512Mi
---
apiVersion: v1
kind: Service
metadata:
  name: anythingmcp
spec:
  selector:
    app: anythingmcp
  ports:
    - name: frontend
      port: 3000
      targetPort: 3000
    - name: backend
      port: 4000
      targetPort: 4000
  type: ClusterIP

kubectl apply -f anythingmcp.yaml

Mit Ingress freigeben (HTTPS)

# ingress.yaml
apiVersion: networking.gke.io/v1
kind: ManagedCertificate
metadata:
  name: anythingmcp-cert
spec:
  domains:
    - mcp.example.com
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: anythingmcp-ingress
  annotations:
    networking.gke.io/managed-certificates: anythingmcp-cert
    kubernetes.io/ingress.class: gce
spec:
  rules:
    - host: mcp.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: anythingmcp
                port:
                  number: 3000

kubectl apply -f ingress.yaml

# Externe IP abrufen (kann einige Minuten dauern)
kubectl get ingress anythingmcp-ingress

Richten Sie den A-Eintrag Ihrer Domain auf die externe IP. Das verwaltete Zertifikat wird automatisch bereitgestellt, sobald sich der DNS-Eintrag verbreitet hat.

Überprüfung & nächste Schritte

kubectl get pods
curl https://mcp.example.com/health

Der erste Benutzer, der sich registriert, wird zum Administrator.

Produktionsempfehlungen:

• Verwenden Sie Cloud SQL anstelle des clusterinternen StatefulSets für Backups und Hochverfügbarkeit
• Aktivieren Sie den Horizontal Pod Autoscaler: kubectl autoscale deployment anythingmcp --min=2 --max=10 --cpu-percent=70
• Verwenden Sie Workload Identity für den Cloud-SQL-Zugriff