FSAdminConfig#

pydantic model controller.config.FSAdminConfig#

Configuration for filesystem administration environment.

Parameters:

data (Any)

Show JSON schema
{
   "title": "FSAdminConfig",
   "description": "Configuration for filesystem administration environment.",
   "type": "object",
   "properties": {
      "affinity": {
         "anyOf": [
            {
               "$ref": "#/$defs/Affinity"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "description": "Node and pod affinity rules for file server pods",
         "title": "Affinity rules"
      },
      "extraAnnotations": {
         "additionalProperties": {
            "type": "string"
         },
         "default": {},
         "description": "Extra annotations to add to all user file server ``Job`` and ``Pod`` Kubernetes resources",
         "title": "Extra annotations",
         "type": "object"
      },
      "extraVolumes": {
         "default": [],
         "description": "Additional volumes available to mount inside the fsadmin pod. Inclusion in this list does not mean that they will be mounted. They must separately be listed under ``extravolumeMounts``.",
         "items": {
            "$ref": "#/$defs/VolumeConfig"
         },
         "title": "Extra volumes",
         "type": "array"
      },
      "extraVolumeMounts": {
         "default": [],
         "description": "Additional volumes to mount inside the fsadmin pod.",
         "items": {
            "$ref": "#/$defs/VolumeMountConfig"
         },
         "title": "Extra mounted volumes",
         "type": "array"
      },
      "image": {
         "$ref": "#/$defs/ContainerImage",
         "description": "Docker image to run as fsadmin",
         "title": "fsadmin Docker image"
      },
      "mountPrefix": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "description": "If given, the mounts will be collected under this directory.",
         "examples": [
            "/mnt"
         ],
         "title": "Prefix for fsadmin mounts"
      },
      "nodeSelector": {
         "additionalProperties": {
            "type": "string"
         },
         "default": {},
         "description": "Labels that must be present on Kubernetes nodes for any fsadmin pods to be scheduled there",
         "examples": [
            {
               "disktype": "ssd"
            }
         ],
         "title": "File server node selector",
         "type": "object"
      },
      "podName": {
         "default": "fsadmin",
         "description": "Pod/container name for fsadmin",
         "title": "fsadmin pod name",
         "type": "string"
      },
      "resources": {
         "anyOf": [
            {
               "$ref": "#/$defs/LabResources"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "description": "Kubernetes resource requests and limits for fsadmin pods",
         "title": "Resource requests and limits"
      },
      "timeout": {
         "$ref": "#/$defs/HumanTimedelta",
         "default": "PT2M",
         "description": "How long to allow for fsadmin pod to be created/deleted",
         "title": "Creation timeout"
      },
      "tolerations": {
         "default": [],
         "description": "Kubernetes tolerations for fsadmin pods",
         "items": {
            "$ref": "#/$defs/Toleration"
         },
         "title": "File server pod tolerations",
         "type": "array"
      }
   },
   "$defs": {
      "Affinity": {
         "additionalProperties": false,
         "description": "Pod affinity rules.",
         "properties": {
            "nodeAffinity": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/NodeAffinity"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Node affinity rules"
            },
            "podAffinity": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/PodAffinity"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Pod affinity rules"
            },
            "podAntiAffinity": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/PodAntiAffinity"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Pod anti-affinity rules"
            }
         },
         "title": "Affinity",
         "type": "object"
      },
      "ContainerImage": {
         "additionalProperties": false,
         "description": "Docker image that may be run as a container.\n\nThe structure of this model should follow the normal Helm chart\nconventions so that `Mend Renovate`_ can detect that this is a Docker\nimage reference and create pull requests to update it automatically.",
         "properties": {
            "repository": {
               "description": "Docker repository from which to pull the image",
               "examples": [
                  "docker.io/lsstit/ddsnet4u"
               ],
               "title": "Repository",
               "type": "string"
            },
            "pullPolicy": {
               "$ref": "#/$defs/PullPolicy",
               "default": "IfNotPresent",
               "description": "Kubernetes image pull policy. Set to ``Always`` when testing images that reuse the same tag.",
               "examples": [
                  "Always"
               ],
               "title": "Pull policy"
            },
            "tag": {
               "description": "Tag of image to use (conventionally the version)",
               "examples": [
                  "1.4.2"
               ],
               "title": "Image tag",
               "type": "string"
            }
         },
         "required": [
            "repository",
            "tag"
         ],
         "title": "ContainerImage",
         "type": "object"
      },
      "HostPathVolumeSource": {
         "additionalProperties": false,
         "description": "Path on Kubernetes node to mount in the container.",
         "properties": {
            "type": {
               "const": "hostPath",
               "title": "Type",
               "type": "string"
            },
            "path": {
               "description": "Absolute host path to mount in the container",
               "examples": [
                  "/home"
               ],
               "pattern": "^/.*",
               "title": "Host path",
               "type": "string"
            }
         },
         "required": [
            "type",
            "path"
         ],
         "title": "HostPathVolumeSource",
         "type": "object"
      },
      "HumanTimedelta": {
         "format": "duration",
         "type": "string"
      },
      "LabResources": {
         "description": "Resource requests and limits for a lab.",
         "properties": {
            "limits": {
               "$ref": "#/$defs/ResourceQuantity",
               "description": "If the user's pod exceeds this CPU limit, it will be throttled. If it exceeds this memory limit, it will usually be killed with an out-of-memory error.",
               "title": "Maximum allowed resources"
            },
            "requests": {
               "$ref": "#/$defs/ResourceQuantity",
               "description": "Guaranteed minimum resources available to the user's lab. If these resources are not available, the cluster will autoscale or the lab spawn will fail.",
               "title": "Minimum requested resources"
            }
         },
         "required": [
            "limits",
            "requests"
         ],
         "title": "LabResources",
         "type": "object"
      },
      "LabelSelector": {
         "additionalProperties": false,
         "description": "Rule for matching labels of pods or namespaces.\n\nAll provided expressions must match. (In other words, they are combined\nwith and.)",
         "properties": {
            "matchExpressions": {
               "default": [],
               "description": "Rules for matching labels",
               "items": {
                  "$ref": "#/$defs/LabelSelectorRequirement"
               },
               "title": "Label match expressions",
               "type": "array"
            },
            "matchLabels": {
               "additionalProperties": {
                  "type": "string"
               },
               "default": {},
               "description": "Label keys and values that must be set",
               "title": "Exact label matches",
               "type": "object"
            }
         },
         "title": "LabelSelector",
         "type": "object"
      },
      "LabelSelectorOperator": {
         "description": "Match operations for label selectors.",
         "enum": [
            "In",
            "NotIn",
            "Exists",
            "DoesNotExist"
         ],
         "title": "LabelSelectorOperator",
         "type": "string"
      },
      "LabelSelectorRequirement": {
         "additionalProperties": false,
         "description": "Single rule for label matching.",
         "properties": {
            "key": {
               "description": "Label key to match",
               "title": "Key",
               "type": "string"
            },
            "operator": {
               "$ref": "#/$defs/LabelSelectorOperator",
               "description": "Label match operator",
               "title": "Operator"
            },
            "values": {
               "default": [],
               "description": "For ``In`` and ``NotIn``, matches any value in this list. For ``Exists`` or ``DoesNotExist``, must be empty.",
               "items": {
                  "type": "string"
               },
               "title": "Matching values",
               "type": "array"
            }
         },
         "required": [
            "key",
            "operator"
         ],
         "title": "LabelSelectorRequirement",
         "type": "object"
      },
      "NFSVolumeSource": {
         "additionalProperties": false,
         "description": "NFS volume to mount in the container.",
         "properties": {
            "type": {
               "const": "nfs",
               "title": "Type",
               "type": "string"
            },
            "server": {
               "description": "Name or IP address of the NFS server for the volume",
               "examples": [
                  "10.13.105.122"
               ],
               "title": "NFS server",
               "type": "string"
            },
            "serverPath": {
               "description": "Absolute path of NFS server export of the volume",
               "examples": [
                  "/share1/home"
               ],
               "pattern": "^/.*",
               "title": "Export path",
               "type": "string"
            },
            "readOnly": {
               "default": false,
               "description": "Whether to mount the NFS volume read-only. If this is true, any mount of this volume will be read-only even if the mount is not marked as such.",
               "title": "Is read-only",
               "type": "boolean"
            }
         },
         "required": [
            "type",
            "server",
            "serverPath"
         ],
         "title": "NFSVolumeSource",
         "type": "object"
      },
      "NodeAffinity": {
         "additionalProperties": false,
         "description": "Node affinity rules.",
         "properties": {
            "preferredDuringSchedulingIgnoredDuringExecution": {
               "default": [],
               "description": "Preference rules used for scheduling and ignored afterwards",
               "items": {
                  "$ref": "#/$defs/PreferredSchedulingTerm"
               },
               "title": "Scheduling terms",
               "type": "array"
            },
            "requiredDuringSchedulingIgnoredDuringExecution": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/NodeSelector"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Required node selection rules",
               "title": "Node selectors"
            }
         },
         "title": "NodeAffinity",
         "type": "object"
      },
      "NodeSelector": {
         "additionalProperties": false,
         "description": "Matching terms for nodes.",
         "properties": {
            "nodeSelectorTerms": {
               "default": [],
               "description": "Matching terms for nodes",
               "items": {
                  "$ref": "#/$defs/NodeSelectorTerm"
               },
               "title": "Terms",
               "type": "array"
            }
         },
         "title": "NodeSelector",
         "type": "object"
      },
      "NodeSelectorOperator": {
         "description": "Match operations for node selectors.",
         "enum": [
            "In",
            "NotIn",
            "Exists",
            "DoesNotExist",
            "Gt",
            "Lt"
         ],
         "title": "NodeSelectorOperator",
         "type": "string"
      },
      "NodeSelectorRequirement": {
         "additionalProperties": false,
         "description": "Individual match rule for nodes.",
         "properties": {
            "key": {
               "description": "Label key to match",
               "title": "Key",
               "type": "string"
            },
            "operator": {
               "$ref": "#/$defs/NodeSelectorOperator",
               "description": "Match operation to use",
               "title": "Operator"
            },
            "values": {
               "default": [],
               "description": "For ``In`` and ``NotIn``, matches any value in this list. For ``Gt`` or ``Lt``, must contain a single member interpreted as an integer. For ``Exists`` or ``DoesNotExist``, must be empty.",
               "items": {
                  "type": "string"
               },
               "title": "Matching values",
               "type": "array"
            }
         },
         "required": [
            "key",
            "operator"
         ],
         "title": "NodeSelectorRequirement",
         "type": "object"
      },
      "NodeSelectorTerm": {
         "additionalProperties": false,
         "description": "Term to match nodes.",
         "properties": {
            "matchExpressions": {
               "default": [],
               "description": "Matching rules applied to node labels",
               "items": {
                  "$ref": "#/$defs/NodeSelectorRequirement"
               },
               "title": "Rules for node labels",
               "type": "array"
            },
            "matchFields": {
               "default": [],
               "description": "Matching rules applied to node fields",
               "items": {
                  "$ref": "#/$defs/NodeSelectorRequirement"
               },
               "title": "Rules for node fields",
               "type": "array"
            }
         },
         "title": "NodeSelectorTerm",
         "type": "object"
      },
      "PVCVolumeResources": {
         "additionalProperties": false,
         "description": "Resources for a persistent volume claim.",
         "properties": {
            "requests": {
               "additionalProperties": {
                  "type": "string"
               },
               "title": "Resource requests",
               "type": "object"
            }
         },
         "required": [
            "requests"
         ],
         "title": "PVCVolumeResources",
         "type": "object"
      },
      "PVCVolumeSource": {
         "additionalProperties": false,
         "description": "A PVC to create to materialize the volume to mount in the container.",
         "properties": {
            "type": {
               "const": "persistentVolumeClaim",
               "title": "Type",
               "type": "string"
            },
            "accessModes": {
               "items": {
                  "$ref": "#/$defs/VolumeAccessMode"
               },
               "title": "Access mode",
               "type": "array"
            },
            "storageClassName": {
               "title": "Storage class",
               "type": "string"
            },
            "resources": {
               "$ref": "#/$defs/PVCVolumeResources",
               "title": "Resources for volume"
            },
            "readOnly": {
               "default": false,
               "description": "Whether to force all mounts of this volume to read-only",
               "title": "Is read-only",
               "type": "boolean"
            }
         },
         "required": [
            "type",
            "accessModes",
            "storageClassName",
            "resources"
         ],
         "title": "PVCVolumeSource",
         "type": "object"
      },
      "PodAffinity": {
         "additionalProperties": false,
         "description": "Pod affinity rules.",
         "properties": {
            "preferredDuringSchedulingIgnoredDuringExecution": {
               "default": [],
               "description": "Preference rules used for scheduling and ignored afterwards",
               "items": {
                  "$ref": "#/$defs/WeightedPodAffinityTerm"
               },
               "title": "Scheduling terms",
               "type": "array"
            },
            "requiredDuringSchedulingIgnoredDuringExecution": {
               "default": [],
               "description": "Required node selection rules",
               "items": {
                  "$ref": "#/$defs/PodAffinityTerm"
               },
               "title": "Node selectors",
               "type": "array"
            }
         },
         "title": "PodAffinity",
         "type": "object"
      },
      "PodAffinityTerm": {
         "additionalProperties": false,
         "description": "Pod matching term for pod affinity.",
         "properties": {
            "labelSelector": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/LabelSelector"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Match rules for pod labels",
               "title": "Pod label match"
            },
            "namespaceSelector": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/LabelSelector"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Match rules for namespace labels",
               "title": "Namespace label match"
            },
            "namespaces": {
               "default": [],
               "description": "List of namespaces to which this term applies. The term will apply to the union of this list of namespaces and any namespaces that match ``namespaceSelector``, if given. If both are empty, only the pod's namespace is matched.",
               "items": {
                  "type": "string"
               },
               "title": "Matching namespaces",
               "type": "array"
            },
            "topologyKey": {
               "description": "Name of the node label that should match between nodes to consider two pods to be scheduled on adjacent nodes, which in turn is the definition of an affinity (and the opposite of an anti-affinity).",
               "title": "Node topology label",
               "type": "string"
            }
         },
         "required": [
            "topologyKey"
         ],
         "title": "PodAffinityTerm",
         "type": "object"
      },
      "PodAntiAffinity": {
         "additionalProperties": false,
         "description": "Pod anti-affinity rules.\n\nNotes\n-----\nThis model is structurally identical to `PodAffinity`, but it has to\nconvert to a different Kubernetes model.",
         "properties": {
            "preferredDuringSchedulingIgnoredDuringExecution": {
               "default": [],
               "description": "Preference rules used for scheduling and ignored afterwards",
               "items": {
                  "$ref": "#/$defs/WeightedPodAffinityTerm"
               },
               "title": "Scheduling terms",
               "type": "array"
            },
            "requiredDuringSchedulingIgnoredDuringExecution": {
               "default": [],
               "description": "Required node selection rules",
               "items": {
                  "$ref": "#/$defs/PodAffinityTerm"
               },
               "title": "Node selectors",
               "type": "array"
            }
         },
         "title": "PodAntiAffinity",
         "type": "object"
      },
      "PreferredSchedulingTerm": {
         "additionalProperties": false,
         "description": "Scheduling term with a weight, used to find preferred nodes.",
         "properties": {
            "preference": {
               "$ref": "#/$defs/NodeSelectorTerm",
               "description": "Selector term for a node",
               "title": "Node selector"
            },
            "weight": {
               "description": "Weight to assign to nodes matching this term",
               "title": "Weight",
               "type": "integer"
            }
         },
         "required": [
            "preference",
            "weight"
         ],
         "title": "PreferredSchedulingTerm",
         "type": "object"
      },
      "PullPolicy": {
         "description": "Pull policy for Docker images in Kubernetes.",
         "enum": [
            "Always",
            "IfNotPresent",
            "Never"
         ],
         "title": "PullPolicy",
         "type": "string"
      },
      "ResourceQuantity": {
         "description": "A Kubernetes resource request or limit.",
         "properties": {
            "cpu": {
               "description": "Number of CPU cores",
               "examples": [
                  1.5
               ],
               "title": "CPU",
               "type": "number"
            },
            "memory": {
               "description": "Amount of memory in bytes. Also accepts strings with SI suffixes, which will be converted to bytes. Be sure to use the suffix with ``i`` to indicate powers of two (1024 rather than 1000) if that is desired.",
               "examples": [
                  1073741824,
                  "1Gi"
               ],
               "title": "Memory",
               "type": "integer"
            }
         },
         "required": [
            "cpu",
            "memory"
         ],
         "title": "ResourceQuantity",
         "type": "object"
      },
      "TaintEffect": {
         "description": "Possible effects of a pod toleration.",
         "enum": [
            "NoSchedule",
            "PreferNoSchedule",
            "NoExecute"
         ],
         "title": "TaintEffect",
         "type": "string"
      },
      "Toleration": {
         "additionalProperties": false,
         "description": "Represents a single pod toleration rule.\n\nToleration rules describe what Kubernetes node taints a pod will tolerate,\nmeaning that the pod can still be scheduled on that node even though the\nnode is marked as tained.",
         "properties": {
            "effect": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/TaintEffect"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Taint effect to match. If ``None``, match all taint effects.",
               "title": "Taint effect"
            },
            "key": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Taint key to match. If ``None``, ``operator`` must be ``Exists``, and this combination is used to match all taints.",
               "title": "Taint key"
            },
            "operator": {
               "$ref": "#/$defs/TolerationOperator",
               "default": "Equal",
               "description": "``Exists`` is equivalent to a wildcard for value and matches all possible taints of a given catgory.",
               "title": "Match operator"
            },
            "tolerationSeconds": {
               "anyOf": [
                  {
                     "type": "integer"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Defines the length of time a ``NoExecute`` taint is tolerated and is ignored for other taint effects. The pod will be evicted this number of seconds after the taint is added, rather than immediately (the default with no toleration). ``None`` says to tolerate the taint forever.",
               "title": "Duration of toleration"
            },
            "value": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Taint value to match. Must be ``None`` if the operator is ``Exists``.",
               "title": "Taint value"
            }
         },
         "title": "Toleration",
         "type": "object"
      },
      "TolerationOperator": {
         "description": "Possible operators for a toleration.",
         "enum": [
            "Equal",
            "Exists"
         ],
         "title": "TolerationOperator",
         "type": "string"
      },
      "VolumeAccessMode": {
         "description": "Access mode for a persistent volume.\n\nThe access modes ``ReadWriteOnce`` and ``ReadWriteOncePod`` are valid\naccess modes in Kubernetes but are intentionally not listed here because\nthey cannot work with user labs or file servers and therefore should be\nrejected by configuration parsing. This should change in the future if\naccess modes are used in other contexts where those access modes may make\nsense.",
         "enum": [
            "ReadOnlyMany",
            "ReadWriteMany"
         ],
         "title": "VolumeAccessMode",
         "type": "string"
      },
      "VolumeConfig": {
         "additionalProperties": false,
         "description": "A volume that may be mounted inside a container.",
         "properties": {
            "name": {
               "description": "Used as the Kubernetes volume name and therefore must be a valid Kubernetes name",
               "pattern": "^[a-z0-9]([-a-z0-9]*[a-z0-9])?$",
               "title": "Name of volume",
               "type": "string"
            },
            "source": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/HostPathVolumeSource"
                  },
                  {
                     "$ref": "#/$defs/NFSVolumeSource"
                  },
                  {
                     "$ref": "#/$defs/PVCVolumeSource"
                  }
               ],
               "title": "Source of volume"
            }
         },
         "required": [
            "name",
            "source"
         ],
         "title": "VolumeConfig",
         "type": "object"
      },
      "VolumeMountConfig": {
         "additionalProperties": false,
         "description": "The mount of a volume inside a container.",
         "properties": {
            "containerPath": {
               "description": "Absolute path at which to mount the volume in the lab container",
               "examples": [
                  "/home"
               ],
               "pattern": "^/.*",
               "title": "Path inside container",
               "type": "string"
            },
            "subPath": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "description": "Mount only this sub-path of the volume source",
               "examples": [
                  "groups"
               ],
               "title": "Sub-path of source to mount"
            },
            "readOnly": {
               "default": false,
               "description": "Whether this mount of the volume should be read-only",
               "examples": [
                  true
               ],
               "title": "Is read-only",
               "type": "boolean"
            },
            "volumeName": {
               "description": "Name of the volume to mount",
               "title": "Volume name",
               "type": "string"
            }
         },
         "required": [
            "containerPath",
            "volumeName"
         ],
         "title": "VolumeMountConfig",
         "type": "object"
      },
      "WeightedPodAffinityTerm": {
         "additionalProperties": false,
         "description": "Pod matching term for pod affinity with an associated weight.",
         "properties": {
            "podAffinityTerm": {
               "$ref": "#/$defs/PodAffinityTerm",
               "description": "Pod affinity matching term",
               "title": "Matching term"
            },
            "weight": {
               "description": "Weight to associate with pods matching this term",
               "maximum": 100,
               "minimum": 1,
               "title": "Associated weight",
               "type": "integer"
            }
         },
         "required": [
            "podAffinityTerm",
            "weight"
         ],
         "title": "WeightedPodAffinityTerm",
         "type": "object"
      }
   },
   "required": [
      "image"
   ]
}

