Construction en plusieurs étapes de Docker · Manifestes K8s · Opérateur de nœud macOS · Mise à l'échelle automatique HPA avec profondeur de file d'attente
Votre OpenClaw fonctionne-t-il toujours en mode natif ? Face aux besoins de collaboration multi-équipes, de mise à l’échelle élastique et de déploiement interrégional, l’installation traditionnelle n’est pas à la hauteur. Ce guide fournit un plan complet de conteneurisation et d'orchestration K8s: comment transformer OpenClaw en une image Docker standard, la déployer sur les nœuds macOS à l'aide de Kubernetes Operator et implémenter la mise à l'échelle automatique avec HPA basée sur des métriques personnalisées. Comprend une optimisation de construction en plusieurs étapes, une configuration privilégiée macOS et une matrice de compromis coût-élasticité.
Déplacer OpenClaw du nœud local vers Docker, puis vers Kubernetes, ne consiste pas à suivre les tendances : cela résout les véritables problèmes de production.
Environnements incohérents: Différents développeurs/nœuds CI ont différentes versions de Node/npm, provoquant des problèmes de « fonctionne sur ma machine ». Les conteneurs garantissent une durée d’exécution identique.
Inefficacité de mise à l’échelle: OpenClaw natif ne peut pas être répliqué rapidement. Lorsque les files d'attente de tâches augmentent, la création manuelle d'instances est trop lente.
Difficulté de déploiement interrégional: Le déploiement manuel sur plusieurs nœuds Mac distants est sujet aux erreurs. La configuration déclarative de K8 permet un déploiement multirégional cohérent.
Lentement: L'échec du nœud nécessite une réinstallation manuelle. Orchestrator détecte et replanifie automatiquement, réduisant ainsi considérablement le MTTR.
Faible utilisation des ressources: Chaque instance consacre une machine entière. K8s permet le partage multi-location et les quotas de ressources, améliorant ainsi l'efficacité globale.
Avantages de la conteneurisation: Les enquêtes DevOps 2026 montrent que les services d'agents IA conteneurisés réduisent les coûts de 70 % et améliorent l'utilisation des ressources de plus de 40 %.
Avant d'écrire un Dockerfile, externalisez la configuration d'OpenClaw du système de fichiers vers les variables d'environnement et le stockage externe : c'est la première étape clé.
| Original (fichier) | Approche conteneurisée | Remarques |
|---|---|---|
openclaw.json Clés API | Carte de configuration/Secret | Les données sensibles doivent utiliser K8s Secret ou un coffre-fort externe |
storage.type = "file" | Changer pour redis ou stockage cloud | Le système de fichiers conteneur est éphémère ; l’État doit être externalisé |
gateway.address = "0.0.0.0:8080" | Variable d'environnement GATEWAY_ADDR | Cartographie des ports via Docker -p ou Service K8s |
skills chemin local | ConfigMap ou conteneur side-car | Les compétences doivent être indépendantes de l'image pour des mises à jour faciles |
logs vers un fichier local | stdout/stderr + collecteur side-car | Suivre 12FA : connectez-vous à la console |
Changement fondamental : faire openclaw.json lire à partir des variables d'environnement. Exemple :
{
"storage": {
"type": "redis",
"host": "${REDIS_HOST}",
"port": 6379,
"password": "${REDIS_PASSWORD}"
},
"gateway": {
"address": "${GATEWAY_ADDR}",
"adminPort": "${ADMIN_PORT}"
},
"llm": {
"provider": "${LLM_PROVIDER}",
"apiKey": "${LLM_API_KEY}"
}
}
Une image Docker efficace et sécurisée constitue la base de l’orchestration K8. Utilisez des builds en plusieurs étapes pour réduire la taille, améliorer la sécurité et ajouter des sondes d’intégrité.
Choisissez une image de base minimale : Utilisez Node.js officiel (par exemple, node:18-alpine) pour l'exécution, et non pour un système d'exploitation complet, afin de réduire la surface d'attaque.
Construction en plusieurs étapes: L'étape 1 installe les dépôts et les compilations ; L'étape 2 contient uniquement des fichiers d'exécution, réduisant ainsi la taille de l'image de 60 % et plus.
Utilisateur non root: Créer un dédié openclaw utilisateur dans Dockerfile et basculez avec USER; évitez la racine à l’intérieur du conteneur.
Ajouter une vérification de l'état: Déclarer HEALTHCHECK appeler OpenClaw /health point final afin que les K8 puissent surveiller l’état de préparation.
Exposer le port: Utiliser EXPOSE 8080; Le service K8s acheminera le trafic en conséquence.
Optimisation des couches : Séparez l'installation des dépendances de la copie source pour exploiter le cache ; utiliser npm ci --only=production pour exclure les développeurs de l’image de production.
# Build stage
FROM node:18 AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build
# Runtime stage
FROM node:18-alpine
WORKDIR /app
RUN addgroup -g 1001 -S openclaw && adduser -u 1001 -S openclaw -G openclaw
COPY --from=builder --chown=openclaw:openclaw /app/dist ./dist
COPY --from=builder --chown=openclaw:openclaw /app/node_modules ./node_modules
COPY --from=builder --chown=openclaw:openclaw /app/package*.json ./
USER openclaw
EXPOSE 8080
HEALTHCHECK --interval=30s --timeout=3s --start-period=10s --retries=3 \
CMD node -e "require('http').get('http://localhost:8080/health', (r) => {if(r.statusCode!==200)throw new Error('unhealthy')})"
CMD ["node", "dist/index.js"]
Le déploiement complet de Kubernetes nécessite plusieurs ressources travaillant ensemble. Vous trouverez ci-dessous l'ensemble minimal pour exécuter OpenClaw sur des nœuds Mac distants.
| Ressource | Objectif | Champs clés |
|---|---|---|
| Déploiement | Gère les répliques de pods et les mises à jour progressives | répliques, stratégie, modèle |
| Service | Équilibrage de charge interne et DNS | type (ClusterIP), ports, sélecteur |
| Entrée | Routage HTTP/HTTPS externe | règles, hôte, chemin, service backend |
| Carte de configuration | Stockage de configuration non sensible | données, immuables |
| Secret | Informations sensibles (clés API, mots de passe) | type : Opaque, données (base64) |
L'exemple YAML suivant illustre une configuration complète de K8 pour OpenClaw. Les secrets doivent être créés séparément.
apiVersion: apps/v1
kind: Deployment
metadata:
name: openclaw
labels:
app: openclaw
spec:
replicas: 2
selector:
matchLabels:
app: openclaw
strategy:
type: RollingUpdate
rollingUpdate:
maxSurge: 1
maxUnavailable: 0
template:
metadata:
labels:
app: openclaw
spec:
containers:
- name: openclaw
image: your-registry/openclaw:latest
ports:
- containerPort: 8080
env:
- name: GATEWAY_ADDR
value: "0.0.0.0:8080"
- name: REDIS_HOST
valueFrom:
configMapKeyRef:
name: openclaw-config
key: redis.host
- name: REDIS_PASSWORD
valueFrom:
secretKeyRef:
name: openclaw-secret
key: redis.password
readinessProbe:
httpGet:
path: /health
port: 8080
initialDelaySeconds: 15
periodSeconds: 10
livenessProbe:
httpGet:
path: /health
port: 8080
initialDelaySeconds: 30
periodSeconds: 30
resources:
requests:
memory: "256Mi"
cpu: "250m"
limits:
memory: "512Mi"
cpu: "500m"
---
apiVersion: v1
kind: Service
metadata:
name: openclaw
spec:
selector:
app: openclaw
ports:
- protocol: TCP
port: 80
targetPort: 8080
type: ClusterIP
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: openclaw
annotations:
nginx.ingress.kubernetes.io/rewrite-target: /
spec:
rules:
- host: openclaw.vpsmesh.com
http:
paths:
- path: /
pathType: Prefix
backend:
service:
name: openclaw
port:
number: 80
---
apiVersion: v1
kind: ConfigMap
metadata:
name: openclaw-config
data:
redis.host: "redis-cluster.vpsmesh.com"
llm.provider: "openai"
Kubernetes fonctionne généralement sous Linux ; le déploiement sur macOS nécessite la gestion des liaisons matérielles, des privilèges et des plugins de périphérique. Un opérateur personnalisé encapsule cette complexité.
node-role.kubernetes.io/macos=true) et des règles d'affinité pour planifier des pods sur les nœuds Mac.securityContext.privileged: true ou allowPrivilegeEscalation: true, mais limitez strictement la portée.k8s-device-plugin) et déclarez des ressources comme limits: apple.com/metal: 1.hostPath or Local PV, mais la persistance/migration des données doit être prise en compte.OpenClawAgent en ressources natives K8 pour un déploiement et une gestion du cycle de vie en un clic.Avertissement de sécurité: L'isolation des conteneurs sur macOS est moins stricte que Linux. Testez minutieusement les conteneurs privilégiés dans un bac à sable et limitez les nœuds sur lesquels ils peuvent atterrir.
Exemple de squelette d'opérateur (utilisant Kopf) :
import kopf
@kopf.on.create('openclawvpsmesh.io', 'v1', 'openclawagents')
def create_fn(spec, **kwargs):
image = spec.get('image', 'your-registry/openclaw:latest')
replicas = spec.get('replicas', 1)
redis_host = spec['redis']['host']
redis_password = spec['redis'].get('password')
deployment = {
"apiVersion": "apps/v1",
"kind": "Deployment",
"metadata": {"name": f"openclaw-{kwargs['name']}"},
"spec": {
"replicas": replicas,
"selector": {"matchLabels": {"app": "openclaw"}},
"template": {
"metadata": {"labels": {"app": "openclaw"}},
"spec": {
"containers": [{
"name": "openclaw",
"image": image,
"env": [
{"name": "REDIS_HOST", "value": redis_host},
{"name": "REDIS_PASSWORD", "value": redis_password}
],
"ports": [{"containerPort": 8080}]
}]
}
}
}
}
return {"status": "created"}
La charge d'OpenClaw est directement corrélée à la profondeur de la file d'attente des tâches. K8s HorizontalPodAutoscaler peut utiliser des métriques personnalisées (longueur de file d'attente, temps de réponse) pour mettre à l'échelle automatiquement les répliques.
| Métrique | Descriptif | Seuils d'échelle | Refroidissement |
|---|---|---|---|
| Utilisation du processeur | % de processeur du pod | scale-out >70 %, scale-in <30 % | 300s |
| Utilisation de la mémoire | % de mémoire du pod | scale-out >80 %, scale-in <40 % | 300s |
| Profondeur de la file d'attente | Tâches en attente OpenClaw | évolutivité > 50 tâches, évolutivité <10 tâches | années 180 |
| Temps de réponse à la tâche | Latence P95 | scale-out > 2 s, scale-in < 500 ms | 300s |
Pour activer la mise à l'échelle basée sur la profondeur de la file d'attente, déployez la pile Prometheus et un exportateur de métriques OpenClaw, puis enregistrez la métrique auprès de l'API Custom Metrics de K8. Exemple HPA :
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
name: openclaw-hpa
spec:
scaleTargetRef:
apiVersion: apps/v1
kind: Deployment
name: openclaw
minReplicas: 2
maxReplicas: 10
metrics:
- type: Resource
resource:
name: cpu
target:
type: Utilization
averageUtilization: 70
- type: Pods
pods:
metric:
name: openclaw_queue_depth
target:
type: AverageValue
averageValue: 50
behavior:
scaleDown:
stabilizationWindowSeconds: 300
policies:
- type: Pods
value: 1
periodSeconds: 300
scaleUp:
stabilizationWindowSeconds: 60
policies:
- type: Pods
value: 2
periodSeconds: 60
Compromis entre coût et élasticité: Un plancher de réplique trop bas gaspille des ressources ; des seuils trop agressifs provoquent des battements. Définissez des références via des tests de charge pendant les heures creuses avant la mise en ligne.
La conteneurisation et les K8 ne sont pas une solution miracle : ils entraînent une complexité opérationnelle et des frais généraux. Voici trois points de données concrets pour décider si l’investissement en vaut la peine.
stabilizationWindowSeconds et les tailles de pas pour éviter les battements.La création de votre propre plate-forme conteneurisée nécessite une expertise approfondie de Kubernetes et de macOS, notamment en matière de création d'images, de planification des ressources, de mise en réseau et de renforcement de la sécurité. Pour la plupart des équipes, cette charge technique est importante.
Pour les environnements de production recherchant des déploiements OpenClaw fiables et élastiques, Le service géré OpenClaw de VpsMesh est souvent le meilleur choix. Nous proposons des nœuds Mac Mini M4 préinstallés avec mise à l'échelle automatique et DR inter-régions : pas besoin d'écrire des opérateurs complexes ou des configurations HPA. Découvrez comment obtenir OpenClaw de niveau entreprise avec un coût de démarrage minimal sur notre page de tarification or commander en ligne maintenant.
Le principal changement est l'externalisation de la configuration. Déplacez les définitions de compétences des répertoires locaux vers les montages de volumes ConfigMap ; remplacez les chemins codés en dur par des variables d'environnement. Assurez-vous que tous les accès aux fichiers utilisent les volumes déclarés. Voir notre Centre d'aide page de conteneurisation pour plus de détails.
L'écosystème de conteneurs macOS est à la traîne par rapport à Linux. Les conteneurs privilégiés, les plug-ins de périphériques et les réseaux CNI ont une prise en charge limitée. Envisagez des distributions légères comme k3s ou minikube et exécutez uniquement des charges de travail non privilégiées ou peu privilégiées. Pour des besoins de hautes performances, évaluez si la conteneurisation est nécessaire ou utilisez les nœuds OpenClaw gérés de VpsMesh.
Déployez la pile Prometheus et un exportateur de métriques OpenClaw pour exposer la profondeur de la file d'attente via l'API Custom Metrics de K8. Configurez ensuite HPA avec type: Pods faisant référence au nom de la métrique. Consultez la documentation K8 sur « Utilisation de Prometheus comme source de métriques personnalisées » pour la configuration de l'adaptateur.