π OpenHands: AI-Driven Development
feat(runtime): add kubernetes support (#8814)
brettstewart54af9ff3fe63
diff --git a/Makefile b/Makefileindex 6d5c0761e4..f98d8b3408 100644--- a/Makefile+++ b/Makefile@@ -12,6 +12,7 @@ DEFAULT_MODEL = "gpt-4o"CONFIG_FILE = config.tomlPRE_COMMIT_CONFIG_PATH = "./dev_config/python/.pre-commit-config.yaml"PYTHON_VERSION = 3.12+KIND_CLUSTER_NAME = "local-hands"# ANSI color codesGREEN=$(shell tput -Txterm setaf 2)@@ -199,6 +200,40 @@ lint:@$(MAKE) -s lint-frontend@$(MAKE) -s lint-backend+kind:+ @echo "$(YELLOW)Checking if kind is installed...$(RESET)"+ @if ! command -v kind > /dev/null; then \+ echo "$(RED)kind is not installed. Please install kind with `brew install kind` to continue$(RESET)"; \+ exit 1; \+ else \+ echo "$(BLUE)kind $(shell kind version) is already installed.$(RESET)"; \+ fi+ @echo "$(YELLOW)Checking if kind cluster '$(KIND_CLUSTER_NAME)' already exists...$(RESET)"+ @if kind get clusters | grep -q "^$(KIND_CLUSTER_NAME)$$"; then \+ echo "$(BLUE)Kind cluster '$(KIND_CLUSTER_NAME)' already exists.$(RESET)"; \+ kubectl config use-context kind-$(KIND_CLUSTER_NAME); \+ else \+ echo "$(YELLOW)Creating kind cluster '$(KIND_CLUSTER_NAME)'...$(RESET)"; \+ kind create cluster --name $(KIND_CLUSTER_NAME) --config kind/cluster.yaml; \+ fi+ @echo "$(YELLOW)Checking if mirrord is installed...$(RESET)"+ @if ! command -v mirrord > /dev/null; then \+ echo "$(RED)mirrord is not installed. Please install mirrord with `brew install metalbear-co/mirrord/mirrord` to continue$(RESET)"; \+ exit 1; \+ else \+ echo "$(BLUE)mirrord $(shell mirrord --version) is already installed.$(RESET)"; \+ fi+ @echo "$(YELLOW)Installing k8s mirrord resources...$(RESET)"+ @kubectl apply -f kind/manifests+ @echo "$(GREEN)Mirrord resources installed successfully.$(RESET)"+ @echo "$(YELLOW)Waiting for Mirrord pod to be ready.$(RESET)"+ @sleep 5+ @kubectl wait --for=condition=Available deployment/ubuntu-dev+ @echo "$(YELLOW)Waiting for Nginx to be ready.$(RESET)"+ @kubectl -n ingress-nginx wait --for=condition=Available deployment/ingress-nginx-controller+ @echo "$(YELLOW)Running make run inside of mirrord.$(RESET)"+ @mirrord exec --target deployment/ubuntu-dev -- make run+test-frontend:@echo "$(YELLOW)Running tests for frontend...$(RESET)"@cd frontend && npm run test@@ -333,3 +368,4 @@ help:# Phony targets.PHONY: build check-dependencies check-system check-python check-npm check-nodejs check-docker check-poetry install-python-dependencies install-frontend-dependencies install-pre-commit-hooks lint-backend lint-frontend lint test-frontend test build-frontend start-backend start-frontend _run_setup run run-wsl setup-config setup-config-prompts setup-config-basic openhands-cloud-run docker-dev docker-run clean help+.PHONY: kinddiff --git a/config.template.toml b/config.template.tomlindex 844fb7e634..e40bfc4d4d 100644--- a/config.template.toml+++ b/config.template.toml@@ -415,3 +415,47 @@ type = "noop"# Configuration for the evaluation, please refer to the specific evaluation# plugin for the available options##############################################################################+++########################### Kubernetes #######################################+# Kubernetes configuration when using the Kubernetes runtime+##############################################################################+[kubernetes]+# The Kubernetes namespace to use for OpenHands resources+#namespace = "default"++# Domain for ingress resources+#ingress_domain = "localhost"++# Size of the persistent volume claim+#pvc_storage_size = "2Gi"++# Storage class for persistent volume claims+#pvc_storage_class = "standard"++# CPU request for runtime pods+#resource_cpu_request = "1"++# Memory request for runtime pods+#resource_memory_request = "1Gi"++# Memory limit for runtime pods+#resource_memory_limit = "2Gi"++# Optional name of image pull secret for private registries+#image_pull_secret = ""++# Optional name of TLS secret for ingress+#ingress_tls_secret = ""++# Optional node selector key for pod scheduling+#node_selector_key = ""++# Optional node selector value for pod scheduling+#node_selector_val = ""++# Optional YAML string defining pod tolerations+#tolerations_yaml = ""++# Run the runtime sandbox container in privileged mode for use with docker-in-docker+#privileged = falsediff --git a/dev_config/python/.pre-commit-config.yaml b/dev_config/python/.pre-commit-config.yamlindex fbb425eec0..e12f358fac 100644--- a/dev_config/python/.pre-commit-config.yaml+++ b/dev_config/python/.pre-commit-config.yaml@@ -7,6 +7,7 @@ repos:- id: end-of-file-fixerexclude: docs/modules/python- id: check-yaml+ args: ["--allow-multiple-documents"]- id: debug-statements- repo: https://github.com/tox-dev/pyproject-fmtdiff --git a/kind/cluster.yaml b/kind/cluster.yamlnew file mode 100644index 0000000000..3402b5fe29--- /dev/null+++ b/kind/cluster.yaml@@ -0,0 +1,9 @@+---+kind: Cluster+apiVersion: kind.x-k8s.io/v1alpha4+name: local-hands+nodes:+- role: control-plane+ extraPortMappings:+ - containerPort: 80 # node port on the cluster for nginx.+ hostPort: 80 # local port for nginx http.diff --git a/kind/manifests/deployment.yaml b/kind/manifests/deployment.yamlnew file mode 100644index 0000000000..dd58cfce9a--- /dev/null+++ b/kind/manifests/deployment.yaml@@ -0,0 +1,19 @@+---+apiVersion: apps/v1+kind: Deployment+metadata:+ name: ubuntu-dev+spec:+ replicas: 1+ selector:+ matchLabels:+ app: ubuntu-dev+ template:+ metadata:+ labels:+ app: ubuntu-dev+ spec:+ containers:+ - name: ubuntu+ image: ubuntu:22.04+ command: ["sleep", "infinity"]diff --git a/kind/manifests/nginx.yaml b/kind/manifests/nginx.yamlnew file mode 100644index 0000000000..f94c6a9089--- /dev/null+++ b/kind/manifests/nginx.yaml@@ -0,0 +1,678 @@+apiVersion: v1+kind: Namespace+metadata:+ labels:+ app.kubernetes.io/instance: ingress-nginx+ app.kubernetes.io/name: ingress-nginx+ name: ingress-nginx+---+apiVersion: v1+automountServiceAccountToken: true+kind: ServiceAccount+metadata:+ labels:+ app.kubernetes.io/component: controller+ app.kubernetes.io/instance: ingress-nginx+ app.kubernetes.io/name: ingress-nginx+ app.kubernetes.io/part-of: ingress-nginx+ app.kubernetes.io/version: 1.12.1+ name: ingress-nginx+ namespace: ingress-nginx+---+apiVersion: v1+automountServiceAccountToken: true+kind: ServiceAccount+metadata:+ labels:+ app.kubernetes.io/component: admission-webhook+ app.kubernetes.io/instance: ingress-nginx+ app.kubernetes.io/name: ingress-nginx+ app.kubernetes.io/part-of: ingress-nginx+ app.kubernetes.io/version: 1.12.1+ name: ingress-nginx-admission+ namespace: ingress-nginx+---+apiVersion: rbac.authorization.k8s.io/v1+kind: Role+metadata:+ labels:+ app.kubernetes.io/component: controller+ app.kubernetes.io/instance: ingress-nginx+ app.kubernetes.io/name: ingress-nginx+ app.kubernetes.io/part-of: ingress-nginx+ app.kubernetes.io/version: 1.12.1+ name: ingress-nginx+ namespace: ingress-nginx+rules:+- apiGroups:+ - ""+ resources:+ - namespaces+ verbs:+ - get+- apiGroups:+ - ""+ resources:+ - configmaps+ - pods+ - secrets+ - endpoints+ verbs:+ - get+ - list+ - watch+- apiGroups:+ - ""+ resources:+ - services+ verbs:+ - get+ - list+ - watch+- apiGroups:+ - networking.k8s.io+ resources:+ - ingresses+ verbs:+ - get+ - list+ - watch+- apiGroups:+ - networking.k8s.io+ resources:+ - ingresses/status+ verbs:+ - update+- apiGroups:+ - networking.k8s.io+ resources:+ - ingressclasses+ verbs:+ - get+ - list+ - watch+- apiGroups:+ - coordination.k8s.io+ resourceNames:+ - ingress-nginx-leader+ resources:+ - leases+ verbs:+ - get+ - update+- apiGroups:+ - coordination.k8s.io+ resources:+ - leases+ verbs:+ - create+- apiGroups:+ - ""+ resources:+ - events+ verbs:+ - create+ - patch+- apiGroups:+ - discovery.k8s.io+ resources:+ - endpointslices+ verbs:+ - list+ - watch+ - get+---+apiVersion: rbac.authorization.k8s.io/v1+kind: Role+metadata:+ labels:+ app.kubernetes.io/component: admission-webhook+ app.kubernetes.io/instance: ingress-nginx+ app.kubernetes.io/name: ingress-nginx+ app.kubernetes.io/part-of: ingress-nginx+ app.kubernetes.io/version: 1.12.1+ name: ingress-nginx-admission+ namespace: ingress-nginx+rules:+- apiGroups:+ - ""+ resources:+ - secrets+ verbs:+ - get+ - create+---+apiVersion: rbac.authorization.k8s.io/v1+kind: ClusterRole+metadata:+ labels:+ app.kubernetes.io/instance: ingress-nginx+ app.kubernetes.io/name: ingress-nginx+ app.kubernetes.io/part-of: ingress-nginx+ app.kubernetes.io/version: 1.12.1+ name: ingress-nginx+rules:+- apiGroups:+ - ""+ resources:+ - configmaps+ - endpoints+ - nodes+ - pods+ - secrets+ - namespaces+ verbs:+ - list+ - watch+- apiGroups:+ - coordination.k8s.io+ resources:+ - leases+ verbs:+ - list+ - watch+- apiGroups:+ - ""+ resources:+ - nodes+ verbs:+ - get+- apiGroups:+ - ""+ resources:+ - services+ verbs:+ - get+ - list+ - watch+- apiGroups:+ - networking.k8s.io+ resources:+ - ingresses+ verbs:+ - get+ - list+ - watch+- apiGroups:+ - ""+ resources:+ - events+ verbs:+ - create+ - patch+- apiGroups:+ - networking.k8s.io+ resources:+ - ingresses/status+ verbs:+ - update+- apiGroups:+ - networking.k8s.io+ resources:+ - ingressclasses+ verbs:+ - get+ - list+ - watch+- apiGroups:+ - discovery.k8s.io+ resources:+ - endpointslices+ verbs:+ - list+ - watch+ - get+---+apiVersion: rbac.authorization.k8s.io/v1+kind: ClusterRole+metadata:+ labels:+ app.kubernetes.io/component: admission-webhook+ app.kubernetes.io/instance: ingress-nginx+ app.kubernetes.io/name: ingress-nginx+ app.kubernetes.io/part-of: ingress-nginx+ app.kubernetes.io/version: 1.12.1+ name: ingress-nginx-admission+rules:+- apiGroups:+ - admissionregistration.k8s.io+ resources:+ - validatingwebhookconfigurations+ verbs:+ - get+ - update+---+apiVersion: rbac.authorization.k8s.io/v1+kind: RoleBinding+metadata:+ labels:+ app.kubernetes.io/component: controller+ app.kubernetes.io/instance: ingress-nginx+ app.kubernetes.io/name: ingress-nginx+ app.kubernetes.io/part-of: ingress-nginx+ app.kubernetes.io/version: 1.12.1+ name: ingress-nginx+ namespace: ingress-nginx+roleRef:+ apiGroup: rbac.authorization.k8s.io+ kind: Role+ name: ingress-nginx+subjects:+- kind: ServiceAccount+ name: ingress-nginx+ namespace: ingress-nginx+---+apiVersion: rbac.authorization.k8s.io/v1+kind: RoleBinding+metadata:+ labels:+ app.kubernetes.io/component: admission-webhook+ app.kubernetes.io/instance: ingress-nginx+ app.kubernetes.io/name: ingress-nginx+ app.kubernetes.io/part-of: ingress-nginx+ app.kubernetes.io/version: 1.12.1+ name: ingress-nginx-admission+ namespace: ingress-nginx+roleRef:+ apiGroup: rbac.authorization.k8s.io+ kind: Role+ name: ingress-nginx-admission+subjects:+- kind: ServiceAccount+ name: ingress-nginx-admission+ namespace: ingress-nginx+---+apiVersion: rbac.authorization.k8s.io/v1+kind: ClusterRoleBinding+metadata:+ labels:+ app.kubernetes.io/instance: ingress-nginx+ app.kubernetes.io/name: ingress-nginx+ app.kubernetes.io/part-of: ingress-nginx+ app.kubernetes.io/version: 1.12.1+ name: ingress-nginx+roleRef:+ apiGroup: rbac.authorization.k8s.io+ kind: ClusterRole+ name: ingress-nginx+subjects:+- kind: ServiceAccount+ name: ingress-nginx+ namespace: ingress-nginx+---+apiVersion: rbac.authorization.k8s.io/v1+kind: ClusterRoleBinding+metadata:+ labels:+ app.kubernetes.io/component: admission-webhook+ app.kubernetes.io/instance: ingress-nginx+ app.kubernetes.io/name: ingress-nginx+ app.kubernetes.io/part-of: ingress-nginx+ app.kubernetes.io/version: 1.12.1+ name: ingress-nginx-admission+roleRef:+ apiGroup: rbac.authorization.k8s.io+ kind: ClusterRole+ name: ingress-nginx-admission+subjects:+- kind: ServiceAccount+ name: ingress-nginx-admission+ namespace: ingress-nginx+---+apiVersion: v1+kind: ConfigMap+metadata:+ labels:+ app.kubernetes.io/component: controller+ app.kubernetes.io/instance: ingress-nginx+ app.kubernetes.io/name: ingress-nginx+ app.kubernetes.io/part-of: ingress-nginx+ app.kubernetes.io/version: 1.12.1+ name: ingress-nginx-controller+ namespace: ingress-nginx+data:+ worker-processes: "2" # Set to a lower number than default+ max-worker-connections: "1024"+---+apiVersion: v1+kind: Service+metadata:+ labels:+ app.kubernetes.io/component: controller+ app.kubernetes.io/instance: ingress-nginx+ app.kubernetes.io/name: ingress-nginx+ app.kubernetes.io/part-of: ingress-nginx+ app.kubernetes.io/version: 1.12.1+ name: ingress-nginx-controller+ namespace: ingress-nginx+spec:+ ipFamilies:+ - IPv4+ ipFamilyPolicy: SingleStack+ ports:+ - appProtocol: http+ name: http+ port: 80+ protocol: TCP+ targetPort: http+ - appProtocol: https+ name: https+ port: 443+ protocol: TCP+ targetPort: https+ selector:+ app.kubernetes.io/component: controller+ app.kubernetes.io/instance: ingress-nginx+ app.kubernetes.io/name: ingress-nginx+ type: LoadBalancer+---+apiVersion: v1+kind: Service+metadata:+ labels:+ app.kubernetes.io/component: controller+ app.kubernetes.io/instance: ingress-nginx+ app.kubernetes.io/name: ingress-nginx+ app.kubernetes.io/part-of: ingress-nginx+ app.kubernetes.io/version: 1.12.1+ name: ingress-nginx-controller-admission+ namespace: ingress-nginx+spec:+ ports:+ - appProtocol: https+ name: https-webhook+ port: 443+ targetPort: webhook+ selector:+ app.kubernetes.io/component: controller+ app.kubernetes.io/instance: ingress-nginx+ app.kubernetes.io/name: ingress-nginx+ type: ClusterIP+---+apiVersion: apps/v1+kind: Deployment+metadata:+ labels:+ app.kubernetes.io/component: controller+ app.kubernetes.io/instance: ingress-nginx+ app.kubernetes.io/name: ingress-nginx+ app.kubernetes.io/part-of: ingress-nginx+ app.kubernetes.io/version: 1.12.1+ name: ingress-nginx-controller+ namespace: ingress-nginx+spec:+ minReadySeconds: 0+ revisionHistoryLimit: 10+ selector:+ matchLabels:+ app.kubernetes.io/component: controller+ app.kubernetes.io/instance: ingress-nginx+ app.kubernetes.io/name: ingress-nginx+ strategy:+ rollingUpdate:+ maxUnavailable: 1+ type: RollingUpdate+ template:+ metadata:+ labels:+ app.kubernetes.io/component: controller+ app.kubernetes.io/instance: ingress-nginx+ app.kubernetes.io/name: ingress-nginx+ app.kubernetes.io/part-of: ingress-nginx+ app.kubernetes.io/version: 1.12.1+ spec:+ containers:+ - args:+ - /nginx-ingress-controller+ - --election-id=ingress-nginx-leader+ - --controller-class=k8s.io/ingress-nginx+ - --ingress-class=nginx+ - --configmap=$(POD_NAMESPACE)/ingress-nginx-controller+ - --validating-webhook=:8443+ - --validating-webhook-certificate=/usr/local/certificates/cert+ - --validating-webhook-key=/usr/local/certificates/key+ - --watch-ingress-without-class=true+ - --publish-status-address=localhost+ env:+ - name: POD_NAME+ valueFrom:+ fieldRef:+ fieldPath: metadata.name+ - name: POD_NAMESPACE+ valueFrom:+ fieldRef:+ fieldPath: metadata.namespace+ - name: LD_PRELOAD+ value: /usr/local/lib/libmimalloc.so+ image: registry.k8s.io/ingress-nginx/controller:v1.12.1@sha256:9724476b928967173d501040631b23ba07f47073999e80e34b120e8db5f234d5+ imagePullPolicy: IfNotPresent+ lifecycle:+ preStop:+ exec:+ command:+ - /wait-shutdown+ livenessProbe:+ failureThreshold: 5+ httpGet:+ path: /healthz+ port: 10254+ scheme: HTTP+ initialDelaySeconds: 10+ periodSeconds: 10+ successThreshold: 1+ timeoutSeconds: 1+ name: controller+ ports:+ - containerPort: 80+ hostPort: 80+ name: http+ protocol: TCP+ - containerPort: 443+ hostPort: 443+ name: https+ protocol: TCP+ - containerPort: 8443+ name: webhook+ protocol: TCP+ readinessProbe:+ failureThreshold: 3+ httpGet:+ path: /healthz+ port: 10254+ scheme: HTTP+ initialDelaySeconds: 10+ periodSeconds: 10+ successThreshold: 1+ timeoutSeconds: 1+ resources:+ requests:+ cpu: 300m+ memory: 256Mi+ limits:+ memory: 512Mi+ securityContext:+ allowPrivilegeEscalation: false+ capabilities:+ add:+ - NET_BIND_SERVICE+ drop:+ - ALL+ readOnlyRootFilesystem: false+ runAsGroup: 82+ runAsNonRoot: true+ runAsUser: 101+ seccompProfile:+ type: RuntimeDefault+ volumeMounts:+ - mountPath: /usr/local/certificates/+ name: webhook-cert+ readOnly: true+ dnsPolicy: ClusterFirst+ nodeSelector:+ kubernetes.io/os: linux+ serviceAccountName: ingress-nginx+ terminationGracePeriodSeconds: 0+ tolerations:+ - effect: NoSchedule+ key: node-role.kubernetes.io/master+ operator: Equal+ - effect: NoSchedule+ key: node-role.kubernetes.io/control-plane+ operator: Equal+ volumes:+ - name: webhook-cert+ secret:+ secretName: ingress-nginx-admission+---+apiVersion: batch/v1+kind: Job+metadata:+ labels:+ app.kubernetes.io/component: admission-webhook+ app.kubernetes.io/instance: ingress-nginx+ app.kubernetes.io/name: ingress-nginx+ app.kubernetes.io/part-of: ingress-nginx+ app.kubernetes.io/version: 1.12.1+ name: ingress-nginx-admission-create+ namespace: ingress-nginx+spec:+ template:+ metadata:+ labels:+ app.kubernetes.io/component: admission-webhook+ app.kubernetes.io/instance: ingress-nginx+ app.kubernetes.io/name: ingress-nginx+ app.kubernetes.io/part-of: ingress-nginx+ app.kubernetes.io/version: 1.12.1+ name: ingress-nginx-admission-create+ spec:+ containers:+ - args:+ - create+ - --host=ingress-nginx-controller-admission,ingress-nginx-controller-admission.$(POD_NAMESPACE).svc+ - --namespace=$(POD_NAMESPACE)+ - --secret-name=ingress-nginx-admission+ env:+ - name: POD_NAMESPACE+ valueFrom:+ fieldRef:+ fieldPath: metadata.namespace+ image: registry.k8s.io/ingress-nginx/kube-webhook-certgen:v1.4.4@sha256:a9f03b34a3cbfbb26d103a14046ab2c5130a80c3d69d526ff8063d2b37b9fd3f+ imagePullPolicy: IfNotPresent+ name: create+ securityContext:+ allowPrivilegeEscalation: false+ capabilities:+ drop:+ - ALL+ readOnlyRootFilesystem: true+ runAsGroup: 65532+ runAsNonRoot: true+ runAsUser: 65532+ seccompProfile:+ type: RuntimeDefault+ nodeSelector:+ kubernetes.io/os: linux+ restartPolicy: OnFailure+ serviceAccountName: ingress-nginx-admission+---+apiVersion: batch/v1+kind: Job+metadata:+ labels:+ app.kubernetes.io/component: admission-webhook+ app.kubernetes.io/instance: ingress-nginx+ app.kubernetes.io/name: ingress-nginx+ app.kubernetes.io/part-of: ingress-nginx+ app.kubernetes.io/version: 1.12.1+ name: ingress-nginx-admission-patch+ namespace: ingress-nginx+spec:+ template:+ metadata:+ labels:+ app.kubernetes.io/component: admission-webhook+ app.kubernetes.io/instance: ingress-nginx+ app.kubernetes.io/name: ingress-nginx+ app.kubernetes.io/part-of: ingress-nginx+ app.kubernetes.io/version: 1.12.1+ name: ingress-nginx-admission-patch+ spec:+ containers:+ - args:+ - patch+ - --webhook-name=ingress-nginx-admission+ - --namespace=$(POD_NAMESPACE)+ - --patch-mutating=false+ - --secret-name=ingress-nginx-admission+ - --patch-failure-policy=Fail+ env:+ - name: POD_NAMESPACE+ valueFrom:+ fieldRef:+ fieldPath: metadata.namespace+ image: registry.k8s.io/ingress-nginx/kube-webhook-certgen:v1.4.4@sha256:a9f03b34a3cbfbb26d103a14046ab2c5130a80c3d69d526ff8063d2b37b9fd3f+ imagePullPolicy: IfNotPresent+ name: patch+ securityContext:+ allowPrivilegeEscalation: false+ capabilities:+ drop:+ - ALL+ readOnlyRootFilesystem: true+ runAsGroup: 65532+ runAsNonRoot: true+ runAsUser: 65532+ seccompProfile:+ type: RuntimeDefault+ nodeSelector:+ kubernetes.io/os: linux+ restartPolicy: OnFailure+ serviceAccountName: ingress-nginx-admission+---+apiVersion: networking.k8s.io/v1+kind: IngressClass+metadata:+ labels:+ app.kubernetes.io/component: controller+ app.kubernetes.io/instance: ingress-nginx+ app.kubernetes.io/name: ingress-nginx+ app.kubernetes.io/part-of: ingress-nginx+ app.kubernetes.io/version: 1.12.1+ name: nginx+spec:+ controller: k8s.io/ingress-nginx+---+apiVersion: admissionregistration.k8s.io/v1+kind: ValidatingWebhookConfiguration+metadata:+ labels:+ app.kubernetes.io/component: admission-webhook+ app.kubernetes.io/instance: ingress-nginx+ app.kubernetes.io/name: ingress-nginx+ app.kubernetes.io/part-of: ingress-nginx+ app.kubernetes.io/version: 1.12.1+ name: ingress-nginx-admission+webhooks:+- admissionReviewVersions:+ - v1+ clientConfig:+ service:+ name: ingress-nginx-controller-admission+ namespace: ingress-nginx+ path: /networking/v1/ingresses+ port: 443+ failurePolicy: Fail+ matchPolicy: Equivalent+ name: validate.nginx.ingress.kubernetes.io+ rules:+ - apiGroups:+ - networking.k8s.io+ apiVersions:+ - v1+ operations:+ - CREATE+ - UPDATE+ resources:+ - ingresses+ sideEffects: Nonediff --git a/kind/manifests/role.yaml b/kind/manifests/role.yamlnew file mode 100644index 0000000000..1c5485dbc3--- /dev/null+++ b/kind/manifests/role.yaml@@ -0,0 +1,14 @@+---+# mirrord-rbac.yaml+apiVersion: rbac.authorization.k8s.io/v1+kind: Role+metadata:+ name: mirrord-role+ namespace: default+rules:+ - apiGroups: [""]+ resources: ["pods", "pods/exec", "pods/portforward", "services", "persistentvolumeclaims"]+ verbs: ["get", "list", "create", "delete", "watch", "update"]+ - apiGroups: ["networking.k8s.io"] # Networking API group (for ingress, networkpolicies, etc.)+ resources: ["ingresses", "networkpolicies"]+ verbs: ["get", "list", "create", "delete", "watch", "update"]diff --git a/kind/manifests/roleBinding.yaml b/kind/manifests/roleBinding.yamlnew file mode 100644index 0000000000..5db395f74e--- /dev/null+++ b/kind/manifests/roleBinding.yaml@@ -0,0 +1,14 @@+---+apiVersion: rbac.authorization.k8s.io/v1+kind: RoleBinding+metadata:+ name: mirrord-binding+ namespace: default+subjects:+ - kind: ServiceAccount+ name: default+ namespace: default+roleRef:+ kind: Role+ name: mirrord-role+ apiGroup: rbac.authorization.k8s.iodiff --git a/kind/manifests/service.yaml b/kind/manifests/service.yamlnew file mode 100644index 0000000000..a04e315884--- /dev/null+++ b/kind/manifests/service.yaml@@ -0,0 +1,12 @@+---+apiVersion: v1+kind: Service+metadata:+ name: ubuntu-dev+spec:+ selector:+ app: ubuntu-dev+ ports:+ - protocol: TCP+ port: 8099+ targetPort: 3000diff --git a/openhands/core/config/kubernetes_config.py b/openhands/core/config/kubernetes_config.pynew file mode 100644index 0000000000..1ba554825c--- /dev/null+++ b/openhands/core/config/kubernetes_config.py@@ -0,0 +1,86 @@+from pydantic import BaseModel, Field, ValidationError+++class KubernetesConfig(BaseModel):+ """Configuration for Kubernetes runtime.++ Attributes:+ namespace: The Kubernetes namespace to use for OpenHands resources+ ingress_domain: Domain for ingress resources+ pvc_storage_size: Size of the persistent volume claim (e.g. "2Gi")+ pvc_storage_class: Storage class for persistent volume claims+ resource_cpu_request: CPU request for runtime pods+ resource_memory_request: Memory request for runtime pods+ resource_memory_limit: Memory limit for runtime pods+ image_pull_secret: Optional name of image pull secret for private registries+ ingress_tls_secret: Optional name of TLS secret for ingress+ node_selector_key: Optional node selector key for pod scheduling+ node_selector_val: Optional node selector value for pod scheduling+ tolerations_yaml: Optional YAML string defining pod tolerations+ """++ namespace: str = Field(+ default='default',+ description='The Kubernetes namespace to use for OpenHands resources',+ )+ ingress_domain: str = Field(+ default='localhost', description='Domain for ingress resources'+ )+ pvc_storage_size: str = Field(+ default='2Gi', description='Size of the persistent volume claim'+ )+ pvc_storage_class: str | None = Field(+ default=None, description='Storage class for persistent volume claims'+ )+ resource_cpu_request: str = Field(+ default='1', description='CPU request for runtime pods'+ )+ resource_memory_request: str = Field(+ default='1Gi', description='Memory request for runtime pods'+ )+ resource_memory_limit: str = Field(+ default='2Gi', description='Memory limit for runtime pods'+ )+ image_pull_secret: str | None = Field(+ default=None,+ description='Optional name of image pull secret for private registries',+ )+ ingress_tls_secret: str | None = Field(+ default=None, description='Optional name of TLS secret for ingress'+ )+ node_selector_key: str | None = Field(+ default=None, description='Optional node selector key for pod scheduling'+ )+ node_selector_val: str | None = Field(+ default=None, description='Optional node selector value for pod scheduling'+ )+ tolerations_yaml: str | None = Field(+ default=None, description='Optional YAML string defining pod tolerations'+ )+ privileged: bool = Field(+ default=False,+ description='Run the runtime sandbox container in privileged mode for use with docker-in-docker',+ )++ model_config = {'extra': 'forbid'}++ @classmethod+ def from_toml_section(cls, data: dict) -> dict[str, 'KubernetesConfig']:+ """+ Create a mapping of KubernetesConfig instances from a toml dictionary representing the [kubernetes] section.++ The configuration is built from all keys in data.++ Returns:+ dict[str, KubernetesConfig]: A mapping where the key "kubernetes" corresponds to the [kubernetes] configuration+ """+ # Initialize the result mapping+ kubernetes_mapping: dict[str, KubernetesConfig] = {}++ # Try to create the configuration instance+ try:+ kubernetes_mapping['kubernetes'] = cls.model_validate(data)+ except ValidationError as e:+ raise ValueError(f'Invalid kubernetes configuration: {e}')++ return kubernetes_mappingdiff --git a/openhands/core/config/openhands_config.py b/openhands/core/config/openhands_config.pyindex a387426eac..83b8af1464 100644--- a/openhands/core/config/openhands_config.py+++ b/openhands/core/config/openhands_config.py@@ -11,6 +11,7 @@ from openhands.core.config.config_utils import (model_defaults_to_dict,)from openhands.core.config.extended_config import ExtendedConfig+from openhands.core.config.kubernetes_config import KubernetesConfigfrom openhands.core.config.llm_config import LLMConfigfrom openhands.core.config.mcp_config import MCPConfigfrom openhands.core.config.sandbox_config import SandboxConfig@@ -107,6 +108,7 @@ class OpenHandsConfig(BaseModel):) # Maximum number of concurrent agent loops allowed per usermcp_host: str = Field(default=f'localhost:{os.getenv("port", 3000)}')mcp: MCPConfig = Field(default_factory=MCPConfig)+ kubernetes: KubernetesConfig = Field(default_factory=KubernetesConfig)defaults_dict: ClassVar[dict] = {}diff --git a/openhands/core/config/utils.py b/openhands/core/config/utils.pyindex b63f9063a6..9507226b19 100644--- a/openhands/core/config/utils.py+++ b/openhands/core/config/utils.py@@ -25,6 +25,7 @@ from openhands.core.config.config_utils import (OH_MAX_ITERATIONS,)from openhands.core.config.extended_config import ExtendedConfig+from openhands.core.config.kubernetes_config import KubernetesConfigfrom openhands.core.config.llm_config import LLMConfigfrom openhands.core.config.mcp_config import MCPConfigfrom openhands.core.config.openhands_config import OpenHandsConfig@@ -228,6 +229,19 @@ def load_from_toml(cfg: OpenHandsConfig, toml_file: str = 'config.toml') -> None# Re-raise ValueError from MCPConfig.from_toml_sectionraise ValueError('Error in MCP sections in config.toml')+ # Process kubernetes section if present+ if 'kubernetes' in toml_config:+ try:+ kubernetes_mapping = KubernetesConfig.from_toml_section(+ toml_config['kubernetes']+ )+ if 'kubernetes' in kubernetes_mapping:+ cfg.kubernetes = kubernetes_mapping['kubernetes']+ except (TypeError, KeyError, ValidationError) as e:+ logger.openhands_logger.warning(+ f'Cannot parse [kubernetes] config from toml, values have not been applied.\nError: {e}'+ )+# Process condenser section if presentif 'condenser' in toml_config:try:@@ -286,6 +300,7 @@ def load_from_toml(cfg: OpenHandsConfig, toml_file: str = 'config.toml') -> None'sandbox','condenser','mcp',+ 'kubernetes',}for key in toml_config:if key.lower() not in known_sections:diff --git a/openhands/runtime/__init__.py b/openhands/runtime/__init__.pyindex 5324ca3322..45f539ef2c 100644--- a/openhands/runtime/__init__.py+++ b/openhands/runtime/__init__.py@@ -5,6 +5,7 @@ from openhands.runtime.impl.docker.docker_runtime import (DockerRuntime,)from openhands.runtime.impl.e2b.e2b_runtime import E2BRuntime+from openhands.runtime.impl.kubernetes.kubernetes_runtime import KubernetesRuntimefrom openhands.runtime.impl.local.local_runtime import LocalRuntimefrom openhands.runtime.impl.modal.modal_runtime import ModalRuntimefrom openhands.runtime.impl.remote.remote_runtime import RemoteRuntime@@ -21,6 +22,7 @@ _DEFAULT_RUNTIME_CLASSES: dict[str, type[Runtime]] = {'runloop': RunloopRuntime,'local': LocalRuntime,'daytona': DaytonaRuntime,+ 'kubernetes': KubernetesRuntime,'cli': CLIRuntime,}@@ -50,6 +52,7 @@ __all__ = ['RunloopRuntime','DockerRuntime','DaytonaRuntime',+ 'KubernetesRuntime','CLIRuntime','get_runtime_cls',]diff --git a/openhands/runtime/impl/kubernetes/README.md b/openhands/runtime/impl/kubernetes/README.mdnew file mode 100644index 0000000000..d58e090435--- /dev/null+++ b/openhands/runtime/impl/kubernetes/README.md@@ -0,0 +1,141 @@+# OpenHands Kubernetes Runtime++This directory contains the Kubernetes runtime implementation for OpenHands, which allows the software to run on Kubernetes clusters for scalable and isolated execution environments.++## Local Development with KIND++For local development and testing, OpenHands provides a convenient setup using KIND (Kubernetes IN Docker) that creates a local Kubernetes cluster.++### Prerequisites++Before setting up the local Kubernetes environment, ensure you have the following tools installed:++1. **KIND (Kubernetes IN Docker)** - [Installation Guide](https://kind.sigs.k8s.io/docs/user/quick-start/)++2. **kubectl** - [Installation Guide](https://kubernetes.io/docs/tasks/tools/#kubectl)++3. **mirrord** - [Installation Guide](https://metalbear.co/mirrord/docs/overview/quick-start/#installation)++ MirrorD is used for network mirroring allowing the locally running process to interact with the kubernetes cluster as if it were running inside of kubernetes.++4. **Docker or Podman** - Required for KIND to work+ - Docker: Follow the official Docker installation guide for your platform+ - Podman: [Installation Guide](https://podman.io/docs/installation)++### Configuration++To use the Kubernetes runtime, you need to configure OpenHands properly. The configuration is done through a TOML configuration file.++#### Required Configuration++Two configuration options are required to use the Kubernetes runtime:++1. **Runtime Type**: Set the runtime to use Kubernetes++ ```toml+ [core]+ runtime = "kubernetes"+ ```++2. **Runtime Container Image**: Specify the container image to use for the runtime environment+ ```toml+ [sandbox]+ runtime_container_image = "docker.all-hands.dev/all-hands-ai/runtime:0.44-nikolaik"+ ```++#### Additional Kubernetes Options++OpenHands provides extensive configuration options for Kubernetes deployments under the `[kubernetes]` section. These options allow you to customize:++- Kubernetes namespace+- Persistent volume configuration+- Ingress and networking settings+- Runtime Pod Security settings+- Resource limits and requests++For a complete list of available Kubernetes configuration options, refer to the `[kubernetes]` section in the `config.template.toml` file in the repository root.++## Local Development Setup++### Quick Start++To set up and run OpenHands with the Kubernetes runtime locally:++First build the application with++```bash+make build+```++Then++```bash+make kind # target is stateless and will check for an existing kind cluster or make a new one if not present.+```++This command will:++1. **Check Dependencies**: Verify that `kind`, `kubectl`, and `mirrord` are installed+2. **Create KIND Cluster**: Create a local Kubernetes cluster named "local-hands" using the configuration in `kind/cluster.yaml`+3. **Deploy Infrastructure**: Apply Kubernetes manifests including:+ - Ubuntu development pod for runtime execution+ - Nginx ingress controller for HTTP routing+ - RBAC configurations for proper permissions+4. **Setup Mirrord**: Install mirrord resources for development workflow+5. **Run Application**: Execute `make run` inside the mirrord environment++### Cluster Configuration++The KIND cluster is configured with:++- **Cluster Name**: `local-hands`+- **Node Configuration**: Single control-plane node+- **Port Mapping**: Host port 80 maps to container port 80 for nginx ingress+- **Base Image**: Ubuntu 22.04 for the development environment++### Infrastructure Components++The local setup includes several Kubernetes resources:++#### Development Environment++- **Deployment**: `ubuntu-dev` - Ubuntu 22.04 container for code execution+- **Service**: Exposes the development environment within the cluster++#### Ingress Controller (Nginx)++- **Namespace**: `ingress-nginx` - Dedicated namespace for ingress resources+- **Deployment**: `ingress-nginx-controller` - Handles HTTP routing and load balancing+- **Service**: LoadBalancer service for external access+- **ConfigMap**: Custom configuration for nginx controller+- **RBAC**: Roles and bindings for proper cluster permissions++#### Development Workflow++- **Mirrord Integration**: Allows running local development server while connecting to cluster resources+- **Port Forwarding**: Direct access to cluster services from localhost++### Usage++Once the environment is set up with `make kind`, the system will:++1. Wait for all deployments to be ready+2. Automatically start the OpenHands application using mirrord+3. Provide access to the application at http://127.0.0.1:3000/++The mirrord integration allows you to develop locally while your application has access to the Kubernetes cluster resources, providing a seamless development experience that mirrors production behavior.++### Troubleshooting++If you encounter issues:++1. **Check cluster status**: `kubectl get nodes`+2. **Verify deployments**: `kubectl get deployments --all-namespaces`+3. **Check ingress**: `kubectl get ingress --all-namespaces`+4. **View logs**: `kubectl logs -l app=ubuntu-dev`++To clean up the environment:++```bash+kind delete cluster --name local-hands+```diff --git a/openhands/runtime/impl/kubernetes/kubernetes_runtime.py b/openhands/runtime/impl/kubernetes/kubernetes_runtime.pynew file mode 100644index 0000000000..fb11631b3f--- /dev/null+++ b/openhands/runtime/impl/kubernetes/kubernetes_runtime.py@@ -0,0 +1,752 @@+from functools import lru_cache+from typing import Callable+from uuid import UUID++import tenacity+import yaml+from kubernetes import client, config+from kubernetes.client.models import (+ V1Container,+ V1ContainerPort,+ V1EnvVar,+ V1HTTPIngressPath,+ V1HTTPIngressRuleValue,+ V1Ingress,+ V1IngressBackend,+ V1IngressRule,+ V1IngressServiceBackend,+ V1IngressSpec,+ V1IngressTLS,+ V1ObjectMeta,+ V1PersistentVolumeClaim,+ V1PersistentVolumeClaimSpec,+ V1PersistentVolumeClaimVolumeSource,+ V1Pod,+ V1PodSpec,+ V1ResourceRequirements,+ V1SecurityContext,+ V1Service,+ V1ServiceBackendPort,+ V1ServicePort,+ V1ServiceSpec,+ V1Toleration,+ V1Volume,+ V1VolumeMount,+)++from openhands.core.config import OpenHandsConfig+from openhands.core.exceptions import (+ AgentRuntimeDisconnectedError,+ AgentRuntimeNotFoundError,+)+from openhands.core.logger import DEBUG+from openhands.core.logger import openhands_logger as logger+from openhands.events import EventStream+from openhands.integrations.provider import PROVIDER_TOKEN_TYPE+from openhands.runtime.impl.action_execution.action_execution_client import (+ ActionExecutionClient,+)+from openhands.runtime.plugins import PluginRequirement+from openhands.runtime.runtime_status import RuntimeStatus+from openhands.runtime.utils.command import get_action_execution_server_startup_command+from openhands.utils.async_utils import call_sync_from_async+from openhands.utils.shutdown_listener import add_shutdown_listener+from openhands.utils.tenacity_stop import stop_if_should_exit++POD_NAME_PREFIX = 'openhands-runtime-'+POD_LABEL = 'openhands-runtime'+++class KubernetesRuntime(ActionExecutionClient):+ """+ A Kubernetes runtime for OpenHands that works with Kind.++ This runtime creates pods in a Kubernetes cluster to run the agent code.+ It uses the Kubernetes Python client to create and manage the pods.++ Args:+ config (OpenHandsConfig): The application configuration.+ event_stream (EventStream): The event stream to subscribe to.+ sid (str, optional): The session ID. Defaults to 'default'.+ plugins (list[PluginRequirement] | None, optional): List of plugin requirements. Defaults to None.+ env_vars (dict[str, str] | None, optional): Environment variables to set. Defaults to None.+ status_callback (Callable | None, optional): Callback for status updates. Defaults to None.+ attach_to_existing (bool, optional): Whether to attach to an existing pod. Defaults to False.+ headless_mode (bool, optional): Whether to run in headless mode. Defaults to True.+ """++ _shutdown_listener_id: UUID | None = None+ _namespace: str = ''++ def __init__(+ self,+ config: OpenHandsConfig,+ event_stream: EventStream,+ sid: str = 'default',+ plugins: list[PluginRequirement] | None = None,+ env_vars: dict[str, str] | None = None,+ status_callback: Callable | None = None,+ attach_to_existing: bool = False,+ headless_mode: bool = True,+ user_id: str | None = None,+ git_provider_tokens: PROVIDER_TOKEN_TYPE | None = None,+ ):+ if not KubernetesRuntime._shutdown_listener_id:+ KubernetesRuntime._shutdown_listener_id = add_shutdown_listener(+ lambda: KubernetesRuntime._cleanup_k8s_resources(+ namespace=self._k8s_namespace,+ remove_pvc=True,+ conversation_id=self.sid,+ ) # this is when you ctrl+c.+ )+ self.config = config+ self._runtime_initialized: bool = False+ self.status_callback = status_callback++ # Load and validate Kubernetes configuration+ if self.config.kubernetes is None:+ raise ValueError(+ 'Kubernetes configuration is required when using KubernetesRuntime. '+ 'Please add a [kubernetes] section to your configuration.'+ )++ self._k8s_config = self.config.kubernetes+ self._k8s_namespace = self._k8s_config.namespace+ KubernetesRuntime._namespace = self._k8s_namespace++ # Initialize ports with default values in the required range+ self._container_port = 8080 # Default internal container port+ self._vscode_port = 8081 # Default VSCode port.+ self._app_ports: list[int] = [+ 30082,+ 30083,+ ] # Default app ports in valid range # The agent prefers these when exposing an application.++ self.k8s_client, self.k8s_networking_client = self._init_kubernetes_client()++ self.pod_image = self.config.sandbox.runtime_container_image+ if not self.pod_image:+ # If runtime_container_image isn't set, use the base_container_image as a fallback+ self.pod_image = self.config.sandbox.base_container_image++ self.pod_name = POD_NAME_PREFIX + sid++ # Initialize the API URL with the initial port value+ self.k8s_local_url = f'http://{self._get_svc_name(self.pod_name)}.{self._k8s_namespace}.svc.cluster.local'+ self.api_url = f'{self.k8s_local_url}:{self._container_port}'++ super().__init__(+ config,+ event_stream,+ sid,+ plugins,+ env_vars,+ status_callback,+ attach_to_existing,+ headless_mode,+ user_id,+ git_provider_tokens,+ )++ @staticmethod+ def _get_svc_name(pod_name: str) -> str:+ """Get the service name for the pod."""+ return f'{pod_name}-svc'++ @staticmethod+ def _get_vscode_svc_name(pod_name: str) -> str:+ """Get the VSCode service name for the pod."""+ return f'{pod_name}-svc-code'++ @staticmethod+ def _get_vscode_ingress_name(pod_name: str) -> str:+ """Get the VSCode ingress name for the pod."""+ return f'{pod_name}-ingress-code'++ @staticmethod+ def _get_vscode_tls_secret_name(pod_name: str) -> str:+ """Get the TLS secret name for the VSCode ingress."""+ return f'{pod_name}-tls-secret'++ @staticmethod+ def _get_pvc_name(pod_name: str) -> str:+ """Get the PVC name for the pod."""+ return f'{pod_name}-pvc'++ @staticmethod+ def _get_pod_name(sid: str) -> str:+ """Get the pod name for the session."""+ return POD_NAME_PREFIX + sid++ @property+ def action_execution_server_url(self):+ return self.api_url++ @property+ def node_selector(self) -> dict[str, str] | None:+ if (+ not self._k8s_config.node_selector_key+ or not self._k8s_config.node_selector_val+ ):+ return None+ return {self._k8s_config.node_selector_key: self._k8s_config.node_selector_val}++ @property+ def tolerations(self) -> list[V1Toleration] | None:+ if not self._k8s_config.tolerations_yaml:+ return None+ tolerations_yaml_str = self._k8s_config.tolerations_yaml+ tolerations = []+ try:+ tolerations_data = yaml.safe_load(tolerations_yaml_str)+ if isinstance(tolerations_data, list):+ for toleration in tolerations_data:+ tolerations.append(V1Toleration(**toleration))+ else:+ logger.error(+ f'Invalid tolerations format. Should be type list: {tolerations_yaml_str}. Expected a list.'+ )+ return None+ except yaml.YAMLError as e:+ logger.error(+ f'Error parsing tolerations YAML: {tolerations_yaml_str}. Error: {e}'+ )+ return None+ return tolerations++ async def connect(self):+ """Connect to the runtime by creating or attaching to a pod."""+ self.log('info', f'Connecting to runtime with conversation ID: {self.sid}')+ self.log('info', f'self._attach_to_existing: {self.attach_to_existing}')+ self.set_runtime_status(RuntimeStatus.STARTING_RUNTIME)+ self.log('info', f'Using API URL {self.api_url}')++ try:+ await call_sync_from_async(self._attach_to_pod)+ except client.rest.ApiException as e:+ # we are not set to attach to existing, ignore error and init k8s resources.+ if self.attach_to_existing:+ self.log(+ 'error',+ f'Pod {self.pod_name} not found or cannot connect to it.',+ )+ raise AgentRuntimeDisconnectedError from e++ self.log('info', f'Starting runtime with image: {self.pod_image}')+ try:+ await call_sync_from_async(self._init_k8s_resources)+ self.log(+ 'info',+ f'Pod started: {self.pod_name}. VSCode URL: {self.vscode_url}',+ )+ except Exception as init_error:+ self.log('error', f'Failed to initialize k8s resources: {init_error}')+ raise AgentRuntimeNotFoundError(+ f'Failed to initialize kubernetes resources: {init_error}'+ ) from init_error++ if not self.attach_to_existing:+ self.log('info', 'Waiting for pod to become ready ...')+ self.set_runtime_status(RuntimeStatus.STARTING_RUNTIME)+ try:+ await call_sync_from_async(self._wait_until_ready)+ except Exception as alive_error:+ self.log('error', f'Failed to connect to runtime: {alive_error}')+ self.send_error_message(+ 'ERROR$RUNTIME_CONNECTION',+ f'Failed to connect to runtime: {alive_error}',+ )+ raise AgentRuntimeDisconnectedError(+ f'Failed to connect to runtime: {alive_error}'+ ) from alive_error++ if not self.attach_to_existing:+ self.log('info', 'Runtime is ready.')++ if not self.attach_to_existing:+ await call_sync_from_async(self.setup_initial_env)++ self.log(+ 'info',+ f'Pod initialized with plugins: {[plugin.name for plugin in self.plugins]}. VSCode URL: {self.vscode_url}',+ )+ if not self.attach_to_existing:+ self.set_runtime_status(RuntimeStatus.READY)+ self._runtime_initialized = True++ def _attach_to_pod(self):+ """Attach to an existing pod."""+ try:+ pod = self.k8s_client.read_namespaced_pod(+ name=self.pod_name, namespace=self._k8s_namespace+ )++ if pod.status.phase != 'Running':+ try:+ self._wait_until_ready()+ except TimeoutError:+ raise AgentRuntimeDisconnectedError(+ f'Pod {self.pod_name} exists but failed to become ready.'+ )++ self.log('info', f'Successfully attached to pod {self.pod_name}')+ return True++ except client.rest.ApiException as e:+ self.log('error', f'Failed to attach to pod: {e}')+ raise++ @tenacity.retry(+ stop=tenacity.stop_after_delay(300) | stop_if_should_exit(),+ retry=tenacity.retry_if_exception_type(TimeoutError),+ reraise=True,+ wait=tenacity.wait_fixed(2),+ )+ def _wait_until_ready(self):+ """Wait until the runtime server is alive by checking the pod status in Kubernetes."""+ self.log('info', f'Checking if pod {self.pod_name} is ready in Kubernetes')+ pod = self.k8s_client.read_namespaced_pod(+ name=self.pod_name, namespace=self._k8s_namespace+ )+ if pod.status.phase == 'Running' and pod.status.conditions:+ for condition in pod.status.conditions:+ if condition.type == 'Ready' and condition.status == 'True':+ self.log('info', f'Pod {self.pod_name} is ready!')+ return True # Exit the function if the pod is ready++ self.log(+ 'info',+ f'Pod {self.pod_name} is not ready yet. Current phase: {pod.status.phase}',+ )+ raise TimeoutError(f'Pod {self.pod_name} is not in Running state yet.')++ @staticmethod+ @lru_cache(maxsize=1)+ def _init_kubernetes_client() -> tuple[client.CoreV1Api, client.NetworkingV1Api]:+ """Initialize the Kubernetes client."""+ try:+ config.load_incluster_config() # Even local usage with mirrord technically uses an incluster config.+ return client.CoreV1Api(), client.NetworkingV1Api()+ except Exception as ex:+ logger.error(+ 'Failed to initialize Kubernetes client. Make sure you have kubectl configured correctly or are running in a Kubernetes cluster.',+ )+ raise ex++ @staticmethod+ def _cleanup_k8s_resources(+ namespace: str, remove_pvc: bool = False, conversation_id: str = ''+ ):+ """Clean up Kubernetes resources with our prefix in the namespace.++ :param remove_pvc: If True, also remove persistent volume claims (defaults to False).+ """+ try:+ k8s_api, k8s_networking_api = KubernetesRuntime._init_kubernetes_client()++ pod_name = KubernetesRuntime._get_pod_name(conversation_id)+ service_name = KubernetesRuntime._get_svc_name(pod_name)+ vscode_service_name = KubernetesRuntime._get_vscode_svc_name(pod_name)+ ingress_name = KubernetesRuntime._get_vscode_ingress_name(pod_name)+ pvc_name = KubernetesRuntime._get_pvc_name(pod_name)++ try:+ if remove_pvc:+ # Delete PVC if requested+ k8s_api.delete_namespaced_persistent_volume_claim(+ name=pvc_name,+ namespace=namespace,+ body=client.V1DeleteOptions(),+ )+ logger.info(f'Deleted PVC {pvc_name}')++ k8s_api.delete_namespaced_pod(+ name=pod_name,+ namespace=namespace,+ body=client.V1DeleteOptions(),+ )+ logger.info(f'Deleted pod {pod_name}')++ k8s_api.delete_namespaced_service(+ name=service_name,+ namespace=namespace,+ )+ logger.info(f'Deleted service {service_name}')+ # Delete the vs code service+ k8s_api.delete_namespaced_service(+ name=vscode_service_name, namespace=namespace+ )+ logger.info(f'Deleted service {vscode_service_name}')++ k8s_networking_api.delete_namespaced_ingress(+ name=ingress_name, namespace=namespace+ )+ logger.info(f'Deleted ingress {ingress_name}')+ except client.rest.ApiException:+ # Service might not exist, ignore+ pass+ logger.info('Cleaned up Kubernetes resources')+ except Exception as e:+ logger.error(f'Error cleaning up k8s resources: {e}')++ def _get_pvc_manifest(self):+ """Create a PVC manifest for the runtime pod."""+ # Create PVC+ pvc = V1PersistentVolumeClaim(+ api_version='v1',+ kind='PersistentVolumeClaim',+ metadata=V1ObjectMeta(+ name=self._get_pvc_name(self.pod_name), namespace=self._k8s_namespace+ ),+ spec=V1PersistentVolumeClaimSpec(+ access_modes=['ReadWriteOnce'],+ resources=client.V1ResourceRequirements(+ requests={'storage': self._k8s_config.pvc_storage_size}+ ),+ storage_class_name=self._k8s_config.pvc_storage_class,+ ),+ )++ return pvc++ def _get_vscode_service_manifest(self):+ """Create a service manifest for the VSCode server."""++ vscode_service_spec = V1ServiceSpec(+ selector={'app': POD_LABEL, 'session': self.sid},+ type='ClusterIP',+ ports=[+ V1ServicePort(+ port=self._vscode_port,+ target_port='vscode',+ name='code',+ )+ ],+ )++ vscode_service = V1Service(+ metadata=V1ObjectMeta(name=self._get_vscode_svc_name(self.pod_name)),+ spec=vscode_service_spec,+ )+ return vscode_service++ def _get_runtime_service_manifest(self):+ """Create a service manifest for the runtime pod execution-server."""+ service_spec = V1ServiceSpec(+ selector={'app': POD_LABEL, 'session': self.sid},+ type='ClusterIP',+ ports=[+ V1ServicePort(+ port=self._container_port,+ target_port='http',+ name='execution-server',+ )+ ],+ )++ service = V1Service(+ metadata=V1ObjectMeta(name=self._get_svc_name(self.pod_name)),+ spec=service_spec,+ )+ return service++ def _get_runtime_pod_manifest(self):+ """Create a pod manifest for the runtime sandbox."""+ # Prepare environment variables+ environment = [+ V1EnvVar(name='port', value=str(self._container_port)),+ V1EnvVar(name='PYTHONUNBUFFERED', value='1'),+ V1EnvVar(name='VSCODE_PORT', value=str(self._vscode_port)),+ ]++ if self.config.debug or DEBUG:+ environment.append(V1EnvVar(name='DEBUG', value='true'))++ # Add runtime startup env vars+ for key, value in self.config.sandbox.runtime_startup_env_vars.items():+ environment.append(V1EnvVar(name=key, value=value))++ # Prepare volume mounts if workspace is configured+ volume_mounts = [+ V1VolumeMount(+ name='workspace-volume',+ mount_path=self.config.workspace_mount_path_in_sandbox,+ ),+ ]+ volumes = [+ V1Volume(+ name='workspace-volume',+ persistent_volume_claim=V1PersistentVolumeClaimVolumeSource(+ claim_name=self._get_pvc_name(self.pod_name)+ ),+ )+ ]++ # Prepare container ports+ container_ports = [+ V1ContainerPort(container_port=self._container_port, name='http'),+ ]++ if self.vscode_enabled:+ container_ports.append(+ V1ContainerPort(container_port=self._vscode_port, name='vscode')+ )++ for port in self._app_ports:+ container_ports.append(V1ContainerPort(container_port=port))++ # Define the readiness probe+ health_check = client.V1Probe(+ http_get=client.V1HTTPGetAction(+ path='/alive',+ port=self._container_port, # Or the port your application listens on+ ),+ initial_delay_seconds=5, # Adjust as needed+ period_seconds=10, # Adjust as needed+ timeout_seconds=5, # Adjust as needed+ success_threshold=1,+ failure_threshold=3,+ )+ # Prepare command+ # Entry point command for generated sandbox runtime pod.+ command = get_action_execution_server_startup_command(+ server_port=self._container_port,+ plugins=self.plugins,+ app_config=self.config,+ override_user_id=0, # if we use the default of app_config.run_as_openhands then we cant edit files in vscode due to file perms.+ override_username='root',+ )++ # Prepare resource requirements based on config+ resources = V1ResourceRequirements(+ limits={'memory': self._k8s_config.resource_memory_limit},+ requests={+ 'cpu': self._k8s_config.resource_cpu_request,+ 'memory': self._k8s_config.resource_memory_request,+ },+ )++ # Set security context for the container+ security_context = V1SecurityContext(privileged=self._k8s_config.privileged)++ # Create the container definition+ container = V1Container(+ name='runtime',+ image=self.pod_image,+ command=command,+ env=environment,+ ports=container_ports,+ volume_mounts=volume_mounts,+ working_dir='/openhands/code/',+ resources=resources,+ readiness_probe=health_check,+ security_context=security_context,+ )++ # Create the pod definition+ image_pull_secrets = None+ if self._k8s_config.image_pull_secret:+ image_pull_secrets = [+ client.V1LocalObjectReference(name=self._k8s_config.image_pull_secret)+ ]+ pod = V1Pod(+ metadata=V1ObjectMeta(+ name=self.pod_name, labels={'app': POD_LABEL, 'session': self.sid}+ ),+ spec=V1PodSpec(+ containers=[container],+ volumes=volumes,+ restart_policy='Never',+ image_pull_secrets=image_pull_secrets,+ node_selector=self.node_selector,+ tolerations=self.tolerations,+ ),+ )++ return pod++ def _get_vscode_ingress_manifest(self):+ """Create an ingress manifest for the VSCode server."""++ tls = []+ if self._k8s_config.ingress_tls_secret:+ runtime_tls = V1IngressTLS(+ hosts=[self.ingress_domain],+ secret_name=self._k8s_config.ingress_tls_secret,+ )+ tls = [runtime_tls]++ rules = [+ V1IngressRule(+ host=self.ingress_domain,+ http=V1HTTPIngressRuleValue(+ paths=[+ V1HTTPIngressPath(+ path='/',+ path_type='Prefix',+ backend=V1IngressBackend(+ service=V1IngressServiceBackend(+ port=V1ServiceBackendPort(+ number=self._vscode_port,+ ),+ name=self._get_vscode_svc_name(self.pod_name),+ )+ ),+ )+ ]+ ),+ )+ ]+ ingress_spec = V1IngressSpec(rules=rules, tls=tls)++ ingress = V1Ingress(+ api_version='networking.k8s.io/v1',+ metadata=V1ObjectMeta(+ name=self._get_vscode_ingress_name(self.pod_name),+ annotations={+ 'external-dns.alpha.kubernetes.io/hostname': self.ingress_domain+ },+ ),+ spec=ingress_spec,+ )++ return ingress++ def _pvc_exists(self):+ """Check if the PVC already exists."""+ try:+ pvc = self.k8s_client.read_namespaced_persistent_volume_claim(+ name=self._get_pvc_name(self.pod_name), namespace=self._k8s_namespace+ )+ return pvc is not None+ except client.rest.ApiException as e:+ if e.status == 404:+ return False+ self.log('error', f'Error checking PVC existence: {e}')++ def _init_k8s_resources(self):+ """Initialize the Kubernetes resources."""+ self.log('info', 'Preparing to start pod...')+ self.set_runtime_status(RuntimeStatus.STARTING_RUNTIME)++ self.log('info', f'Runtime will be accessible at {self.api_url}')++ pod = self._get_runtime_pod_manifest()+ service = self._get_runtime_service_manifest()+ vscode_service = self._get_vscode_service_manifest()+ pvc_manifest = self._get_pvc_manifest()+ ingress = self._get_vscode_ingress_manifest()++ # Create the pod in Kubernetes+ try:+ if not self._pvc_exists():+ # Create PVC if it doesn't exist+ self.k8s_client.create_namespaced_persistent_volume_claim(+ namespace=self._k8s_namespace, body=pvc_manifest+ )+ self.log('info', f'Created PVC {self._get_pvc_name(self.pod_name)}')+ self.k8s_client.create_namespaced_pod(+ namespace=self._k8s_namespace, body=pod+ )+ self.log('info', f'Created pod {self.pod_name}.')+ # Create a service to expose the pod for external access+ self.k8s_client.create_namespaced_service(+ namespace=self._k8s_namespace, body=service+ )+ self.log('info', f'Created service {self._get_svc_name(self.pod_name)}')++ # Create second service service for the vscode server.+ self.k8s_client.create_namespaced_service(+ namespace=self._k8s_namespace, body=vscode_service+ )+ self.log(+ 'info', f'Created service {self._get_vscode_svc_name(self.pod_name)}'+ )++ # create the vscode ingress.+ self.k8s_networking_client.create_namespaced_ingress(+ namespace=self._k8s_namespace, body=ingress+ )+ self.log(+ 'info',+ f'Created ingress {self._get_vscode_ingress_name(self.pod_name)}',+ )++ # Wait for the pod to be running+ self._wait_until_ready()++ except client.rest.ApiException as e:+ self.log('error', f'Failed to create pod and services: {e}')+ raise+ except RuntimeError as e:+ self.log('error', f'Port forwarding failed: {e}')+ raise++ def close(self):+ """Close the runtime and clean up resources."""+ # this is called when a single conversation question is answered or a tab is closed.+ self.log(+ 'info',+ f'Closing runtime and cleaning up resources for conersation ID: {self.sid}',+ )+ # Call parent class close method first+ super().close()++ # Return early if we should keep the runtime alive or if we're attaching to existing+ if self.config.sandbox.keep_runtime_alive or self.attach_to_existing:+ self.log(+ 'info', 'Keeping runtime alive due to configuration or attach mode'+ )+ return++ try:+ self._cleanup_k8s_resources(+ namespace=self._k8s_namespace,+ remove_pvc=False,+ conversation_id=self.sid,+ )+ except Exception as e:+ self.log('error', f'Error closing runtime: {e}')++ @property+ def ingress_domain(self) -> str:+ """Get the ingress domain for the runtime."""+ return f'{self.sid}.{self._k8s_config.ingress_domain}'++ @property+ def vscode_url(self) -> str | None:+ """Get the URL for VSCode server if enabled."""+ if not self.vscode_enabled:+ return None+ token = super().get_vscode_token()+ if not token:+ return None++ protocol = 'https' if self._k8s_config.ingress_tls_secret else 'http'+ vscode_url = f'{protocol}://{self.ingress_domain}/?tkn={token}&folder={self.config.workspace_mount_path_in_sandbox}'+ self.log('info', f'VSCode URL: {vscode_url}')+ return vscode_url++ @property+ def web_hosts(self) -> dict[str, int]:+ """Get web hosts dict mapping for browser access."""+ hosts = {}+ for idx, port in enumerate(self._app_ports):+ hosts[f'{self.k8s_local_url}:{port}'] = port+ return hosts++ @classmethod+ async def delete(cls, conversation_id: str):+ """Delete resources associated with a conversation."""+ # This is triggered when you actually do the delete in the UI on the convo.+ try:+ cls._cleanup_k8s_resources(+ namespace=cls._namespace,+ remove_pvc=True,+ conversation_id=conversation_id,+ )++ except Exception as e:+ logger.error(+ f'Error deleting resources for conversation {conversation_id}: {e}'+ )diff --git a/poetry.lock b/poetry.lockindex 447235a7f2..6d48e97e7a 100644--- a/poetry.lock+++ b/poetry.lock@@ -1,4 +1,4 @@-# This file is automatically @generated by Poetry 2.1.3 and should not be changed by hand.+# This file is automatically @generated by Poetry 2.1.1 and should not be changed by hand.[[package]]name = "aioboto3"@@ -462,7 +462,7 @@ description = "LTS Port of Python audioop"optional = falsepython-versions = ">=3.13"groups = ["main"]-markers = "python_version == \"3.13\""+markers = "python_version >= \"3.13\""files = [{file = "audioop_lts-0.2.1-cp313-abi3-macosx_10_13_universal2.whl", hash = "sha256:fd1345ae99e17e6910f47ce7d52673c6a1a70820d78b67de1b7abb3af29c426a"},{file = "audioop_lts-0.2.1-cp313-abi3-macosx_10_13_x86_64.whl", hash = "sha256:e175350da05d2087e12cea8e72a70a1a8b14a17e92ed2022952a4419689ede5e"},@@ -2299,6 +2299,18 @@ https = ["urllib3 (>=1.24.1)"]paramiko = ["paramiko"]pgp = ["gpg"]+[[package]]+name = "durationpy"+version = "0.10"+description = "Module for converting between datetime.timedelta and Go's Duration strings."+optional = false+python-versions = "*"+groups = ["main"]+files = [+ {file = "durationpy-0.10-py3-none-any.whl", hash = "sha256:3b41e1b601234296b4fb368338fdcd3e13e0b4fb5b67345948f4f2bf9868b286"},+ {file = "durationpy-0.10.tar.gz", hash = "sha256:1fa6893409a6e739c9c72334fc65cca1f355dbdd93405d30f726deb5bde42fba"},+]+[[package]]name = "e2b"version = "1.5.1"@@ -3039,8 +3051,8 @@ files = [google-api-core = {version = ">=1.34.1,<2.0.dev0 || >=2.11.dev0,<3.0.0dev", extras = ["grpc"]}google-auth = ">=2.14.1,<2.24.0 || >2.24.0,<2.25.0 || >2.25.0,<3.0.0dev"proto-plus = [- {version = ">=1.25.0,<2.0.0dev", markers = "python_version >= \"3.13\""},{version = ">=1.22.3,<2.0.0dev"},+ {version = ">=1.25.0,<2.0.0dev", markers = "python_version >= \"3.13\""},]protobuf = ">=3.20.2,<4.21.0 || >4.21.0,<4.21.1 || >4.21.1,<4.21.2 || >4.21.2,<4.21.3 || >4.21.3,<4.21.4 || >4.21.4,<4.21.5 || >4.21.5,<6.0.0dev"@@ -3062,8 +3074,8 @@ googleapis-common-protos = ">=1.56.2,<2.0.0"grpcio = {version = ">=1.49.1,<2.0.0", optional = true, markers = "python_version >= \"3.11\" and extra == \"grpc\""}grpcio-status = {version = ">=1.49.1,<2.0.0", optional = true, markers = "python_version >= \"3.11\" and extra == \"grpc\""}proto-plus = [- {version = ">=1.25.0,<2.0.0", markers = "python_version >= \"3.13\""},{version = ">=1.22.3,<2.0.0"},+ {version = ">=1.25.0,<2.0.0", markers = "python_version >= \"3.13\""},]protobuf = ">=3.19.5,<3.20.0 || >3.20.0,<3.20.1 || >3.20.1,<4.21.0 || >4.21.0,<4.21.1 || >4.21.1,<4.21.2 || >4.21.2,<4.21.3 || >4.21.3,<4.21.4 || >4.21.4,<4.21.5 || >4.21.5,<7.0.0"requests = ">=2.18.0,<3.0.0"@@ -3281,8 +3293,8 @@ google-api-core = {version = ">=1.34.1,<2.0.dev0 || >=2.11.dev0,<3.0.0", extrasgoogle-auth = ">=2.14.1,<2.24.0 || >2.24.0,<2.25.0 || >2.25.0,<3.0.0"grpc-google-iam-v1 = ">=0.14.0,<1.0.0"proto-plus = [- {version = ">=1.25.0,<2.0.0", markers = "python_version >= \"3.13\""},{version = ">=1.22.3,<2.0.0"},+ {version = ">=1.25.0,<2.0.0", markers = "python_version >= \"3.13\""},]protobuf = ">=3.20.2,<4.21.0 || >4.21.0,<4.21.1 || >4.21.1,<4.21.2 || >4.21.2,<4.21.3 || >4.21.3,<4.21.4 || >4.21.4,<4.21.5 || >4.21.5,<7.0.0"@@ -4788,6 +4800,34 @@ files = [{file = "kiwisolver-1.4.8.tar.gz", hash = "sha256:23d5f023bdc8c7e54eb65f03ca5d5bb25b601eac4d7f1a042888a1f45237987e"},]+[[package]]+name = "kubernetes"+version = "33.1.0"+description = "Kubernetes python client"+optional = false+python-versions = ">=3.6"+groups = ["main"]+files = [+ {file = "kubernetes-33.1.0-py2.py3-none-any.whl", hash = "sha256:544de42b24b64287f7e0aa9513c93cb503f7f40eea39b20f66810011a86eabc5"},+ {file = "kubernetes-33.1.0.tar.gz", hash = "sha256:f64d829843a54c251061a8e7a14523b521f2dc5c896cf6d65ccf348648a88993"},+]++[package.dependencies]+certifi = ">=14.05.14"+durationpy = ">=0.7"+google-auth = ">=1.0.1"+oauthlib = ">=3.2.2"+python-dateutil = ">=2.5.3"+pyyaml = ">=5.4.1"+requests = "*"+requests-oauthlib = "*"+six = ">=1.9.0"+urllib3 = ">=1.24.2"+websocket-client = ">=0.32.0,<0.40.0 || >0.40.0,<0.41.dev0 || >=0.43.dev0"++[package.extras]+adal = ["adal (>=1.0.2)"]+[[package]]name = "lazy-loader"version = "0.4"@@ -5146,11 +5186,8 @@ files = [{file = "lxml-5.4.0-cp36-cp36m-win_amd64.whl", hash = "sha256:7ce1a171ec325192c6a636b64c94418e71a1964f56d002cc28122fceff0b6121"},{file = "lxml-5.4.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:795f61bcaf8770e1b37eec24edf9771b307df3af74d1d6f27d812e15a9ff3872"},{file = "lxml-5.4.0-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:29f451a4b614a7b5b6c2e043d7b64a15bd8304d7e767055e8ab68387a8cacf4e"},- {file = "lxml-5.4.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:891f7f991a68d20c75cb13c5c9142b2a3f9eb161f1f12a9489c82172d1f133c0"},{file = "lxml-5.4.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4aa412a82e460571fad592d0f93ce9935a20090029ba08eca05c614f99b0cc92"},- {file = "lxml-5.4.0-cp37-cp37m-manylinux_2_28_aarch64.whl", hash = "sha256:ac7ba71f9561cd7d7b55e1ea5511543c0282e2b6450f122672a2694621d63b7e"},{file = "lxml-5.4.0-cp37-cp37m-manylinux_2_28_x86_64.whl", hash = "sha256:c5d32f5284012deaccd37da1e2cd42f081feaa76981f0eaa474351b68df813c5"},- {file = "lxml-5.4.0-cp37-cp37m-musllinux_1_2_aarch64.whl", hash = "sha256:ce31158630a6ac85bddd6b830cffd46085ff90498b397bd0a259f59d27a12188"},{file = "lxml-5.4.0-cp37-cp37m-musllinux_1_2_x86_64.whl", hash = "sha256:31e63621e073e04697c1b2d23fcb89991790eef370ec37ce4d5d469f40924ed6"},{file = "lxml-5.4.0-cp37-cp37m-win32.whl", hash = "sha256:be2ba4c3c5b7900246a8f866580700ef0d538f2ca32535e991027bdaba944063"},{file = "lxml-5.4.0-cp37-cp37m-win_amd64.whl", hash = "sha256:09846782b1ef650b321484ad429217f5154da4d6e786636c38e434fa32e94e49"},@@ -6544,8 +6581,8 @@ files = [[package.dependencies]googleapis-common-protos = ">=1.52,<2.0"grpcio = [- {version = ">=1.66.2,<2.0.0", markers = "python_version >= \"3.13\""},{version = ">=1.63.2,<2.0.0", markers = "python_version < \"3.13\""},+ {version = ">=1.66.2,<2.0.0", markers = "python_version >= \"3.13\""},]opentelemetry-api = ">=1.15,<2.0"opentelemetry-exporter-otlp-proto-common = "1.34.1"@@ -9308,6 +9345,7 @@ files = [{file = "setuptools-80.9.0-py3-none-any.whl", hash = "sha256:062d34222ad13e0cc312a4c02d73f059e86a4acbfbdea8f8f76b28c99f306922"},{file = "setuptools-80.9.0.tar.gz", hash = "sha256:f36b47402ecde768dbfafc46e8e4207b4360c654f1f3bb84475f0a28628fb19c"},]+markers = {evaluation = "platform_system == \"Linux\" and platform_machine == \"x86_64\""}[package.extras]check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1) ; sys_platform != \"cygwin\"", "ruff (>=0.8.0) ; sys_platform != \"cygwin\""]@@ -9550,7 +9588,7 @@ description = "Standard library aifc redistribution. \"dead battery\"."optional = falsepython-versions = "*"groups = ["main"]-markers = "python_version == \"3.13\""+markers = "python_version >= \"3.13\""files = [{file = "standard_aifc-3.13.0-py3-none-any.whl", hash = "sha256:f7ae09cc57de1224a0dd8e3eb8f73830be7c3d0bc485de4c1f82b4a7f645ac66"},{file = "standard_aifc-3.13.0.tar.gz", hash = "sha256:64e249c7cb4b3daf2fdba4e95721f811bde8bdfc43ad9f936589b7bb2fae2e43"},@@ -9567,7 +9605,7 @@ description = "Standard library chunk redistribution. \"dead battery\"."optional = falsepython-versions = "*"groups = ["main"]-markers = "python_version == \"3.13\""+markers = "python_version >= \"3.13\""files = [{file = "standard_chunk-3.13.0-py3-none-any.whl", hash = "sha256:17880a26c285189c644bd5bd8f8ed2bdb795d216e3293e6dbe55bbd848e2982c"},{file = "standard_chunk-3.13.0.tar.gz", hash = "sha256:4ac345d37d7e686d2755e01836b8d98eda0d1a3ee90375e597ae43aaf064d654"},@@ -10899,7 +10937,7 @@ version = "1.8.0"description = "WebSocket client for Python with low level API options"optional = falsepython-versions = ">=3.8"-groups = ["runtime"]+groups = ["main", "runtime"]files = [{file = "websocket_client-1.8.0-py3-none-any.whl", hash = "sha256:17b44cc997f5c498e809b22cdf2d9c7a9e71c02c8cc2b6c56e7c2d1239bfa526"},{file = "websocket_client-1.8.0.tar.gz", hash = "sha256:3239df9f44da632f96012472805d40a23281a991027ce11d2f45a6f24ac4c3da"},@@ -11729,4 +11767,4 @@ cffi = ["cffi (>=1.11)"][metadata]lock-version = "2.1"python-versions = "^3.12,<3.14"-content-hash = "df8217d9808a5a1f5886e0328cbeb5032b20c28a677154888bd010f7bc945cb2"+content-hash = "cce67d8303f93acbf92f3a3603ad07ff82fea4163fc8c38614b3ecb172c34052"diff --git a/pyproject.toml b/pyproject.tomlindex 38f41495ee..c877aa2e56 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -85,6 +85,8 @@ stripe = ">=11.5,<13.0"google-cloud-aiplatform = "*"anthropic = { extras = [ "vertex" ], version = "*" }boto3 = "*"+kubernetes = "^33.1.0"+pyyaml = "^6.0.2"[tool.poetry.group.dev]optional = truediff --git a/tests/unit/test_kubernetes_config.py b/tests/unit/test_kubernetes_config.pynew file mode 100644index 0000000000..3bac845395--- /dev/null+++ b/tests/unit/test_kubernetes_config.py@@ -0,0 +1,62 @@+import pytest+from pydantic import ValidationError++from openhands.core.config.kubernetes_config import KubernetesConfig+++def test_kubernetes_config_defaults():+ """Test that KubernetesConfig has correct default values."""+ config = KubernetesConfig()+ assert config.namespace == 'default'+ assert config.ingress_domain == 'localhost'+ assert config.pvc_storage_size == '2Gi'+ assert config.pvc_storage_class is None+ assert config.resource_cpu_request == '1'+ assert config.resource_memory_request == '1Gi'+ assert config.resource_memory_limit == '2Gi'+ assert config.image_pull_secret is None+ assert config.ingress_tls_secret is None+ assert config.node_selector_key is None+ assert config.node_selector_val is None+ assert config.tolerations_yaml is None+ assert config.privileged is False+++def test_kubernetes_config_custom_values():+ """Test that KubernetesConfig accepts custom values."""+ config = KubernetesConfig(+ namespace='test-ns',+ ingress_domain='test.example.com',+ pvc_storage_size='5Gi',+ pvc_storage_class='fast',+ resource_cpu_request='2',+ resource_memory_request='2Gi',+ resource_memory_limit='4Gi',+ image_pull_secret='pull-secret',+ ingress_tls_secret='tls-secret',+ node_selector_key='zone',+ node_selector_val='us-east-1',+ tolerations_yaml='- key: special\n value: true',+ privileged=True,+ )++ assert config.namespace == 'test-ns'+ assert config.ingress_domain == 'test.example.com'+ assert config.pvc_storage_size == '5Gi'+ assert config.pvc_storage_class == 'fast'+ assert config.resource_cpu_request == '2'+ assert config.resource_memory_request == '2Gi'+ assert config.resource_memory_limit == '4Gi'+ assert config.image_pull_secret == 'pull-secret'+ assert config.ingress_tls_secret == 'tls-secret'+ assert config.node_selector_key == 'zone'+ assert config.node_selector_val == 'us-east-1'+ assert config.tolerations_yaml == '- key: special\n value: true'+ assert config.privileged is True+++def test_kubernetes_config_validation():+ """Test that KubernetesConfig validates input correctly."""+ # Test that extra fields are not allowed+ with pytest.raises(ValidationError):+ KubernetesConfig(extra_field='not allowed')