Fields:
field affinity: Annotated[Affinity | None, Field(title='Affinity rules', description='Node and pod affinity rules for file server pods')] = None#

Node and pod affinity rules for file server pods

field extraAnnotations: Annotated[dict[str, str], Field(title='Extra annotations', description='Extra annotations to add to all user file server Job and Pod Kubernetes resources')] = {} (name 'extra_annotations')#

Extra annotations to add to all user file server Job and Pod Kubernetes resources

field extraVolumeMounts: Annotated[list[VolumeMountConfig], Field(title='Extra mounted volumes', description='Additional volumes to mount inside the fsadmin pod.')] = [] (name 'extra_volume_mounts')#

Additional volumes to mount inside the fsadmin pod.

field extraVolumes: Annotated[list[VolumeConfig], Field(title='Extra volumes', description='Additional volumes available to mount inside the fsadmin pod. Inclusion in this list does not mean that they will be mounted. They must separately be listed under extravolumeMounts.')] = [] (name 'extra_volumes')#

Additional volumes available to mount inside the fsadmin pod. Inclusion in this list does not mean that they will be mounted. They must separately be listed under extravolumeMounts.

field image: Annotated[ContainerImage, Field(title='fsadmin Docker image', description='Docker image to run as fsadmin')] [Required]#

Docker image to run as fsadmin

field mountPrefix: Annotated[str | None, Field(title='Prefix for fsadmin mounts', description='If given, the mounts will be collected under this directory.', examples=['/mnt'])] = None (name 'mount_prefix')#

If given, the mounts will be collected under this directory.

field nodeSelector: Annotated[dict[str, str], Field(title='File server node selector', description='Labels that must be present on Kubernetes nodes for any fsadmin pods to be scheduled there', examples=[{'disktype': 'ssd'}])] = {} (name 'node_selector')#

Labels that must be present on Kubernetes nodes for any fsadmin pods to be scheduled there

field podName: Annotated[str, Field(title='fsadmin pod name', description='Pod/container name for fsadmin')] = 'fsadmin' (name 'pod_name')#

Pod/container name for fsadmin

field resources: Annotated[LabResources | None, Field(title='Resource requests and limits', description='Kubernetes resource requests and limits for fsadmin pods')] = None#

Kubernetes resource requests and limits for fsadmin pods

field timeout: Annotated[HumanTimedelta, Field(title='Creation timeout', description='How long to allow for fsadmin pod to be created/deleted')] = datetime.timedelta(seconds=120)#

How long to allow for fsadmin pod to be created/deleted

field tolerations: Annotated[list[Toleration], Field(title='File server pod tolerations', description='Kubernetes tolerations for fsadmin pods')] = []#

Kubernetes tolerations for fsadmin pods